Introduction au framework Spring

Date de publication : 23 novembre 2004 , Date de mise a jour : 30 novembre 2004

Par Erik Gollot
 

Vous avez peut être entendu parlé des « conteneurs légers » comme alternatives au serveurs d'application, qualifiés, eux, de conteneurs « lourds » ? Non ?
Bon, vous avez alors peut être entendu parlé du pattern IoC (Inversion Of Control) ou du pattern « Dependency Injection » ? Non ?
Bon quoi d'autre alors…vous avez peut être entendu parlé de SPRING ou Pico ou Avalon ? Non, toujours pas ?
Eh bien c'est pas grave, moi je vais vous parler de SPRING et en fait de tous ces sujets car SPRING aborde effectivement tous ces sujets.
Téléchargez la version pdf

1. De quoi s'agit-il ?

• Le mode transactionnel
• L'appel d'EJBs
• La création d'EJBs
• La persistance d'objets
• La création d'une interface Web
• L'appel et la création de WebServices

2. Pourquoi vous avez besoin de SPRING ? Le pattern IoC

2.1. Le pattern IoC

Product
package product;

import factory.DAOFactory;
import product.dao.ProductDAO;

public class Product{
	
	private ProductDAO dao;
	
	private long id;
	private String name;
	private String description;
	
	public Product(){
		dao = (ProductDAO)DAOFactory.getFactory("ProductDAO");
	}

	public String getName(){return name;}
	
	//etc
}

DAOFactory
package factory;

import product.dao.ProductDAOImpl;
import product.dao.ClientDAOImpl;
import product.dao.CommandDAOImpl;

import java.util.*;

public class DAOFactory{
	
	private Hashtable factories;
	private static DAOFactory self = null;
	
	protected DAOFactory(){
		factories = new Hashtable();
		factories.put("ProductDAO", new ProductDAOImpl());
		factories.put("ClientDAO", new ClientDAOImpl());
		factories.put("CommandDAO", new CommandDAOImpl());
	}
	
	public static Object getFactory(String factoryName) throws NullPointerException {
		return DAOFactory.self().get(factoryName);
	}
	
	protected Object get(String factoryName) throws NullPointerException {
		return factories.get(factoryName);
	}
	
	public static synchronized DAOFactory self(){
		if(self == null){
			self = new DAOFactory();
		}
		return self;
	}
}

Product
package product;

import factory.DAOFactory;
import product.dao.ProductDAO;

public class Product{
	
	private ProductDAO dao;
	
	private long id;
	private String name;
	private String description;
	
	public void setProductDAO(ProductDAO dao){
		this.dao = dao;
	}

	public String getName(){return name;}
	
	//etc
}

<beans>
	<bean id="productDAO" class="product.dao.ProductDAOImpl"></bean>
	<bean class="product.Product">
		<property name="productDAO">
			<ref bean="productDAO"/>
		</property>
	</bean>
</beans>

3. Configurer une application

3.1. Les principes

<beans>
	<!-- Première fabrique-->
	<bean id="productDAO" class="product.dao.ProductDAOImpl"></bean>
	<!-- Seconde fabrique-->
	<bean class="product.Product">
		<property name="productDAO">
			<ref bean="productDAO"/>
		</property>
	</bean>
</beans>

3.1.1. Cycle de vie d'un Bean

	<bean class="product.Product" singleton="false">
		<property name="productDAO">
			<ref bean="productDAO"/>
		</property>
	</bean>

« springfactory ».getBean(«product») ;

3.1.2. Déclaration des propriétés

