How to use

of

method

in

org.springframework.data.domain.PageRequest

private int check() {
 PageRequest pageable = PageRequest.of(0, 1);
 appService.findAll(pageable);
 return 0;
}

private int check() {
 PageRequest pageable = PageRequest.of(0, 1);
 appService.findAll(pageable);
 return 0;
}

 @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();
 }
}

@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
 PageableHandlerMethodArgumentResolver pageResolver =
     new PageableHandlerMethodArgumentResolver();
 pageResolver.setFallbackPageable(PageRequest.of(0, 10));
 argumentResolvers.add(pageResolver);
}

/**
 * 根据条件生成带排序的 Pageable 对象
 *
 * @param page
 * @param size
 * @param sort
 * @return
 */
private PageRequest genSortedPageable(Integer page, Integer size, Integer sort) {
  if (sort == null || sort.equals(ProjectSortEnum.DEFAULT.getCode())) {
    //不传排序或默认排序，直接返回
    return PageRequest.of(page, size);
  } else if (sort.equals(ProjectSortEnum.DIFFICULTY_LOW_TO_HIGH.getCode())) {
    //难度从低到高排序
    return PageRequest.of(page, size, Sort.Direction.ASC, "projectDifficulty");
  } else if (sort.equals(ProjectSortEnum.DIFFICULTY_HIGH_TO_LOW.getCode())) {
    //难度从高到低排序
    return PageRequest.of(page, size, Sort.Direction.DESC, "projectDifficulty");
  }
  return PageRequest.of(page, size);
}

