Requête de dépôt jpa de données de ressort dynamique avec des clauses arbitraires et

vous pouvez utiliser les spécifications que Spring-data vous donne hors de la boîte. et être capable d'utiliser l'API de critères pour construire des requêtes de manière programmatique.Pour prendre en charge les spécifications, vous pouvez étendre votre interface de dépôt avec L'interface JpaSpecificationExecutor

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

}

l'interface supplémentaire (JpaSpecificationExecutor) comporte des méthodes qui vous permettent d'exécuter les spécifications de différentes façons.

par exemple, la méthode findAll retournera toutes les entités qui correspondent la spécification:

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

La Spécification de l'interface se présente comme suit:

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

D'accord, alors quel est le cas d'utilisation typique? Les spécifications peuvent facilement être utilisées pour construire un ensemble extensible de prédicats sur une entité qui peut ensuite être combiné et utilisé avec JpaRepository sans la nécessité de déclarer une requête (méthode) pour chaque combinaison nécessaire. Voici un exemple: Exemple 2.15. Spécifications pour un client

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
            }
        };
    }
}

vous avez exprimé certains critères au niveau de l'abstraction des besoins de l'entreprise et créé des spécifications exécutables. Ainsi, un client peut utiliser une spécification comme suit:

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

vous pouvez également combiner L'exemple de spécification 2.17. Spécifications Combinées

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

comme vous pouvez le voir, les spécifications offrent quelques méthodes de code à coller pour enchaîner et combiner les spécifications. Ainsi, l'extension de votre couche d'accès aux données est il suffit de créer de nouvelles implémentations de spécification et en les combinant avec celles déjà existantes.

et vous pouvez créer des spécifications Complexes, voici un exemple

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[] {}));
            }
        };
    }
}

Ici JPA Repository de docs

à Partir de Spring Data JPA 1.10 il y a une autre option pour ce qui est Interrogation Par Exemple. Votre dépôt devrait implémenter en dehors de JpaRepository QueryByExampleExecutor interface où vous obtenez des méthodes comme:

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

alors vous créez le Exemple pour la recherche de la forme:

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

puis:

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

si certains paramètres sont nuls, ils ne seront pas pris en compte dans la clause WHERE so you obtenez des requêtes dynamiques.

pour affiner la correspondance des attributs des chaînes de caractères, jetez un coup d'oeil à ExampleMatcher

ExampleMatcher ce qui fait unlike par exemple:

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

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