Какие знаешь способы обращения к БД?

Способы обращения к БД в Java приложениях

Каждый способ имеет свои преимущества, недостатки и область применения. Выбор зависит от требований проекта, сложности запросов и производительности.

1. JDBC (Java Database Connectivity)

Низкоуровневое API для прямого взаимодействия с БД.

import java.sql.*;

public class UserJdbcRepository {
    private final String connectionUrl = "jdbc:postgresql://localhost:5432/mydb";
    
    public User findById(Long id) {
        String sql = "SELECT id, email, name FROM users WHERE id = ?";
        
        try (Connection conn = DriverManager.getConnection(connectionUrl);
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            stmt.setLong(1, id);
            ResultSet rs = stmt.executeQuery();
            
            if (rs.next()) {
                return new User(
                    rs.getLong("id"),
                    rs.getString("email"),
                    rs.getString("name")
                );
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        return null;
    }
}

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

• Максимальный контроль над запросами
• Отличная производительность для простых операций
• Встроено в Java (не требует зависимостей)

Недостатки:

• Много boilerplate кода
• Управление ресурсами сложное (try-with-resources помогает)
• Подвержена SQL injection (если не использовать PreparedStatement)
• Маппинг результатов в объекты скучный

2. ORM (Object-Relational Mapping) — Hibernate/JPA

Hibernate — самый популярный ORM для Java.

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(nullable = false)
    private String name;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Post> posts = new ArrayList<>();
    
    // getters, setters, constructors
}

// Repository
@Repository
public class UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

Использование:

@Service
public class UserService {
    private final UserRepository repository;
    
    public User findById(Long id) {
        return repository.findById(id).orElseThrow();
    }
    
    public void save(User user) {
        repository.save(user); // Hibernate автоматически генерирует SQL
    }
    
    public void delete(User user) {
        repository.delete(user); // Каскадное удаление постов
    }
}

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

• Маппинг между объектами и таблицами автоматический
• Абстракция от конкретной БД (можно менять на лету)
• Управление связями между сущностями
• Lazy loading и eager loading
• Query Language (HQL/JPQL) — объектно-ориентированный

Недостатки:

• Проблема N+1 запросов (часто)
• Сложные запросы требуют HQL/JPQL
• Производительность ниже, чем JDBC для простых операций
• Магия Hibernate может быть непредсказуема
• Дорого для чтения больших объёмов данных

3. MyBatis

Полуавтоматический маппер SQL и Java объектов.

<!-- mybatis-config.xml -->
<mapper namespace="com.example.UserMapper">
    <select id="findById" parameterType="long" resultType="User">
        SELECT id, email, name FROM users WHERE id = #{id}
    </select>
    
    <insert id="save" parameterType="User">
        INSERT INTO users (email, name) VALUES (#{email}, #{name})
    </insert>
</mapper>

@Mapper
public interface UserMapper {
    User findById(Long id);
    void save(User user);
}

// Использование
@Service
public class UserService {
    private final UserMapper mapper;
    
    public User findById(Long id) {
        return mapper.findById(id);
    }
}

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

• Контроль над SQL запросами
• Меньше магии, чем в Hibernate
• Хорошее соотношение между контролем и простотой
• Отличная производительность

Недостатки:

• Нужно писать SQL вручную (может быть скучно)
• Не автоматизирует сложные связи
• Меньше абстракции от БД

4. Spring Data JDBC

Легковесной ORM для простых случаев.

@Table("users")
public class User {
    @Id
    private Long id;
    private String email;
    private String name;
}

@Repository
public interface UserRepository extends CrudRepository<User, Long> {
    User findByEmail(String email);
}

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

• Простой и лёгкий
• Без N+1 проблем (не поддерживает lazy loading)
• Хорошая производительность
• Spring Data интеграция

Недостатки:

• Ограниченная поддержка связей
• Меньше функций, чем Hibernate

5. Raw SQL с Spring JdbcTemplate

Оборачивает JDBC в удобный интерфейс.

@Repository
public class UserJdbcTemplateRepository {
    private final JdbcTemplate jdbcTemplate;
    
    public User findById(Long id) {
        String sql = "SELECT id, email, name FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, new UserRowMapper(), id);
    }
    
    public List<User> findAll() {
        String sql = "SELECT * FROM users";
        return jdbcTemplate.query(sql, new UserRowMapper());
    }
    
    public void save(User user) {
        String sql = "INSERT INTO users (email, name) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getEmail(), user.getName());
    }
    
    private static class UserRowMapper implements RowMapper<User> {
        @Override
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            return new User(
                rs.getLong("id"),
                rs.getString("email"),
                rs.getString("name")
            );
        }
    }
}

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

• Контроль над SQL
• Хорошая производительность
• Меньше boilerplate, чем JDBC

Недостатки:

• Нужно маппировать результаты вручную
• Зависит от Spring

6. QueryDSL

Типобезопасные запросы с использованием API.

QUser user = QUser.user;

List<User> users = queryFactory
    .selectFrom(user)
    .where(user.email.eq("test@example.com"))
    .fetch();

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

• Типобезопасность на compile time
• Красивый API
• Лучше, чем string-based JPQL

Недостатки:

• Требует code generation
• Зависит от Hibernate/JPA

7. R2DBC (Reactive)

Для асинхронных, неблокирующих операций.

@Repository
public interface UserRepository extends ReactiveCrudRepository<User, Long> {
    Mono<User> findByEmail(String email);
}

@Service
public class UserService {
    private final UserRepository repository;
    
    public Mono<User> findById(Long id) {
        return repository.findById(id);
    }
}

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

• Неблокирующие операции
• Хорошо работает с WebFlux
• Масштабируемость для high-concurrency приложений

Недостатки:

• Сложнее отлаживать
• Меньше поддержка, чем JDBC/Hibernate

Сравнительная таблица

Рекомендации по выбору

Используй Hibernate/JPA когда:

• Много связанных сущностей
• Не требуется оптимизация сложных запросов
• Нужна абстракция от БД
• Большое приложение с многими таблицами

Используй MyBatis когда:

• Нужен контроль над SQL
• Много сложных запросов
• Важна производительность
• Маппирование не очень сложное

Используй Spring Data JDBC когда:

• Простые CRUD операции
• Связи минимальны
• Нужна лёгкость и скорость

Используй JDBC/JdbcTemplate когда:

• Очень простые операции
• Максимальный контроль нужен
• Производительность критична

Используй R2DBC когда:

• Реактивное приложение (WebFlux)
• High-concurrency требования
• Асинхронная обработка

Выбор способа доступа к БД — это один из самых важных решений в архитектуре приложения, влияющий на производительность, тестируемость и масштабируемость.