How to use

getTotalElements

method

in

org.springframework.data.domain.Page

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

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

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

return new PageDTO<>(instanceDTOs, pageable, instanceConfigsPage.getTotalElements());

  @Override
  public Object execute(Query query) {
    GeoResults<Object> geoResults = doExecuteQuery(query);
    Page<GeoResult<Object>> page = PageableExecutionUtils.getPage(geoResults.getContent(), accessor.getPageable(),
        () -> {
          Query countQuery = mongoQuery.createCountQuery(accessor);
          countQuery = mongoQuery.applyQueryMetaAttributesWhenPresent(countQuery);
          return operation.matching(countQuery).count();
        });
    // transform to GeoPage after applying optimization
    return new GeoPage<>(geoResults, accessor.getPageable(), page.getTotalElements());
  }
}

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

  @Override
  public Object execute(Query query) {
    GeoResults<Object> geoResults = doExecuteQuery(query);
    Page<GeoResult<Object>> page = PageableExecutionUtils.getPage(geoResults.getContent(), accessor.getPageable(),
        () -> {
          Query countQuery = mongoQuery.createCountQuery(accessor);
          countQuery = mongoQuery.applyQueryMetaAttributesWhenPresent(countQuery);
          return operation.matching(countQuery).count();
        });
    // transform to GeoPage after applying optimization
    return new GeoPage<>(geoResults, accessor.getPageable(), page.getTotalElements());
  }
}

/**
 * Page 数据处理，预防redis反序列化报错
 * @param page
 * @return
 */
public static Map toPage(Page page) {
  Map map = new HashMap();
  map.put("content",page.getContent());
  map.put("totalElements",page.getTotalElements());
  return map;
}

 public <T> Map<String, Object> findEasyUIData(Page<T> page) {
  Map<String, Object> map = new HashMap<String, Object>();
  map.put("rows", page.getContent());
  map.put("total", page.getTotalElements());
  return map;
 }
}

@Override
public Page<UserRolesMappingResponse> getAllUserRolesMapping(String searchTerm, int page, int size) {
  Page<UserRolesMapping> userRoleMappings = userRolesMappingRepository.findAllUserRolesMappingDetails(searchTerm, new PageRequest(page, size));
  List<UserRolesMappingResponse> allUserRoleMappingsList = userRoleMappings.getContent().parallelStream().map(fetchUserRolesMappingDetials).collect(Collectors.toList());
  Page<UserRolesMappingResponse> allUserRoleMappings = new PageImpl<UserRolesMappingResponse>(allUserRoleMappingsList, new PageRequest(page, size), userRoleMappings.getTotalElements());
  return allUserRoleMappings;
}

private Page<TaskJobExecutionRel> getPageableRelationships(Page<TaskExecution> taskExecutions, Pageable pageable) {
  List<TaskJobExecutionRel> taskJobExecutionRels = new ArrayList<>();
  for (TaskExecution taskExecution : taskExecutions.getContent()) {
    taskJobExecutionRels
        .add(new TaskJobExecutionRel(sanitizePotentialSensitiveKeys(taskExecution), new ArrayList<>(
            this.explorer.getJobExecutionIdsByTaskExecutionId(taskExecution.getExecutionId()))));
  }
  return new PageImpl<>(taskJobExecutionRels, pageable, taskExecutions.getTotalElements());
}

public PageResp(Page<T> page) {
  this.rows = page.getContent();
  this.page = page.getNumber() + 1;
  this.pagesize = page.getSize();
  this.total = page.getTotalElements();
}

public final Page<Target> convertToPage(Page<Source> sourcePage, Map<String, Object> parameters) {
  List<Target> targets = new ArrayList(sourcePage.getContent().size());
  for (Source source : sourcePage) {
    targets.add(convert(source, parameters));
  }
  Pageable pageable = new PageRequest(sourcePage.getNumber(), sourcePage.getSize(), sourcePage.getSort());
  Page<Target> targetPage = new PageImpl(targets, pageable, sourcePage.getTotalElements());
  return targetPage;
}

private Page<AssetGroupView> buildAssetGroupView(final Page<AssetGroupDetails> allAssetGroups) {
  List<AssetGroupView> allAssetGroupList = Lists.newArrayList();
  allAssetGroups.getContent().forEach(assetGroup -> {
    AssetGroupView assetGroupView = new AssetGroupView();
    assetGroupView.setGroupId(assetGroup.getGroupId());
    assetGroupView.setGroupName(assetGroup.getGroupName());
    assetGroupView.setTargetTypes(assetGroup.getTargetTypes());
    allAssetGroupList.add(assetGroupView);
  });
  return new PageImpl<AssetGroupView>(allAssetGroupList, PageRequest.of(allAssetGroups.getNumber(), allAssetGroups.getSize()),allAssetGroups.getTotalElements());
}