在 spring 引导中生成过滤

Question

I'm trying to generify the filtering process to be able to apply filters on any of my entities.

Using some code online I build this:

public enum FilterOperation {
    // @formatter:off
    LESS_EQUAL_THAN("<=", CriteriaBuilder::lessThanOrEqualTo),
    GREATER_EQUAL_THAN(">=", CriteriaBuilder::greaterThanOrEqualTo),
    CONTAINS(":>", CriteriaBuilder::like),
    GREATER_THAN(">", CriteriaBuilder::greaterThan),
    LESS_THAN("<", CriteriaBuilder::lessThan),
    EQUALS("::", CriteriaBuilder::equal);
    // @formatter:on

    private final String operationName;
    private final FilterPredicateFunction operation;

    private static Pattern separator = Pattern.compile("([\\S\\s]+)§([\\S\\s]+)");

    FilterOperation(String operationName, FilterPredicateFunction operation) {
        this.operationName = operationName;
        this.operation = operation;
    }

    public String getOperationName() {
        return operationName;
    }

    public Predicate build(CriteriaBuilder builder, Root<?> entity, String key, String value) {
        // Split value by character §
        Matcher m = separator.matcher(value);
        if (m.matches()) {
            String type = m.group(2);
            if (type.equals("UUID")) {
                return builder.equal(entity.get(key), UUID.fromString(m.group(1)));
            } else {
                throw new WrongFilterException("Filter operation not found");
            }
        } else {
            // No § found we expect a string search
            return operation.predicate(builder, entity.get(key), value.toString());
        }
    }

    static FilterOperation parse(String str) {
        for (FilterOperation filter : FilterOperation.values()) {
            if (str.equals(filter.getOperationName())) {
                return filter;
            }
        }

        throw new WrongFilterException(String.format("Filter operation not found", str));
    }

    @FunctionalInterface
    interface FilterPredicateFunction {
        Predicate predicate(CriteriaBuilder builder, Path<String> key, String value);
    }
}

Here is an example of URL with filtering:

http://localhost:8080/api/type/284c5f72-559d-4e62-a316-6bd23259c213/slot/filter?filter=name:>Samedi&filter=id::773f7313-0f37-4465-a707-7295c2bb87a3§UUID

As you can see I have two cases, one with only a field, an operation, and the value name:>Samedi and a second case where I add the type with a separator character: id::773f7313-0f37-4465-a707-7295c2bb87a3§UUID

Just to precise, another class call my build function like this:

return (Specification<T>) (root, query, cb) -> op.build(cb, root, key, value);

With for example key as 'id' and value as '773f7313-0f37-4465-a707-7295c2bb87a3§UUID'

In my code actually, I use the builder.equal function to create Predicates for my custom type (here UUID) and not the operation defined at the beginning of my enum, but now I want to add the support for the LocalTime type and use the right operation to be able to use a greaterThan or less than.

 if (type.equals("UUID")) {
     return builder.equal(entity.get(key), UUID.fromString(m.group(1)));
 } else {
     throw new WrongFilterException("Filter operation not found");
 }

To this:

if (type.equals("UUID")) {
  return operation.predicate(builder, entity.get(key), UUID.fromString(m.group(1)));
} else {
  throw new WrongFilterException("Filter operation not found");
}

But then I have this error:

Required type: String Provided: UUID

Obviously, that error came from my FilterPredicateFunction that can only take a String, I try to change it to object but then all my CriteriaBuilder::methodName get this error: Cannot resolve method 'greaterThanOrEqualTo'

What can I do to use any operation on any type of data? Any idea on how I can achieve this?

EDIT: I add all other class that I use to better understand the process:

public class EntitySpecificationBuilder<T> {

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static <T> Optional<Specification<T>> parse(List<String> filters) {
        if (filters == null || filters.isEmpty()) {
            return Optional.empty();
        }

        List<Specification> criterias = mapSpecifications(filters);
        if (criterias.isEmpty()) {
            return Optional.empty();
        }

        Specification<T> root = Specification.where(criterias.get(0));
        for (int index = 1; index < criterias.size(); index++) {
            root = Specification.where(root).and(criterias.get(index));
        }
        return Optional.of(root);
    }

    @SuppressWarnings("rawtypes")
    private static <T> List<Specification> mapSpecifications(List<String> filters) {
        return filters.stream().map(str -> {
            for (FilterOperation op : FilterOperation.values()) {
                int index = str.indexOf(op.getOperationName());
                if (index > 0) {
                    String key = str.substring(0, index);
                    String value = str.substring(index + op.getOperationName().length());

                        return (Specification<T>) (root, query, cb) -> op.build(cb, root, key, value);

                }
            }

            return null;
        }).filter(Objects::nonNull).collect(Collectors.toList());
    }
}

The builder:

public class FindAllBuilder<E, R extends PagingAndSortingRepository<E, ?> & JpaSpecificationExecutor<E>> {

    private final R repository;

    private Specification<E> filters;

    private Sort sort = Sort.unsorted();

    public static <E, R extends PagingAndSortingRepository<E, ?> & JpaSpecificationExecutor<E>> FindAllBuilder<E, R> usingRepository(
            R repository) {
        return new FindAllBuilder<>(repository);
    }

    private FindAllBuilder(R repository) {
        this.repository = repository;
    }

    public Page<E> findAll(Pageable pageable) {
        return repository.findAll(filters, pageable);
    }

    public FindAllBuilder<E, R> filterBy(List<String> listFilters) {
        Optional<Specification<E>> opFilters = EntitySpecificationBuilder.parse(listFilters);
        if (opFilters.isPresent()) {
            if (filters == null) {
                filters = Specification.where(opFilters.get());
            } else {
                filters = filters.and(opFilters.get());
            }
        }

        return this;
    }

    public FindAllBuilder<E, R> sortBy(String orderBy, String orderDir) {
        if (!orderBy.isEmpty()) {
            sort = Sort.by(Direction.fromOptionalString(orderDir).orElse(Direction.ASC), orderBy);
        }

        return this;
    }
}

And how I call it in my controller:

FindAllBuilder.usingRepository(this.repository).filterBy(filters).findAll(pageable).map(MyMapper.INSTANCE::toDTO);

With filter as an array of string that looks like this: name:>test

The awful way to do this would to transform my buildChild function to something like this:

public Predicate buildChild(CriteriaBuilder builder, Root<?> entity, String pKey, String cKey, String value) {
    Matcher m = separator.matcher(value);
    if (m.matches()) {
        String type = m.group(2);
        if (type.equals("UUID")) {
            if(operationName.equals(FilterOperation.EQUALS.getOperationName())) {
                return builder.equal(entity.get(pKey).get(cKey), UUID.fromString(m.group(1)));
            } else if (operationName.equals(FilterOperation.CONTAINS.getOperationName())) {
                return builder.like(...);
            } etc...
            
        } else if (type.equals("LocalTime")) {
            ....
        }
        
        else {
            throw new WrongFilterException("Filter operation not found");
        }
    } else {
        // No § found we expect a string search
        return operation.predicate(builder, entity.get(pKey).get(cKey), value.toString());
    }
}

But I would have to implement for each type of data each type of operation, this will be a lot of ifs.

Answer 1

I'm trying to get what you are trying to achieve, but from first look, if your logic is fine but the function waits for String and you pass UUID , so Instead of casting it to Object why not to replace:

UUID.fromString(m.group(1))

with

m.group(1)

so you pass the same value but with String type, and if you are using

UUID.fromString()

to make sure the incoming string is in UUID format you can separate this validation step.

let me know if it works with you.