Spring + Hibernate : Mise en place d’un DAO générique

Introduction

Les opérations de base pour la persistance des données sont toutes identiques quelques soit l’objet à sauvegarder, les méthodes en question sont celles d’un CRUD : enregistrement (Create), lecture (Read), mise à jour (Update) et suppression (Delete).

La plupart du temps ces méthodes sont répétées et redéfinies dans chacun des DAO de notre application, la seule différence notable est le type des objets que ces méthodes prennent en paramètre, cependant avec Java 5 et les generics pourquoi ne pas les écrire une fois pour toutes dans un DAO générique ? cela est possible et est considéré comme une bonne pratique, la redondance des données étant à éviter à tout prix.

L’exemple ci-dessous utilise Hibernate pour la persistance des données et Spring pour la création des objets et leurs dépendances.

Définition

• Spring : framework open souce J2EE qui prend en charge la création d’objets et la mise en relation d’objets par l’intermédiaire d’un fichier de configuration XML qui décrit les objets à fabriquer et les relations de dépendances entre ces objets.3 concepts font la force de Spring :

1. le pattern inversion de contrôle (ou IOC)
2. la programmation orientée aspect (ou AOP)
3. une couche d’abstraction permettant d’intégrer d’autres frameworks existant

• Hibernate : framework open source Java qui simplifie la persistance des objets en base de données relationnelle. Son utilisation remplace la mise en place de JDBC et propose entre autres le cache des objets, les sessions et les transactions.
• DAO : de son vrai nom Data Access Object, ce patron de conception (ou pattern) permet de séparer la couche d’accès aux données de la couche logique applicative.  Son utilisation permet de s’abstraire de la façon dont les données sont stockées au niveau des objets métier.

DAO Générique

• Voici l’interface du DAO générique, les méthodes disponibles sont celles d’un CRUD, les interfaces des autres DAO devront étendre celle-ci :

public interface GenericDao<T, PK extends Serializable> {
	PK create(T newInstance);
	T read(PK id);
	List<T> readAll();
	void update(T transientObject);
	void delete(T persistentObject);
}

• Son implémentation est tout simple, cependant pour en bénéficier les implémentations des autres DAO devront étendre celui-ci. A noter que c’est le constructeur de cette classe qui permet de typer les objets concernés par le DAO :

public class GenericDaoImpl<T, PK extends Serializable> implements GenericDao<T, PK> {
	private SessionFactory sessionFactory;
	private Class<T> type;
	public GenericDaoImpl(Class<T> type) {
		this.type = type;
	}
	public PK create(T o) {
		return (PK) getSession().save(o);
	}
	public T read(PK id) {
		return (T) getSession().get(type, id);
	}
	public List<T> readAll() {
		Criteria crit = getSession().createCriteria(type);
		return crit.list();
	}
	public void update(T o) {
		getSession().update(o);
	}
	public void delete(T o) {
		getSession().delete(o);
	}
	public Session getSession() {
		boolean allowCreate = true;
		return SessionFactoryUtils.getSession(sessionFactory, allowCreate);
	}
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
}

DAO spécifique

• Exemple d’interface d’un DAO propre à votre application qui doit pouvoir appeler les méthodes du DAO générique plus d’autres qui lui sont propre :

public interface CardDao extends GenericDao<Card, Integer> {
	/**
	 * Récupération de tous les artistes différents
	 * @return
	 * @throws DataAccessException
	 */
	List<String> selectAllArtists() throws DataAccessException;
}

• Son implémentation, désormais les méthodes create, read, update, delete ainsi que selectAllArtists sont accessibles :

public class CardDaoImpl extends GenericDaoImpl<Card, Integer> implements CardDao {
	/**
	 * @param type
	 */
	public CardDaoImpl(Class<Card> type) {
		super(type);
	}
	/* (non-Javadoc)
	 * @see fr.geeks.magic.domain.dao.CardDao#selectAllArtists()
	 */
	public List<String> selectAllArtists() throws DataAccessException {
		Query query = getSession().createQuery("select distinct(artist) from Card where artist not like '(none)' order by artist");
		List<String> artists = query.list();
		return artists;
	}
}

Configuration XML

