Как установить соединение с БД

Как установить соединение с БД

Установление соединения с базой данных — это критичный процесс для любого Java приложения, работающего с персистентными данными. Существует несколько подходов, от низкоуровневого JDBC до высокоуровневых ORM фреймворков.

Подход 1: Прямое JDBC соединение

Это самый низкоуровневый способ подключиться к БД:

import java.sql.*;

public class JdbcConnection {
    public static void main(String[] args) {
        // Параметры подключения
        String url = "jdbc:postgresql://localhost:5432/mydb";
        String user = "admin";
        String password = "password";
        
        try {
            // Загрузить драйвер
            Class.forName("org.postgresql.Driver");
            
            // Установить соединение
            Connection conn = DriverManager.getConnection(url, user, password);
            
            // Использовать соединение
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
            
            // Закрыть ресурсы
            rs.close();
            stmt.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            System.err.println("Драйвер БД не найден");
        } catch (SQLException e) {
            System.err.println("Ошибка БД: " + e.getMessage());
        }
    }
}

Проблемы:

• Нужно вручную закрывать соединения
• Создание нового соединения для каждого запроса дорого
• Нет пула соединений
• Код повторяется

Подход 2: Try-with-resources для автоматического закрытия

Модернный способ работать с соединениями:

public class JdbcTryWithResources {
    public static void queryUsers(String url, String user, String password) 
            throws SQLException {
        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        }  // Автоматически закроет resultSet → stmt → conn
    }
}

Преимущества:

• Автоматическое закрытие ресурсов
• Чище код
• Безопаснее

Подход 3: Connection Pool (пул соединений)

Пул соединений переиспользует соединения, что намного эффективнее:

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class ConnectionPool {
    private static HikariDataSource dataSource;
    
    static {
        // Настроить параметры пула
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
        config.setUsername("admin");
        config.setPassword("password");
        config.setMaximumPoolSize(10);        // Максимум 10 соединений
        config.setMinimumIdle(2);             // Минимум 2 простаивающих
        config.setConnectionTimeout(30000);   // 30 сек timeout
        config.setIdleTimeout(600000);        // Закрыть неиспользуемые через 10 мин
        config.setMaxLifetime(1800000);       // Максимум 30 мин на соединение
        
        dataSource = new HikariDataSource(config);
    }
    
    public static DataSource getDataSource() {
        return dataSource;
    }
    
    public static void queryUsers() throws SQLException {
        // Получить соединение из пула
        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        }
        // Соединение возвращается в пул, не закрывается
    }
}

Когда использовать:

• В production приложениях
• Когда нужно много операций к БД
• Когда требуется высокая производительность

Подход 4: Spring с JdbcTemplate

Spring упрощает работу с БД:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;
    
    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    public List<Map<String, Object>> getAllUsers() {
        return jdbcTemplate.queryForList("SELECT * FROM users");
    }
    
    public void addUser(String name, String email) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        jdbcTemplate.update(sql, name, email);
    }
    
    public int countUsers() {
        return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM users", Integer.class);
    }
}

// application.properties
// spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
// spring.datasource.username=admin
// spring.datasource.password=password
// spring.datasource.hikari.maximum-pool-size=10

Подход 5: Spring с JPA/Hibernate

Для object-relational mapping:

import javax.persistence.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

// Entity класс
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name")
    private String name;
    
    @Column(name = "email")
    private String email;
    
    // getters и setters
    public Long getId() { return id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// Repository интерфейс
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    List<User> findByNameContaining(String name);
}

// Service использует repository
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    public User createUser(User user) {
        return userRepository.save(user);
    }
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

// Конфигурация в application.properties
// spring.jpa.hibernate.ddl-auto=update
// spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect

Подход 6: Асинхронные соединения

Для высокопроизводительных приложений:

import io.r2dbc.pool.ConnectionPool;
import io.r2dbc.pool.ConnectionPoolConfiguration;
import io.r2dbc.postgresql.PostgresqlConnectionFactory;
import io.r2dbc.spi.Connection;
import reactor.core.publisher.Mono;

public class AsyncDatabase {
    private final ConnectionPool pool;
    
