Какие знаешь технологии взаимодействия с БД?

Технологии взаимодействия с базами данных в Java

Взаимодействие с БД - это фундаментальная часть практически всех Java приложений. Существует множество подходов и технологий, каждая с собственными плюсами и минусами.

1. JDBC (Java Database Connectivity)

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

import java.sql.*;

public class UserDAO {
  
  public User getUserById(Long id) throws SQLException {
    String sql = "SELECT id, name, email FROM users WHERE id = ?";
    
    // Получить соединение (обычно из connection pool)
    try (Connection conn = getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {
      
      pstmt.setLong(1, id);
      
      try (ResultSet rs = pstmt.executeQuery()) {
        if (rs.next()) {
          return new User(
            rs.getLong("id"),
            rs.getString("name"),
            rs.getString("email")
          );
        }
      }
    }
    return null;
  }
}

Плюсы:

• Полный контроль
• Максимальная производительность
• Работает с любой БД

Минусы:

• Много boilerplate кода
• Требует ручного управления ресурсами
• Требует ручного маппинга результатов
• SQL injection уязвимость если не осторожен

2. JPA (Java Persistence API) с Hibernate

Объектно-реляционное маппирование (ORM) - стандарт Java.

import javax.persistence.*;
import org.hibernate.annotations.CreationTimestamp;

@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<Order> orders;
  
  @CreationTimestamp
  private LocalDateTime createdAt;
}

// DAO с Spring Data JPA
public interface UserRepository extends JpaRepository<User, Long> {
  Optional<User> findByEmail(String email);
  List<User> findByNameContaining(String name);
}

// Использование
@Service
public class UserService {
  
  private final UserRepository userRepository;
  
  public User getUser(Long id) {
    return userRepository.findById(id)
      .orElseThrow(() -> new UserNotFoundException(id));
  }
  
  public void createUser(String name, String email) {
    User user = new User(name, email);
    userRepository.save(user);
  }
}

Плюсы:

• Минимум boilerplate
• Автоматическое маппирование
• Поддержка отношений (One-to-Many, Many-to-Many)
• HQL/JPQL для запросов
• Кэширование

Минусы:

• Сложнее для сложных запросов
• N+1 проблема если не осторожен
• Overhead на большие таблицы
• Magic (сложно понять что происходит)

3. Spring Data JPA

Обертка над JPA/Hibernate, упрощающая работу.

public interface UserRepository extends 
    JpaRepository<User, Long>,
    JpaSpecificationExecutor<User> {
  
  // Query methods - автоматически генерируются
  Optional<User> findByEmail(String email);
  List<User> findByNameContaining(String name);
  Page<User> findByStatusOrderByCreatedAtDesc(String status, Pageable pageable);
  
  // Custom JPQL
  @Query("SELECT u FROM User u WHERE u.email = :email")
  Optional<User> findByEmailCustom(@Param("email") String email);
  
  // Native SQL
  @Query(value = "SELECT * FROM users WHERE status = ?1", nativeQuery = true)
  List<User> findByStatusNative(String status);
  
  // Deletion
  void deleteByStatusAndCreatedAtBefore(String status, LocalDateTime date);
}

// Использование
@Service
public class UserService {
  
  @Autowired
  private UserRepository userRepository;
  
  public Page<User> getActiveUsers(int page) {
    return userRepository.findByStatusOrderByCreatedAtDesc(
      "ACTIVE", 
      PageRequest.of(page, 20)
    );
  }
}

4. MyBatis

Полуавтоматическое маппирование, больше контроля чем ORM.

