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實現復雜查詢。