Spring data JPA how to create a generic specification builder

user_9772778 0
Viewed 9259

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: enter image description here

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?

spring-data-jpa generics java
2 Answers

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)
);
Jens_Schauder_666860

public class GenericSpecificationBuilder {

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 donot have to create seperate implementations of Specification for each entity, unless you want to restrict some operations for some entity.

user_107778660
Related