    public AsyncDatabase() {
        // Создать R2DBC соединение (реактивное)
        PostgresqlConnectionFactory connectionFactory = 
            new PostgresqlConnectionFactory(
                io.r2dbc.postgresql.api.PostgresqlConnectionFactoryProvider
                    .builder()
                    .host("localhost")
                    .port(5432)
                    .database("mydb")
                    .username("admin")
                    .password("password")
                    .build()
            );
        
        ConnectionPoolConfiguration config = 
            ConnectionPoolConfiguration.builder(connectionFactory)
                .maxIdleTime(Duration.ofMinutes(30))
                .maxAcquireTime(Duration.ofSeconds(3))
                .build();
        
        this.pool = new ConnectionPool(config);
    }
    
    // Реактивный запрос
    public Mono<List<String>> getAllUserNames() {
        return pool.create()
            .flatMapMany(conn -> 
                conn.createStatement("SELECT name FROM users")
                    .execute()
            )
            .flatMap(result -> result.map((row, meta) -> row.get("name", String.class)))
            .collectList();
    }
}

Чеклист установления соединения

public class DatabaseConnectionChecklist {
    
    // 1. Убедитесь, что драйвер установлен
    // Maven dependency: org.postgresql:postgresql:42.5.0
    
    // 2. Проверьте правильность параметров
    private static final String URL = "jdbc:postgresql://host:port/database";
    private static final String USER = "username";
    private static final String PASSWORD = "password";
    
    // 3. Используйте пул соединений в production
    // HikariCP - самый популярный
    
    // 4. Установите правильные таймауты
    // connectionTimeout: сколько ждать получить соединение из пула
    // idleTimeout: сколько ждать перед закрытием неиспользуемого соединения
    // maxLifetime: максимум времени жизни соединения
    
    // 5. Обрабатывайте исключения правильно
    public void handleConnectionError() {
        try {
            // операция с БД
        } catch (SQLException e) {
            if (e.getMessage().contains("Connection refused")) {
                // Сервер БД не запущен или неправильный хост
            } else if (e.getMessage().contains("password authentication failed")) {
                // Неправильные учётные данные
            } else if (e.getMessage().contains("database does not exist")) {
                // БД не создана
            }
        }
    }
}

Типичные ошибки

// ❌ Ошибка 1: забыли закрыть соединение
public void badConnection() throws SQLException {
    Connection conn = DriverManager.getConnection(url, user, password);
    // Использование
    // Забыли: conn.close();
    // Утечка соединения!
}

// ✅ Правильно:
public void goodConnection() throws SQLException {
    try (Connection conn = DriverManager.getConnection(url, user, password)) {
        // Использование
    }  // Автоматически закроется
}

// ❌ Ошибка 2: создание нового соединения для каждого запроса
public void inefficient() throws SQLException {
    for (int i = 0; i < 1000; i++) {
        Connection conn = DriverManager.getConnection(url, user, password);  // Дорого!
        // один запрос
        conn.close();
    }
}

// ✅ Правильно: использовать пул соединений
public void efficient() throws SQLException {
    for (int i = 0; i < 1000; i++) {
        try (Connection conn = dataSource.getConnection()) {
            // один запрос
        }  // Возвращает в пул, не закрывает
    }
}

// ❌ Ошибка 3: неправильная обработка исключений
public void badError() {
    try {
        // код с БД
    } catch (Exception e) {
        e.printStackTrace();  // Просто печать, нет логирования
    }
}

// ✅ Правильно:
public void goodError() {
    try {
        // код с БД
    } catch (SQLException e) {
        logger.error("Database error: {}", e.getMessage(), e);
        throw new RuntimeException(e);
    }
}

Мониторинг соединений

@Component
public class DatabaseHealthCheck {
    private final DataSource dataSource;
    private static final Logger logger = LoggerFactory.getLogger(DatabaseHealthCheck.class);
    
    public DatabaseHealthCheck(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    @Scheduled(fixedRate = 60000)  // Проверять каждую минуту
    public void checkDatabaseHealth() {
        try (Connection conn = dataSource.getConnection()) {
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT 1");
            if (rs.next()) {
                logger.info("Database connection OK");
            }
        } catch (SQLException e) {
            logger.error("Database connection failed", e);
            // Отправить alert
        }
    }
}

Резюме

• JDBC: низкоуровневый, нужно вручную управлять ресурсами
• Try-with-resources: нужно использовать для автоматического закрытия
• Connection Pool (HikariCP): обязателен для production
• Spring JdbcTemplate: упрощает работу, но остаётся SQL
• JPA/Hibernate: ORM, объектно-ориентированный подход
• R2DBC: асинхронные реактивные соединения
• Всегда: обрабатывайте ошибки, логируйте, мониторьте