Что нравится для работы с БД

# Что нравится для работы с БД

Мой опыт и предпочтения

За 10+ лет разработки на Java я работал с разными подходами и инструментами. Вот что мне нравится больше всего:

1. JPA + Hibernate

Почему это мой выбор

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Post> posts = new ArrayList<>();
}

Мне нравится:

• Object-Relational Mapping — работаю с объектами, а не с SQL
• Lazy loading — загружаю связанные данные только когда нужно
• Cascade operations — автоматическое каскадное удаление
• HQL (Hibernate Query Language) — более объектно-ориентированный подход
• Миграции — вместе с Flyway/Liquibase версионирую схему БД

2. Spring Data JPA

В контексте Spring Data JPA получается очень чистый и удобный код:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    
    List<User> findByCreatedAtAfter(LocalDateTime date);
    
    @Query("SELECT u FROM User u WHERE u.status = :status ORDER BY u.createdAt DESC")
    List<User> findActiveUsers(@Param("status") String status);
}

// Использование
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}

Почему нравится:

• CRUD операции бесплатно — не нужно писать boilerplate
• Query methods — декларативный стиль запросов
• Pagination & Sorting — встроенная поддержка
• Type-safe — компилятор проверит ошибки
• Стиль жизни Spring — интеграция со всей экосистемой

3. JDBC Template (для простых случаев)

Иногда ORM — оverkill. Для простых запросов используется JdbcTemplate:

@Service
public class StatsService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public Map<String, Integer> getUserStats() {
        String sql = "SELECT country, COUNT(*) as user_count FROM users GROUP BY country";
        
        return jdbcTemplate.query(sql, (rs, rowNum) -> {
            Map<String, Integer> row = new HashMap<>();
            row.put(rs.getString("country"), rs.getInt("user_count"));
            return row;
        });
    }
}

Почему иногда лучше JDBC Template:

• Полный контроль над SQL — когда нужна оптимизация
• Легче — не нужна вся мощь ORM
• Быстрее — прямой доступ к данным

4. QueryDSL (для сложных фильтров)

Когда много динамических условий, QueryDSL отлично помогает:

QUser qUser = QUser.user;

List<User> users = queryFactory
    .selectFrom(qUser)
    .where(
        qUser.email.like("%.com")
        .and(qUser.createdAt.after(LocalDateTime.now().minusDays(30)))
        .and(qUser.status.in("ACTIVE", "TRIAL"))
    )
    .orderBy(qUser.createdAt.desc())
    .limit(10)
    .fetch();

Почему нравится:

• Type-safe queries — ошибки видны на компиляции
• Динамические фильтры — легче строить сложные условия
• SQL in Java — не нужно писать SQL строки
• IDE поддержка — автодополнение работает

5. Миграции БД (Flyway)

-- db/migration/V1__initial_schema.sql
CREATE TABLE users (
    id BIGSERIAL PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

-- db/migration/V2__add_user_status.sql
ALTER TABLE users ADD COLUMN status VARCHAR(20) DEFAULT 'ACTIVE';

Почему это важно:

• Версионирование схемы — как git для БД
• Воспроизводимость — любой может создать БД с нуля
• Коллаборация — команда работает с одной схемой
• CI/CD — миграции автоматически применяются при деплое

6. Транзакции и изоляция

@Service
public class PaymentService {
    @Autowired
    private AccountRepository accountRepository;
    
    @Transactional
    public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findByIdForUpdate(fromId);
        Account to = accountRepository.findByIdForUpdate(toId);
        
        from.debit(amount);
        to.credit(amount);
        
        accountRepository.save(from);
        accountRepository.save(to);
        // Если выброс исключения — все откатится автоматически
    }
}

Почему нравится:

• ACID гарантии — деньги не теряются
• Автоматическое управление — Spring само открывает/закрывает транзакции
• Логирование — видно какие транзакции работают
• Performance — кэширование на уровне сессии

7. Кэширование запросов

@Service
@EnableCaching
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Cacheable(value = "users", key = "#email")
    public User findByEmail(String email) {
        return userRepository.findByEmail(email);
    }
    
    @CacheEvict(value = "users", allEntries = true)
    public User updateUser(User user) {
        return userRepository.save(user);
    }
}

Мне нравится:

• Прозрачное кэширование — просто добавляю аннотацию
• Разные стратегии — Redis, Ehcache, Memory
• Инвалидация — автоматическая очистка при изменениях

8. Логирование SQL

# application.properties
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.generate_statistics=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.stat=DEBUG

Почему это критично:

• Видю какие запросы выполняются — понимаю производительность
• Отлаживаю N+1 проблемы — вижу все лишние запросы
• Оптимизирую — вижу какой JOIN выбран

9. Дополнительные инструменты

• Liquibase — как Flyway но мощнее (для сложных миграций)
• Testcontainers — реальная БД в Docker для тестов
• H2/PostgreSQL — H2 для тестов, PostgreSQL для продакшена
• DataGrip — IDE от JetBrains, лучший инструмент для работы с БД

Мой типичный стек

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>
<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>
<dependency>
    <groupId>com.querydsl</groupId>
    <artifactId>querydsl-jpa</artifactId>
</dependency>

Что я избегаю

1. Raw JDBC — слишком verbose для обычной разработки
2. Динамический SQL без QueryDSL — ошибки найти сложнее
3. Без транзакций — риск потери данных
4. БД без миграций — chaos в production
5. Без логирования SQL — слепой полёт

Заключение

Мне нравится баланс между мощью ORM (Hibernate) и контролем (QueryDSL, JDBC). С Spring Data JPA получается clean code, который легко тестировать и поддерживать. Плюс proper миграции и логирование — и разработка становится приятной.