С помощью какой сущности можно выполнить запрос в базе данных

С помощью какой сущности можно выполнить запрос в базе данных

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

1. JDBC Connection (низкоуровневый подход)

Это самый низкоуровневый способ, где ты работаешь непосредственно с подключением и SQL:

import java.sql.*;

public class JdbcExample {
    public void queryDatabase() throws SQLException {
        // Получаем Connection из пула
        Connection conn = DriverManager.getConnection(
            "jdbc:postgresql://localhost:5432/mydb",
            "user",
            "password"
        );
        
        try {
            // 1. Создаем Statement
            String sql = "SELECT id, name, email FROM users WHERE age > ?";
            PreparedStatement stmt = conn.prepareStatement(sql);
            stmt.setInt(1, 18);
            
            // 2. Выполняем запрос
            ResultSet rs = stmt.executeQuery();
            
            // 3. Обрабатываем результаты
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                System.out.println(name + " (" + email + ")");
            }
            
            // Закрываем ресурсы (важно!)
            rs.close();
            stmt.close();
        } finally {
            conn.close();
        }
    }
}

Преимущества:

• Полный контроль над SQL
• Максимальная производительность
• Понимание того, что происходит

Недостатки:

• Много boilerplate кода
• Управление ресурсами вручную
• Уязвимость к SQL injection (если не использовать PreparedStatement)
• Нет типизации

2. JdbcTemplate (Spring)

Spring предоставляет удобный wrapper для работы с JDBC:

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    private final JdbcTemplate jdbcTemplate;
    
    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    // Запрос с возвращением одного значения
    public int getUserCount() {
        return jdbcTemplate.queryForObject(
            "SELECT COUNT(*) FROM users",
            Integer.class
        );
    }
    
    // Запрос с параметрами
    public List<User> findUsersByAge(int minAge) {
        String sql = "SELECT id, name, email, age FROM users WHERE age > ? ORDER BY name";
        
        return jdbcTemplate.query(
            sql,
            new Object[]{minAge},
            new RowMapper<User>() {
                @Override
                public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                    return new User(
                        rs.getInt("id"),
                        rs.getString("name"),
                        rs.getString("email"),
                        rs.getInt("age")
                    );
                }
            }
        );
    }
    
    // Запрос с использованием lambda (Java 8+)
    public User findUserById(int id) {
        String sql = "SELECT id, name, email, age FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(
            sql,
            new Object[]{id},
            (rs, rowNum) -> new User(
                rs.getInt("id"),
                rs.getString("name"),
                rs.getString("email"),
                rs.getInt("age")
            )
        );
    }
    
    // Вставка данных
    public int createUser(String name, String email, int age) {
        String sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
        return jdbcTemplate.update(sql, name, email, age);
    }
    
    // Batch операции
    public int[] batchCreateUsers(List<User> users) {
        String sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
        
        return 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());
                ps.setInt(3, user.getAge());
            }
            
            @Override
            public int getBatchSize() {
                return users.size();
            }
        });
    }
}

Преимущества:

• Управление ресурсами автоматическое
• Меньше boilerplate кода
• Типизированные параметры
• Хорошая производительность

Недостатки:

• По-прежнему много SQL вручную
• Нужно вручную маппировать результаты
• Нет ORM преимуществ

3. JPA/Hibernate (ORM)

Объектно-реляционное отображение — наиболее абстрактный подход:

import javax.persistence.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

// Сущность
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @Column(nullable = false)
    private Integer age;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Post> posts;
    
    // Getters и setters...
}

// Repository
@Repository
public interface UserRepository extends JpaRepository<User, Integer> {
    
    // Метод-запрос по названию
    List<User> findByAgeGreaterThan(int age);
    
    // Более сложный запрос
    List<User> findByNameContainingIgnoreCaseAndAgeGreaterThan(String name, int age);
    
    // JPQL запрос (HQL)
    @Query("SELECT u FROM User u WHERE u.age > :minAge ORDER BY u.name")
    List<User> findAdultUsers(@Param("minAge") int minAge);
    
    // Native SQL запрос
    @Query(value = """
        SELECT u.* FROM users u 
        WHERE u.age > :age 
        AND u.email LIKE :emailPattern
        """, nativeQuery = true)
    List<User> findWithNativeQuery(
        @Param("age") int age,
        @Param("emailPattern") String emailPattern
    );
    
    // Кастомный метод с сложной логикой
    @Query("""
        SELECT u FROM User u 
        LEFT JOIN FETCH u.posts
        WHERE u.age > :age
    """)
    List<User> findWithPostsEagerLoaded(@Param("age") int age);
}

// Использование
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> getAdultUsers() {
        // Простой запрос — автоматическое SQL генерируется
        return userRepository.findByAgeGreaterThan(18);
    }
    
    public List<User> searchUsers(String name, int minAge) {
        // Сложный запрос
        return userRepository.findByNameContainingIgnoreCaseAndAgeGreaterThan(
            name, minAge
        );
    }
    
    public List<User> getAdultUsersCustom() {
        // Кастомный JPQL запрос
        return userRepository.findAdultUsers(18);
    }
}

4. Spring Data JPA QueryDSL (типизированные запросы)

Для более типизированных и безопасных запросов:

import com.querydsl.core.types.Predicate;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;

@Repository
public interface UserRepository extends 
    JpaRepository<User, Integer>,
    QuerydslPredicateExecutor<User> {
}

// Использование с QueryDSL
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> findUsers(String name, int minAge) {
        QUser user = QUser.user;
        
        // Типизированный запрос — ошибки выявляются на этапе компиляции!
        Predicate predicate = user.age.gt(minAge)
            .and(user.name.containsIgnoreCase(name));
        
        return userRepository.findAll(predicate);
    }
}

5. Сравнительная таблица

6. Практический пример: выбор инструмента

// Сценарий 1: Быстрый отчет, выполняемый раз в день
// → Используй JDBC/JdbcTemplate
public void generateDailyReport() {
    String sql = """SELECT DATE(created_at) as date, COUNT(*) as count
                     FROM orders GROUP BY DATE(created_at)""";
    List<Map<String, Object>> results = jdbcTemplate.queryForList(sql);
}

// Сценарий 2: REST API для основных операций CRUD
// → Используй Spring Data JPA
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public User getUserById(Integer id) {
        return userRepository.findById(id).orElseThrow();
    }
}

// Сценарий 3: Сложные фильтры с динамическими условиями
// → Используй QueryDSL или Specifications
public List<User> advancedSearch(UserFilter filter) {
    Predicate predicate = buildPredicate(filter);
    return userRepository.findAll(predicate);
}

// Сценарий 4: Очень высокие требования к производительности
// → Используй JDBC + кеширование
public List<User> getPopularUsers() {
    // Кешируется на 1 час, выполняется нативный SQL
    return cacheManager.get("popular_users", () -> 
        jdbcTemplate.query(...)
    );
}

Лучшие практики

1. Используй Spring Data JPA для 80% запросов — это оптимальный баланс
2. JDBC только для критичных по производительности операций
3. Всегда используй PreparedStatement чтобы избежать SQL injection
4. Избегай N+1 проблемы с FETCH JOIN или @EntityGraph
5. Мониторь медленные запросы с помощью Spring Boot Actuator
6. Используй Flyway или Liquibase для миграций, не Hibernate auto-ddl

Итог: выбирай инструмент в зависимости от сложности задачи. Spring Data JPA — универсальный выбор для большинства случаев, но знай альтернативы для специфичных задач.