How to use

Pageable

in

org.springframework.data.domain

@Override
public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
  Assert.notNull(pageable, "Pageable must not be null!");
  RedisOperationChain operationChain = createQuery(example);
  KeyValueQuery<RedisOperationChain> query = new KeyValueQuery<>(operationChain);
  Iterable<T> result = keyValueTemplate.find(
      query.orderBy(pageable.getSort()).skip(pageable.getOffset()).limit(pageable.getPageSize()),
      entityInformation.getJavaType());
  long count = operationChain.isEmpty() ? keyValueTemplate.count(entityInformation.getJavaType())
      : keyValueTemplate.count(query, entityInformation.getJavaType());
  List<S> list = new ArrayList<>();
  for (T t : result) {
    list.add((S) t);
  }
  return new PageImpl<>(list, pageable, count);
}

@Test
public void testDoReadFirstReadNoResults() throws Exception {
  ArgumentCaptor<PageRequest> pageRequestContainer = ArgumentCaptor.forClass(PageRequest.class);
  when(repository.findAll(pageRequestContainer.capture())).thenReturn(new PageImpl<>(new ArrayList<>()));
  assertNull(reader.doRead());
  Pageable pageRequest = pageRequestContainer.getValue();
  assertEquals(0, pageRequest.getOffset());
  assertEquals(0, pageRequest.getPageNumber());
  assertEquals(1, pageRequest.getPageSize());
  assertEquals("id: ASC", pageRequest.getSort().toString());
}

/**
 * Configures the {@link Pageable} to use.
 *
 * @param pageable must not be {@literal null}
 * @return
 */
public NearQuery with(Pageable pageable) {
  Assert.notNull(pageable, "Pageable must not be 'null'.");
  if (pageable.isPaged()) {
    this.num = pageable.getOffset() + pageable.getPageSize();
    this.skip = pageable.getOffset();
  }
  return this;
}

public PageDTO(List<T> content, Pageable pageable, long total) {
 this.total = total;
 this.content = content;
 this.page = pageable.getPageNumber();
 this.size = pageable.getPageSize();
}

/**
 * Sets the given pagination information on the {@link Query} instance. Will transparently set {@code skip} and
 * {@code limit} as well as applying the {@link Sort} instance defined with the {@link Pageable}.
 *
 * @param pageable
 * @return
 */
public Query with(Pageable pageable) {
  if (pageable.isUnpaged()) {
    return this;
  }
  this.limit = pageable.getPageSize();
  this.skip = pageable.getOffset();
  return with(pageable.getSort());
}

@Override
public List<JobInstanceExecutions> listTaskJobInstancesForJobName(Pageable pageable, String jobName)
    throws NoSuchJobException {
  Assert.notNull(pageable, "pageable must not be null");
  Assert.notNull(jobName, "jobName must not be null");
  List<JobInstanceExecutions> taskJobInstances = new ArrayList<>();
  for (JobInstance jobInstance : jobService.listJobInstances(jobName, getPageOffset(pageable),
      pageable.getPageSize())) {
    taskJobInstances.add(getJobInstanceExecution(jobInstance));
  }
  return taskJobInstances;
}

@Override
public Page<T> findAll(Pageable pageable) {
  Assert.notNull(pageable, "Pageable must not be null!");
  if (pageable.isUnpaged()) {
    List<T> result = findAll();
    return new PageImpl<>(result, Pageable.unpaged(), result.size());
  }
  Iterable<T> content = operations.findInRange(pageable.getOffset(), pageable.getPageSize(), pageable.getSort(),
      entityInformation.getJavaType());
  return new PageImpl<>(IterableConverter.toList(content), pageable,
      this.operations.count(entityInformation.getJavaType()));
}

  /**
   * Binds the parameters to the given query and applies special parameter types (e.g. pagination).
   *
   * @param query must not be {@literal null}.
   * @param values values of method parameters to be assigned to the query parameters.
   */
  Query bindAndPrepare(Query query, Object[] values) {

    Assert.notNull(query, "Query must not be null!");

    ParametersParameterAccessor accessor = new ParametersParameterAccessor(parameters, values);

    Query result = bind(query, values);

    if (!useJpaForPaging || !parameters.hasPageableParameter() || accessor.getPageable().isUnpaged()) {
      return result;
    }

    result.setFirstResult((int) accessor.getPageable().getOffset());
    result.setMaxResults(accessor.getPageable().getPageSize());

    return result;
  }
}