• Positionnement d'une valeur par défaut
• Passage de paramètres de configuration (login, password, nom JNDI, URL, classes d'une driver)
• Initialisation de tableaux ou de listes

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	<property name="driverClassName">
		<value>com.mysql.jdbc.Driver</value>
	</property>
	<property name="url">
		<value>jdbc:mysql://localhost/spring</value>
	</property>
	<property name="username">
		<value>sample</value>
	</property>
	<property name="password">
		<value>sample</value>
	</property>
</bean>
<bean id="mySessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
	<property name="mappingRessources">
		<list>
			<value>sample.hbm.xml</value>
		</list>
	</property>
</bean>

3.2. Accéder au fichier de configuration

3.2.1. Cas d'une application type client « Swing »

ClassPathResource res = new ClassPathResource("applicationContext.xml");
// Notre fabrique SPRING permettant l'accès aux beans déclarés
XmlBeanFactory factory = new XmlBeanFactory(res);

3.2.2. Cas d'une application web (war)

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value>
</context-param>

<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- Ou utilisation de la servlet ContextLoaderServlet-->
<servlet>
	<servlet-name>context</servlet-name>
	<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
	<load-on-startup>1</load-on-startup>
</servlet>

Dans le cas de l'usage de la servlet ContextLoaderServlet, le fichier par défaut recherché est /WEB-INF/applicationContext.xml.

3.2.3. Cas d'un EJB (« ejbjar »)

public class MyComponentEJB extends AbstractStatelessSessionBean implements IMycomponent{

}

public void setSessionContext(SessionContext sessionContext){
	super.setSessionContext(sessionContext);
	setBeanFactoryLocator(ContextSingletonBeanFactoryLocator.getInstance());
}

3.3. Utiliser la configuration au « runtime »

ClassPathResource res = new ClassPathResource("applicationContext.xml");
// La fabrique SPRING est chargée, les singletons sont créés
XmlBeanFactory factory = new XmlBeanFactory(res);

// On utilise la méthode getBean en passant le nom du bean pour créer
// ou récupérer un bean déclaré dans le fichier de configuration
IVehiculeServices vservices = (IVehiculeServices)factory.getbean("myVehiculeServices");

4. Le mode transactionnel

• Déclaration d'un « TransactionInterceptor » nous permettant de dire quelles sont les méthodes que l'on veut déclarer transactionnelles. Ici toutes les méthodes des classes implémentant l'interface IVehiculeServices.
• Déclaration de la classe qui implémente notre interface, ici la classe VehiculeServices.
• Déclaration d'un proxy sur notre classe VehiculeServices. Dans cette déclaration, nous devons dire pour quelle classe on veut créer un proxy et aussi quel type d'interception on veut réaliser autour des différentes méthodes. Dans notre cas, on va donc passer notre « TransactionInterceptor ».

<bean id="myTransactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
	<property name="transactionManager">
		<ref bean="myTransactionManager"/>
	</property>
	<property name="transactionAttributeSource">
		<value>IVehiculeServices.*=PROPAGATION_REQUIRED</value>
	</property>
</bean>
<bean id="myVehiculeServicesTarget" class="VehiculeServices">
	<property name="sessionFactory">
		<ref bean="mySessionFactory"/>
	</property>
</bean>
<bean id="myVehiculeServices" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="proxyInterfaces">
		<value>IVehiculeServices</value>
	</property>
	<property name="interceptorNames">
		<list>
			<value>myTransactionInterceptor</value>
			<value>myvehiculeServicesTarget</value>
		</list>
	</property>
</bean>

s = (IVehiculeService)factory.getBean("myVehiculeServices");

4.1. Le gestionnaire de transactions

• Vous utilisez simplement SPRING avec un driver JDBC et un gestionnaire de DataSource comme celui offert par jakarta-commons, utilisez DataSourceTransactionManager
• Vous utilisez SPRING avec le framework de persistance Hibernate, utilisez HibernateTransactionManager
• Vous utilisez SPRING dans le contexte d'un serveur d'application J2EE et/ou vous utilisez JTA, utilisez JtaTransactionManager

Exemple avec Hibernate et MySQL
<bean id="mySessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
	<property name="mappingResources">
		<list>
			<value>sample.hbm.xml</value>
		</list>
	</property>
	<property name="hibernateProperties">
		<props>
			<prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>
			<prop key="hibernate.show_sql">true</prop>
		</props>
	</property>
	<property name="dataSource"><ref bean="myDataSource"/></property>
</bean>
<bean id="myTransactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
	<property name="sessionFactory"><ref bean="mySessionFactory"/></property>
</bean>

5. Les EJBs

5.1. Les EJBs locaux

<bean id="myProductServices" 
		class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
	<property name="jndiName"><value>myProductServices</value></property>
	<property name="businessInterface"><value>IProductServices</value></property>
</bean>
<bean id="myController" class="myController">
	<property name="myProductServices"><ref bean="myProductServices"/></property>
</bean>

5.2. Les EJBs remotes

• Vous ne déclarez aucune exception dans l'interface métier de votre EJB et vous utilisez cette interface dans le fichier de configuration de SPRING.
• Vous déclarez des remote exceptions dans l'interface métier de votre EJB et vous utilisez cette interface dans le fichier de configuration de SPRING.
• Vous déclarez des remote exceptions dans l'interface métier de votre EJB et vous créez une seconde interface métier côté « client » sans les remotes exceptions et vous utilisez cette interface dans le fichier de configuration de SPRING. Dans ce cas, c'est le proxy SPRING qui se charge d'intercepter les exceptions remote et de les transformer en « RuntimeException ».

6. Conclusion

• Struts/Tiles, Velocity, FreeMarker, WebWork, Spring Web flow
• Hibernate, iBatis
• J2EE/EJB
• Hessian, Burlap, RMI, Spring's http invoker