JPA Critères de l'API avec plusieurs paramètres

J'ai besoin de faire une méthode de recherche qui utilise la JPA Critères de l'API avec plusieurs paramètres.
Maintenant, le problème est que chaque paramètre est requis. Ainsi, certains pourraient être nulle, et qu'ils ne devraient pas être inclus dans la requête. J'ai essayé cela avec la CriteriaBuilder mais je ne pouvais pas voir comment le faire fonctionner.

Avec Hibernate Critères d'API c'est assez facile. Il suffit de créer les critères et ensuite ajouter des Restrictions.

Criteria criteria = session.createCriteria(someClass.class);
if(someClass.getName() != null) {
   criteria.add(Restrictions.like("name", someClass.getName());
}

Comment aurais-je pu réaliser la même chose avec JPA Critères d'API?

InformationsquelleAutor mokuril | 2012-08-30

Concept est de construire la matrice de javax.la persistance.Prédicat qui ne contient que des prédicats que nous voulons utiliser:

Exemple de l'entité à être interrogé:

@Entity
public class A {
    @Id private Long id;    
    String someAttribute;
    String someOtherAttribute;
    ...
}

Requête elle-même:

    //some parameters to your method
    String param1 = "1";
    String paramNull = null;

    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery cq = qb.createQuery();
    Root<A> customer = cq.from(A.class);

    //Constructing list of parameters
    List<Predicate> predicates = new ArrayList<Predicate>();

    //Adding predicates in case of parameter not being null
    if (param1 != null) {
        predicates.add(
                qb.equal(customer.get("someAttribute"), param1));
    }
    if (paramNull != null) {
        predicates.add(
                qb.equal(customer.get("someOtherAttribute"), paramNull));
    }
    //query itself
    cq.select(customer)
            .where(predicates.toArray(new Predicate[]{}));
    //execute query and do something with result
    em.createQuery(cq).getResultList();

Comment obtenez-vous l' em exemple ?
em c'est l'EntityManager, serait probablement juste être autocâblés dans. La config de la classe configurer.

InformationsquelleAutor Mikko Maunu

6

Prendre un coup d'oeil à ce site JPA Critères d'API. Il y a beaucoup d'exemples.

Mise à jour: Fournir un exemple concret

Nous allons chercher pour les Comptes avec un solde inférieur à une valeur spécifique:
```
SELECT a FROM Account a WHERE a.balance < :value
```
D'abord créer un critère Constructeur
```
CriteriaBuilder builder = entityManager.getCriteriaBuilder();

CriteriaQuery<Account> accountQuery = builder.createQuery(Account.class);
Root<Account> accountRoot = accountQuery.from(Account.class);
ParameterExpression<Double> value = builder.parameter(Double.class);
accountQuery.select(accountRoot).where(builder.lt(accountRoot.get("balance"), value));
```
Pour obtenir le résultat régler le paramètre(s) et exécutez la requête:
```
TypedQuery<Account> query = entityManager.createQuery(accountQuery);
query.setParameter(value, 1234.5);
List<Account> results = query.getResultList();
```
BTW: L'entityManager est injecté quelque part dans un EJB/Service/DAO.
- Si je n'ai pas définir un paramètre, comment cela va se refléter dans la requête? Depuis que j'ai encore besoin d'ajouter d'autres paramètres à la CriteriaQuery. Et si l'un d'eux est nul cela va conduire à des résultats inattendus.
InformationsquelleAutor Sal
1

Mikko réponse a fonctionné à merveille. Seul changement que j'avais besoin de faire, est de le remplacer:

cq.select(customer).where(predicates.toArray(new Predicate[]{}));

avec:
```
Predicate [] predicatesarr = predicates.toArray(new Predicate[predicates.size()]); 
cq.select(customer).where(predicatesarr);
```
Quelque part la conversion de liste à un tableau à l'origine, n'a pas de travail.

InformationsquelleAutor Vandana Chadha

D'abord, Mikko réponse que m'a fait ma réponse. Upvote pour que.

Mon scénario était que je voulais relation parent/enfant et je voulais trouver une correspondance sur ~tout~ l'enfant.

Employé a plusieurs JobTitle(s).

Je voulais trouver un employé (où la a de nombreux titres d'emploi), mais le trouver sur ~tout de la jobtitles-je envoyer.

SQL ressemblerait à:

Select * from dbo.Employé (e) s se joindre dbo.JobTitle jt de l'e.EmployeeKey = jt.EmployeeKey
OÙ ( jt.JobTitleName = "programmeur" OU jt.JobTitleName = 'badcop' )

Je l'ai jeté dans le sexe et la date de naissance pour compléter l'exemple (et de donner plus de "facultatif") critères d')

Mon JPA code

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.jpa.domain.Specification;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
public class MyEmployeeSpecification implements Specification<MyEmployee> {
private MyEmployee filter;
public MyEmployeeSpecification(MyEmployee filter) {
super();
this.filter = filter;
}
public Predicate toPredicate(Root<MyEmployee> root, CriteriaQuery<?> cq,
CriteriaBuilder cb) {
Predicate returnPred = cb.disjunction();
List<Predicate> patientLevelPredicates = new ArrayList<Predicate>();
if (filter.getBirthDate() != null) {
patientLevelPredicates.add(
cb.equal(root.get("birthDate"), filter.getBirthDate()));
}
if (filter.getBirthDate() != null) {
patientLevelPredicates.add(
cb.equal(root.get("gender"), filter.getGender()));
}
if (null != filter.getJobTitles() && filter.getJobTitles().size() > 0) {
List<Predicate> jobTitleLevelPredicates = new ArrayList<Predicate>();
Join<JobTitle, JobTitle> hnJoin = root.join("jobtitles");
for (JobTitle hnw : filter.getJobTitles()) {
if (null != hnw) {
if (StringUtils.isNotBlank(hnw.getJobTitleName())) {
jobTitleLevelPredicates.add(cb.equal(hnJoin.get("getJobTitleName"), hnw.getFamily()));
}
}
}
patientLevelPredicates.add(cb.or(jobTitleLevelPredicates.toArray(new Predicate[]{})));
}
returnPred = cb.and(patientLevelPredicates.toArray(new Predicate[]{}));
return returnPred;
}
}

Mais j'ai pensé que la mienne à cause de prédicats.toArray(new Prédicat[]{}) , aka, les varargs truc. (Merci Mikko)

Je fais aussi de la "implémente Specifiction" la méthode.

Autres liens utiles:

JPA cahier des charges par Exemple

JPA CriteriaBuilder conjointement à des critères d'une disjonction critères

InformationsquelleAutor granadaCoder

Une solution simple pour le Printemps, en utilisant les expressions lambda:

Specification<User> specification = (root, query, builder) -> {
List<Predicate> predicates = new ArrayList<>();
if (!Optional.ofNullable(criteria.getName()).orElse("").equals("")) {
//like
predicates.add(builder.like(root.get("name"), "%" + criteria.getName() + "%"));
}
if (Optional.ofNullable(criteria.getParentId()).orElse(0L) != 0) {
//equal
predicates.add(builder.equal(root.get("parent"), criteria.getParentId()));
}
//AND all predicates
return builder.and(predicates.toArray(new Predicate[0]));
};
repository.findAll(specification);

InformationsquelleAutor Hamid Mohayeji

Vous devez vous connecter pour publier un commentaire.