How to use

getContent

method

in

org.springframework.data.domain.Page

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

private Collection<String> getBranchReleaseKeys(long releaseId) {
 Page<ReleaseHistory> releaseHistories = releaseHistoryService
   .findByReleaseIdAndOperationInOrderByIdDesc(releaseId, BRANCH_RELEASE_OPERATIONS, FIRST_ITEM);
 if (!releaseHistories.hasContent()) {
  return null;
 }
 Map<String, Object> operationContext = gson
   .fromJson(releaseHistories.getContent().get(0).getOperationContext(), OPERATION_CONTEXT_TYPE_REFERENCE);
 if (operationContext == null || !operationContext.containsKey(ReleaseOperationContext.BRANCH_RELEASE_KEYS)) {
  return null;
 }
 return (Collection<String>) operationContext.get(ReleaseOperationContext.BRANCH_RELEASE_KEYS);
}

@Override
public <T> List<T> queryForList(StringQuery query, Class<T> clazz) {
  return queryForPage(query, clazz).getContent();
}

@Override
public <T> List<T> queryForList(CriteriaQuery query, Class<T> clazz) {
  return queryForPage(query, clazz).getContent();
}

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

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

@GetMapping("/by-namespace")
public PageDTO<InstanceDTO> getInstancesByNamespace(
  @RequestParam("appId") String appId, @RequestParam("clusterName") String clusterName,
  @RequestParam("namespaceName") String namespaceName,
  @RequestParam(value = "instanceAppId", required = false) String instanceAppId,
  Pageable pageable) {
 Page<Instance> instances;
 if (Strings.isNullOrEmpty(instanceAppId)) {
  instances = instanceService.findInstancesByNamespace(appId, clusterName,
    namespaceName, pageable);
 } else {
  instances = instanceService.findInstancesByNamespaceAndInstanceAppId(instanceAppId, appId,
    clusterName, namespaceName, pageable);
 }
 List<InstanceDTO> instanceDTOs = BeanUtils.batchTransform(InstanceDTO.class, instances.getContent());
 return new PageDTO<>(instanceDTOs, pageable, instances.getTotalElements());
}

/**
 * 返回分页成功数据
 */
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;
}

/**
 * 返回分页成功数据
 */
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;
}

public Page<Instance> findInstancesByNamespace(String appId, String clusterName, String
  namespaceName, Pageable pageable) {
 Page<InstanceConfig> instanceConfigs = instanceConfigRepository.
   findByConfigAppIdAndConfigClusterNameAndConfigNamespaceNameAndDataChangeLastModifiedTimeAfter(appId, clusterName,
     namespaceName, getValidInstanceConfigDate(), pageable);
 List<Instance> instances = Collections.emptyList();
 if (instanceConfigs.hasContent()) {
  Set<Long> instanceIds = instanceConfigs.getContent().stream().map
    (InstanceConfig::getInstanceId).collect(Collectors.toSet());
  instances = findInstancesByIds(instanceIds);
 }
 return new PageImpl<>(instances, pageable, instanceConfigs.getTotalElements());
}

public Page<Instance> findInstancesByNamespaceAndInstanceAppId(String instanceAppId, String
  appId, String clusterName, String
                                  namespaceName, Pageable
                                  pageable) {
 Page<Object> instanceIdResult = instanceConfigRepository
   .findInstanceIdsByNamespaceAndInstanceAppId(instanceAppId, appId, clusterName,
     namespaceName, getValidInstanceConfigDate(), pageable);
 List<Instance> instances = Collections.emptyList();
 if (instanceIdResult.hasContent()) {
  Set<Long> instanceIds = instanceIdResult.getContent().stream().map((Object o) -> {
   if (o == null) {
    return null;
   }
   if (o instanceof Integer) {
    return ((Integer)o).longValue();
   }
   if (o instanceof Long) {
    return (Long) o;
   }
   //for h2 test
   if (o instanceof BigInteger) {
    return ((BigInteger) o).longValue();
   }
   return null;
  }).filter(Objects::nonNull).collect(Collectors.toSet());
  instances = findInstancesByIds(instanceIds);
 }
 return new PageImpl<>(instances, pageable, instanceIdResult.getTotalElements());
}

  @RequestMapping(value = "/save", method = RequestMethod.POST)
  public List<Person> savePerson(@RequestBody String personName) {
    Person p = new Person(personName);
    personRepository.save(p);
    List<Person> people = personRepository.findAll(new PageRequest(0, 10)).getContent();
    return people;
  }
}

@Override
public <T> T queryForObject(StringQuery 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;
}

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

@Override
public List<ProjectInfoVO> getProjectList(Integer page, Integer size, Integer sort) {
  Page<ProjectInfo> pages = projectInfoRepository.findAll(genSortedPageable(page, size, sort));
  List<ProjectInfo> projectList = pages.getContent();
  return packageProductInfoVO(projectList, sort);
}

@Override
public List<ProjectInfoVO> getProjectListByTypeAndProgress(Integer page, Integer size, Integer type, Integer progress, Integer sort) {
  Page<ProjectInfo> pages = projectInfoRepository.findByCategoryTypeAndProjectProgress(
      genSortedPageable(page, size, sort), type, progress);
  List<ProjectInfo> list = pages.getContent();
  return packageProductInfoVO(list, sort);
}

@Override
public List<ProjectInfoVO> getProjectListByCategoryType(Integer page, Integer size, Integer type, Integer sort) {
  Page<ProjectInfo> pages = projectInfoRepository.findByCategoryType(genSortedPageable(page, size, sort), type);
  List<ProjectInfo> list = pages.getContent();
  return packageProductInfoVO(list, sort);
}

@Override
public List<ProjectInfoVO> getProjectListByProjectProgress(Integer page, Integer size, Integer progress, Integer sort) {
  Page<ProjectInfo> pages = projectInfoRepository.findByProjectProgress(genSortedPageable(page, size, sort), progress);
  List<ProjectInfo> list = pages.getContent();
  return packageProductInfoVO(list, sort);
}

Set<String> otherReleaseKeys = Sets.newHashSet();
for (InstanceConfig instanceConfig : instanceConfigsPage.getContent()) {
 instanceConfigMap.put(instanceConfig.getInstanceId(), instanceConfig);
 otherReleaseKeys.add(instanceConfig.getReleaseKey());

@Before
public void setUp() throws Exception {
  MockitoAnnotations.initMocks(this);
  this.sorts = new HashMap<>();
  this.sorts.put("id", Sort.Direction.ASC);
  this.pageRequestContainer = ArgumentCaptor.forClass(PageRequest.class);
  List<String> testResult = new ArrayList<>();
  testResult.add(TEST_CONTENT);
  when(page.getContent()).thenReturn(testResult);
  when(page.getSize()).thenReturn(5);
  when(this.repository.foo(this.pageRequestContainer.capture())).thenReturn(this.page);
}