JPA Criteria API：实现复杂多条件查询与高效分页

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name = "employees")
public class EmployeeEntity implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "employee_type_id")
    private EmployeeType type; // 关联到 EmployeeType 实体

    private String name;

    // 构造函数
    public EmployeeEntity() {}

    public EmployeeEntity(EmployeeType type, String name) {
        this.type = type;
        this.name = name;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public EmployeeType getType() { return type; }
    public void setType(EmployeeType type) { this.type = type; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    @Override
    public String toString() {
        return "EmployeeEntity{" +
               "id=" + id +
               ", type=" + (type != null ? type.getName() : "null") +
               ", name='" + name + '\'' +
               '}';
    }
}

@Entity
@Table(name = "employee_types")
class EmployeeType implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name; // 例如："Teachers", "Carers"

    // 构造函数
    public EmployeeType() {}

    public EmployeeType(String name) {
        this.name = name;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    @Override
    public String toString() {
        return "EmployeeType{" +
               "id=" + id +
               ", name='" + name + '\'' +
               '}';
    }
}

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;

public class EmployeeRepositoryCriteria {

    public List<EmployeeEntity> findEmployeesByCriteria(
            String typeName1, String typeName2, String nameFilter,
            int pageNumber, int pageSize, EntityManager entityManager) {

        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<EmployeeEntity> cq = cb.createQuery(EmployeeEntity.class);
        Root<EmployeeEntity> employee = cq.from(EmployeeEntity.class);

        List<Predicate> predicates = new ArrayList<>();

        // 1. 添加员工类型筛选条件 (模拟“联合”效果：typeName1 或 typeName2)
        // 注意：这里假设type是一个关联实体，通过join来访问其属性
        Join<EmployeeEntity, EmployeeType> employeeTypeJoin = employee.join("type", JoinType.INNER);

        Predicate typePredicate1 = cb.equal(employeeTypeJoin.get("name"), typeName1);
        Predicate typePredicate2 = cb.equal(employeeTypeJoin.get("name"), typeName2);

        // 使用 cb.or() 实现逻辑 OR，即员工类型是 typeName1 或 typeName2
        predicates.add(cb.or(typePredicate1, typePredicate2));

        // 2. 添加员工名称模糊筛选条件
        if (nameFilter != null && !nameFilter.trim().isEmpty()) {
            predicates.add(cb.like(employee.get("name"), "%" + nameFilter.trim() + "%"));
        }

        // 组合所有条件
        if (!predicates.isEmpty()) {
            cq.where(cb.and(predicates.toArray(new Predicate[0])));
        }

        // 添加排序
        cq.orderBy(cb.asc(employee.get("name")));

        // 创建TypedQuery
        TypedQuery<EmployeeEntity> query = entityManager.createQuery(cq);

        // 设置分页参数
        query.setFirstResult(pageNumber * pageSize); // 起始索引
        query.setMaxResults(pageSize);               // 每页最大记录数

        return query.getResultList();
    }

    // 为了获取总记录数，通常需要另一个CriteriaQuery
    public long countEmployeesByCriteria(
            String typeName1, String typeName2, String nameFilter,
            EntityManager entityManager) {

        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Long> countCq = cb.createQuery(Long.class);
        Root<EmployeeEntity> employee = countCq.from(EmployeeEntity.class);
        countCq.select(cb.count(employee)); // 选择计数

        List<Predicate> predicates = new ArrayList<>();

        Join<EmployeeEntity, EmployeeType> employeeTypeJoin = employee.join("type", JoinType.INNER);
        Predicate typePredicate1 = cb.equal(employeeTypeJoin.get("name"), typeName1);
        Predicate typePredicate2 = cb.equal(employeeTypeJoin.get("name"), typeName2);
        predicates.add(cb.or(typePredicate1, typePredicate2));

        if (nameFilter != null && !nameFilter.trim().isEmpty()) {
            predicates.add(cb.like(employee.get("name"), "%" + nameFilter.trim() + "%"));
        }

        if (!predicates.isEmpty()) {
            countCq.where(cb.and(predicates.toArray(new Predicate[0])));
        }

        return entityManager.createQuery(countCq).getSingleResult();
    }
}