Ottenere il modello di ibernazione corretto in un DAO CRUD Spring generico

Question

Sono ancora abbastanza nuovo su Spring, e ho trovato irritante creare tutti questi DAO CRUD, quindi ho creato un "public domain GenericCRUDDAO che estende HibernateDaoSupport implementa CRUDDAO". Nei miei oggetti di servizio dico semplicemente qualcosa come

private GenericCRUDDAO<User, Integer> userDAO = new GenericCRUDDAO<User, Integer>();

e non più devo scrivere semplici DAO e collegarli. Sìì! Ad eccezione di una cosa, sono sicuro che tutto ciò che hai sperimentato gli sviluppatori Spring vede subito: non riesco a ottenere il modello Hibernate all'interno di GenericCRUDDAO, quindi

HibernateTemplate ht = getHibernateTemplate();

mi dà un ht che è nullo. Non così buono. Ho pensato di collegarlo, ovvero creare un beanCRUDDAO generico e quindi impostare un AnnotationSessionFactoryBean statico, ma ciò non mi darebbe comunque un HibernateTemplate. Qualche suggerimento su come aggirare ciò in modo da poter avere il mio modello di ibernazione?

Qualche altro problema con la creazione di un DAO CRUD generico a cui dovrei pensare?

Saluti

Nik

Answer 1

Per molti, HibernateTemplate e HibernateDaoSupport sono fuori gioco, e invece è preferibile iniettare un SessionFactory . Non tutti, intendiamoci, ma è una tendenza, che ho adottato non molto tempo fa, rimuovendo HibernateTemplate dal mio DAO generico.

Questo blog ha un riassunto abbastanza buono.

Gli esempi dell'autore dovrebbero essere in grado di aiutarti ad arrivare dove vuoi.

Answer 2

GenericDao

Bene, per me se il tuo GenericDAO è "generico", allora potresti aver bisogno di una sola istanza e fare tutto con quella singola istanza.

Sono sicuro che non ti disturba a collegare l'istanza, è alla ripetizione che ti arrabbi (e sono d'accordo con te).

Ad esempio, potresti passare la classe Entity a un metodo generico .

• salvataggio vuoto pubblico (Classe, E ...): consente di salvare una o più istanze di tipo E, essendo E una delle tue entità.
• public E load (Class, Long id): carica un'entità.

• ...

  /** Assuming the entities have a superclass SuperEntity with getIdent(). */
  public class GenericDaoImpl implements GenericDao {
  
     /** Save a bunch of entities */
     public void save(SuperEntity... entities) {
       for(SuperEntity entity : entities) {
         getSession().save(entity);
       }
     }
  
     /** Load any entity. */
     public <E extends SuperEntity> E load(Class<E> entityClass, Long ident) {
       return (E)getSession().load(entityClass, ident);
     }
  
     // other generic methods
  }
  

---

Variante

Nelle nostre applicazioni, in realtà abbiamo una variante per questo. Poiché abbiamo molte richieste specifiche per ogni Dao, abbiamo comunque bisogno delle classi Dao specifiche (creare la classe e collegarla), quindi per evitare il caso speciale di un Dao che non sarebbe definito, creiamo subito le classi Dao specifiche.

Codifica

Ma in nessun modo ripetiamo il codice. Tutti i nostri Daos estendono il GenericDao, fornendo nel costruttore il parametro Class necessario. Codice di esempio (non completo, semplice per ottenere l'idea di base):

    public abstract class GenericDaoImpl<E extends SuperEntity> 
        implements GenericDao<E> {

       /** Available for generic methods, so it is not a parameter 
        * for the generic methods. */
       private final Class<E> entityClass;

       protected GenericDaoImpl(Class<E> entityClass) {
         this.entityClass = entityClass;
       }

       // generic implementation ; can be made efficient, as it may 
       // send the orders as a batch
       public void save(E... entities) {
         for(SuperEntity entity : entities) {
           getSession().save(entityClass, entity.getIdent());
         }
         // possibly add flushing, clearing them from the Session ...
       }

       // other generic methods
    }

    public class PersonDaoImpl extends GenericDaoImpl<Person> 
        implements PersonDao {

      /** Constructor, instanciating the superclass with the class parameter. */
      public PersonDaoImpl() {
        super(Person.class);
      }

      /** Specific method. */
      public List<Person> findByAge(int minAge, int maxAge) {
        //....
      }
    }

cablaggio

Cablare tutti i fagioli non è fatale. Al giorno d'oggi, ci sono molte politiche di autowiring, non devi preoccuparti. Li vedi in primavera
http: //static.springsource. org / primavera / docs / 2.5.x / riferimento / beans.html # fagioli-annotation-config