JPA getSingleResult () ou null

J'ai une insertOrUpdateméthode qui insère un Entityquand il n'existe pas ou le met à jour s'il existe. Pour activer cela, je dois findByIdAndForeignKey, s'il retourne nullinsérer sinon, mettre à jour. Le problème est de savoir comment vérifier s'il existe? Alors j'ai essayé getSingleResult. Mais cela lève une exception si le

public Profile findByUserNameAndPropertyName(String userName, String propertyName) {
    String namedQuery = Profile.class.getSimpleName() + ".findByUserNameAndPropertyName";
    Query query = entityManager.createNamedQuery(namedQuery);
    query.setParameter("name", userName);
    query.setParameter("propName", propertyName);
    Object result = query.getSingleResult();
    if (result == null) return null;
    return (Profile) result;
}

mais getSingleResultjette un Exception.

Merci

Lancer une exception est la façon dont getSingleResult()indique qu'elle est introuvable. Personnellement, je ne supporte pas ce genre d'API. Cela force la gestion des exceptions parasites sans réel avantage. Il vous suffit d'encapsuler le code dans un bloc try-catch.

Vous pouvez également rechercher une liste et voir si elle est vide. Cela ne fait pas exception. En fait, étant donné que vous ne faites pas techniquement une recherche de clé primaire, il peut y avoir plusieurs résultats (même si l'un, les deux ou la combinaison de vos clés ou contraintes étrangères rend cela impossible dans la pratique), c'est probablement la solution la plus appropriée.

J'ai encapsulé la logique dans la méthode d'aide suivante.

public class JpaResultHelper {
    public static Object getSingleResultOrNull(Query query){
        List results = query.getResultList();
        if (results.isEmpty()) return null;
        else if (results.size() == 1) return results.get(0);
        throw new NonUniqueResultException();
    }
}

Essayez ceci dans Java 8:

Optional first = query.getResultList().stream().findFirst();

Voici une bonne option pour faire cela:

public static <T> T getSingleResult(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list == null || list.isEmpty()) {
        return null;
    }

    return list.get(0);
}

Spring a une méthode utilitaire pour cela:

TypedQuery<Profile> query = em.createNamedQuery(namedQuery, Profile.class);
...
return org.springframework.dao.support.DataAccessUtils.singleResult(query.getResultList());

J'ai fait (en Java 8):

query.getResultList().stream().findFirst().orElse(null);

À partir de JPA 2.2 , au lieu de .getResultList()vérifier si la liste est vide ou de créer un flux, vous pouvez renvoyer le flux et prendre le premier élément.

.getResultStream()
.findFirst()
.orElse(null);

Si vous souhaitez utiliser le mécanisme try / catch pour gérer ce problème .. alors il peut être utilisé pour agir comme if / else. J'ai utilisé le try / catch pour ajouter un nouvel enregistrement alors que je n'en trouvais pas un existant.

try {  //if part

    record = query.getSingleResult();   
    //use the record from the fetched result.
}
catch(NoResultException e){ //else part
    //create a new record.
    record = new Record();
    //.........
    entityManager.persist(record); 
}

Voici une version typée / générique, basée sur l'implémentation de Rodrigo IronMan:

 public static <T> T getSingleResultOrNull(TypedQuery<T> query) {
    query.setMaxResults(1);
    List<T> list = query.getResultList();
    if (list.isEmpty()) {
        return null;
    }
    return list.get(0);
}

Il existe une alternative que je recommanderais:

Query query = em.createQuery("your query");
List<Element> elementList = query.getResultList();
return CollectionUtils.isEmpty(elementList ) ? null : elementList.get(0);

Cette sauvegarde contre l'exception de pointeur nul, garantit qu'un seul résultat est renvoyé.

Alors ne fais pas ça!

Vous avez deux options:

1. Exécutez une sélection pour obtenir le COUNT de votre jeu de résultats et n'extrayez les données que si ce nombre est différent de zéro; ou

2. Utilisez l'autre type de requête (qui obtient un jeu de résultats) et vérifiez si elle a 0 ou plusieurs résultats. Il devrait en avoir 1, alors retirez-le de votre collection de résultats et vous avez terminé.

J'irais avec la deuxième suggestion, en accord avec Cletus. Il donne de meilleures performances que (potentiellement) 2 requêtes. Moins de travail aussi.

