Ad esempio, ho una domanda del genere:

Query q = sess.createQuery("from Cat cat");
List cats = q.list();

Se provo a fare qualcosa di simile, mostra il seguente avviso

Type safety: The expression of type List needs unchecked conversion to conform to List<Cat>


List<Cat> cats = q.list();

C'è un modo per evitarlo?

Usarlo @SuppressWarningsovunque, come suggerito, è un buon modo per farlo, anche se implica un po 'di digitazione con le dita ogni volta che chiami q.list().

Ci sono altre due tecniche che suggerirei:

Scrivi un cast-helper

Rifattorizza semplicemente tutto @SuppressWarningsin un unico posto:

List<Cat> cats = MyHibernateUtils.listAndCast(q);

...

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

Impedire a Eclipse di generare avvisi per problemi inevitabili

In Eclipse, vai su Finestra> Preferenze> Java> Compilatore> Errori / Avvisi e in Tipo generico, seleziona la casella di controllo Ignore unavoidable generic type problems due to raw APIs

Ciò disattiverà gli avvisi non necessari per problemi simili come quello descritto sopra che sono inevitabili.

Alcuni commenti:

• Ho scelto di passare al Queryinvece del risultato di q.list()perché in questo modo questo metodo di "imbroglio" può essere utilizzato solo per barare con Hibernate, e non per barare Listin generale.
• Potresti aggiungere metodi simili per .iterate()ecc.

È passato molto tempo da quando è stata posta la domanda, ma spero che la mia risposta possa essere utile a qualcuno come me.

Se dai un'occhiata alla documentazione api javax.persistence , vedrai che da allora sono stati aggiunti alcuni nuovi metodi Java Persistence 2.0. Uno di questi è createQuery(String, Class<T>)che ritorna TypedQuery<T>. Puoi usarlo TypedQueryesattamente come l'hai fatto Querycon quella piccola differenza che tutte le operazioni sono ora sicure.

Quindi, cambia il tuo codice in questo modo:

Query q = sess.createQuery("from Cat cat", Cat.class);
List<Cat> cats = q.list();

E sei pronto.

Lo usiamo @SuppressWarnings("unchecked")anche noi, ma molto spesso cerchiamo di usarlo solo sulla dichiarazione della variabile, non sul metodo nel suo insieme:

public List<Cat> findAll() {
    Query q = sess.createQuery("from Cat cat");
    @SuppressWarnings("unchecked")
    List<Cat> cats = q.list();
    return cats;
}

Prova a usare TypedQueryinvece di Query. Ad esempio invece di questo: -

Query q = sess.createQuery("from Cat cat", Cat.class);
List<Cat> cats = q.list();

Usa questo:-

TypedQuery<Cat> q1 = sess.createQuery("from Cat cat", Cat.class);
List<Cat> cats = q1.list();

Nel nostro codice annotiamo i metodi chiamanti con:

@SuppressWarnings ( "incontrollato")

So che sembra un hack, ma un co-sviluppatore ha controllato di recente e ha scoperto che era tutto ciò che potevamo fare.

Apparentemente, il metodo Query.list () nell'API Hibernate non è sicuro "per impostazione predefinita" e non ci sono piani per cambiarlo .

Credo che la soluzione più semplice per evitare gli avvisi del compilatore sia in effetti aggiungere @SuppressWarnings ("unchecked"). Questa annotazione può essere inserita a livello di metodo o, se all'interno di un metodo, subito prima di una dichiarazione di variabile.

Nel caso in cui si disponga di un metodo che incapsula Query.list () e restituisce List (o Collection), viene visualizzato anche un avviso. Ma questo è soppresso usando @SuppressWarnings ("rawtypes").

Il metodo listAndCast (Query) proposto da Matt Quail è meno flessibile di Query.list (). Mentre posso fare:

Query q = sess.createQuery("from Cat cat");
ArrayList cats = q.list();

Se provo il codice qui sotto:

Query q = sess.createQuery("from Cat cat");
ArrayList<Cat> cats = MyHibernateUtils.listAndCast(q);

Riceverò un errore di compilazione: Type mismatch: cannot convert from List to ArrayList

Non è una svista o un errore. L'avvertimento riflette un vero problema sottostante: non c'è modo che il compilatore java possa essere veramente sicuro che la classe hibernate farà il suo lavoro correttamente e che l'elenco che restituirà conterrà solo gatti. Qualsiasi suggerimento qui va bene.

