
| auteur : Gildas Cuisinier |
Afin de configurer un conteneur Spring, il est nécessaire de créer un fichier xml contenant la définition des divers Beans qui seront gérés par Spring.
Voici un exemple simple de ce fichier, version Spring 2.0 utilisant des namespaces :
<? xml version="1.0" encoding="UTF-8"? >
< beans xmlns = " http://www.springframework.org/schema/beans "
xmlns : xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi : schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd " >
< bean name = " unBean " class = " com.developpez.spring.unBean " >
< property name = " unePropriete " value = " Hello world " / >
< / bean >
< / beans >
|
Le même fichier, mais pour Spring 1.2 qui utilise une DTD à la place des namespaces :
<? xml version="1.0" encoding="UTF-8" ? >
<! DOCTYPE beans PUBLIC " -//SPRING//DTD BEAN//EN " " http://www.springframework.org/dtd/spring-beans.dtd " >
< beans >
< bean name = " unBean " class = " com.developpez.spring.unBean " >
< property name = " unePropriete " value = " Hello world " / >
< / bean >
< / beans >
|
Une fois le fichier créé, il est nécessaire d'instancier une fabrique de Beans ( Bean Factory ) ou un contexte d'application ( ApplicationContext ). Il existe diverses implémentations de ces interfaces, mais les deux principales chargent un ( ou plusieurs ) fichier situé soit par un chemin sur le disque, soit dans le classpath :
ApplicationContext ap = new ClassPathXmlApplicationContext (" com/developpez/spring/applicationContext.xml " );
ApplicationContext ap2 = new FileSystemXmlApplicationContext (" c:\\applicationContext.xml " );
Resource resource = new ClassPathResource (" com/developpez/spring/beans.xml " );
BeanFactory factory = new XmlBeanFactory (resource);
Resource resource2 = new FileSystemResource (" c:\\beans.xml " );
BeanFactory factory2 = new XmlBeanFactory (resource);
|
Une fois une instance créée, la récupération d'un Bean Spring se fait via la méthode getBean :
MonBean bean = (MonBean )ap.getBean (" monBean " );
MonBean bean2 = (MonBean) factory.getBean (" monBean " );
|
|
lien : Documentation officiel de Spring - Fabrique de Beans
|
| auteur : Gildas Cuisinier | La définition d'un bean dans le fichier de configuration se fait comme ceci :
< beans >
< bean id = " monBean " class = " com.developpez.spring.MonBean " / >
< / beans >
|
|
|
Il est possible de donner plusieurs noms à un Bean via l'attribut name, par exemple le bean :
< beans xmlns = " http://www.springframework.org/schema/beans "
xmlns : xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi : schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd " >
< bean id = " monBean " class = " com.developpez.spring.MonBean " name = " monBeanAlias,aliasMonBean " / >
< / beans >
|
possède le nom monBean ( définit par l'ID ) mais aussi monBeanAlias et aliasMonBean. Les différents noms étant séparés par une virgule
|
| auteur : Gildas Cuisinier |
Si rien n'est spécifié, Spring considère tout Bean comme un singleton.
Autrement dit, lorsque deux demandes sont faites pour un même Bean, c'est la même instance de l'objet qui est fournie par le BeanFactory/ApplicationContext.
Si vous désirez qu'un nouvel objet soit instancié à chaque fois il faut le spécifier dans la définition du Bean :
< beans >
< bean id = " monBean " class = " com.developpez.spring.MonBean " singleton = " false " / >
< / beans >
|
Depuis la version 2.0 de Spring, c'est via l'attribut Scope que cela est géré :
< ! - - Bean Singleton - - >
< bean id= " monBean " class = " com.developpez.spring.MonBean " scope= " singleton " / >
< / beans>
< ! - - Bean non Singleton - - >
< bean id= " monBean " class = " com.developpez.spring.MonBean " scope= " prototype " / >
< / beans>
|
|
lien : Documentation officielle, Scope
|
| auteur : Gildas Cuisinier | Spring fournit des balises afin de pouvoir gérer facilement les propriétés de type Properties :
< bean id = " monBean " class = " com.developpez.spring.MonBean " name = " monBeanAlias,aliasMonBean " >
< property name = " proprietes " >
< props >
< prop key = " application.nom " > Mon Application< / prop >
< prop key = " application.version " > 1.0.0< / prop >
< prop key = " application.auteur " > Gildas Cuisinier< / prop >
< / props >
< / property >
< / bean >
|
équivaut à un fichier properties :
application.nom=Mon Application
application.version=1.0.0
application.auteur=Gildas Cuisinier
|
|
| auteur : Gildas Cuisinier |
Afin d'illustrer l'injection de Bean dans un autre grâce à Spring partons d'un exemple :
Soit un service, qui possède entre autre une méthode pour lister les utilisateurs :
public class UserService {
private UserDao userDao;
public void setUserDao (UserDao userDao) {
this .userDao = userDao;
}
public List listUsers (){
return userDao.listUsers ();
}
}
|
Le service utilise un DAO pour les utilisateurs. Les méthodes de ce DAO sont définies dans une interface :
public interface UserDao {
public List listUsers ();
}
|
Et une implémentation de cette interface :
public class UserDaoImpl implements UserDao {
public List listUsers () {
List result = new ArrayList ();
result.add (new User (" hikage " , " password " ));
result.add (new User (" spring " , " spring " ));
return result;
}
}
|
Afin de spécifier à Spring d'injecter une référence du DAO au service, il faut déclarer tout d'abord un bean pointant sur l'implémentation du DAO :
< bean id = " userDao " class = " com.developpez.spring.UserDaoImpl " / >
|
Ensuite, dans la déclaration du service en lui-même, il est nécessaire de créer une propriété :
< bean id = " userService " class = " com.developpez.spring.UserService " >
< property name = " userDao " ref = " userDao " / >
< / bean >
|
Dès lors, lorsque l'on récupérera une instance du service, Spring injectera automatiquement une instance de l'implémentation.
|
lien : Documentation officielle, References to other beans
|
| auteur : Gildas Cuisinier |
Pour injecter des propriétés via le constructeur d'une classe, il faut utiliser les balises constructor-arg.
Soit la classe :
public class BeanConstructor {
private String chaine;
private Integer entier;
public BeanConstructor (String chaine, Integer entier) {
this .chaine = chaine;
this .entier = entier;
}
}
|
Il est possible de spécifier les arguments via leur index :
< bean id = " beanConstructeur2 " class = " com.developpez.hikage.BeanConstructor " >
< constructor-arg index = " 0 " value = " Test " / >
< constructor-arg index = " 1 " value = " 23 " / >
< / bean >
|
Cependant, imaginons maintenant que la classe possède un constructeur supplémentaire :
public BeanConstructor (String chaine, String chaine2)
|
Dans ce cas, il est préférable de spécifier à Spring de quel type sont les paramètres, afin de s'assurer de passer par le bon constructeur :
< bean id = " beanConstructeur " class = " com.developpez.hikage.BeanConstructor " >
< constructor-arg type = " java.lang.String " value = " Test " / >
< constructor-arg type = " java.lang.Integer " value = " 23 " / >
< / bean >
|
|
| auteur : Gildas Cuisinier |
Soit un fichier properties qui contient les informations suivantes :
datasource.driver=org.mysql.driver.Driver
datasource.url=jdbc://mysql:localhost/maBase
datasource.username=dbUser
datasource.password=dbPassword
|
Il est possible de récupérer ces informations sous forme de variables dans le fichier de configuration de Spring en ajoutant un Bean :
< bean name = " propertyPlaceholder " class = " org.springframework.beans.factory.config.PropertyPlaceholderConfigurer " >
< property name = " locations " >
< value > classpath:com/developpez/hikage/properties/datasource.properties< / value >
< / property >
< / bean >
|
Ensuite, pour accèder aux variables il suffit de les encadrer dans ${ } :
< bean id = " datasource " class = " com.developpez.hikage.Datasource " >
< property name = " urlConnection " value = " ${datasource.url} " / >
< property name = " drivers " value = " ${datasource.drivers} " / >
< property name = " username " value = " ${datasource.username} " / >
< property name = " password " value = " ${datasource.password} " / >
< / bean >
|
|
| auteur : Gildas Cuisinier |
Les informations nécessaires à la configuration sont parfois stockées dans des champs statiques d'une classe ou d'une interface. Spring fournit une classe utilitaire pour récupérer ces informations pour ainsi les injecter dans un bean.
Par exemple, le nom d'une application est stockée dans une classe Constants :
public class Constants {
public static final String APPLICATION_NAME = " FAQ Spring " ;
}
|
La classe FieldRetrievingFactoryBean fournit un moyen d'injecter cette information dans la propriété applicationName de la classe ApplicationInformation :
< bean id = " applicationInformation " class = " com.developpez.spring.ApplicationInformation " >
< property name = " applicationName " >
< bean class = " org.springframework.beans.factory.config.FieldRetrievingFactoryBean " >
< property name = " staticField " value = " com.developpez.spring.Constants.APPLICATION_NAME " / >
< / bean >
< / property >
< / bean >
|
Depuis la version 2.0 de Spring, via le namespace util, il existe un raccouçi pour faire la même opération :
< bean id = " applicationInformationV2 " class = " com.developpez.spring.ApplicationInformation " >
< property name = " applicationName " >
< util : constant static-field = " com.developpez.spring.Constants.APPLICATION_NAME " / >
< / property >
< / bean >
|
|
lien : Documentation officielle de Spring, Schema Utils
|
| auteur : Gildas Cuisinier |
Soit la classe :
public class MonBean {
private String chaine;
private Integer entier;
private Long entierLong;
private Boolean booleen;
private Float flottant;
public void setChaine (String chaine) { this .chaine = chaine ; }
public String getChaine () { return this .chaine ; }
public void setEntier (Integer entier) { this .entier = entier ; }
public Integer getEntier () { return this .entier ; }
public void setEntierLong (Long entierLong) { this .entierLong = entierLong ; }
public String getEntierLong () { return this .entierLong ; }
public void setBooleen ( Boolean booleen ) { this .booleen = booleen ; }
public Boolean getBooleen () { return this .booleen; }
public void setFlottant (Float flottant) { this .flottant = flottant ; }
public Float getFlottant () { return this .flottant } ;
}
|
Voici un exemple de fichier de configuration qui spécifie les valeurs des types simples :
< beans xmlns = " http://www.springframework.org/schema/beans "
xmlns : xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi : schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd " >
< bean id = " monBean " class = " com.developpez.spring.MonBean " >
< property name = " chaine " value = " Visitez Developpez.com " / >
< property name = " booleen " value = " true " / >
< property name = " entier " value = " 10 " / >
< property name = " flottant " value = " 10.3 " / >
< property name = " entierLong " value = " 204 " / >
< / bean >
< / beans >
|
|
| auteur : Gildas Cuisinier |
Soit la classe :
public class BeanList {
private List list;
public List getList () {
return list;
}
public void setList (List list) {
this .list = list;
}
}
|
Il est possible de définir cette liste via les balises :
< bean id = " beanList " class = " com.developpez.hikage.BeanList " >
< property name = " list " >
< list >
< value > Valeur 1< / value >
< value > Valeur 2< / value >
< value > Valeur 3< / value >
< ref bean = " monBean " / >
< / list >
< / property >
< / bean >
|
|
| auteur : Gildas Cuisinier |
Soit une classe :
public class BeanMap {
private Map map;
public Map getMap () { return map;}
public void setMap (Map map) { this .map = map; }
}
|
Pour configurer celle-ci via le fichier XML, il faut utiliser les balises :
< bean id = " beanMap " class = " com.developpez.hikage.BeanMap " >
< property name = " map " >
< map >
< entry >
< key > < value > Clé de type String< / value > < / key >
< value > Valeur associé de type String< / value >
< / entry >
< entry >
< key > < ref bean = " monBeanCle " > < / ref > < / key >
< ref bean = " monBeanValeur " > < / ref >
< / entry >
< / map >
< / property >
< / bean >
|
Il est aussi possible d'écrire ces lignes de manière abrégée :
< bean id = " beanMap " class = " com.developpez.hikage.BeanMap " >
< property name = " map " >
< map >
< entry key = " Ma clé de type String " value = " Valeur associée de type String " / >
< entry key-ref = " monBean " value-ref = " monBean " / >
< / map >
< / property >
< / bean >
|
|
| auteur : Gildas Cuisinier |
Il est parfois nécessaire à un Bean de possèder une référence à l'ApplicationContext ( ou le BeanFactory ) qui s'occupe de son cycle de vie. Pour cela, il suffit simplement que celui-ci implémente une de ces deux interfaces pour que Spring injecte automatiquement la référence correspondante :
public interface ApplicationContextAware {
void setApplicationContext (org.springframework.context.ApplicationContext applicationContext) throws org.springframework.beans.BeansException;
}
public interface BeanFactoryAware {
void setBeanFactory (org.springframework.beans.factory.BeanFactory beanFactory) throws org.springframework.beans.BeansException;
}
|
|
lien : Javadoc ApplicationContextAware
lien : Javadoc BeanFactoryAware
|
| auteur : Gildas Cuisinier |
Dans le cas de l'injection de dépendance par accesseurs, il n'est pas possible de manière standard de vérifier que tous les arguments obligatoires sont fournis. De plus, il est parfois nécessaire d'effectuer certaines opérations de configuration manuellement.
Pour cela, Spring fournit une interface :
public interface InitializingBean {
void afterPropertiesSet() throws java.lang.Exception;
}
|
Dès qu'un bean implémente cette interface, Spring appellera la méthode afterPropertiesSet après l'appel de tous les accesseurs, fournissant ainsi un moyen de vérifier l'existance de tous les paramètres ainsi que leur validité, ou encore de configurer certaines ressources manuellement.
|
Consultez les autres F.A.Q's
Les sources présentés sur cette pages sont libre de droits,
et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Copyright ©2004
Developpez LLC. Tout droits réservés Developpez LLC.
Aucune reproduction, même partielle, ne peut être faite de ce site et de
l'ensemble de son contenu : textes, documents et images sans l'autorisation
expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans
de prison et jusqu'à 300 000 E de dommages et intérets.
Cette page est déposée à la SACD.
|