Le DAO avec Spring et Hibernate

1. Vue d'ensemble

Cet article montre comment implémenter le DAO avec Spring et Hibernate . Pour la configuration principale d'Hibernate, consultez l'article précédent sur Hibernate 5 avec Spring.

2. Plus de modèles de printemps

À partir de Spring 3.0 et Hibernate 3.0.1, le Spring HibernateTemplate n'est plus nécessaire pour gérer la session Hibernate. Il est désormais possible d'utiliser des sessions contextuelles - des sessions gérées directement par Hibernate et actives tout au long d'une transaction.

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

2.1. Traduction d'exceptions sans HibernateTemplate

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

Sans le modèle, ce mécanisme est toujours activé et actif pour tous les DAO annotés avec l' annotation @Repository . Sous le capot, cela utilise un postprocesseur Spring bean qui conseillera tous les beans @Repository avec tous les PersistenceExceptionTranslator trouvés dans le contexte Spring.

Une chose à retenir est que la traduction d'exceptions utilise des proxies. Pour que Spring puisse créer des proxys autour des classes DAO, ceux-ci ne doivent pas être déclarés comme finaux .

2.2. Gestion de session Hibernate sans le modèle

Lorsque le support Hibernate pour les sessions contextuelles est sorti, le HibernateTemplate est devenu essentiellement obsolète. En fait, le Javadoc de la classe met désormais en évidence cet aspect (en gras par rapport à l'original):

REMARQUE: 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 par le DAO de base - un DAO abstrait et paramétré qui prend en charge les opérations génériques courantes et que nous pouvons étendre pour chaque entité:

public abstract class AbstractHibernateDAO{ private Class clazz; @Autowired private SessionFactory sessionFactory; public void setClazz(Class clazzToSet) { clazz = clazzToSet; } public T findOne(long id) { return (T) getCurrentSession().get( clazz, id ); } public List 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 indiqué, le DAO abstrait n'étend aucun modèle Spring (tel que HibernateTemplate ). Au lieu de cela, Hibernate SessionFactory est injecté directement dans le DAO, et aura le rôle de l'API Hibernate principale, à travers la Session contextuelle qu'elle expose:

this.sessionFactory.getCurrentSession ();

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

Maintenant, regardons un exemple d'implémentation de ce DAO , pour une entité Foo :

@Repository public class FooDAO extends AbstractHibernateDAO implements IFooDAO{ public FooDAO(){ setClazz(Foo.class ); } }

4. Conclusion

Cet article a couvert la configuration et l'implémentation de la couche de persistance avec Hibernate et Spring.

Les raisons de cesser de s'appuyer sur des 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, avec presque aucune dépendance au moment de la compilation sur Spring.

L'implémentation de ce projet simple se trouve dans le projet github.