Consulta dinámica del repositorio jpa de datos de primavera con cláusulas arbitrarias y

Puede usar las especificaciones que Spring-data le proporciona de inmediato. y ser capaz de usar la API de criterios para crear consultas programmatically.To especificaciones de soporte puede ampliar su interfaz de repositorio con la interfaz JpaSpecificationExecutor

public interface CustomerRepository extends SimpleJpaRepository<T, ID>, JpaSpecificationExecutor {

}

La interfaz adicional(JpaSpecificationExecutor ) lleva métodos que le permiten ejecutar Especificaciones de una variedad de maneras.

Por ejemplo, el método findAll devolverá todas las entidades que coincidan con especificación:

List<T> findAll(Specification<T> spec);

La interfaz de especificación es la siguiente:

public interface Specification<T> {
     Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}

Bien, entonces, ¿cuál es el caso de uso típico? Las especificaciones se pueden usar fácilmente para construir un conjunto extensible de predicados sobre una entidad que luego se puede combinar y usar con JpaRepository sin la necesidad de declarar una consulta (método) para cada combinación necesaria. Aquí hay un ejemplo: Ejemplo 2.15. Especificaciones para un cliente

public class CustomerSpecs {
    public static Specification<Customer> isLongTermCustomer() {
        return new Specification<Customer>() {
            public Predicate toPredicate(
                Root<Customer> root, CriteriaQuery<?> query,
                CriteriaBuilder builder) {
                LocalDate date = new LocalDate().minusYears(2);
                return builder.lessThan(root.get('dateField'), date);
            }
        };
    }

    public static Specification<Customer> hasSalesOfMoreThan(MontaryAmount value) {
        return new Specification<Customer>() {
            public Predicate toPredicate(
                Root<T> root, CriteriaQuery<?> query,
                CriteriaBuilder builder) {
                // build query here
            }
        };
    }
}

Usted expresó algunos criterios sobre un requisito de negocio nivel de abstracción y especificaciones ejecutables creadas. Así que un cliente podría usar una Especificación de la siguiente manera:

List customers = customerRepository.findAll(isLongTermCustomer());

También puede combinar el Ejemplo de especificación 2.17. Especificaciones combinadas

    MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
    List<Customer> customers = customerRepository.findAll(
        where(isLongTermCustomer()).or(hasSalesOfMoreThan(amount)));

Como puede ver, Specifications ofrece algunos métodos de código de pegamento para encadenar y combinar Especificaciones. Por lo tanto, extender su capa de acceso a datos es solo es cuestión de crear nuevas implementaciones de especificaciones y combinándolos con otros ya existente.

Y puede crear Especificaciones Complejas, aquí hay un ejemplo

public class WorkInProgressSpecification {
    public static Specification<WorkInProgress> findByCriteria(final SearchCriteria searchCriteria) {

        return new Specification<WorkInProgress>() {

            @Override
            public Predicate toPredicate(
                Root<WorkInProgress> root,
                CriteriaQuery<?> query, CriteriaBuilder cb) {

                List<Predicate> predicates = new ArrayList<Predicate>();

                if (searchCriteria.getView() != null && !searchCriteria.getView().isEmpty()) {
                    predicates.add(cb.equal(root.get("viewType"), searchCriteria.getView()));
                }
                if (searchCriteria.getFeature() != null && !searchCriteria.getFeature().isEmpty()) {
                    predicates.add(cb.equal(root.get("title"), searchCriteria.getFeature()));
                }
                if (searchCriteria.getEpic() != null && !searchCriteria.getEpic().isEmpty()) {
                    predicates.add(cb.equal(root.get("epic"), searchCriteria.getEpic()));
                }
                if (searchCriteria.getPerformingGroup() != null && !searchCriteria.getPerformingGroup().isEmpty()) {
                    predicates.add(cb.equal(root.get("performingGroup"), searchCriteria.getPerformingGroup()));
                }
                if (searchCriteria.getPlannedStartDate() != null) {
                    System.out.println("searchCriteria.getPlannedStartDate():" + searchCriteria.getPlannedStartDate());
                    predicates.add(cb.greaterThanOrEqualTo(root.<Date>get("plndStartDate"), searchCriteria.getPlannedStartDate()));
                }
                if (searchCriteria.getPlannedCompletionDate() != null) {
                    predicates.add(cb.lessThanOrEqualTo(root.<Date>get("plndComplDate"), searchCriteria.getPlannedCompletionDate()));
                }
                if (searchCriteria.getTeam() != null && !searchCriteria.getTeam().isEmpty()) {
                    predicates.add(cb.equal(root.get("agileTeam"), searchCriteria.getTeam()));
                }

                return cb.and(predicates.toArray(new Predicate[] {}));
            }
        };
    }
}

Aquí están los Respositorios de JPA docs

Desde Spring Data JPA 1.10 hay otra opción para esto es Consulta Por Ejemplo. Su repositorio debe implementar aparte de JpaRepository también la interfaz QueryByExampleExecutor donde obtiene métodos como:

<S extends T> Iterable<S> findAll(Example<S> example)

Luego crea el Ejemplo para buscar como:

Employee e = new Employee();
e.setEmployeeNumber(getEmployeeNumberSomewherFrom());
e.setName(getNameSomewhereFrom());
e.setMarried(getMarriedSomewhereFrom());
e.setProfession(getProfessionSomewhereFrom());
e.setDateOfBirth(getDateOfBirthSomewhereFrom());

Y luego:

employeeRepository.findAll(Example.of(e));

Si algunos parámetros son null no se tomarán en la cláusula WHERE para obtener consultas dinámicas.

Para refinar la coincidencia de Atributos de cadena echa un vistazo a ExampleMatcher's

Un ExampleMatcher que no distingue mayúsculas de minúsculas like es por ejemplo:

ExampleMatcher matcher = ExampleMatcher.matching().
          withMatcher("profession", ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.CONTAINING).ignoreCase());

Ejemplos de QBE: https://github.com/spring-projects/spring-data-examples/tree/master/jpa/query-by-example