Obtenir le bon modèle Hibernate dans un Spring CRUD DAO générique

Question

Je suis encore nouveau au printemps, et j'ai trouvé cela irritant de faire tous ces DAO CRUD, alors j'ai créé une "classe publique GenericCRUDDAO" qui étend HibernateDaoSupport implémente CRUDDAO ". Dans mes objets de service, je dis simplement quelque chose comme

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

et je ne dois plus écrire de DAO simples et les câbler. Yay! À une exception près, je suis sûr que tous les développeurs expérimentés de Spring ont tout de suite vu: je ne parviens pas à insérer le modèle Hibernate dans GenericCRUDDAO, ce qui

HibernateTemplate ht = getHibernateTemplate();

me donne un ht qui est null. Pas si bon. J'ai pensé l'installer, c'est-à-dire créer un bean generic CRUDDAO puis définir un AnnotationSessionFactoryBean statique, mais cela ne me permettait toujours pas d'obtenir un modèle Hibernate. Avez-vous des suggestions sur la façon de résoudre ce problème afin d’obtenir mon modèle Hibernate?

Est-ce que je devrais penser à créer un CRUD DAO générique?

A bientôt

Nik

Answer 1

Pour beaucoup, HibernateTemplate et HibernateDaoSupport sont sur les outs, et l'injection d'un SessionFactory est préférable. Remarquez que ce n’est pas tout le monde, mais c’est une tendance que j’ai adoptée il y a peu, qui consiste à supprimer HibernateTemplate de mon propre DAO générique.

Ce blog présente un très bon résumé.

Les exemples de l'auteur devraient pouvoir vous aider à atteindre votre objectif.

Answer 2

GenericDao

Eh bien, pour moi, si votre nom GenericDAO est "générique", il se peut que vous n'ayez besoin que d'une seule instance et que vous fassiez tout avec cette seule instance.

Je suis sûr que cela ne vous dérange pas de câbler par exemple, c'est à la répétition que vous vous énervez (et je suis d'accord avec vous).

Par exemple, vous pouvez transmettre la classe Entity à une méthode générique .

• public void save (Class, E ...): vous permet de sauvegarder une ou plusieurs instances de type E, E étant l'une de vos entités.
• public E load (Class, Long id): charge une 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

Dans nos applications, nous avons en réalité une variante pour cela. Parce que nous avons beaucoup de demandes spécifiques pour chaque Dao, nous avons de toute façon besoin des classes de Dao spécifiques (créez la classe et transmettez-la), donc pour éviter le cas particulier d'un Dao qui ne serait pas défini, nous créons immédiatement les classes de Dao spécifiques.

Codage

Mais en aucun cas nous ne répétons le code. Tous nos Daos étend GenericDao, en fournissant dans le constructeur le paramètre Class requis. Exemple de code (non complet, simple pour avoir l’idée de 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) {
        //....
      }
    }

Câblage

Câbler tous les haricots n’est pas une fatalité. De nos jours, il existe de nombreuses stratégies de mise en service automatique, vous n'avez pas à vous en préoccuper. Les voir au printemps
http: //static.springsource. org / spring / docs / 2.5.x / reference / beans.html # beans-annotation-config