Emmanuel PIERRE - Tutoriels et Astuces en Java

Aller au contenu | Aller au menu | Aller à la recherche

vendredi 18 juillet 2008

Créer un service de configuration avec Spring (3)

1- Configuration des fichiers web.xml et applicationContext.xml

web.xml : on utilise le listener Spring et on indique le chemin vers notre fichier xml.

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
 
<!-- Listener spring permettant de charger le context -->
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

applicationContext.xml : on utilise à peu près la même configuration que pour les tests, sauf que notre fichier de propriétés n'est pas dans le classpath

<property name="resource" value="file:C:/temp/configurationService.properties"/>

2- Utilisation du service dans une servlet

Exemple avec la servlet AfficherMessagesAction, dans la méthode doPost() : on récupère par exemple la propriété "cle.test.resource" et on l'utilise dans la servlet !

ConfigurationService configurationService = ServiceLocator.getConfigurationService();
String propriete = configurationService.getProperties("cle.test.resource");
int nbProprietes = configurationService.getNbProperties();
 
PrintWriter out = resp.getWriter();
out.println("<html><head><title>AfficherMessagesAction</title><body>");
out.println("propriete : "+propriete+"<br/>");
out.println("nbPropriete : "+nbProprietes+"<br/>");

Créer un service de configuration avec Spring (2)

1- Configuration d'un fichier applicationContext-test.xml pour tester le service
La librairie spring-test permet de réaliser des tests junit très facilement..
On crée tout d'abord un fichier applicationContext-test.xml dans le répertoire src/test/resources qui va uniquement être utilisé dans nos tests.

<!-- Service de configuration -->
<bean id="configurationService" init-method="init" 
		class="fr.minimarmotte.projects.service.impl.ConfigurationServiceImpl">
	<property name="resource" value="classpath:configurationServiceTest.properties"/>
</bean>

On précise :

  • Le nom du bean : configurationService
  • La méthode d'initialisation du service : init-method="init"
  • L'implémentation choisie pour notre service : ConfigurationServiceImpl

On renseigne la propriété resource : classpath:configurationServiceTest.properties
En ce qui concerne cette propriété, on peut aussi utiliser file:C/temp... pour spécifier un fichier qui n'est pas dans le classpath. Ceci est possible grâce à l'utilisation de l'interface Resource fournie par Spring. Pour en savoir plus : spring reference 2.5 chapter 4 (voir 4.6)

(Cette petite application utilise juste une servlet pour afficher des données et non un framework de présentation comme spring mvc, struts... J'ai donc utilisé une classe ServiceLocator pour accéder à mon service dans ma classe de test)

2- Création d'une classe de base pour tous les tests

Dans cette classe abstraite, on indique le fichier contexte à utiliser. Pour plus d'infos sur l'utilisation conjointe de spring-test et junit 4.4 : spring reference 2.5 Chapter 8 Testing.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
    "/applicationContext-test.xml"
})
public abstract class AbstractBaseTest 
	extends AbstractJUnit4SpringContextTests {
 
}


3- Création de la classe de test ConfigurationServiceImplTest

On crée par exemple le test suivant :

@Test
public void testGetPropertiesWithGoodKey() {
	ConfigurationService configurationService = ServiceLocator.getConfigurationService();
	String value = configurationService.getProperties("cle.test.resource");
	assertEquals("il y a bien une resource",value);
}

On récupère la propriété correspondant à la clé cle.test.resource et on s'assure que la valeur est la bonne.
Cette clé se trouve dans le fichier configurationServiceTest.properties qui ne sert que pour les tests.

Créer un service de configuration avec Spring (1)

Détails :
Dans un premier temps on crée une simple servlet AfficherMessagesAction.
Imaginons que cette servlet ait besoin de propriétés de configuration. Une url vers une autre application par exemple, ou un paramètre "nombre de lignes par tableau"...
Il est souhaitable de configurer cette propriété dans un fichier .properties et de pouvoir la récupérer facilement par la suite.
On va donc créer un service ConfigurationService qui va charger ce fichier .properties et rendre les paramètres de configuration disponibles dans toute l'application.

Projet réalisé avec :
Eclipse Europa 3.3.1.1
Apache Tomcat 5.5.26
Plugin Maven pour Eclipse http://m2eclipse.codehaus.org/
Java JDK 1.5
Spring 2.5.5


(Les sources du projet sont disponibles en annexe)

1- Création de l'interface ConfigurationService
Les fonctionnalités de notre service de configuration sont très simples. On veut pouvoir :

  • obtenir une propriété à partir d'une clé
  • obtenir le nombre de propriétés de notre service
  • pouvoir initialiser ce service

D'où l'interface suivante :

public interface ConfigurationService {
 
	/**
	 * Initialisation du service de configuration
	 */
	void init();
 
	/**
	 * Récuparation d'une propriété à partir de sa clé
	 * @param key clé
	 * @return - une propriété <br>
	 * - null si la clé est null, ou si elle n'existe pas 
	 */
	String getProperties(String key);
 
	/**
	 * Retourne le nombre de propriétés
	 * @return
	 */
	int getNbProperties();
 
}


2- Création de l'implémentation ConfigurationServiceImpl

public class ConfigurationServiceImpl implements ConfigurationService {
	private Properties properties;
	private Resource resource;
	private static Log logger = LogFactory.getLog(ConfigurationServiceImpl.class);
 
	public String getProperties(String key) {
		if(key==null || "".equals(key)) {
			return null;
		} else {
			String propertie = properties.getProperty(key);
			if(propertie==null) {
				logger.warn("Aucune propriete associee a la cle : "+key);
			}
			return propertie;
		}
	}
 
	public void init() {
		properties = new Properties();
		if(resource!=null) {
			//on verifie que le fichier resource existe
			if(resource.exists()) {
				try {
					//on charge le fichier resource dans l'objet properties
					properties.load(resource.getInputStream());
				} catch (IOException e) {
					logger.warn("Erreur lors du chargement du fichier resource : "+
						resource.getDescription(),e);
				}
			} else {
				logger.warn("Le fichier resource n'existe pas : "+
					resource.getDescription());
			}
		} else {
			logger.warn("Le fichier resource est null");
		}
	}
 
	public int getNbProperties() {
		if(properties==null) {
			return 0;
		} else {
			return properties.size();
		}		
	}
 
	public void setResource(Resource resource) {
		this.resource = resource;
	}
}


Précisions :

  • Les propriétés utilisées dans toute notre application sont stockées dans un Properties.
  • On définit un attribut resource avec son setter public. Avec Spring, nous allons pouvoir charger un fichier au démarrage de l'application.
  • La méthode init utilise la ressource chargée pour remplir l'objet properties.