How to use

Page

in

org.springframework.data.domain

/**
 * 返回分页成功数据
 */
public CommonResult pageSuccess(Page pageInfo) {
  Map<String, Object> result = new HashMap<>();
  result.put("pageSize", pageInfo.getSize());
  result.put("totalPage", pageInfo.getTotalPages());
  result.put("total", pageInfo.getTotalElements());
  result.put("pageNum", pageInfo.getNumber());
  result.put("list", pageInfo.getContent());
  this.code = SUCCESS;
  this.message = "操作成功";
  this.data = result;
  return this;
}

private PageDTO<ReleaseHistoryDTO> transform2PageDTO(Page<ReleaseHistory> releaseHistoriesPage, Pageable pageable){
 if (!releaseHistoriesPage.hasContent()) {
  return null;
 }
 List<ReleaseHistory> releaseHistories = releaseHistoriesPage.getContent();
 List<ReleaseHistoryDTO> releaseHistoryDTOs = new ArrayList<>(releaseHistories.size());
 for (ReleaseHistory releaseHistory : releaseHistories) {
  releaseHistoryDTOs.add(transformReleaseHistory2DTO(releaseHistory));
 }
 return new PageDTO<>(releaseHistoryDTOs, pageable, releaseHistoriesPage.getTotalElements());
}

@Override
public <T> T queryForObject(CriteriaQuery query, Class<T> clazz) {
  Page<T> page = queryForPage(query, clazz);
  Assert.isTrue(page.getTotalElements() < 2, "Expected 1 but found " + page.getTotalElements() + " results");
  return page.getTotalElements() > 0 ? page.getContent().get(0) : null;
}

public PlatformPageImpl(Page page) {
  super(page.getContent(),
      new PageRequest(page.getNumber(), page.getSize(), page.getSort()),
      page.getTotalElements());
  this.number = page.getNumber();
  this.size = page.getSize();
  this.totalPages = page.getTotalPages();
  this.numberOfElements = page.getNumberOfElements();
  this.totalElements = page.getTotalElements();
  this.first = page.isFirst();
  this.last = page.isLast();
  this.content = page.getContent();
  this.sort = page.getSort();
}

private PublicationStatsImport getLastImportByType(StatisticType statisticType) {
  Pageable pageable = new PageRequest(0, 1, Direction.DESC, "collectionDate");
  Page<PublicationStatsImport> imports = importRepository.getImportsByType(statisticType, pageable);
  if (imports.getTotalElements() == 0) {
    return null;
  }
  PublicationStatsImport lastImport = imports.getContent().get(0);
  return lastImport;
}

public List<Post> getArchivePosts() {
  log.debug("Get all archive posts from database.");
  Pageable page = new PageRequest(0, Integer.MAX_VALUE, Sort.Direction.DESC, "createdAt");
  return postRepository.findAllByPostTypeAndPostStatus(PostType.POST, PostStatus.PUBLISHED, page)
      .getContent()
      .stream()
      .map(this::extractPostMeta)
      .collect(Collectors.toList());
}

  private Page<Violation> mapBackendToFrontendViolations(final Page<ViolationEntity> backendViolations) {
    final PageRequest currentPageRequest = new PageRequest(
        backendViolations.getNumber(),
        backendViolations.getSize(),
        backendViolations.getSort());
    return new PageImpl<>(
        backendViolations.getContent().stream().map(entityToDto::convert).collect(toList()),
        currentPageRequest,
        backendViolations.getTotalElements());
  }
}

/**
 * Performs the actual reading of a page via the repository.
 * Available for overriding as needed.
 *
 * @return the list of items that make up the page
 * @throws Exception Based on what the underlying method throws or related to the
 *             calling of the method
 */
@SuppressWarnings("unchecked")
protected List<T> doPageRead() throws Exception {
  Pageable pageRequest = PageRequest.of(page, pageSize, sort);
  MethodInvoker invoker = createMethodInvoker(repository, methodName);
  List<Object> parameters = new ArrayList<>();
  if(arguments != null && arguments.size() > 0) {
    parameters.addAll(arguments);
  }
  parameters.add(pageRequest);
  invoker.setArguments(parameters.toArray());
  Page<T> curPage = (Page<T>) doInvoke(invoker);
  return curPage.getContent();
}

public List<App> findAll(Pageable pageable) {
 Page<App> page = appRepository.findAll(pageable);
 return page.getContent();
}

@Override
public Collection<T> getNext() {
  if (currentPage < 0) {
    return null;
  }
  Page<T> page = getNextPage(new PageRequest(currentPage, maxResults), repo);
  currentPage++;
  if (page.getTotalPages() == currentPage) {
    currentPage = -1;
  }
  return page.getContent();
}

@Override
public Page<Rating> findByApiPageable(final String api, final Pageable pageable) throws TechnicalException {
  LOGGER.debug("Find rating by api [{}] with pagination", api);
  final org.springframework.data.domain.Page<RatingMongo> ratingPageMongo =
      internalRatingRepository.findByApi(api, new PageRequest(pageable.pageNumber(), pageable.pageSize(), Sort.Direction.DESC, "createdAt"));
  final List<Rating> ratings = ratingPageMongo.getContent().stream().map(this::map).collect(toList());
  final Page<Rating> ratingPage = new Page<>(ratings, ratingPageMongo.getNumber(), ratingPageMongo.getNumberOfElements(), ratingPageMongo.getTotalElements());
  LOGGER.debug("Find rating by api [{}] with pagination - DONE", api);
  return ratingPage;
}

