Какие знаешь способы выполнить SQL запрос через JDBC?

Способы выполнения SQL запросов через JDBC

JDBC (Java Database Connectivity) — это базовый API для работы с реляционными БД. Существует несколько подходов к выполнению SQL запросов, каждый с своими плюсами и минусами. Расскажу о всех основных способах.

1. Statement (простые запросы)

Statement используется для простых SQL запросов без параметров.

public void executeSimpleQuery() throws SQLException {
    Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/mydb", "user", "password"
    );
    
    Statement statement = connection.createStatement();
    
    // Чтение данных
    String query = "SELECT id, name, email FROM users WHERE age > 18";
    ResultSet resultSet = statement.executeQuery(query);
    
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("ID: " + id + ", Name: " + name);
    }
    
    // Модификация данных
    String updateQuery = "UPDATE users SET name = 'John' WHERE id = 1";
    int affectedRows = statement.executeUpdate(updateQuery);
    System.out.println("Rows affected: " + affectedRows);
    
    resultSet.close();
    statement.close();
    connection.close();
}

Плюсы:

• Простая реализация
• Подходит для простых запросов

Минусы:

• Уязвим к SQL injection (если параметры конкатенируются со строкой)
• Нет переиспользования подготовленного плана запроса

2. PreparedStatement (защита от SQL injection)

PreparedStatement — это рекомендуемый способ, заменяет переменные на плейсхолдеры ?.

public void executeWithPreparedStatement() throws SQLException {
    Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/mydb", "user", "password"
    );
    
    // Плейсхолдеры защищают от SQL injection
    String query = "SELECT id, name, email FROM users WHERE age > ? AND name = ?";
    PreparedStatement preparedStatement = connection.prepareStatement(query);
    
    // Устанавливаем параметры
    preparedStatement.setInt(1, 18);           // Первый ?  - INT
    preparedStatement.setString(2, "John");    // Второй ? - STRING
    
    ResultSet resultSet = preparedStatement.executeQuery();
    
    while (resultSet.next()) {
        System.out.println(resultSet.getString("name"));
    }
    
    resultSet.close();
    preparedStatement.close();
    connection.close();
}

Плюсы:

• Защита от SQL injection — параметры экранируются автоматически
• Кэширование плана запроса — БД не парсит один и тот же запрос дважды
• Повышенная производительность при повторных запросах

Минусы:

• Немного сложнее синтаксис

3. CallableStatement (вызов хранимых процедур)

CallableStatement вызывает хранимые процедуры в БД.

public void executeStoredProcedure() throws SQLException {
    Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/mydb", "user", "password"
    );
    
    // Вызов хранимой процедуры: CALL get_user_by_id(?, ?)
    String procedureCall = "{ CALL get_user_by_id(?, ?) }";
    CallableStatement callableStatement = connection.prepareCall(procedureCall);
    
    // IN параметр
    callableStatement.setInt(1, 5);
    
    // OUT параметр (возвращаемое значение)
    callableStatement.registerOutParameter(2, Types.VARCHAR);
    
    // Выполнить
    callableStatement.execute();
    
    // Получить результат
    String userName = callableStatement.getString(2);
    System.out.println("User name: " + userName);
    
    callableStatement.close();
    connection.close();
}

Плюсы:

• Вызов логики на уровне БД
• Безопасное разделение логики
• Хорошая производительность

Минусы:

• Зависимость от конкретной СУБД
• Сложность тестирования

4. Пакетная обработка (Batch Processing)

Batch используется для выполнения множества запросов одним вызовом.

public void batchInsert(List<User> users) throws SQLException {
    Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/mydb", "user", "password"
    );
    
    String insertQuery = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
    PreparedStatement statement = connection.prepareStatement(insertQuery);
    
    // Добавляем запросы в батч
    for (User user : users) {
        statement.setString(1, user.getName());
        statement.setString(2, user.getEmail());
        statement.setInt(3, user.getAge());
        
        statement.addBatch();  // Добавить в очередь
    }
    
    // Выполнить все запросы одним вызовом
    int[] results = statement.executeBatch();
    
    // results[i] = количество строк, затронутых i-й командой
    System.out.println("Inserted rows: " + Arrays.stream(results).sum());
    
    statement.close();
    connection.close();
}

Плюсы:

• Значительное ускорение при большом количестве операций
• Меньше round-trip'ов к БД

Минусы:

• Требует больше памяти для накопления запросов
• Может быть сложнее обрабатывать ошибки

5. Connection Pooling (переиспользование соединений)

Это не прямой способ выполнения запроса, но критично для production.

// HikariCP - самый быстрый пул соединений
public class HikariDatabaseConfig {
    public static DataSource createDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("user");
        config.setPassword("password");
        config.setMaximumPoolSize(20);      // макс соединений
        config.setMinimumIdle(5);            // минимум ожидающих
        config.setConnectionTimeout(10000);  // timeout подключения
        config.setIdleTimeout(600000);       // timeout неиспользуемого соединения
        
        return new HikariDataSource(config);
    }
}

public void executeWithPooling(DataSource dataSource) throws SQLException {
    // Берём соединение из пула
    Connection connection = dataSource.getConnection();
    
    // Используем
    String query = "SELECT * FROM users";
    PreparedStatement statement = connection.prepareStatement(query);
    ResultSet resultSet = statement.executeQuery();
    
    // Закрываем - соединение возвращается в пул
    resultSet.close();
    statement.close();
    connection.close();
}

Плюсы:

• Переиспользование соединений (дорогая операция)
• Улучшенная производительность
• Управление ресурсами

6. Spring JdbcTemplate (wrapper вокруг JDBC)

В modern Java часто используют Spring для упрощения JDBC кода.

@Repository
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;
    
    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    // Чтение данных
    public List<User> findUsersByAge(int age) {
        String query = "SELECT id, name, email FROM users WHERE age > ?";
        return jdbcTemplate.query(query, new Object[]{age}, (rs, rowNum) -> 
            new User(
                rs.getInt("id"),
                rs.getString("name"),
                rs.getString("email")
            )
        );
    }
    
    // Чтение одного значения
    public String getUserNameById(int id) {
        String query = "SELECT name FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(query, new Object[]{id}, String.class);
    }
    
    // Обновление/вставка
    public void insertUser(String name, String email, int age) {
        String query = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
        jdbcTemplate.update(query, name, email, age);
    }
    
    // Batch обработка
    public void batchInsertUsers(List<User> users) {
        String query = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
        
        jdbcTemplate.batchUpdate(query, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                User user = users.get(i);
                ps.setString(1, user.getName());
                ps.setString(2, user.getEmail());
                ps.setInt(3, user.getAge());
            }
            
            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }
}

Плюсы:

• Меньше boilerplate кода
• Автоматическое управление ресурсами (close)
• Интеграция с транзакциями

Минусы:

• Зависимость от Spring
• Меньше контроля над деталями

Сравнение методов

Best practices для JDBC

• ВСЕГДА используй PreparedStatement, никогда Statement
• Используй Connection Pool в production (HikariCP, c3p0)
• Закрывай ресурсы — используй try-with-resources:

try (Connection conn = dataSource.getConnection();
     PreparedStatement stmt = conn.prepareStatement(query)) {
    stmt.setString(1, value);
    stmt.executeUpdate();
} // Автоматически закроются

• Используй Batch для bulk операций
• Профилируй медленные запросы
• Логируй SQL запросы при разработке

В целом: PreparedStatement + Connection Pool = стандарт для надёжной работы с БД в Java.