No, ma puoi isolarlo in metodi di query specifici e sopprimere gli avvisi con @SuppressWarnings("unchecked")un'annotazione.

Le versioni più recenti di Hibernate ora supportano un Query<T>oggetto indipendente dai tipi , quindi non devi più usare @SuppressWarningso implementare qualche hack per far sparire gli avvisi del compilatore. Nell'API della sessione , Session.createQueryora restituirà un Query<T>oggetto indipendente dai tipi . Puoi usarlo in questo modo:

Query<Cat> query = session.createQuery("FROM Cat", Cat.class);
List<Cat> cats = query.list();

Puoi anche usarlo quando il risultato della query non restituirà un gatto:

public Integer count() {
    Query<Integer> query = sessionFactory.getCurrentSession().createQuery("SELECT COUNT(id) FROM Cat", Integer.class);
    return query.getSingleResult();
}

O quando si esegue una selezione parziale:

public List<Object[]> String getName() {
    Query<Object[]> query = sessionFactory.getCurrentSession().createQuery("SELECT id, name FROM Cat", Object[].class);
    return query.list();
}

Abbiamo avuto lo stesso problema. Ma non è stato un grosso problema per noi perché abbiamo dovuto risolvere altri problemi più importanti con Hibernate Query e Session.

In particolare:

1. controllare quando è possibile eseguire il commit di una transazione. (volevamo contare quante volte una trasmissione è stata "avviata" ed eseguire il commit solo quando la trasmissione è stata "terminata" lo stesso numero di volte in cui è stata avviata. Utile per il codice che non sa se è necessario avviare una transazione. Ora qualsiasi codice che necessita di una trasmissione ne "avvia" uno e lo termina una volta terminato.)
2. Raccolta delle metriche delle prestazioni.
3. Ritardare l'avvio della transazione finché non si sa che qualcosa verrà effettivamente fatto.
4. Comportamento più delicato per query.uniqueResult ()

Quindi per noi abbiamo:

1. Crea un'interfaccia (AmplafiQuery) che estenda Query
2. Crea una classe (AmplafiQueryImpl) che estenda AmplafiQuery e racchiuda un org.hibernate.Query
3. Crea un Txmanager che restituisca un Tx.
4. Tx ha i vari metodi createQuery e restituisce AmplafiQueryImpl

E infine

AmplafiQuery ha un "asList ()" che è una versione abilitata generica di Query.list () AmplafiQuery ha un "unique ()" che è una versione abilitata generica di Query.uniqueResult () (e registra semplicemente un problema invece di lanciare un eccezione)

Questo è un sacco di lavoro solo per evitare @SuppressWarnings. Tuttavia, come ho detto (ed elencato) ce ne sono molti altri migliori! motivi per fare il lavoro di avvolgimento.

So che questo è più vecchio, ma 2 punti da notare a partire da oggi in Matt Quails Answer.

Punto 1

Questo

List<Cat> cats = Collections.checkedList(Cat.class, q.list());

Dovrebbe essere questo

List<Cat> cats = Collections.checkedList(q.list(), Cat.class);

Punto 2

Da questa

List list = q.list();

a questa

List<T> list = q.list();

ridurrebbero altri avvisi ovviamente nei marcatori dei tag di risposta originali sono stati rimossi dal browser.

Prova questo:

Query q = sess.createQuery("from Cat cat");
List<?> results = q.list();
for (Object obj : results) {
    Cat cat = (Cat) obj;
}

Una buona soluzione per evitare avvisi di sicurezza dei tipi con query di ibernazione è utilizzare uno strumento come TorpedoQuery per aiutarti a creare hql indipendente dai tipi.

Cat cat = from(Cat.class);
org.torpedoquery.jpa.Query<Entity> select = select(cat);
List<Cat> cats = select.list(entityManager);

TypedQuery<EntityName> createQuery = entityManager.createQuery("from EntityName", EntityName.class);
List<EntityName> resultList = createQuery.getResultList();

Se non vuoi usare @SuppressWarnings ("unchecked") puoi fare quanto segue.

   Query q = sess.createQuery("from Cat cat");
   List<?> results =(List<?>) q.list();
   List<Cat> cats = new ArrayList<Cat>();
   for(Object result:results) {
       Cat cat = (Cat) result;
       cats.add(cat);
    }

Cordiali saluti, ho creato un metodo util che fa questo per me in modo da non sporcare il mio codice e non devo usare @SupressWarning.