private void populateTargetFilterQuery(final Rollout rollout) {
  final Page<TargetFilterQuery> filterQueries = targetFilterQueryManagement.findByQuery(PageRequest.of(0, 1),
      rollout.getTargetFilterQuery());
  if (filterQueries.getTotalElements() > 0) {
    final TargetFilterQuery filterQuery = filterQueries.getContent().get(0);
    targetFilterQueryCombo.setValue(filterQuery.getName());
  }
}

private void resultPrint(Specification<MyOrder> spec) {
  //分页查询
  Pageable pageable = new PageRequest(0, 10, Sort.Direction.DESC, "id");
  //查询的分页结果
  Page<MyOrder> page = myOrderRepository.findAll(spec, pageable);
  System.out.println(page);
  System.out.println(page.getTotalElements());
  System.out.println(page.getTotalPages());
  for (MyOrder c : page.getContent()) {
    System.out.println(c.toString());
  }
}

public PagingResult<AdminVersion> search(SearchParam param, PageParam pageParam) {
  Page<AdminVersion> page = adminVersionDao.findAll(new Specification<AdminVersion>() {
    @Override
    public Predicate toPredicate(Root<AdminVersion> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
      return null;
    }
  }, new PageRequest(pageParam.getPage(), pageParam.getLimit()));
  return PagingResult.wrapResult(page.getContent(), page.getTotalElements(), pageParam.getPage(), page.getSize());
}

  @Override
  protected void doInTransactionWithoutResult(TransactionStatus theArg0) {
    int maxResult = 1000;
    Page<TermConcept> concepts = myConceptDao.findResourcesRequiringReindexing(new PageRequest(0, maxResult));
    if (concepts.hasContent() == false) {
      if (myChildToParentPidCache != null) {
        ourLog.info("Clearing parent concept cache");
        myNextReindexPass = System.currentTimeMillis() + DateUtils.MILLIS_PER_MINUTE;
        myChildToParentPidCache = null;
      }
      return;
    }
    if (myChildToParentPidCache == null) {
      myChildToParentPidCache = ArrayListMultimap.create();
    }
    ourLog.info("Indexing {} / {} concepts", concepts.getContent().size(), concepts.getTotalElements());
    int count = 0;
    StopWatch stopwatch = new StopWatch();
    for (TermConcept nextConcept : concepts) {
      if (isBlank(nextConcept.getParentPidsAsString())) {
        StringBuilder parentsBuilder = new StringBuilder();
        createParentsString(parentsBuilder, nextConcept.getId());
        nextConcept.setParentPids(parentsBuilder.toString());
      }
      saveConcept(nextConcept);
      count++;
    }
    ourLog.info("Indexed {} / {} concepts in {}ms - Avg {}ms / resource", count, concepts.getContent().size(), stopwatch.getMillis(), stopwatch.getMillisPerOperation(count));
  }
});

public List<T> fetchAllPagesAsList(Function<Pageable, Page<T>> function) {
  List<T> results = new LinkedList<>();
  Page<T> page = function.apply(new PageRequest(0, pageSize));
  while (page.getNumber() < page.getTotalPages()) {
    results.addAll(page.getContent());
    page = function.apply(new PageRequest(page.getNumber() + 1, pageSize));
  }
  return results;
}

private SearchSimilarContentResult mapPageToResult(String sourceId, Page<SimilarityRelation> page) {
  SearchSimilarContentResult result = new SearchSimilarContentResult();
  result.setHasMore(page.hasNext());
  result.setSimilarContents(mapSimilarityRelations(sourceId, page.getContent()));
  result.setTotalSize(page.getTotalElements());
  result.setPageNo(page.getNumber());
  return result;
}

private static void printPageEmployees(String title, Page<Employee> empPage) {
  printTitle(title);
  System.out.printf("현재 페이지/전체 페이지 = %d/%d\n", empPage.getNumber(), empPage.getTotalPages());
  System.out.printf("현재 페이지 엘리먼트 개수/전체 개수/페이지 크기 = %d/%d/%d\n",
      empPage.getNumberOfElements(), empPage.getTotalElements(), empPage.getSize());
  System.out.printf("isFirst() = %s, isLast() = %s, hasNext() = %s, hasPrevious() = %s\n",
      empPage.isFirst(), empPage.isLast(), empPage.hasNext(), empPage.hasPrevious());
  for (Employee emp : empPage) {
    System.out.println(emp.toString());
  }
}

@SuppressWarnings("unchecked")
@Override
public PageDto<Dto> covertToDto(Page<Entity> es) {
  if (es == null) {
    return new PageDto<Dto>(Collections.EMPTY_LIST, 0, 0);
  }
  return new PageDto<Dto>(covertToDto(es.getContent()),
      es.getTotalPages(), es.getTotalElements());
}

 @GetMapping("/by-namespace/count")
 public long getInstancesCountByNamespace(@RequestParam("appId") String appId,
                     @RequestParam("clusterName") String clusterName,
                     @RequestParam("namespaceName") String namespaceName) {
  Page<Instance> instances = instanceService.findInstancesByNamespace(appId, clusterName,
    namespaceName, PageRequest.of(0, 1));
  return instances.getTotalElements();
 }
}