Как работаешь с реляционной базой в Java

Работа с реляционными базами данных в Java

Я работаю с реляционными БД в Java уже более 10 лет, используя различные подходы и инструменты. Расскажу о наиболее эффективных способах и best practices.

1. JDBC (Java Database Connectivity)

JDBC — это фундамент для работы с любой реляционной БД в Java. Это низкоуровневый API, предоставляющий прямой доступ к SQL запросам.

String url = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";

try (Connection conn = DriverManager.getConnection(url, username, password)) {
    String sql = "SELECT * FROM users WHERE id = ?";
    PreparedStatement stmt = conn.prepareStatement(sql);
    stmt.setInt(1, userId);
    
    ResultSet rs = stmt.executeQuery();
    while (rs.next()) {
        String name = rs.getString("name");
        String email = rs.getString("email");
    }
} catch (SQLException e) {
    e.printStackTrace();
}

Ключевые правила JDBC:

• Всегда используй PreparedStatement вместо Statement — защита от SQL инъекций
• Работай с try-with-resources — автоматическое закрытие ресурсов
• Избегай конкатенации строк в SQL запросах

2. ORM фреймворки (Hibernate, JPA)

JPA (Java Persistence API) и Hibernate — объектно-релационное отображение. Таблицы БД представлены как объекты Java.

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name", nullable = false)
    private String name;
    
    @Column(name = "email", 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);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(String name, String email) {
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        return userRepository.save(user);
    }
}

Преимущества ORM: меньше SQL кода, удобная объектная модель, автоматическое управление связями.

Недостатки: N+1 queries, сложнее отлаживать, overhead для простых случаев.

3. Работа с транзакциями

Транзакции обеспечивают ACID свойства — атомарность, консистентность, изоляцию и долговечность.

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public Order createOrder(Long userId, List<OrderItem> items) {
        Order order = new Order();
        order.setUserId(userId);
        order.setItems(items);
        Order savedOrder = orderRepository.save(order);
        
        Payment payment = new Payment();
        payment.setOrderId(savedOrder.getId());
        paymentRepository.save(payment);
        
        return savedOrder;
    }
}

Если возникнет исключение, вся операция откатится (rollback).

4. Connection Pooling

Connection Pool — пул переиспользуемых подключений. Критично для production!

@Configuration
public class DataSourceConfig {
    @Bean
    public HikariConfig hikariConfig() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000);
        return config;
    }
}

5. Query Performance Optimization

Оптимизация запросов — критически важна для приложения.

// Плохо: N+1 problem
List<User> users = userRepository.findAll();
for (User user : users) {
    List<Post> posts = postRepository.findByUserId(user.getId());
}

// Хорошо: Eager loading
@Query("SELECT u FROM User u LEFT JOIN FETCH u.posts")
List<User> findAllWithPosts();

// Или через EntityGraph
@EntityGraph(attributePaths = {"posts"})
List<User> findAll();

Техники оптимизации:

• Indexing — индексы на часто используемые поля
• Query analysis — использование EXPLAIN для анализа
• Caching — кеширование часто запрашиваемых данных
• Batch operations — пакетные операции вместо один-за-одним

6. Миграции БД

Flyway и Liquibase — версионирование схемы БД.

// application.yml
spring:
  flyway:
    locations: classpath:db/migration
    baselineOnMigrate: true

-- V1__Create_users_table.sql
CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL
);

7. Best Practices

• Используй connection pooling в production (HikariCP)
• **Избегай SELECT *** — явно указывай нужные поля
• Установи правильные timeouts для избежания зависания
• Монитори slow queries через логирование
• Используй индексы на foreign key колонки
• Нормализуй схему (обычно до 3NF)
• Регулярно делай backup'ы БД

В реальных проектах я комбинирую подходы: JDBC для сложных аналитических запросов, JPA/Hibernate для основного CRUD, специализированные инструменты для высоконагруженных систем.