/**
 * 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();
}

protected Iterator<T> doPageRead() {
  if (queryString != null) {
    Pageable pageRequest = PageRequest.of(page, pageSize, sort);
    Pageable pageRequest = PageRequest.of(page, pageSize);
    query.with(pageRequest);

String namespaceName = release.getNamespaceName();
PageRequest page = PageRequest.of(0, 2);
List<Release> twoLatestActiveReleases = findActiveReleases(appId, clusterName, namespaceName, page);
if (twoLatestActiveReleases == null || twoLatestActiveReleases.size() < 2) {

@Test
public void testQueryObjectWithIgnoredPageSize() throws Exception {
  reader = new MongoItemReader<>();
  reader.setTemplate(template);
  
  Query query = new Query()
      .with(Sort.by(new Order(Sort.Direction.ASC, "_id")))
      .with(PageRequest.of(0, 50));
  reader.setQuery(query);
  reader.setTargetType(String.class);
  
  reader.afterPropertiesSet();
  
  ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class);
  when(template.find(queryContainer.capture(), eq(String.class))).thenReturn(new ArrayList<>());
  
  assertFalse(reader.doPageRead().hasNext());
  
  Query actualQuery = queryContainer.getValue();
  assertFalse(reader.doPageRead().hasNext());
  assertEquals(10, actualQuery.getLimit());
  assertEquals(0, actualQuery.getSkip());
}

@Test
public void testQueryObjectWithPageSize() throws Exception {
  reader = new MongoItemReader<>();
  reader.setTemplate(template);
  
  Query query = new Query()
      .with(Sort.by(new Order(Sort.Direction.ASC, "_id")))
      .with(PageRequest.of(30, 50));
  reader.setQuery(query);
  reader.setTargetType(String.class);
  reader.setPageSize(100);
  
  reader.afterPropertiesSet();
  
  ArgumentCaptor<Query> queryContainer = ArgumentCaptor.forClass(Query.class);
  when(template.find(queryContainer.capture(), eq(String.class))).thenReturn(new ArrayList<>());
  
  assertFalse(reader.doPageRead().hasNext());
  
  Query actualQuery = queryContainer.getValue();
  assertFalse(reader.doPageRead().hasNext());
  assertEquals(100, actualQuery.getLimit());
  assertEquals(0, actualQuery.getSkip());
}

.withTypes(typeName).withPageable(PageRequest.of(0, pageSize)).build();

@Test
public void testSettingCurrentItemCountExplicitly() throws Exception {
  reader.setCurrentItemCount(3);
  reader.setPageSize(2);
  PageRequest request = PageRequest.of(1, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>() {{
    add("3");
    add("4");
  }}));
  request = PageRequest.of(2, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>(){{
    add("5");
    add("6");
  }}));
  reader.open(new ExecutionContext());
  Object result = reader.read();
  assertEquals("3", result);
  assertEquals("4", reader.read());
  assertEquals("5", reader.read());
  assertEquals("6", reader.read());
}

@Test
public void testResetOfPage() throws Exception {
  reader.setPageSize(2);
  PageRequest request = PageRequest.of(0, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>(){{
    add("1");
    add("2");
  }}));
  request = PageRequest.of(1, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>() {{
    add("3");
    add("4");
  }}));
  ExecutionContext executionContext = new ExecutionContext();
  reader.open(executionContext);
  Object result = reader.read();
  reader.close();
  assertEquals("1", result);
  reader.open(executionContext);
  assertEquals("1", reader.read());
  assertEquals("2", reader.read());
  assertEquals("3", reader.read());
}

private Collection<ResourceReindexJobEntity> getResourceReindexJobEntities() {
  Collection<ResourceReindexJobEntity> jobs = myTxTemplate.execute(t -> myReindexJobDao.findAll(PageRequest.of(0, 10), false));
  assert jobs != null;
  return jobs;
}

@Test
public void testSettingCurrentItemCountRestart() throws Exception {
  reader.setCurrentItemCount(3);
  reader.setPageSize(2);
  PageRequest request = PageRequest.of(1, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>(){{
    add("3");
    add("4");
  }}));
  request = PageRequest.of(2, 2, new Sort(Direction.ASC, "id"));
  when(repository.findAll(request)).thenReturn(new PageImpl<>(new ArrayList<Object>() {{
    add("5");
    add("6");
  }}));
  ExecutionContext executionContext = new ExecutionContext();
  reader.open(executionContext);
  Object result = reader.read();
  reader.update(executionContext);
  reader.close();
  assertEquals("3", result);
  reader.open(executionContext);
  assertEquals("4", reader.read());
  assertEquals("5", reader.read());
  assertEquals("6", reader.read());
}

private void expungeJobsMarkedAsDeleted() {
  myTxTemplate.execute(t -> {
    Collection<ResourceReindexJobEntity> toDelete = myReindexJobDao.findAll(PageRequest.of(0, 10), true);
    toDelete.forEach(job -> {
      ourLog.info("Purging deleted job[{}]", job.getId());
      myReindexJobDao.deleteById(job.getId());
    });
    return null;
  });
}

protected void expungeHistoricalVersionsOfId(Long theResourceId, AtomicInteger theRemainingCount) {
  ResourceTable resource = myResourceTableDao.findById(theResourceId).orElseThrow(IllegalArgumentException::new);
  Pageable page = PageRequest.of(0, theRemainingCount.get());
  Slice<Long> versionIds = myResourceHistoryTableDao.findForResourceId(page, resource.getId(), resource.getVersion());
  ourLog.debug("Found {} versions of resource {} to expunge", versionIds.getNumberOfElements(), resource.getIdDt().getValue());
  for (Long nextVersionId : versionIds) {
    expungeHistoricalVersion(nextVersionId);
    if (theRemainingCount.decrementAndGet() <= 0) {
      return;
    }
  }
}

  @Override
  public Pageable resolveArgument(MethodParameter methodParameter, ModelAndViewContainer mavContainer,
      NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {

    Pageable pageable = delegate.resolveArgument(methodParameter, mavContainer, webRequest, binderFactory);

    if (pageable == null || pageable.getSort() == null) {
      return pageable;
    }

    Sort translated = translator.translateSort(pageable.getSort(), methodParameter, webRequest);
    return PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), translated);
  }
}

@Bean
@Override
public HateoasPageableHandlerMethodArgumentResolver pageableResolver() {
  HateoasPageableHandlerMethodArgumentResolver resolver = super.pageableResolver();
  resolver.setPageParameterName(repositoryRestConfiguration().getPageParamName());
  resolver.setSizeParameterName(repositoryRestConfiguration().getLimitParamName());
  resolver.setFallbackPageable(PageRequest.of(0, repositoryRestConfiguration().getDefaultPageSize()));
  resolver.setMaxPageSize(repositoryRestConfiguration().getMaxPageSize());
  return resolver;
}

  @Override
  public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
      NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    Pageable pageable = delegate.resolveArgument(parameter, mavContainer, webRequest, binderFactory);

    if (pageable == null || pageable.getSort() == null) {
      return new DefaultedPageable(pageable, delegate.isFallbackPageable(pageable));
    }

    Sort translated = translator.translateSort(pageable.getSort(), parameter, webRequest);
    pageable = PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), translated);

    return new DefaultedPageable(pageable, delegate.isFallbackPageable(pageable));
  }
}