Qual è il modo "corretto" per eseguire il cast di Hibernate Query.list () in List <Type>?

Sono un principiante con Hibernate e sto scrivendo un metodo semplice per restituire un elenco di oggetti che corrispondono a un filtro specifico. List<Foo>sembrava un tipo di ritorno naturale.

Qualunque cosa faccia, non riesco a rendere felice il compilatore, a meno che non ne utilizzi un brutto @SuppressWarnings.

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;

public class Foo {

    public Session acquireSession() {
        // All DB opening, connection etc. removed,
        // since the problem is in compilation, not at runtime.
        return null;
    }

    @SuppressWarnings("unchecked") /* <----- */

    public List<Foo> activeObjects() {
        Session s = acquireSession();
        Query   q = s.createQuery("from foo where active");
        return (List<Foo>) q.list();
    }
}

Vorrei sbarazzarmeneSuppressWarnings . Ma se lo faccio, ricevo l'avvertimento

Warning: Unchecked cast from List to List<Foo>

(Posso ignorarlo, ma vorrei non ottenerlo in primo luogo) e se rimuovo il generico per conformarmi al .list()tipo restituito, ottengo l'avvertenza

Warning: List is a raw type. References to generic type List<E>
should be parameterized.

Ho notato che org.hibernate.mapping fa dichiarare unList ; ma è un tipo completamente diverso - Queryrestituisce a java.util.List, come tipo grezzo. Trovo strano che un Hibernate recente (4.0.x) non implementa i tipi parametrizzati, quindi sospetto che sia io invece a fare qualcosa di sbagliato.

Sembra molto simile risultato di Cast Hibernate a un elenco di oggetti , ma qui non ho errori "difficili" (il sistema conosce il tipo Foo e non sto usando una SQLQuery ma una semplice Query). Quindi nessuna gioia.

Ho anche esaminato l' eccezione di Hibernate Class Cast poiché sembrava promettente, ma poi mi sono reso conto di no realtà ricevo Exception... il mio problema è solo quello di un avvertimento - uno stile di codifica, se vuoi.

La documentazione su jboss.org, i manuali di Hibernate e diversi tutorial non sembrano trattare l'argomento in modo così dettagliato (o non ho cercato nei posti giusti?). Quando entrano nei dettagli, usano il casting al volo - e questo su tutorial che non erano sul sito ufficiale jboss.org, quindi sono un po 'diffidente.

Il codice, una volta compilato, funziona senza problemi apparenti ... che io sappia ... ancora; ei risultati sono quelli attesi.

Quindi: lo sto facendo bene? Mi manca qualcosa di ovvio? Esiste un modo "ufficiale" o "consigliato" per farlo ?

La risposta breve @SuppressWarningsè la strada giusta da percorrere.

Risposta lunga, Hibernate restituisce un raw Listdal Query.listmetodo, vedi qui . Questo non è un bug con Hibernate o qualcosa che può essere risolto, il tipo restituito dalla query non è noto in fase di compilazione.

Quindi quando scrivi

final List<MyObject> list = query.list();

Stai eseguendo un cast non sicuro da Lista List<MyObject>- questo non può essere evitato.

Non c'è modo di eseguire il cast in sicurezza poiché List potrebbe contenere qualsiasi cosa.

L'unico modo per far sparire l'errore è ancora più brutto

final List<MyObject> list = new LinkedList<>();
for(final Object o : query.list()) {
    list.add((MyObject)o);
}

La risoluzione consiste nell'usare invece TypedQuery. Quando crei una query da EntityManager chiamala in questo modo:

TypedQuery<[YourClass]> query = entityManager.createQuery("[your sql]", [YourClass].class);
List<[YourClass]> list = query.getResultList(); //no type warning

Funziona allo stesso modo per query con nome, query con nome native, ecc. I metodi corrispondenti hanno gli stessi nomi di quelli che restituirebbero la query vanilla. Usa questo invece di una query ogni volta che conosci il tipo di ritorno.

Puoi evitare gli avvisi del compilatore con soluzioni alternative come questa:

List<?> resultRaw = query.list();
List<MyObj> result = new ArrayList<MyObj>(resultRaw.size());
for (Object o : resultRaw) {
    result.add((MyObj) o);
}

Ma ci sono alcuni problemi con questo codice:

• creato ArrayList superfluo
• ciclo non necessario su tutti gli elementi restituiti dalla query
• codice più lungo.

E la differenza è solo estetica, quindi utilizzare soluzioni alternative è, a mio parere, inutile.

Devi convivere con questi avvertimenti o sopprimerli.

Per rispondere alla tua domanda, non esiste un "modo corretto" per farlo. Ora, se è solo l'avvertimento che ti dà fastidio, il modo migliore per evitarne la proliferazione è avvolgere il Query.list()metodo in un DAO:

public class MyDAO {

