How to use

org.springframework.data.domain.Sort$Order

constructor

private Sort convertToSort(Map<String, Sort.Direction> sorts) {
  List<Sort.Order> sortValues = new ArrayList<>();
  for (Map.Entry<String, Sort.Direction> curSort : sorts.entrySet()) {
    sortValues.add(new Sort.Order(curSort.getValue(), curSort.getKey()));
  }
  return Sort.by(sortValues);
}

  private Sort convertToSort(Map<String, Sort.Direction> sorts) {
    List<Sort.Order> sortValues = new ArrayList<>();

    for (Map.Entry<String, Sort.Direction> curSort : sorts.entrySet()) {
      sortValues.add(new Sort.Order(curSort.getValue(), curSort.getKey()));
    }

    return Sort.by(sortValues);
  }
}

private static List<Order> combine(List<Order> orders, @Nullable Direction direction, List<Path<?, ?>> paths) {
  List<Order> result = new ArrayList<Sort.Order>(orders);
  for (Path<?, ?> path : paths) {
    result.add(new Order(direction, path.toString()));
  }
  return result;
}

@ApiOperation(value = "获取日志列表信息", notes = "获取日志列表信息，系统管理员默认可以访问")
@RequestMapping(value = "/", method = RequestMethod.GET)
public BaseResponse<List<ResErrLog>> getErrorLogList(@QuerydslPredicate(root = ErrorInfo.class) Predicate predicate, @RequestParam(value = "page", defaultValue = "0") Integer page,
                           @RequestParam(value = "size", defaultValue = "15") Integer size) throws BaseException {
  //添加排序 默认按照最后访问时间进行倒排
  Sort sort = new Sort(new Sort.Order(Sort.Direction.DESC, "execTime"));
  Pageable pageable = new PageRequest(page, size, sort);
  return service.getErrorLogList(pageable, predicate);
}

@Override
public Sort createSort() {
  List<Order> orders = new ArrayList<Order>();
  orders.add(new Order(Direction.ASC, "ip"));
  orders.add(new Order(Direction.ASC, "organisation.id"));
  orders.add(new Order(Direction.ASC, "id"));
  Sort sort = new Sort(orders);
  return sort;
}

@Override
public Sort createSort() {
  List<Order> orders = new ArrayList<Order>();
  orders.add(new Order(Direction.ASC, "organisation.id"));
  orders.add(new Order(Direction.ASC, "id"));
  Sort sort = new Sort(orders);
  return sort;
}

@Override
public Sort createSort() {
  List<Order> orders = new ArrayList<Order>();
  orders.add(new Order(Direction.ASC, "bwmetaId"));
  orders.add(new Order(Direction.ASC, "id"));
  Sort sort = new Sort(orders);
  return sort;
}

/**
 * @deprecated use {@link Sort#Sort(Direction, List)} instead.
 */
@Deprecated
public static List<Order> create(Direction direction, Iterable<String> properties) {
  List<Order> orders = new ArrayList<Sort.Order>();
  for (String property : properties) {
    orders.add(new Order(direction, property));
  }
  return orders;
}

  @Override
  public Order unmarshal(OrderDto source) throws Exception {
    return source == null ? null : new Order(source.direction, source.property);
  }
}

@Override
public Map<Long, String> fetchData() {
  final Pageable pageable = new PageRequest(0, Integer.MAX_VALUE, new Sort(new Order(Direction.ASC, "id")));
  final Page<CocosUserDomain> domainsPage = domainService.fetchAll(new UserDomainFilter(), pageable);
  return domainsPage.getContent().stream().collect(Collectors.toMap(CocosUserDomain::getId, CocosUserDomain::getDomainName));
}

@Override
public Optional<Launch> findLastLaunch(String projectId, String launchName, String mode) {
  Query query = query(where(PROJECT_ID_REFERENCE).is(projectId)).addCriteria(where(NAME).is(launchName))
      .addCriteria(where(MODE).is(mode))
      .limit(1)
      .with(new Sort(Lists.newArrayList(new Sort.Order(DESC, START_TIME), new Sort.Order(DESC, NUMBER))));
  List<Launch> launches = mongoTemplate.find(query, Launch.class);
  return !launches.isEmpty() ? Optional.of(launches.get(0)) : Optional.empty();
}

public Builder desc(boolean condition, String property) {
  if (condition) {
    orders.add(new Order(DESC, property));
  }
  return this;
}

@Override
public Sort deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
  final ArrayNode node = jsonParser.getCodec().readTree(jsonParser);
  final Order[] orders = new Order[node.size()];
  int i = 0;
  for (JsonNode jsonNode : node) {
    orders[i] = new Order(Direction.valueOf(jsonNode.get("direction").asText()), jsonNode.get("property").asText());
    i++;
  }
  return new Sort(orders);
}

public Builder asc(boolean condition, String property) {
  if (condition) {
    orders.add(new Order(ASC, property));
  }
  return this;
}

private static List<Order> combine(List<Order> orders, @Nullable Direction direction, List<Path<?, ?>> paths) {
  List<Order> result = new ArrayList<Sort.Order>(orders);
  for (Path<?, ?> path : paths) {
    result.add(new Order(direction, path.toString()));
  }
  return result;
}

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

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

@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 testQueryObject() throws Exception {
  reader = new MongoItemReader<>();
  reader.setTemplate(template);
  
  Query query = new Query()
      .with(Sort.by(new Order(Sort.Direction.ASC, "_id")));
  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 testAfterPropertiesSetForQueryObject() throws Exception{
  reader = new MongoItemReader<>();
  
  reader.setTemplate(template);
  reader.setTargetType(String.class);
  
  Query query1 = new Query().with(Sort.by(new Order(Sort.Direction.ASC, "_id")));
  reader.setQuery(query1);
  reader.afterPropertiesSet();
}