En combinant les bits utiles des réponses existantes (limiter le nombre de résultats, vérifier que le résultat est unique) et en utilisant le nom de la méthode estabilshed (Hibernate), on obtient:

/**
 * Return a single instance that matches the query, or null if the query returns no results.
 *
 * @param query query (required)
 * @param <T> result record type
 * @return record or null
 */
public static <T> T uniqueResult(@NotNull TypedQuery<T> query) {
    List<T> results = query.setMaxResults(2).getResultList();
    if (results.size() > 1) throw new NonUniqueResultException();
    return results.isEmpty() ? null : results.get(0);
}

La méthode non documentée uniqueResultOptionaldans org.hibernate.query.Query devrait faire l'affaire. Au lieu d'avoir à attraper un, NoResultExceptionvous pouvez simplement appeler query.uniqueResultOptional().orElse(null).

J'ai résolu ce problème en utilisant List<?> myList = query.getResultList();et en vérifiant si myList.size()égal à zéro.

Voici la même logique que d'autres suggérées (obtenir le resultList, renvoyer son seul élément ou null), en utilisant Google Guava et un TypedQuery.

public static <T> getSingleResultOrNull(final TypedQuery<T> query) {
    return Iterables.getOnlyElement(query.getResultList(), null); 
}

Notez que Guava renverra l'exception IllegalArgumentException peu intuitive si le jeu de résultats a plus d'un résultat. (L'exception a du sens pour les clients de getOnlyElement (), car elle prend la liste de résultats comme argument, mais est moins compréhensible pour les clients de getSingleResultOrNull ().)

Voici une autre extension, cette fois dans Scala.

customerQuery.getSingleOrNone match {
  case Some(c) => // ...
  case None    => // ...
}

Avec ce souteneur:

import javax.persistence.{NonUniqueResultException, TypedQuery}
import scala.collection.JavaConversions._

object Implicits {

  class RichTypedQuery[T](q: TypedQuery[T]) {

    def getSingleOrNone : Option[T] = {

      val results = q.setMaxResults(2).getResultList

      if (results.isEmpty)
        None
      else if (results.size == 1)
        Some(results.head)
      else
        throw new NonUniqueResultException()
    }
  }

  implicit def query2RichQuery[T](q: TypedQuery[T]) = new RichTypedQuery[T](q)
}

Regardez ce code:

return query.getResultList().stream().findFirst().orElse(null);

Quand findFirst()est appelé peut-être peut-être lancé une NullPointerException.

la meilleure approche est:

return query.getResultList().stream().filter(Objects::nonNull).findFirst().orElse(null);

Donc, toute la solution «essayez de réécrire sans exception» dans cette page a un problème mineur. Soit il ne lance pas d'exception NonUnique, ni ne le lance également dans certains cas erronés (voir ci-dessous).

Je pense que la bonne solution est (peut-être) celle-ci:

public static <L> L getSingleResultOrNull(TypedQuery<L> query) {
    List<L> results = query.getResultList();
    L foundEntity = null;
    if(!results.isEmpty()) {
        foundEntity = results.get(0);
    }
    if(results.size() > 1) {
        for(L result : results) {
            if(result != foundEntity) {
                throw new NonUniqueResultException();
            }
        }
    }
    return foundEntity;
}

Son retour avec null s'il y a 0 élément dans la liste, retourne non unique s'il y a différents éléments dans la liste, mais ne retourne pas non-unique quand l'un de vos sélections n'est pas correctement conçu et retourne le même objet plus d'une fois.

N'hésitez pas à commenter.

J'ai réalisé cela en obtenant une liste de résultats puis en vérifiant si elle est vide

public boolean exist(String value) {
        List<Object> options = getEntityManager().createNamedQuery("AppUsers.findByEmail").setParameter('email', value).getResultList();
        return !options.isEmpty();
    }

C'est tellement ennuyeux qui getSingleResult()jette des exceptions

Jette:

1. NoResultException - s'il n'y a pas de résultat
2. NonUniqueResultException - si plus d'un résultat et une autre exception sur laquelle vous pouvez obtenir plus d'informations à partir de leur documentation

Cela fonctionne pour moi:

Optional<Object> opt = Optional.ofNullable(nativeQuery.getSingleResult());
return opt.isPresent() ? opt.get() : null;