Nous venons de voir que simplement deux classes suffisent à rendre générique les principales actions d’un CRUD, pour ce qui est de la configuration Spring c’est un peu plus compliqué tout en restant accessible avec un peu de concentration

Voici un exemple de fichier de configuration Spring pour l’utilisation du DAO générique, la partie sur les transactions n’est pas utile mais je la laisse pour exemple.

• Partie Persistance : source de données utilisant JNDI, propriétés Hibernate (sessionFactory), et gestionnaire de transaction Hibernate

	<!--
		========================= Start of PERSISTENCE DEFINITIONS =========================
	-->
	<!-- DataSource Definition via JNDI -->
	<bean id="dbMagicWeb" class="org.springframework.jndi.JndiObjectFactoryBean" lazy-init="true">
		<property name="jndiName" value="java:comp/env/jdbc/dbMagicWeb" />
	</bean>
	<!-- Hibernate SessionFactory Definition -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="mappingResources">
			<list>
				<value>fr/geeks/magic/domain/model/Card.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.bytecode.use_reflection_optimizer">true</prop>
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
			</props>
		</property>
		<property name="dataSource" ref="dbMagicWeb" />
	</bean>
	<!-- Hibernate Transaction Manager Definition -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

• Partie DAO : proxy DAO pour l’injection du sessionFactory d’Hibernate qui permet d’exécuter les requêtes, injection de l’objet concerné par les méthodes génériques

	<!--
		========================= Start of DAO DEFINITIONS =========================
	-->
	<!-- proxy for DAO using generic DAO -->
	<bean id="proxyDAO" abstract="true">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<!-- Card Dao definition -->
	<bean id="cardDao" class="fr.geeks.magic.domain.dao.hibernate.CardDaoImpl" parent="proxyDAO">
		<constructor-arg value="fr.geeks.magic.domain.model.Card" />
	</bean>

• Partie Service : proxy pour les transactions automatiques sur nos services métier, injection des DAO au service

	<!--
		========================= Start of SERVICE DEFINITIONS =========================
	-->
	<!-- Transactional proxy for Services -->
	<bean id="proxyService" abstract="true"
		class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<property name="transactionManager" ref="transactionManager" />
		<property name="transactionAttributes">
			<props>
				<prop key="find*">PROPAGATION_REQUIRED, readOnly</prop>
				<prop key="get*">PROPAGATION_REQUIRED, readOnly</prop>
				<prop key="*">PROPAGATION_REQUIRED, -java.lang.Exception</prop>
			</props>
		</property>
	</bean>
	<!-- Card service target -->
	<bean id="cardServiceTarget" class="fr.geeks.magic.business.service.impl.CardServiceImpl"
		init-method="init">
		<property name="cardDao" ref="cardDao" />
	</bean>
	<!-- Card service -->
	<bean id="cardService" parent="proxyService">
		<property name="target" ref="cardServiceTarget" />
	</bean>

Conclusion

Finalement ce n’est pas bien compliqué d’utiliser un DAO générique pour Hibernate, deux classes à ajouter à votre projet ainsi qu’une modification dans votre fichier de configuration Spring.

Je me demande si cela est envisageable avec l’utilisation de JDBC uniquement, je vois mal comment … si quelqu’un a déjà vu ça, je suis preneur ^^

Sources

Voici les sources d’un exemple d’utilisation du DAO générique : sources disponibles.

L’exemple n’est pas une WebApp mais plutôt un Batch, les paramètres de connexion à votre base de données sont à modifier dans le fichier JndiDatasourceCreator.java.

Cet article a été écrit par :

Mimie – qui a déjà rédigé 123 posts sur Des Geeks et des lettres.

Passionné d'informatique et développeur JavaEE de métier, je me consacre principalement à écrire des billets sur les sujets du Web et de la programmation Web. Ce blog est un espace qui me permet de partager mes découvertes avec vous et me sert accessoirement de pense bête !

Contacter l'auteur

Jetez aussi un oeil sur :

• EhCache + Spring : Mise en place d’un cache applicatif
• MySQL : Récupérer l’auto-increment lors d’une insertion avec Spring DAO
• Utilisation du contexte JNDI de Tomcat via Spring
• JUnit : Test unitaire hors conteneur J2EE avec Spring et JNDI
• Struts : intégration dans un contexte Spring