如何处理JPA（标准和谓词）中的分页

Question

当我使用此代码时：

Page<Books> result1 = new PageImpl<>(result, sortOrder, total);

它不起作用，我想返回页面对象。任何帮助都将受到赞赏。

你可以尝试这个

private Page<Books> getFiltereBooks(Params params,
            Pageable pageable) {

        CriteriaBuilder builder =  em.getCriteriaBuilder();
        CriteriaQuery<Books> criteria = builder.createQuery(Books.class);
        Root<Books> booksRoot = criteria.from(Books.class);
        List<Predicate> predicates = new ArrayList<Predicate>();

        predicates.add(builder.equal(booksRoot.get("id"), params.getRequestId()));

        predicates.add(builder.like(builder.lower(booksRoot.get("name")), 
                    "%" + params.getName().toLowerCase() + "%"));

        criteria.where(builder.and(predicates.toArray( new Predicate[predicates.size()])));

        criteria.orderBy(builder.desc(booksRoot.get("id")));

        // This query fetches the Books as per the Page Limit
        List<Books> result = em.createQuery(criteria).setFirstResult((int) pageable.getOffset()).setMaxResults(pageable.getPageSize()).getResultList();

        // Create Count Query
        CriteriaQuery<Long> countQuery = builder.createQuery(Long.class);
        Root<Books> booksRootCount = countQuery.from(Books.class);
        countQuery.select(builder.count(booksRootCount)).where(builder.and(predicates.toArray(new Predicate[predicates.size()])));

        // Fetches the count of all Books as per given criteria
        Long count = em.createQuery(countQuery).getSingleResult();

        Page<Books> result1 = new PageImpl<>(result, pageable, count);
        return result1;
    }

Answer 1

Predicate[] getPredicate(Root<Entity> root, CriteriaBuilder criteriaBuilder, filter params) {
    Predicate[] predicatesArr = null;
    List<Predicate> predicates = new ArrayList<>();
    
    // fill your predicates list here

    predicatesArr = predicates.toArray(new Predicate[predicates.size()]);

    return predicatesArr;
}

您需要添加一种为每个查询创建谓词的方法，请注意，您正在使用相同的谓词列表“从不同查询中播放的diver of diver of diver of diver of diver of dive of dy dield” act of [分页和计数]

Answer 2

    Root<Books> booksRoot = criteria.from(Books.class);
    predicates.add(builder.equal(booksRoot.get("id"), params.getRequestId()));

您可以举以下示例：您需要做的是创建两个单独的查询，一个用于搜索，另一个用于count。

@Override
public Page<Offer> findOfferWithSearch(String strFilter, String keyWord, String loggedInId, Pageable paging, boolean isMarketOffers) {

    Map<String, String> filterValue = UtilityClass.extractFilterValues(strFilter);

    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

    // Build the main query for Offer records
    CriteriaQuery<Offer> criteriaQuery = criteriaBuilder.createQuery(Offer.class);

    // Create a separate count query to get the total number of matching records
    CriteriaQuery<Long> countQuery = criteriaBuilder.createQuery(Long.class);

    Root<Offer> offerRoot = criteriaQuery.from(Offer.class);
    Root<Offer> countOfferRoot = countQuery.from(Offer.class);
    countQuery.select(criteriaBuilder.countDistinct(countOfferRoot));

    criteriaQuery.distinct(true);
    countQuery.distinct(true);

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

    if (!isMarketOffers) {
        predicates.add(criteriaBuilder.equal(offerRoot.get("dtCreateBy"), loggedInId));
        countPredicates.add(criteriaBuilder.equal(countOfferRoot.get("dtCreateBy"), loggedInId));
    }
    predicates.add(criteriaBuilder.equal(offerRoot.get("isActive"), true));
    countPredicates.add(criteriaBuilder.equal(countOfferRoot.get("isActive"), true));

    // Add dropdown filter predicates using a stream
    Stream.of("currency", "against", "offerType")
            .filter(filterValue::containsKey)
            .forEach(key -> {
                predicates.add(criteriaBuilder.equal(offerRoot.get(key), filterValue.get(key)));
                countPredicates.add(criteriaBuilder.equal(countOfferRoot.get(key), filterValue.get(key)));
            });

    List<Predicate> searchPredicates = new ArrayList<>();
    List<Predicate> countSearchPredicates = new ArrayList<>();

    if (UtilityClass.isNumber(keyWord)) {
        try {
            BigDecimal numberValue = new BigDecimal(keyWord);
            // For integers, also check quantity
            if (numberValue.scale() == 0) {
                Long longValue = numberValue.longValueExact();
                searchPredicates.add(criteriaBuilder.equal(offerRoot.get("quantity"), longValue));
                countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("quantity"), longValue));
            }
            searchPredicates.add(criteriaBuilder.equal(offerRoot.get("amount"), numberValue));
            countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("amount"), numberValue));
            searchPredicates.add(criteriaBuilder.equal(offerRoot.get("rates"), numberValue));
            countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("rates"), numberValue));
            searchPredicates.add(criteriaBuilder.equal(offerRoot.get("netRate"), numberValue));
            countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("netRate"), numberValue));
            searchPredicates.add(criteriaBuilder.equal(offerRoot.get("spotRates"), numberValue));
            countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("spotRates"), numberValue));
            searchPredicates.add(criteriaBuilder.equal(offerRoot.get("inverseRates"), numberValue));
            countSearchPredicates.add(criteriaBuilder.equal(countOfferRoot.get("inverseRates"), numberValue));

        } catch (NumberFormatException | ArithmeticException e) {
            log.error("Ignore invalid or non-integer numbers");
        }
    } else {
        keyWord = keyWord.trim().toLowerCase();
        String likePattern = "%" + keyWord + "%";
        searchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(offerRoot.get("currency")), likePattern));
        searchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(offerRoot.get("against")), likePattern));
        searchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(offerRoot.get("offerType")), likePattern));
        countSearchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(countOfferRoot.get("currency")), likePattern));
        countSearchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(countOfferRoot.get("against")), likePattern));
        countSearchPredicates.add(criteriaBuilder.like(criteriaBuilder.lower(countOfferRoot.get("offerType")), likePattern));
    }
    predicates.add(criteriaBuilder.or(searchPredicates.toArray(new Predicate[0])));
    countPredicates.add(criteriaBuilder.or(countSearchPredicates.toArray(new Predicate[0])));

    criteriaQuery.where(predicates.toArray(new Predicate[0]));
    countQuery.where(countPredicates.toArray(new Predicate[0]));

    criteriaQuery.orderBy(criteriaBuilder.desc(offerRoot.get("id")));
    // Execute query for count
    Long totalRecords = entityManager.createQuery(countQuery).getSingleResult();
    // Execute the main query with pagination
    TypedQuery<Offer> typedQuery = entityManager.createQuery(criteriaQuery);
    typedQuery.setFirstResult((int) paging.getOffset());
    typedQuery.setMaxResults(paging.getPageSize());
    List<Offer> offerList = typedQuery.getResultList();

    return new PageImpl<>(offerList, paging, totalRecords);
}

Answer 3