Как JPA репозиторий обрабатывает созданные методы, если их реализация создаётся динамически при запуске

# Как JPA репозиторий обрабатывает методы с динамической реализацией

Основной механизм: Dynamic Proxy + Method Interception

Spring Data JPA использует Dynamic Proxy для создания реализации репозиториев во время запуска. Это происходит через комбинацию нескольких механизмов:

1. Интерфейс репозитория

public interface UserRepository extends JpaRepository<User, Long> {
    // Методы из JpaRepository реализуются автоматически
    // Кастомные методы тоже обрабатываются динамически
    User findByUsername(String username);
    List<User> findByAgeGreaterThan(int age);
    User findByEmailAndActive(String email, boolean active);
}

2. Процесс создания Dynamic Proxy

Этап 1: Регистрация

Во время запуска Spring сканирует приложение и находит интерфейсы, расширяющие Repository:

@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
public class RepositoryConfiguration {
    // Spring Data JPA автоматически находит все Repository интерфейсы
}

Этап 2: Анализ методов

Для каждого метода Spring Data JPA:

1. Парсит имя метода — анализирует название по специальным ключевым словам
2. Определяет параметры — какие поля используются для поиска
3. Генерирует запрос — создаёт SQL на основе анализа

// Метод: findByAgeGreaterThanAndLastNameContaining
// Парсинг:
// - find         → SELECT
// - By           → WHERE
// - Age          → поле age
// - GreaterThan  → оператор >
// - And          → логический AND
// - LastName     → поле lastName
// - Containing   → оператор LIKE

// Результирующий SQL:
// SELECT * FROM users WHERE age > ? AND last_name LIKE ?

3. Динамическое создание реализации

Spring использует Java Dynamic Proxy API (Proxy, InvocationHandler) или CGLIB для создания реализации:

public class ProxyBasedUserRepository {
    // Псевдокод: как примерно работает
    
    private static class RepositoryProxy implements InvocationHandler {
        private final EntityManager entityManager;
        private final QueryMethod queryMethod;
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) {
            // Обработка методов JpaRepository
            if (method.getName().equals("save")) {
                return entityManager.persist(args[0]);
            }
            
            // Обработка кастомных методов
            if (method.getName().equals("findByUsername")) {
                String username = (String) args[0];
                return entityManager.createQuery(
                    "SELECT u FROM User u WHERE u.username = :username"
                ).setParameter("username", username).getSingleResult();
            }
            
            return null;
        }
    }
}

4. Реальный пример из Spring Data JPA

Query Method

public interface ProductRepository extends JpaRepository<Product, Long> {
    // 1. Simple property
    Product findByName(String name);
    
    // 2. Complex property expressions
    List<Product> findByCategory_Name(String categoryName);
    
    // 3. Multiple conditions
    List<Product> findByPriceGreaterThanAndCategoryName(
        BigDecimal price, 
        String categoryName
    );
    
    // 4. Sorting
    List<Product> findByPriceGreaterThan(BigDecimal price, Sort sort);
    
    // 5. Pagination
    Page<Product> findByActive(boolean active, Pageable pageable);
}

Использование

@Service
public class ProductService {
    @Autowired
    private ProductRepository repository;
    
    public Product getProduct(String name) {
        // Spring вызывает динамически созданный метод
        return repository.findByName(name);
    }
    
    public List<Product> getExpensiveProducts(BigDecimal price) {
        // Spring генерирует SQL: 
        // SELECT p FROM Product p WHERE p.price > :price AND p.category.name = :categoryName
        return repository.findByPriceGreaterThanAndCategoryName(price, "Electronics");
    }
}

5. @Query аннотация для большей контроля

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

public interface UserRepository extends JpaRepository<User, Long> {
    // Spring парсит имя метода → генерирует SQL
    User findByUsername(String username);
    
    // Явный JPQL запрос
    @Query("SELECT u FROM User u WHERE u.username = ?1 AND u.active = true")
    User findActiveByUsername(String username);
    
    // Native SQL
    @Query(value = "SELECT * FROM users WHERE email = ?1", nativeQuery = true)
    User findByEmail(String email);
    
    // С параметрами
    @Query("SELECT u FROM User u WHERE u.age > :minAge AND u.status = :status")
    List<User> findByAgeAndStatus(@Param("minAge") int age, @Param("status") String status);
}

6. Ключевые моменты обработки

Query Method Keywords

// Ключевые слова для парсинга названия метода:
findBy         // SELECT
countBy        // COUNT
existsBy       // EXISTS
deleteBy       // DELETE
readBy         // SELECT (alias для find)

// Операторы:
GreaterThan    // >
LessThan       // <
Equals         // =
Containing     // LIKE
Between        // BETWEEN
In             // IN
Like           // LIKE

Порядок создания

1. Spring сканирует бины → находит interfaces, расширяющие Repository
2. Для каждого интерфейса создаёт RepositoryFactory
3. RepositoryFactory анализирует методы интерфейса
4. Использует QueryLookupStrategy для определения реализации
5. Генерирует реализацию используя Dynamic Proxy
6. Регистрирует бин в ApplicationContext

7. Под капотом: QueryMethodEvaluationContextProvider

// Spring Data JPA использует компоненты вроде:
// - QueryMethodEvaluationContextProvider
// - RepositoryFactorySupport
// - QueryMethodInvoker
// - PartTreeJpaQuery (парсер Query Method)

public class PartTreeJpaQuery {
    // Парсит метод вроде findByAgeGreaterThanAndLastNameContaining
    // и создаёт tree из Parts:
    // find + By + Age + GreaterThan + And + LastName + Containing
    // ↓
    // Part 1: age > ?
    // Part 2: lastName LIKE ?
}

Вывод

Spring Data JPA обрабатывает Query Methods через:

1. Анализ имени метода — парсинг по ключевым словам
2. Динамическое создание прокси — через Java Proxy или CGLIB
3. Генерацию запросов — создание SQL/JPQL на основе анализа
4. Инвокацию — перехват вызовов и выполнение сгенерированного запроса
5. Кэширование — результаты анализа кэшируются для производительности

Это позволяет разработчикам писать понятные и типобезопасные методы без явного написания SQL.