    @SuppressWarnings("unchecked")
    public static <T> List<T> list(Query q){
        return q.list();
    }
}

In questo modo puoi usare l' @SuppressWarnings("unchecked")unica volta.

L'unico modo in cui ha funzionato per me era con un Iterator.

Iterator iterator= query.list().iterator();
Destination dest;
ArrayList<Destination> destinations= new ArrayList<>();
Iterator iterator= query.list().iterator();
    while(iterator.hasNext()){
        Object[] tuple= (Object[]) iterator.next();
        dest= new Destination();
        dest.setId((String)tuple[0]);
        dest.setName((String)tuple[1]);
        dest.setLat((String)tuple[2]);
        dest.setLng((String)tuple[3]);
        destinations.add(dest);
    }

Con altri metodi che ho trovato, ho avuto problemi di lancio

List<Person> list = new ArrayList<Person>();
Criteria criteria = this.getSessionFactory().getCurrentSession().createCriteria(Person.class);
for (final Object o : criteria.list()) {
    list.add((Person) o);
}

Usi un ResultTransformer come quello:

public List<Foo> activeObjects() {
    Session s = acquireSession();
    Query   q = s.createQuery("from foo where active");
    q.setResultTransformer(Transformers.aliasToBean(Foo.class));
    return (List<Foo>) q.list();
}

Il modo corretto è usare i trasformatori Hibernate:

public class StudentDTO {
private String studentName;
private String courseDescription;

public StudentDTO() { }  
...
} 

.

List resultWithAliasedBean = s.createSQLQuery(
"SELECT st.name as studentName, co.description as courseDescription " +
"FROM Enrolment e " +
"INNER JOIN Student st on e.studentId=st.studentId " +
"INNER JOIN Course co on e.courseCode=co.courseCode")
.setResultTransformer( Transformers.aliasToBean(StudentDTO.class))
.list();

StudentDTO dto =(StudentDTO) resultWithAliasedBean.get(0);

L'iterazione attraverso Object [] è ridondante e avrebbe qualche penalità nelle prestazioni. Informazioni dettagliate sull'utilizzo dei transofrmers sono disponibili qui: Transformers for HQL e SQL

Se stai cercando una soluzione ancora più semplice, puoi utilizzare un trasformatore di mappa fuori dagli schemi:

List iter = s.createQuery(
"select e.student.name as studentName," +
"       e.course.description as courseDescription" +
"from   Enrolment as e")
.setResultTransformer( Transformers.ALIAS_TO_ENTITY_MAP )
.iterate();

String name = (Map)(iter.next()).get("studentName");

Solo usando Transformers Non ha funzionato per me stavo ricevendo un'eccezione di tipo cast.

sqlQuery.setResultTransformer(Transformers.aliasToBean(MYEngityName.class)) non ha funzionato perché stavo ottenendo Array of Object nell'elemento della lista di restituzione non nel tipo fisso di elemento della lista MYEngityName.

Ha funzionato per me quando apporto le seguenti modifiche Quando ho aggiunto sqlQuery.addScalar(-)ogni colonna selezionata e il suo tipo e per una colonna di tipo String specifica, non è necessario mappare il suo tipo. piaceaddScalar("langCode");

E mi sono unito a MYEngityName con NextEnity, non possiamo solo select *nella query che fornirà un array di oggetti nell'elenco di restituzione.

Di seguito il codice di esempio:

session = ht.getSessionFactory().openSession();
                String sql = new StringBuffer("Select txnId,nft.mId,count,retryReason,langCode FROM  MYEngityName nft INNER JOIN NextEntity m on nft.mId  =  m.id where nft.txnId < ").append(lastTxnId)
                       .append(StringUtils.isNotBlank(regionalCountryOfService)? " And  m.countryOfService in ( "+ regionalCountryOfService +" )" :"")
                       .append(" order by nft.txnId desc").toString();
                SQLQuery sqlQuery = session.createSQLQuery(sql);
                sqlQuery.setResultTransformer(Transformers.aliasToBean(MYEngityName.class));
                sqlQuery.addScalar("txnId",Hibernate.LONG)
                        .addScalar("merchantId",Hibernate.INTEGER)
                        .addScalar("count",Hibernate.BYTE)
                        .addScalar("retryReason")
                        .addScalar("langCode");
                sqlQuery.setMaxResults(maxLimit);
                return sqlQuery.list();

Potrebbe aiutare qualcuno. in questo modo lavora per me.

Ho trovato la soluzione migliore qui , la chiave di questo problema è il metodo addEntity

public static void testSimpleSQL() {
    final Session session = sessionFactory.openSession();
    SQLQuery q = session.createSQLQuery("select * from ENTITY");
    q.addEntity(Entity.class);
    List<Entity> entities = q.list();
    for (Entity entity : entities) {
        System.out.println(entity);
    }
}