Spring Boot中Spring Data JPA复杂查询

在Spring Boot中，使用Spring Data JPA进行复杂查询非常简单。Spring Data JPA是基于JPA的一个持久层框架，它提供了一种更简洁、更快速的方式来操作数据库。要实现复杂查询，你可以使用以下方法：

1. 方法命名查询：

在Repository接口中，你可以通过定义方法名来实现复杂查询。方法名应该根据查询的需求来命名。例如：

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByLastName(String lastName);
    User findByFirstNameAndLastName(String firstName, String lastName);
}

2. 使用@Query注解：

你可以在Repository接口中使用@Query注解来编写自定义的JPQL（Java Persistence Query Language）查询。例如：

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.email = ?1")
    User findByEmail(String email);

    @Query("SELECT u FROM User u WHERE u.age BETWEEN ?1 AND ?2")
    List<User> findByAgeBetween(int startAge, int endAge);
}

3. 使用Criteria API：

Criteria API是一种类型安全的查询API，它允许你构建复杂的查询。首先，你需要在Repository接口中添加一个方法，该方法返回一个CriteriaBuilder实例：

public interface UserRepository extends JpaRepository<User, Long> {
    CriteriaBuilder criteriaBuilder();
}

然后，在你的服务类中，你可以使用Criteria API构建复杂查询：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> findUsersByAgeAndCity(int age, String city) {
        CriteriaBuilder criteriaBuilder = userRepository.criteriaBuilder();
        CriteriaQuery<User> criteriaQuery = criteriaBuilder.createQuery(User.class);
        Root<User> userRoot = criteriaQuery.from(User.class);

        List<Predicate> predicates = new ArrayList<>();
        predicates.add(criteriaBuilder.equal(userRoot.get("age"), age));
        predicates.add(criteriaBuilder.equal(userRoot.get("city"), city));

        criteriaQuery.where(predicates.toArray(new Predicate[0]));
        return userRepository.findAll(criteriaQuery);
    }
}

4. 使用Spring Data JPA的 Specification接口：

Specification接口允许你编写动态查询。首先，你需要创建一个实现Specification接口的类，然后在该类中编写查询条件：

public class UserSpecification implements Specification<User> {
    private SearchCriteria searchCriteria;

    public UserSpecification(SearchCriteria searchCriteria) {
        this.searchCriteria = searchCriteria;
    }

    @Override
    public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
        switch (searchCriteria.getOperation()) {
            case EQUAL:
                return builder.equal(root.get(searchCriteria.getKey()), searchCriteria.getValue());
            case GREATER_THAN:
                return builder.greaterThanOrEqualTo(root.get(searchCriteria.getKey()), (Comparable) searchCriteria.getValue());
            // 其他操作...
            default:
                return null;
        }
    }
}

然后，在你的Repository接口中，添加一个方法，该方法接受一个Specification实例：

public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
}

最后，在你的服务类中，使用Specification实例构建复杂查询：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> findUsersByAgeAndCity(int age, String city) {
        SearchCriteria searchCriteria = new SearchCriteria();
        searchCriteria.setKey("age");
        searchCriteria.setValue(age);
        searchCriteria.setOperation(SearchCriteria.Operation.EQUAL);

        SearchCriteria cityCriteria = new SearchCriteria();
        cityCriteria.setKey("city");
        cityCriteria.setValue(city);
        cityCriteria.setOperation(SearchCriteria.Operation.EQUAL);

        UserSpecification specification = new UserSpecification(searchCriteria);
        specification = Specification.where(specification).and(new UserSpecification(cityCriteria));

        return userRepository.findAll(specification);
    }
}

通过以上方法，你可以在Spring Boot中使用Spring Data JPA实现复杂查询。