Hibernate 6添加Predicate时抛出重复注册异常的原因及解决

import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.Order;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;

import com.abned.forms.GetAllForm;
import com.abned.forms.PaginationForm;
import com.abned.SortingForm;
import com.abned.forms.SortingForm.SortingDirection;

public abstract class GetAllService {
private final EntityManager em;
public GetAllService(EntityManager em) {
this.em = em;
}

public GetAllResponse<T> getAll(GetAllForm form) {
    final CriteriaBuilder cb = em.getCriteriaBuilder();
    final CriteriaQuery<T> cq = cb.createQuery(getEntityClass());
    final Root<T> query = buildRootQuery(cq);
    final List<Predicate> predicates = buildPredicates(cb, query, form);

    if (!predicates.isEmpty()) {
        cq.where(predicates.toArray(new Predicate[predicates.size()]));
    }
    cq.distinct(true);
    cq.orderBy(buildOrderBy(cb, query, form));
    
    final TypedQuery<T> typedQuery = em.createQuery(cq);
    buildPagination(form.getPagination(), typedQuery);
    addAdditionalBuiltins(form, typedQuery);

    final List<T> results = typedQuery.getResultList();
    return new GetAllResponse<T>(results, nbTotal(predicates));
}

protected Root<T> buildRootQuery(CriteriaQuery<T> cq) {
    return cq.from(getEntityClass());
}

protected Long nbTotal(final List<Predicate> predicates) {
    final CriteriaBuilder cb = em.getCriteriaBuilder();
    final CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
    final Root<T> query = countQuery.from(getEntityClass());
    if (!predicates.isEmpty()) {
        countQuery.where(predicates.toArray(new Predicate[0]));
    }
    final List<Long> totals = em.createQuery(countQuery.select(cb.countDistinct(query))).getResultList();
    if (!totals.isEmpty()) {
        return totals.get(0);
    }
    return 0L;
}

protected void buildPagination(PaginationForm pagination, TypedQuery<T> typedQuery) {
    if (pagination == null) {
        return;
    }
    if (null != pagination.getLimit() && pagination.getLimit() > 0) {
        if (null != pagination.getPage() && pagination.getPage() > 0) {
            typedQuery.setFirstResult((pagination.getPage().intValue() - 1) * pagination.getLimit());
        }
        typedQuery.setMaxResults(pagination.getLimit());
    }
}

protected void addAdditionalBuiltins(GetAllForm form, TypedQuery<T> typedQuery) {}

protected abstract List<Predicate> buildPredicates(CriteriaBuilder cb, Root<T> query, GetAllForm form);
protected abstract Class<T> getEntityClass();

protected Order[] buildOrderBy(CriteriaBuilder cb, Root<T> query, GetAllForm form) {
    final List<Order> orders = new ArrayList<>();
    final SortingForm orderBy = form.getSorting();
    if (orderBy != null) {
        final Expression<? extends Serializable> order = getOrderByExpression(query, orderBy);
        if (orderBy.getDir() == null || orderBy.getDir() == SortingDirection.ASC) {
            orders.add(cb.asc(order));
        } else {
            orders.add(cb.desc(order));
        }
    }
    return orders.toArray(new Order[orders.size()]);
}

protected Expression<? extends Serializable> getOrderByExpression(Root<T> query, SortingForm orderBy) {
    return query.get(orderBy.getColumn());
}

}

</details>

<details><summary>实现类GetAllExtractionTable代码</summary>
```java
import org.springframework.stereotype.Service;

import com.abned.entities.ExtractionTable;
import com.abned.forms.GetAllExtractionTableForm;
import com.abned.forms.GetAllForm;

import jakarta.persistence.EntityManager;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;

@Service
public class GetAllExtractionTable extends GetAllService<ExtractionTable> {
    public GetAllExtractionTable(EntityManager em) {
        super(em);
    }

    @Override
    protected List<Predicate> buildPredicates(CriteriaBuilder cb, Root<ExtractionTable> query, GetAllForm form) {
        final List<Predicate> predicates = new ArrayList<>();
        if (form instanceof GetAllExtractionTableForm) {
            final GetAllExtractionTableForm criteria = (GetAllExtractionTableForm) form;
            if (null != criteria.getOnglet()) {
                predicates.add(cb.equal(query.get("onglet"), criteria.getOnglet()));
            }
            if (null != criteria.getType()) {
                predicates.add(cb.equal(query.get("type"), criteria.getType()));
            }
            if (null != criteria.getIds() && !criteria.getIds().isEmpty()) {
                predicates.add(query.get("id").in(criteria.getIds()));
            }
        }
        return predicates;
    }

    @Override
    protected Class<ExtractionTable> getEntityClass() {
        return ExtractionTable.class;
    }
}