Java 类org.springframework.data.domain.Sort.NullHandling 实例源码

private Object create(String direction, String property, boolean isIgnoreCase, String nullHandling)
        throws IOException {
    if (property == null) {
        throw new IOException(getType().getName() + " expects name.");
    }

    try {
        return _constructor.newInstance(//
                isNullValue(direction) ? null : Direction.fromStringOrNull(direction), //
                property, //
                isIgnoreCase, //
                isNullValue(nullHandling) ? null : NullHandling.valueOf(nullHandling));
    }
    catch (Exception e) {
        throw new IOExceptionWrapper(e);
    }
}

@Test
public void testSort_Order() throws Exception {
    Hessian2Serialization.addSerializer(Sort.Order.class, new OrderSerializer());
    Hessian2Serialization.addDeserializer(Sort.Order.class, new OrderDeserializer());

    final Sort.Order[] orders = new Sort.Order[3];
    orders[0] = new Sort.Order(Sort.Direction.ASC, "order_num", null);
    orders[1] = new Sort.Order(null, "order_num", null);
    orders[2] = new Sort.Order(Sort.Direction.DESC, "create_time", NullHandling.NULLS_LAST);

    final byte[] buf = Hessian2Serialization.serialize(orders);

    //      System.out.println(new String(buf));

    final Sort.Order[] expectOrders = Hessian2Serialization.deserialize(buf);

    for (int i = 0; i < orders.length; i++) {
        Assert.assertTrue(orders[i].equals(expectOrders[i]));
    }
}

/**
 * Sort on a sequence of fields, possibly none.
 *
 * @param query
 *            If not null, will contain one of more {@link Sort.Order}
 *            objects.
 * @return A sequence of comparators or {@code null}
 */
public Comparator<?> resolve(KeyValueQuery<?> query) {

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

    CompoundComparator<Object> compoundComparator = new CompoundComparator<>();

    for (Order order : query.getSort()) {

        if (order.getProperty().indexOf('.') > -1) {
            throw new UnsupportedOperationException("Embedded fields not implemented: " + order);
        }

        if (order.isIgnoreCase()) {
            throw new UnsupportedOperationException("Ignore case not implemented: " + order);
        }

        if (NullHandling.NATIVE != order.getNullHandling()) {
            throw new UnsupportedOperationException("Null handling not implemented: " + order);
        }

        PropertyComparator propertyComparator = new PropertyComparator(order.getProperty(),
                order.isAscending());

        compoundComparator.addComparator(propertyComparator);
    }

    return compoundComparator;
}

public OrderDeserializer() {
    try {
        _constructor = getType().getDeclaredConstructor(Direction.class, String.class, boolean.class,
                NullHandling.class);
        _constructor.setAccessible(true);
    }
    catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Test
public void testSort() throws Exception {
    Hessian2Serialization.addSerializer(Sort.Order.class, new OrderSerializer());
    Hessian2Serialization.addDeserializer(Sort.Order.class, new OrderDeserializer());
    Hessian2Serialization.addSerializer(Sort.class, new SortSerializer());
    Hessian2Serialization.addDeserializer(Sort.class, new SortDeserializer());

    final Sort.Order[] orders = new Sort.Order[3];
    orders[0] = new Sort.Order(Sort.Direction.ASC, "order_num", null);
    orders[0] = null;
    orders[2] = new Sort.Order(Sort.Direction.DESC, "create_time", NullHandling.NULLS_LAST);

    final Sort sort = new Sort(orders);

    final byte[] buf = Hessian2Serialization.serialize(sort);

    final Sort expectSort = Hessian2Serialization.deserialize(buf);

    final Iterator<Order> iterator = expectSort.iterator();
    int i = 0;
    while (iterator.hasNext()) {
        Order expect = iterator.next();

        Assert.assertTrue(orders[i] == expect || orders[i].equals(expect));
        ++i;
    }
}

/**
 * <P>
 * Sort on a sequence of fields, possibly none.
 * </P>
 *
 * @param query If not null, will contain one of more {@link Sort.Order} objects.
 * @return A sequence of comparators or {@code null}
 */
public Comparator<Entry<?, ?>> resolve(KeyValueQuery<?> query) {

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

    CompoundComparator<Entry<?, ?>> compoundComparator = new CompoundComparator<>();

    for (Order order : query.getSort()) {

        if (order.getProperty().indexOf('.') > -1) {
            throw new UnsupportedOperationException("Embedded fields not implemented: " + order);
        }

        if (order.isIgnoreCase()) {
            throw new UnsupportedOperationException("Ignore case not implemented: " + order);
        }

        if (NullHandling.NATIVE != order.getNullHandling()) {
            throw new UnsupportedOperationException("Null handling not implemented: " + order);
        }

        HazelcastPropertyComparator hazelcastPropertyComparator = new HazelcastPropertyComparator(order.getProperty(),
                order.isAscending());

        compoundComparator.addComparator(hazelcastPropertyComparator);
    }

    return compoundComparator;
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public Comparator<?> resolve(KeyValueQuery<?> query) {

    if (query.getSort().isUnsorted()) {
        return null;
    }

    Optional<Comparator<?>> comparator = Optional.empty();
    for (Order order : query.getSort()) {

        SpelPropertyComparator<Object> spelSort = new SpelPropertyComparator<>(order.getProperty(), parser);

        if (Direction.DESC.equals(order.getDirection())) {

            spelSort.desc();

            if (!NullHandling.NATIVE.equals(order.getNullHandling())) {
                spelSort = NullHandling.NULLS_FIRST.equals(order.getNullHandling()) ? spelSort.nullsFirst()
                        : spelSort.nullsLast();
            }
        }

        if (!comparator.isPresent()) {
            comparator = Optional.of(spelSort);
        } else {

            SpelPropertyComparator<Object> spelSortToUse = spelSort;
            comparator = comparator.map(it -> it.thenComparing(spelSortToUse));
        }
    }

    return comparator.orElseThrow(
            () -> new IllegalStateException("No sort definitions have been added to this CompoundComparator to compare"));
}

@Test // DATACMNS-525
public void toOrderSpecifierConvertsSortWithNullHandlingCorrectly() {

    Sort sort = Sort.by(new Sort.Order(Direction.DESC, "firstname", NullHandling.NULLS_LAST));

    OrderSpecifier<?>[] specifiers = toOrderSpecifier(sort, builder);

    assertThat(specifiers,
            IsArrayContainingInOrder.arrayContaining(QPerson.person.firstname.desc().nullsLast()));
}