private SearchRequest prepareSearch(Query query, Optional<QueryBuilder> builder) {
  Assert.notNull(query.getIndices(), "No index defined for Query");
  Assert.notNull(query.getTypes(), "No type defined for Query");
  if (query.getPageable().isPaged()) {
    startRecord = query.getPageable().getPageNumber() * query.getPageable().getPageSize();
    sourceBuilder.size(query.getPageable().getPageSize());

/**
 * Returns the current {@link Sort} or the given one if the current one is unsorted.
 *
 * @param sort must not be {@literal null}.
 * @return
 */
default Sort getSortOr(Sort sort) {
  Assert.notNull(sort, "Fallback Sort must not be null!");
  return getSort().isSorted() ? getSort() : sort;
}

@Override
public final <T extends Query> T setPageable(Pageable pageable) {
  Assert.notNull(pageable);
  this.pageable = pageable;
  return (T) this.addSort(pageable.getSort());
}

public UnpagedPageImpl(@NonNull List<T> content, long total) {
  Assert.notNull(content, "content must not be null!");
  this.pageable = Pageable.unpaged();
  this.content = content;
  this.total = total;
}

DefaultSelectSpecSupport(String table) {
  Assert.hasText(table, "Table name must not be null!");
  this.table = table;
  this.projectedFields = Collections.emptyList();
  this.sort = Sort.unsorted();
  this.page = Pageable.unpaged();
}

@Override
public Page<T> findAll(Predicate predicate, Pageable pageable) {
  AbstractCollQuery<T, ?> query = prepareQuery(predicate);
  if (pageable.isPaged() || pageable.getSort().isSorted()) {
    query.offset(pageable.getOffset());
    query.limit(pageable.getPageSize());
    if (pageable.getSort().isSorted()) {
      query.orderBy(toOrderSpecifier(pageable.getSort(), builder));
    }
  }
  return new PageImpl<>(query.fetchResults().getResults(), pageable, count(predicate));
}

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

/**
 * Add a dynamic part of a query for the pagination support.
 *
 * @param sql Builder instance.
 * @param pageable Pageable instance.
 * @return Builder instance.
 */
public static StringBuilder addPaging(StringBuilder sql, Pageable pageable) {
  if (pageable.getSort() != null)
    addSorting(sql, pageable.getSort());
  sql.append(" LIMIT ").append(pageable.getPageSize()).append(" OFFSET ").append(pageable.getOffset());
  return sql;
}

@Override
public <T> Page<T> getPage(Class<T> clazz, Query query, Pageable pageable, HibernateParameter... parameters) {
 long totalItemCount = count(query, parameters);
 List<T> items = find(clazz, query, pageable.getPageNumber() * pageable.getPageSize(), pageable.getPageSize(), parameters);
 return new PageImpl<T>(items, pageable, totalItemCount);
}

@Override
protected String getPathPart(Object[] args) {
  Pageable page = (Pageable) args[0];
  return "?page=" + page.getPageNumber() + "&size=" + page.getPageSize() + "&sort=" + page.getSort().toString().replace(": ", ",");
}

@Override
public <T> Page<T> getPage(Class<T> clazz, Criteria criteria, Pageable pageable) {
 Criteria countCriteria = HibernateTool.copyCriteria(criteria);
 long totalItemCount = count(countCriteria);
 List<T> items = find(clazz, criteria,
            pageable.getPageNumber() * pageable.getPageSize(),
            pageable.getPageSize(),
            CriteriaTool.toOrders(pageable.getSort()).toArray(new Order[0]));
 return new PageImpl<T>(items, pageable, totalItemCount);
}

/**
 * Reads the given {@link TypedQuery} into a {@link Page} applying the given {@link Pageable} and
 * {@link Specification}.
 *
 * @param query must not be {@literal null}.
 * @param domainClass must not be {@literal null}.
 * @param spec can be {@literal null}.
 * @param pageable can be {@literal null}.
 * @return
 */
protected <S extends T> Page<S> readPage(TypedQuery<S> query, final Class<S> domainClass, Pageable pageable,
    @Nullable Specification<S> spec) {
  if (pageable.isPaged()) {
    query.setFirstResult((int) pageable.getOffset());
    query.setMaxResults(pageable.getPageSize());
  }
  return PageableExecutionUtils.getPage(query.getResultList(), pageable,
      () -> executeCountQuery(getCountQuery(spec, domainClass)));
}