Как можно совместить базу данных и приложение в Java?

# Интеграция базы данных и Java приложения

Основные подходы к работе с БД

В Java существуют несколько уровней абстракции для работы с базами данных, от низкоуровневого JDBC до высокоуровневых ORM фреймворков.

1. JDBC (Java Database Connectivity)

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

import java.sql.*;

public class UserDAO {
    private static final String JDBC_URL = "jdbc:postgresql://localhost:5432/mydb";
    private static final String USER = "postgres";
    private static final String PASSWORD = "password";
    
    public List<User> getAllUsers() throws SQLException {
        List<User> users = new ArrayList<>();
        String sql = "SELECT id, name, email FROM users";
        
        try (Connection conn = DriverManager.getConnection(JDBC_URL, USER, PASSWORD);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            
            while (rs.next()) {
                users.add(new User(
                    rs.getLong("id"),
                    rs.getString("name"),
                    rs.getString("email")
                ));
            }
        }
        return users;
    }
    
    public void insertUser(User user) throws SQLException {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        
        try (Connection conn = DriverManager.getConnection(JDBC_URL, USER, PASSWORD);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            pstmt.setString(1, user.getName());
            pstmt.setString(2, user.getEmail());
            pstmt.executeUpdate();
        }
    }
}

Плюсы:

• Полный контроль над SQL
• Высокая производительность
• Работает везде

Минусы:

• Много boilerplate кода
• Утечки ресурсов если не закрывать соединения
• Маппинг результатов вручную

2. Connection Pooling (важно для production)

Вместо создания нового соединения для каждого запроса, используем пул.

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class DatabaseConfig {
    private static HikariDataSource dataSource;
    
    public static DataSource getDataSource() {
        if (dataSource == null) {
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
            config.setUsername("postgres");
            config.setPassword("password");
            config.setMaximumPoolSize(10);
            config.setMinimumIdle(2);
            config.setConnectionTimeout(10000);
            config.setIdleTimeout(600000);
            config.setMaxLifetime(1800000);
            
            dataSource = new HikariDataSource(config);
        }
        return dataSource;
    }
}

// Использование
DataSource ds = DatabaseConfig.getDataSource();
try (Connection conn = ds.getConnection()) {
    // Работа с БД
}

Параметры HikariCP:

• maximumPoolSize: максимум соединений в пуле (10-20)
• minimumIdle: минимум idle соединений
• connectionTimeout: таймаут получения соединения
• idleTimeout: максимум времени idle соединения

3. JPA/Hibernate (ORM)

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

import javax.persistence.*;

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

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByDepartment(Department department);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email).orElse(null);
    }
    
    @Transactional
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

persistence.xml конфигурация:

<persistence>
    <persistence-unit name="default">
        <provider>org.hibernate.jpa.HibernatePeristenceProvider</provider>
        <class>com.example.User</class>
        <properties>
            <property name="jakarta.persistence.jdbc.driver" value="org.postgresql.Driver"/>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/mydb"/>
            <property name="jakarta.persistence.jdbc.user" value="postgres"/>
            <property name="jakarta.persistence.jdbc.password" value="password"/>
            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQL10Dialect"/>
            <property name="hibernate.hbm2ddl.auto" value="validate"/>
            <property name="hibernate.show_sql" value="false"/>
        </properties>
    </persistence-unit>
</persistence>

4. Spring Data JPA (рекомендуется)

Высокоуровневая абстракция над JPA с автоматической генерацией CRUD операций.

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// application.properties
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=password
spring.datasource.hikari.maximum-pool-size=10
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContainingIgnoreCase(String name);
    Page<User> findByDepartment(Department dept, Pageable pageable);
    
    @Query("SELECT u FROM User u WHERE u.email = :email AND u.active = true")
    Optional<User> findActiveUserByEmail(@Param("email") String email);
    
    @Modifying
    @Transactional
    @Query("UPDATE User u SET u.lastLogin = CURRENT_TIMESTAMP WHERE u.id = :id")
    void updateLastLogin(@Param("id") Long id);
}

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    @Autowired
    private UserRepository userRepository;
    
    @GetMapping("/{email}")
    public ResponseEntity<User> getUser(@PathVariable String email) {
        return ResponseEntity.ok(userRepository.findByEmail(email).orElseThrow());
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        return ResponseEntity.status(HttpStatus.CREATED).body(userRepository.save(user));
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
        return ResponseEntity.noContent().build();
    }
}

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

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

<!-- pom.xml -->
<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
    <version>9.16.0</version>
</dependency>

-- src/main/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
);

CREATE INDEX idx_email ON users(email);

# application.properties
spring.flyway.locations=classpath:db/migration
spring.flyway.baseline-on-migrate=true

6. Трансакции и обработка ошибок

@Service
@Transactional
public class TransferService {
    @Autowired
    private AccountRepository accountRepository;
    
    @Transactional
    public void transferMoney(Long fromId, Long toId, BigDecimal amount) throws InsufficientFundsException {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();
        
        if (from.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException("Insufficient balance");
        }
        
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        
        accountRepository.save(from);
        accountRepository.save(to);
    }
}

Выбор подхода

Best Practices

1. Используй Connection Pooling - HikariCP в production
2. Параметризованные запросы - защита от SQL injection
3. Кэширование - Redis/Memcached для часто используемых данных
4. Индексы - на полях в WHERE, JOIN, ORDER BY
5. Lazy loading vs Eager loading - выбирай в зависимости от случая
6. Мониторинг slow queries - включай логирование медленных запросов
7. Batch операции - для bulk insert/update
8. Read replicas - для масштабирования чтения