Le DAO avec Spring et Hibernate

1. Vue d'ensemble

Cet article montrera commentimplement the DAO with Spring and Hibernate. Pour la configuration principale de Hibernate, consultez l'article précédent deHibernate 5 with Spring.

2. Plus de modèles de printemps

À partir de Spring 3.0 et Hibernate 3.0.1,the Spring HibernateTemplate is no longer necessary pour gérer la session Hibernate. Il est désormais possible d’utilisercontextual sessions -sessions managed directly by Hibernate et actif sur toute la portée d’une transaction.

Par conséquent, il est désormais recommandé d'utiliser directement l'API Hibernate au lieu desHibernateTemplate.. Cela découplera efficacement l'implémentation de la couche DAO de Spring.

2.1. Traduction d'exception sans lesHibernateTemplate

La traduction d'exceptions était l'une des responsabilités deHibernateTemplate - traduire les exceptions Hibernate de bas niveau en exceptions Spring génériques de niveau supérieur.

Sans le modèle, l'annotationthis mechanism is still enabled and activefor all the DAOs annotated with the @Repository. Sous le capot, cela utilise un postprocesseur Spring bean qui conseillera tous les beans@Repository avec tous lesPersistenceExceptionTranslator trouvés dans le contexte Spring.

Une chose à garder à l'esprit est que la traduction d'exception utilise des proxies. Pour que Spring puisse créer des proxys autour des classes DAO, ceux-ci ne doivent pas être déclarés commefinal.

2.2. Gestion de session Hibernate sans le modèle

Lorsque le support Hibernate pour les sessions contextuelles est sorti, lesHibernateTemplate sont essentiellement devenus obsolètes. En fait, la Javadoc de la classe met maintenant en évidence cet aspect (gras de l'original):

Note
Depuis Hibernate 3.0.1, le code d'accès transactionnel Hibernate peut également être codé dans le style Hibernate ordinaire. Par conséquent, pour les projets nouvellement démarrés, envisagez plutôt d'adopter le style Hibernate3 standard de codage des objets d'accès aux données, basé sur \ {@ link org.hibernate.SessionFactory # getCurrentSession ()}.

3. Le DAO

Nous allons commencer parthe base DAO – an abstract, parametrized DAO qui prend en charge les opérations génériques courantes et que nous pouvons étendre pour chaque entité:

public abstract class AbstractHibernateDAO< T extends Serializable >{
   private Class< T > clazz;

   @Autowired
   private SessionFactory sessionFactory;

   public void setClazz(Class< T > clazzToSet) {
      clazz = clazzToSet;
   }

   public T findOne(long id) {
      return (T) getCurrentSession().get( clazz, id );
   }
   public List< T > findAll() {
      return getCurrentSession()
       .createQuery( "from " + clazz.getName() ).list();
   }

   public void save(T entity) {
      getCurrentSession().persist( entity );
   }

   public T update(T entity) {
      return (T) getCurrentSession().merge( entity );
   }

   public void delete(T entity) {
      getCurrentSession().delete( entity );
   }
   public void deleteById(long id) {
      final T entity = findOne( id);
      delete( entity );
   }

   protected final Session getCurrentSession(){
      return sessionFactory.getCurrentSession();
   }
}

Quelques aspects sont intéressants ici - comme discuté, le DAO abstrait n’étend aucun modèle Spring (tel queHibernateTemplate). Au lieu de cela, le HibernateSessionFactory est injecté directement dans le DAO, et aura le rôle de l'API Hibernate principale, via lesSession contextuels qu'il expose:

this.sessionFactory.getCurrentSession();

Notez également que le constructeur reçoit lesClass de l'entité comme paramètre à utiliser dans les opérations génériques.

Maintenant, regardonsan example implementation of this DAO, pour une entitéFoo:

@Repository
public class FooDAO extends AbstractHibernateDAO< Foo > implements IFooDAO{

   public FooDAO(){
      setClazz(Foo.class );
   }
}

4. Conclusion

Cet article traite de la configuration et de la mise en œuvre de la couche de persistance avec Hibernate et Spring.

Les raisons de cesser de compter sur les modèles pour la couche DAO ont été discutées, ainsi que les pièges possibles de la configuration de Spring pour gérer les transactions et la session Hibernate. Le résultat final est une implémentation DAO légère et propre, ne dépendant presque pas de Spring lors de la compilation.

L'implémentation de ce projet simple se trouve dansthe github project.

TOC

Le DAO avec Spring et Hibernate