JPA getSingleResult () o null

Ho un insertOrUpdatemetodo che inserisce un Entityquando non esiste o lo aggiorna se lo fa. Per abilitare questo, devo findByIdAndForeignKey, se restituito nullinserire se non quindi aggiornare. Il problema è come posso verificare se esiste? Quindi ci ho provato getSingleResult. Ma genera un'eccezione se il

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

ma getSingleResultgenera un Exception.

Grazie

Lanciare un'eccezione è come getSingleResult() indica che non può essere trovato. Personalmente non sopporto questo tipo di API. Forza la gestione spuria delle eccezioni senza alcun vantaggio reale. Devi solo racchiudere il codice in un blocco try-catch.

In alternativa puoi cercare un elenco e vedere se è vuoto. Questo non fa eccezione. In realtà, dal momento che tecnicamente non stai effettuando una ricerca della chiave primaria, potrebbero esserci più risultati (anche se uno, entrambi o la combinazione di chiavi esterne o vincoli lo rendono impossibile nella pratica), quindi questa è probabilmente la soluzione più appropriata.

Ho incapsulato la logica nel seguente metodo di supporto.

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

Prova questo in Java 8:

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

Ecco una buona opzione per farlo:

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 ha un metodo di utilità per questo:

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

Ho fatto (in Java 8):

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

Da JPA 2.2 , invece di .getResultList()e controllare se l'elenco è vuoto o creare un flusso è possibile restituire il flusso e prendere il primo elemento.

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

Se si desidera utilizzare il meccanismo try / catch per gestire questo problema ... allora può essere usato per agire come se / else. Ho usato il tentativo / cattura per aggiungere un nuovo record quando non ne ho trovato uno esistente.

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

Ecco una versione tipizzata / generica, basata sull'implementazione di 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);
}

C'è un'alternativa che consiglierei:

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

Questa protezione contro l'eccezione del puntatore null, garantisce solo 1 risultato restituito.

Quindi non farlo!

Hai due opzioni:

1. Esegui una selezione per ottenere il COUNT del set di risultati e inserisci i dati solo se questo conteggio è diverso da zero; o

2. Utilizzare l'altro tipo di query (che ottiene un set di risultati) e verificare se ha 0 o più risultati. Dovrebbe avere 1, quindi estrailo dalla raccolta dei risultati e il gioco è fatto.

Andrei con il secondo suggerimento, in accordo con Cletus. Offre prestazioni migliori rispetto (potenzialmente) a 2 query. Anche meno lavoro.

Combinando i bit utili delle risposte esistenti (limitando il numero di risultati, verificando che il risultato sia univoco) e usando il nome del metodo stabilito (Hibernate), otteniamo:

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

Il metodo non documentato uniqueResultOptionalin org.hibernate.query.Query dovrebbe fare il trucco. Invece di dover prendere un NoResultExceptionpuoi semplicemente chiamare query.uniqueResultOptional().orElse(null).

Ho risolto questo usando List<?> myList = query.getResultList();e controllando se è myList.size()uguale a zero.

Ecco la stessa logica suggerita da altri (ottieni l'elenco dei risultati, restituisce il suo unico elemento o null), utilizzando Google Guava e un TypedQuery.

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

Si noti che Guava restituirà illegalintuitivo IllegalArgumentException se il set di risultati ha più di un risultato. (L'eccezione ha senso per i client di getOnlyElement (), poiché considera l'elenco dei risultati come argomento, ma è meno comprensibile per i client di getSingleResultOrNull ().)

Ecco un'altra estensione, questa volta a Scala.

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

Con questo magnaccia:

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

Guarda questo codice:

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

quando findFirst() viene chiamato, forse può essere lanciata una NullPointerException.

il miglior approccio è:

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

Quindi tutta la soluzione "prova a riscrivere senza eccezioni" in questa pagina presenta un problema minore. O non genera l'eccezione NonUnique, né in alcuni casi sbagliati (vedi sotto).

Penso che la soluzione corretta sia (forse) questa:

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

Viene restituito con null se è presente 0 elemento nell'elenco, restituisce non univoco se ci sono elementi diversi nell'elenco, ma non restituisce non univoco quando una delle selezioni non è progettata correttamente e restituisce lo stesso oggetto più di una volta.

Sentiti libero di commentare.

Ho raggiunto questo obiettivo ottenendo un elenco di risultati e verificando se è vuoto

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

È così fastidioso che getSingleResult()genera eccezioni

Produce:

1. NoResultException - se non ci sono risultati
2. NonUniqueResultException - se più di un risultato e qualche altra eccezione è possibile ottenere maggiori informazioni dalla loro documentazione

Questo per me funziona:

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