Какие знаешь способы работы с БД в Spring?

Способы работы с БД в Spring

Spring предоставляет несколько уровней абстракции для работы с базами данных, от низкоуровневого доступа к высокоуровневому ORM. Выбор подхода зависит от требований проекта.

1. JDBC Template — низкоуровневый доступ

JdbcTemplate — оборачивает работу с JDBC и убирает boilerplate код типа открытия/закрытия соединений:

@Repository
public class UserRepository {
    @Autowired private JdbcTemplate jdbcTemplate;
    
    public User findById(Long id) {
        String sql = "SELECT * FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, 
            new Object[]{id},
            new UserRowMapper()
        );
    }
    
    public void save(User user) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getEmail());
    }
}

class UserRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        return new User(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getString("email")
        );
    }
}

Плюсы: простота, полный контроль над SQL, минимальный overhead. Минусы: много кода для маппинга, нет автоматического отслеживания изменений.

2. JPA/Hibernate — ORM фреймворк

JPA (Java Persistence API) с реализацией Hibernate — стандарт ORM в Java. Преобразует объекты в строки БД автоматически:

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

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String name);
}

Плюсы: минимум кода, автоматическое управление связями, защита от SQL-инъекций, JPQL для сложных запросов. Минусы: медленнее JDBC, проблема N+1 запросов, сложная оптимизация для высоконагруженных систем.

3. Spring Data repositories

Декларативный способ создания CRUD операций без написания реализации:

// Простейший CRUD
public interface UserRepository extends JpaRepository<User, Long> {
}

// Query methods — автоматическая генерация запросов
public interface OrderRepository extends JpaRepository<Order, Long> {
    List<Order> findByUserIdAndStatusOrderByCreatedAtDesc(Long userId, OrderStatus status);
    
    @Query("SELECT o FROM Order o WHERE o.price > :minPrice AND o.status = :status")
    List<Order> findExpensiveOrders(@Param("minPrice") BigDecimal minPrice, 
                                    @Param("status") OrderStatus status);
    
    @Query(value = "SELECT * FROM orders WHERE price > :price", nativeQuery = true)
    List<Order> findRawSQL(@Param("price") BigDecimal price);
}

Query Methods — маджик Spring Data, анализирует имя метода и генерирует SQL:

public interface ProductRepository extends JpaRepository<Product, Long> {
    // Эти методы создаются автоматически
    List<Product> findByCategory(String category);
    List<Product> findByCategoryAndPrice(String category, Double price);
    List<Product> findByPriceGreaterThan(Double price);
    List<Product> findByNameContainingIgnoreCase(String name);
}

4. QueryDSL — типобезопасные запросы

Для сложных запросов вместо строк JPQL используется API:

@Repository
public class OrderRepositoryCustom {
    @Autowired private JPAQuery<Order> query;
    
    public List<Order> complexQuery(String userName, BigDecimal minPrice, LocalDate date) {
        QOrder order = QOrder.order;
        QUser user = QUser.user;
        
        return query
            .select(order)
            .from(order)
            .join(order.user, user)
            .where(user.name.contains(userName)
                .and(order.price.goe(minPrice))
                .and(order.createdAt.after(date)))
            .orderBy(order.createdAt.desc())
            .fetch();
    }
}

Плюсы: типобезопасность, IDE автодополнение, компилироваемость. Минусы: дополнительная генерация кода, setup сложнее.

5. Liquibase / Flyway — миграции БД

Управление версиями схемы БД:

// application.yml
spring:
  liquibase:
    change-log: classpath:db/changelog/db.changelog-master.yaml

// db/changelog/db.changelog-master.yaml
databaseChangeLog:
  - changeSet:
      id: 001-create-users
      author: dev
      changes:
        - createTable:
            tableName: users
            columns:
              - column:
                  name: id
                  type: BIGINT
                  constraints:
                    primaryKey: true
              - column:
                  name: email
                  type: VARCHAR(255)
                  constraints:
                    unique: true

6. Spring JDBC Batch Operations

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

@Service
public class BatchUserService {
    @Autowired private JdbcTemplate jdbcTemplate;
    
    public void saveBatch(List<User> users) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        
        jdbcTemplate.batchUpdate(sql, 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());
            }
            
            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }
}

7. R2DBC — реактивный доступ к БД

Для высоконагруженных приложений с асинхронным I/O:

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

@Service
public class ReactivUserService {
    @Autowired private UserR2dbcRepository repository;
    
    public Mono<User> getUser(Long id) {
        return repository.findById(id);
    }
    
    public Flux<User> getAllUsers() {
        return repository.findAll();
    }
}

Сравнение подходов

Оптимизация и best practices

// Избежать N+1 проблемы с fetch join
@Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.posts WHERE u.id = ?1")
User findByIdWithPosts(Long id);

// Использовать projections для выбора отдельных полей
public interface UserProjection {
    Long getId();
    String getName();
}

List<UserProjection> findByIdIn(List<Long> ids);

// Batch loading
@Query(value = "SELECT * FROM users WHERE id IN :ids", nativeQuery = true)
List<User> findAllByIds(@Param("ids") List<Long> ids);

// Использовать @Transactional(readOnly = true) для оптимизации
@Transactional(readOnly = true)
public List<User> getAllUsers() {
    return userRepository.findAll();
}

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