JPA getSingleResult () oder null

Ich habe eine insertOrUpdateMethode, die ein einfügt, Entitywenn es nicht existiert, oder es aktualisiert, wenn es existiert. Um dies zu aktivieren, muss ich findByIdAndForeignKey, wenn es zurückgegeben hat, nulleinfügen, wenn nicht, dann aktualisieren. Das Problem ist, wie überprüfe ich, ob es existiert? Also habe ich es versucht getSingleResult. Aber es löst eine Ausnahme aus, wenn die

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

aber getSingleResultwirft ein Exception.

Vielen Dank

Das Auslösen einer Ausnahme getSingleResult()zeigt an, dass sie nicht gefunden werden kann. Persönlich kann ich diese Art von API nicht ausstehen. Es erzwingt eine falsche Ausnahmebehandlung ohne wirklichen Nutzen. Sie müssen den Code nur in einen Try-Catch-Block einschließen.

Alternativ können Sie eine Liste abfragen und prüfen, ob sie leer ist. Das wirft keine Ausnahme. Da Sie technisch gesehen keine Primärschlüssel-Suche durchführen, kann es zu mehreren Ergebnissen kommen (selbst wenn einer, beide oder die Kombination Ihrer Fremdschlüssel oder Einschränkungen dies in der Praxis unmöglich macht). Dies ist wahrscheinlich die geeignetere Lösung.

Ich habe die Logik in der folgenden Hilfsmethode gekapselt.

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

Versuchen Sie dies in Java 8:

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

Hier ist eine gute Option dafür:

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 hat hierfür eine Utility-Methode :

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

Ich habe getan (in Java 8):

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

Ab JPA 2.2 können Sie anstelle von .getResultList()und überprüfen, ob die Liste leer ist oder einen Stream erstellen, den Stream zurückgeben und das erste Element übernehmen.

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

Wenn Sie den Try / Catch-Mechanismus verwenden möchten, um dieses Problem zu lösen, können Sie sich wie if / else verhalten. Ich habe try / catch verwendet, um einen neuen Datensatz hinzuzufügen, wenn ich keinen vorhandenen gefunden habe.

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

Hier ist eine typisierte / generische Version, die auf der Implementierung von Rodrigo IronMan basiert:

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

Es gibt eine Alternative, die ich empfehlen würde:

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

Dies schützt vor einer Nullzeiger-Ausnahme und garantiert, dass nur 1 Ergebnis zurückgegeben wird.

Also tu das nicht!

Sie haben zwei Möglichkeiten:

1. Führen Sie eine Auswahl aus, um den COUNT Ihrer Ergebnismenge zu erhalten, und ziehen Sie die Daten nur ein, wenn diese Anzahl ungleich Null ist. oder

2. Verwenden Sie die andere Art von Abfrage (die eine Ergebnismenge erhält) und prüfen Sie, ob 0 oder mehr Ergebnisse vorliegen. Es sollte 1 haben, also ziehen Sie das aus Ihrer Ergebnissammlung und Sie sind fertig.

Ich würde dem zweiten Vorschlag in Übereinstimmung mit Cletus folgen. Es bietet eine bessere Leistung als (möglicherweise) 2 Abfragen. Auch weniger Arbeit.

Durch Kombinieren der nützlichen Bits der vorhandenen Antworten (Begrenzen der Anzahl der Ergebnisse, Überprüfen, ob das Ergebnis eindeutig ist) und Verwenden des Namens der stabilisierbaren Methode (Ruhezustand) erhalten wir:

/**
 * 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);
}

Die undokumentierte Methode uniqueResultOptionalin org.hibernate.query.Query sollte den Trick ausführen. Anstatt einen zu fangen NoResultException, können Sie einfach anrufen query.uniqueResultOptional().orElse(null).

Ich habe dies gelöst, indem ich verwendet List<?> myList = query.getResultList();und überprüft habe, ob es myList.size()gleich Null ist.

Hier ist die gleiche Logik wie von anderen vorgeschlagen (Abrufen der Ergebnisliste, Zurückgeben des einzigen Elements oder Null) unter Verwendung von Google Guava und einer TypedQuery.

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

Beachten Sie, dass Guava die nicht intuitive IllegalArgumentException zurückgibt, wenn die Ergebnismenge mehr als ein Ergebnis enthält. (Die Ausnahme ist für Clients von getOnlyElement () sinnvoll, da sie die Ergebnisliste als Argument verwendet, für Clients von getSingleResultOrNull () jedoch weniger verständlich ist.)

Hier ist eine weitere Erweiterung, diesmal in Scala.

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

Mit diesem Zuhälter:

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

Schauen Sie sich diesen Code an:

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

Wenn findFirst()aufgerufen wird, kann möglicherweise eine NullPointerException ausgelöst werden.

Der beste Ansatz ist:

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

Die gesamte Lösung "Versuchen Sie ausnahmslos, neu zu schreiben" auf dieser Seite weist daher ein kleines Problem auf. Entweder wird keine NonUnique-Ausnahme ausgelöst, oder es wird auch in einigen falschen Fällen eine Ausnahme ausgelöst (siehe unten).

Ich denke, die richtige Lösung ist (vielleicht) folgende:

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

Es wird mit null zurückgegeben, wenn die Liste 0 Elemente enthält, und es wird nicht eindeutig zurückgegeben, wenn die Liste verschiedene Elemente enthält. Es wird jedoch nicht eindeutig zurückgegeben, wenn eines Ihrer ausgewählten Elemente nicht ordnungsgemäß entworfen wurde und dasselbe Objekt mehrmals zurückgibt.

Fühlen Sie sich frei zu kommentieren.

Ich habe dies erreicht, indem ich eine Ergebnisliste erhalten und dann überprüft habe, ob sie leer ist

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

Es ist so nervig, dass es getSingleResult()Ausnahmen gibt

Würfe:

1. NoResultException - wenn kein Ergebnis vorliegt
2. NonUniqueResultException - Wenn mehr als ein Ergebnis und eine andere Ausnahme vorliegen, zu der Sie weitere Informationen aus der Dokumentation erhalten können

Das funktioniert bei mir:

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