Spring data JPA how to create a generic specification builder

Question

I have different specifications classes:

public class UserSpecification implements Specification<ApplicationUser> {
    private SearchCriteria criteria;

    public UserSpecification(SearchCriteria criteria) {
        this.criteria = criteria;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Predicate toPredicate(Root<ApplicationUser> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
       ...
    }
}

public class HotelSpecification implements Specification<Hotel> {

    private SearchCriteria criteria;

    public HotelSpecification(SearchCriteria criteria) {
        this.criteria = criteria;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Predicate toPredicate(Root<Hotel> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
      ...
    }
}

So I try to use a generic builder to compose specifications of the same type because the builder class is 99% duplicate which only differs in class type.

public class MySpecificationBuilder {
    private final List<SearchCriteria> params;

    public MySpecificationBuilder () {
        params = new ArrayList<>();
    }

    public MySpecificationBuilder with(String key, String value) {
        params.add(new SearchCriteria(key, value));
        return this;
    }

    public Specification<?> build() {
        if (params.size() == 0) {
            return null;
        }

        List<Specification<?>> specs = new ArrayList<>();
        for (SearchCriteria param : params) {
            specs.add(new UserSpecification(param));  //how to make here generic
        }

        Specification<?> result = specs.get(0);
        for (int i = 1; i < specs.size(); i++) {
            result = Specification.where(result).and(specs.get(i)); //warning 1
        }
        return result;
    }
}

-warning 1:

I would like to know if it encourages/it's possible to use a generic specification builder. If so, how do I create a generic builder for different specifications?

Answer 1

public class GenericSpecificationBuilder<T> {

    private final List<SearchCriteria> params;

    public GenericSpecificationBuilder() {
        params = new ArrayList<SearchCriteria>();
    }

    public GenericSpecificationBuilder with(String key, String operation, Object value,String perdicateType) {
        params.add(new SearchCriteria(key, operation, value, perdicateType));
        return this;
    }

    public Specification<T> build() {
        if (params.size() == 0) {
            return null;
        }

        List<Specification> specs = params.stream()
                .map(x -> getSpecification(x))
                .collect(Collectors.toList());

        Specification result = specs.get(0);

        for (int i = 1; i < params.size(); i++) {
            System.out.println(params.get(i)
                    .isOrPredicate()
            );
            result = params.get(i-1)
                    .isOrPredicate()
                    ? Specification.where(result)
                    .or(specs.get(i))
                    : Specification.where(result)
                    .and(specs.get(i));
        }
        return result;
    }

    public Specification<T> getSpecification(SearchCriteria criteria) {
        Specification<T> specification = new Specification<T>() {
            @Override
            public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Predicate predicate = genericCriteria(criteria,root,criteriaBuilder);
                return predicate;
            }
        };
        return specification;
    }


    public Predicate genericCriteria(SearchCriteria criteria, Root<?> root, CriteriaBuilder builder){

        if (criteria.getOperation().equalsIgnoreCase(">")) {
            return builder.greaterThanOrEqualTo(
                    root.<String> get(criteria.getKey()), criteria.getValue().toString());
        }
        else if (criteria.getOperation().equalsIgnoreCase("<")) {
            return builder.lessThanOrEqualTo(
                    root.<String> get(criteria.getKey()), criteria.getValue().toString());
        }
        else if (criteria.getOperation().equalsIgnoreCase(":")) {
            if (root.get(criteria.getKey()).getJavaType() == String.class) {
                return builder.like(
                        root.<String>get(criteria.getKey()), "%" + criteria.getValue() + "%");
            } else {
                return builder.equal(root.get(criteria.getKey()), criteria.getValue());
            }
        }
        return null;
    }
}

This way you do not have to create separate implementations of Specification for each entity, unless you want to restrict some operations for some entity.

Answer 2

If I understand your goal correctly something like this should work.

public <T> Specification<T> build(Function<SearchCriteria, Specification<T>> mappingToSpecification) {
    if (params.size() == 0) {
        return null;
    }

    List<Specification<T>> specs = new ArrayList<>();
    for (SearchCriteria param : params) {
        specs.add(mappingToSpecification.apply(param));  //how to make here generic
    }

    Specification<T> result = specs.get(0);
    for (int i = 1; i < specs.size(); i++) {
        result = Specification.where(result).and(specs.get(i)); //warning 1
    }
    return result;
}

The build method has a type parameter allowing you to use it for different types, like so:

// Assumes builder.with has been called previously
builder.build(
    searchCriteria -> new MyObjectSpecification((SearchCriteria) searchCriteria)
);