Beans

Présentation des composants Spring

Ce site ne sera plus alimenté de contenu après août 2014. Tous les nouveaux articles seront redigés pour www.waitingforcode.com

Spring introduit une nomination pour les objets gérés par l'injection des dépendances. Ces objets sont appelés des beans.

Qu'est-ce que c'est un bean dans Spring ?

Un bean est un objet totalement managé par inversion of control container (IoC). Ce dernier s'occupe d'initialiser et d'assembler cet objet.

Les beans sont représentés dans les méta-données de configuration qui servent ensuite à IoC dans la gestion des beans. La configuration peut être exprimée soit en fichiers XML, soit en annotations.

Composition des beans

Sur la base de notre projet de gestion de la bibliothèque, on analysera la définition d'un bean à travers un fichier XML.

<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean" />

Ce fragment de code représente la définition la plus simple du bean. On remarque la présence des 2 attributs :
- id : permet de spécifier l'identifiant du bean. Il peut exister uniquement un seul élément avec un identifiant donné.
- class : représente la classe du bean.

Les beans peuvent être appelés aussi avec l'attribut name. Cependant, une seule condition est à respecter. Un nom (bean peut en avoir plusieurs) doit être unique dans le contexte. Si un bean contient tous les attributs de nommage, l'attribut le plus important est id. Si celui-ci était absent, Spring chercherait l'attribut name. Si celui-ci n'était pas spécifié, il prendrait l'attribut class pour déterminer le nom du bean dans le contexte.

afficher le code

A part les deux attributs mentionnés précédemment, on retrouve une balise property. Elle représente la propriété utilisée par le bean. Chaque propriété doit posséder son propre setter dans la classe définie dans l'attribut class.

En occurrence, on présente deux méthodes de définition des propriétés :
- la première repose sur une simple précision de valeur dans l'attribut value. Par exemple, pour la propriété maxUploadSize< on retrouvera le setter setMaxUploadSize() (documentation du CommonsMultipartResolver). Comme on peut le constater, le setter prend en paramètre un long tandis qu'on lui passe un String< dans le XML. La conversion entre deux types se fait via JavaBeans PropertyEditors.
- la deuxième méthode présente la définition d'une propriété par référence à un bean déjà existant. En occurrence, la propriété dataSource se réfère au bean au même identifiant, défini plus loin dans le code.

<bean id="jpaFlowExecutionListener" 
      class="org.springframework.webflow.persistence.JpaFlowExecutionListener">
    <constructor-arg ref="emf" />
    <constructor-arg ref="transactionManager" />
</bean>

La présence des balises constructor-arg aide Spring à trouver le constructeur à utiliser. En occurrence, il n'existe qu'un seul constructeur avec des paramètres (Javadoc du JpaFlowExecutionListener). IoC< va alors récupérer les beans emf et transactionManager, et ensuite chercher le constructeur correspondant.

afficher le code

On peut également passer des collections en paramètre. Dans l'exemple ci-dessus, on remarque la définition d'une liste de properties, d'une map, d'une liste et d'un set.

Cycle de vie d'un bean

TODO : fournir un exemple complet d'initialisation d'un bean

Le cycle de vie d'un bean dans Spring peut se résumer à 9 étapes :

  1. Instanciation : le container trouve la définition d'un bean dans le fichier de configuration et créé une instance grâce à la Java Reflection API
  2. Définition des propriétés : injection des propriétés du bean
  3. Définition du nom du bean : définition du nom sous lequel le bean sera connu par le contexte d'application
  4. Définition de la fabrique du bean : si le bean implémente BeanFactoryAware, la méthode setBeanFactory() est appélée
  5. Pré-initialisation : si un BeanPostProcessors est défini, la méthode postProcessBeforeInitialization() est appelée avant l'initialisation du bean
  6. Initialisation : si le bean implémente IntializingBean, la méthode afterPropertySet() est alors appelée. Sinon, c'est la fonction spécifiée dans l'attribut init-method qui est alors invoquée.
  7. Post-initialisation : si un BeanPostProcessors est défini, la méthode postProcessBeforeInitialization() est appelée après l'initialisation du bean
  8. Prêt à l'emploi : bean peut être utilisé par l'application
  9. Destruction : bean est détruit. Par défaut, la fonction destroy() est appélée à ce moment-là. Cependant, une méthode destruction peut être déterminée dans l'attribut destroy-method dans le XML, comme suit :
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
                destroy-method="close">
            < -- ... -->
    

Les méthodes d'initialisation et de destruction peuvent être aussi spécifiés au niveau de la balise beans, comme sur cet exemple :

<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-3.0.xsd"
    default-init-method="customInit" 
    default-destroy-method="customDestroy">
Bartosz KONIECZNY Concepts de base

Une question ? Une remarque ?

*

*

Moi

Développeur d'applications Internet et journaliste passionné par l'adjectif français. Un aigle polonais orienté vers la progression, volant très haut et écoutant du zouk après les matches du foot français.

Vous appréciez mon travail ?

Pour contribuer au développement de ce site, ou pour remercier pour des articles rédigés, vous pouvez faire un don.

Un conseil Symfony1

Comment afficher un template depuis le fichier d'action ?

Pour le faire il suffit d'appeler la méthode renderPartial() dans le return final.

return $this->renderPartial('ton_template', array('parametres' => 'un paramètre'));