// UserMapper.xml
<mapper namespace="com.example.mapper.UserMapper">
  <resultMap id="userResult" type="com.example.User">
    <id column="id" property="id" />
    <result column="name" property="name" />
    <result column="email" property="email" />
    <collection property="orders" 
                select="getOrdersByUserId" 
                column="id" />
  </resultMap>
  
  <select id="getUserById" parameterType="Long" resultMap="userResult">
    SELECT * FROM users WHERE id = #{id}
  </select>
  
  <select id="getOrdersByUserId" parameterType="Long" resultType="Order">
    SELECT * FROM orders WHERE user_id = #{id}
  </select>
  
  <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO users (name, email) VALUES (#{name}, #{email})
  </insert>
</mapper>

// Java Interface
public interface UserMapper {
  User getUserById(Long id);
  void insertUser(User user);
}

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

Плюсы:

• Контроль над SQL
• Хорошо для сложных запросов
• Легко оптимизировать
• Dynamic SQL

Минусы:

• XML конфигурация
• Больше кода для маппинга
• Требует поддержки маппингов при изменении схемы

5. jOOQ (Java Object Oriented Querying)

Typed SQL Builder с типобезопасностью.

import static generated.Tables.*;
import org.jooq.*;

@Service
public class UserService {
  
  private final DSLContext dsl;
  
  public User getUserById(Long id) {
    return dsl.select(USERS.ID, USERS.NAME, USERS.EMAIL)
      .from(USERS)
      .where(USERS.ID.eq(id))
      .fetchOneInto(User.class);
  }
  
  public List<User> getActiveUsers() {
    return dsl.select(USERS.ID, USERS.NAME, USERS.EMAIL)
      .from(USERS)
      .where(USERS.STATUS.eq("ACTIVE"))
      .orderBy(USERS.CREATED_AT.desc())
      .fetch()
      .into(User.class);
  }
  
  public void createUser(String name, String email) {
    dsl.insertInto(USERS, USERS.NAME, USERS.EMAIL)
      .values(name, email)
      .execute();
  }
}

Плюсы:

• Type-safe SQL
• IDE автодополнение
• Легко читать и поддерживать
• Полный контроль над SQL
• Отличные для сложных запросов

Минусы:

• Требует code generation
• Кривая обучения
• Больше памяти чем JDBC

6. QueryDSL

Легкий type-safe query builder.

import com.querydsl.jpa.impl.JPAQueryFactory;

@Service
public class UserService {
  
  private final JPAQueryFactory queryFactory;
  
  public User getUserById(Long id) {
    return queryFactory
      .selectFrom(QUser.user)
      .where(QUser.user.id.eq(id))
      .fetchOne();
  }
  
  public List<User> searchUsers(String name, String status) {
    BooleanBuilder where = new BooleanBuilder();
    if (name != null) {
      where.and(QUser.user.name.containsIgnoreCase(name));
    }
    if (status != null) {
      where.and(QUser.user.status.eq(status));
    }
    
    return queryFactory
      .selectFrom(QUser.user)
      .where(where)
      .fetch();
  }
}

7. Liquibase и Flyway (Schema Management)

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

# Flyway: resources/db/migration/V1__Create_users_table.sql
CREATE TABLE users (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

# Автоматически применяется при запуске приложения

# Liquibase: db.changelog-master.xml
<databaseChangeLog>
  <changeSet id="1" author="dev">
    <createTable tableName="users">
      <column name="id" type="BIGSERIAL">
        <constraints primaryKey="true" />
      </column>
      <column name="name" type="VARCHAR(255)">
        <constraints nullable="false" />
      </column>
    </createTable>
  </changeSet>
</databaseChangeLog>

8. Reactive Database Access

Для асинхронного взаимодействия с БД.

import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface UserR2dbcRepository extends R2dbcRepository<User, Long> {
  Mono<User> findByEmail(String email);
  Flux<User> findByStatusOrderByCreatedAtDesc(String status);
}

@Service
public class UserService {
  
  private final UserR2dbcRepository userRepository;
  
  public Mono<User> getUser(Long id) {
    return userRepository.findById(id);
  }
  
  public Flux<User> getActiveUsers() {
    return userRepository.findByStatusOrderByCreatedAtDesc("ACTIVE")
      .take(100);  // Backpressure
  }
}

Плюсы:

• Non-blocking I/O
• Масштабируемость
• Меньше потоков

Минусы:

• Сложнее отладка
• Не все драйверы поддерживают
• Требует reactive мышления

9. Embedded БД (для тестов)

// H2 для тестов
@SpringBootTest
@TestPropertySource(properties = {
  "spring.datasource.url=jdbc:h2:mem:testdb",
  "spring.datasource.driver-class-name=org.h2.Driver",
  "spring.h2.console.enabled=true"
})
class UserRepositoryTest {
  
  @Autowired
  private UserRepository userRepository;
  
  @Test
  void shouldCreateUser() {
    User user = new User("John", "john@example.com");
    User saved = userRepository.save(user);
    assert saved.getId() != null;
  }
}

10. Connection Pooling

Управление пулом соединений - критично для производительности.

@Configuration
public class DataSourceConfig {
  
  @Bean
  public DataSource dataSource() {
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl("jdbc:postgresql://localhost/mydb");
    config.setUsername("user");
    config.setPassword("password");
    config.setMaximumPoolSize(20);  // Максимум соединений
    config.setMinimumIdle(5);        // Минимум соединений
    config.setConnectionTimeout(10000); // 10 секунд
    config.setIdleTimeout(600000);      // 10 минут
    config.setMaxLifetime(1800000);     // 30 минут
    
    return new HikariDataSource(config);
  }
}

Сравнение технологий

Рекомендации

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

• Standard CRUD операции
• Быстрая разработка важнее производительности
• Нужна портативность между БД

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

• Сложные запросы
• Максимальная производительность
• Полный контроль над SQL
• Большой объем данных

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

• Микро-оптимизация
• Встроенные или специализированные драйверы
• Batch операции

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

• Reactive приложения
• Высокая concurrency
• WebFlux приложения

Выбор технологии зависит от требований проекта, но Spring Data JPA - хороший выбор по умолчанию для большинства случаев!