GRATUIT

Vos offres d'emploi informatique

Développeurs, chefs de projets, ingénieurs, informaticiens
Postez gratuitement vos offres d'emploi ici visibles par 4 000 000 de visiteurs uniques par mois

emploi.developpez.com

Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :


Présentation des namespaces Spring


               Version PDF (Miroir)

I. Introduction
II. Liste des namespaces de Spring Framework 2.5
Le schéma P
Le schéma Util
Configuration
constant
list
map
set
property-path
properties
Le schéma Context
Configuration
property-placeholder
annotation-config
component-scan
load-time-weaver
spring-configured
mbean-export
Le schéma Lang
Configuration
groovy
jruby
Le schéma JMS
Configuration
listener-container
jca-listener-container
Le schéma Aop
Configuration
config
aspectj-autoproxy
scoped-proxy
Le schéma TX
Configuration
advice
annotation-driven
jta-configuration-manager
Le schéma JEE
Configuration
II-I. Namespace de Spring Web Service
Le schema OXM
Configuration
Le schema SWS
Configuration
IV. Conclusion


I. Introduction


II. Liste des namespaces de Spring Framework 2.5


Le schéma P

Le schéma P, bien que présent depuis la version 2 de Spring, est très peu connu malgré sa grande utilité. Celui-ci permet de réduire considérablement la taille d'un fichier de configuration XML en fournissant un raccourçi pour la définition des propriétés d'un bean.

Voici la définition d'un bean sans l'utilisation du namespace p :
<bean id="monBean" class="be.hikage.spring.BeanProprietes">
        <property name="proprieteSimple" value="maValeur"/>
        <property name="collaborateur" ref="maDependanceBean"/>
</bean>
Le même bean défini grâce au namespace p :
<bean id="monBean" class="be.hikage.spring.BeanProprietes"  p:proprieteSimple="maValeur" p:collaborateur-ref="maDependanceBean"/>
Le namespace p permet donc de définir des propriétés de cette manière :

L'utilisation du namespace nécessite l'ajout de :
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"/>

Le schéma Util

Le schéma util, comme son nom propose différent tag utilitaire pour la définition de bean de type Map, Set ou List ou encore définir un Bean dont la valeur est une constante d'une classe.

Voici la liste des tags que le namespace propose :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
				http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

constant

Le tag constant permet de définir simplement un bean à partir d'une constante statique d'une classe.

Soit une classe avec une propriété statique :
public class ProprietesStatiques {

    public static final ProprietesStatiques PROPRIETE_1 = new ProprietesStatiques(101, "ADMIN");

	// Constructeur privé et accesseurs
}
Si vous devez injecter PROPRIETE_1 dans un autre bean, cela est possible via le tag constant :
<bean class="be.hikage.spring.MonBeanAvecProprietesStatiques">
        <property name="maValeur">
               <util:constant static-field="be.hikage.spring.ProprietesStatiques.PROPRIETE_1"/>
        </property>
    </bean>
Il est tout à fait possible de définir un bean propre ( opposé à un inner bean dans l'exemple précedent ) en utilisant l'attribut id :
<util:constant id="propriete" static-field="be.hikage.spring.ProprietesStatiques.PROPRIETE_1" />
Il est ensuite tout à fait possible de l'injecter de manière normale dans un autre bean :
<bean class="be.hikage.spring.MonBeanAvecProprietesStatiques">
	<property name="maValeur" ref="propriete1" />
</bean>

list

Le tag list permet quand à lui de définir un bean de type List.

Voici un exemple d'une liste insérée en tant qu'Inner Bean
<bean class="be.hikage.spring.MonBeanCollection">
    <property name="maListe">
        <util:list>
            <value>Ma valeur 1</value>
            <value>Ma valeur 2</value>
            <value>Ma valeur 3</value>
        </util:list>
    </property>
</bean>    
Mais il est tout à fait possible de définir un bean à part de cette manière :
<util:list id="maListe"  list-class="java.util.LinkedList" scope="singleton">
    <!-- Valeur de type simple -->
   <value>Valeur 1</value>
   <!-- Valeur de type collaboateur -->
    <ref local="propriete1"/>
</util:list>
Dans cet exemple, on voit qu'il est possible de spécifier le scope du bean, mais aussi l'implémentation de List que l'on désire utiliser ( ici LinkedList ).
De plus, on peut voir qu'il est possible d'ajouter des élements simple ( via la balise value ) mais aussi des collaborateurs ( via la balise ref ).

Parmi les autres attributs possible, il y a aussi value type :
<bean class="be.hikage.spring.MonBeanCollection">
    <property name="maListe" >
        <util:list value-type="java.lang.Integer">
            <value>30</value>
            <value>60</value>
            <value>20</value>
        </util:list>
    </property>
</bean>
L'attribut permet de spécifier le type d'objet de type simple qui sera ajouter dans la liste. Dans notre exemple, on spécifie qu'il s'agit d'Integer. Si cette attribut n'avait pas été défini, ce serait des String qui seraient ajoutées.


map

Le tag map est l'équivalent du tag list, mais pour les structures de type java.util.Map.
<util:map id="maMap" key-type="java.lang.String" scope="singleton" map-class="java.util.TreeMap" value-type="java.net.URL">
    <entry key="monSite" value="http://www.hikage.be"/>
    <entry key="mesArticles" value="http://hikage.developpez.com"/>
    <entry key="monBlog" value="http://blog.developpez.com/?blog=78"/>
</util:map>
Les élements fils du type sont des entry qui possède :


set

Toujours dans l'optique d'aide à la définition de collection, le tag set permet le même type de définition que les tags list et map, mais cette fois pour les objet java.lang.Set.
<util:set id="monSet" scope="singleton" set-class="java.util.TreeSet" value-type="java.lang.String">
        <value>Une entree</value>
        <value>Une entree 2</value>
        <value>Une entree 3</value>
    </util:set>

property-path


properties


Le schéma Context

Le schéma context est apparu avec la version 2.5 de Spring, et fournit divers tag utile pour la configuration d'un ApplicationContext.

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

property-placeholder


annotation-config


component-scan


load-time-weaver


spring-configured


mbean-export


Le schéma Lang

Le schéma Lang fournit manière d'intégrer des classes créées dans des langages dynamiques ( Groovy, JRuby ou BeanShell ) en tant que Bean Spring.

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:lang="http://www.springframework.org/schema/lang"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.5.xsd">

groovy

Le tag groovy permet comme son nom le permet de définir un bean implémenté en Groovy.

Soit une classe Groovy qui implémente la fonctionnalité d'envoie d'émail :

class GroovyMailer implements Mailer{

    public void sendMail(String destination, String sujet, String message) {
        print "Message à ${destination} concernant ${sujet} [ ${message}]"
    }
Sa définition dans le fichier XML se fait de la manière suivante :

   <lang:groovy id="groovyMailer" script-source="classpath:be/hikage/spring/GroovyMailer.groovy"/>
Dès lors, le bean Groovy peut être injecté dans n'importe quels autres beans de manière tout à fait normale.

Voici la liste des attributs du tags groovy :

Si les 7 premiers attributs ont le même fonctionnement que ceux de la balise bean générale, les deux derniers valent la peine d'être détaillés.

customizer-ref permet de fournir une référence vers un autre bean ( implémentant l'interface GroovyObjectCustomizer ). Ce dernier va être appellé après la création du bean, et pourra modifier le comportement de celui-ci, par exemple en modifiant sa metaclasse.

TODO ajouter un exemple

L'autre fonctionnalité intéressante est cette fournie par refresh-check-delay. Le fait de spécifier une valeur pour cet attribut permet d'activer la vérification de changement de manière périodique.
Autrement dit, si le script Groovy est modifié, la nouvelle version sera prise en compte à un moment donné. C'est tout l'intérêt des languages dynamiques de pouvoir modifié des classes sans avoir à recharger l'application complète.

Le nombre de balises filles acceptées par le tag groovy est de deux : inline-script et property.
Le premier permet de définir directement dans le fichier XML le code Groovy correspondant au Bean ( et donc ne plus utilisé script-source ).

Le second quand à lui présent pour permettre de configurer les propriétes de la classe Groovy.

  <bean id="groovyTracer" class="be.hikage.spring.GroovyTracer"/>
    <lang:groovy id="groovyMailer">
        <lang:inline-script>
package be.hikage.spring
class GroovyMailer implements Mailer{

	String origine;
	
	public void sendMail(String destination, String sujet, String message) {
		print "Message à ${destination} concernant ${sujet} [ ${message}]"
	}
}
        </lang:inline-script>
        <lang:property name="origine" value="gildas.cuisinier@redaction-developpez.com"/>
    </lang:groovy>

jruby

Le tag jruby est identique au tag groovy, mais pour le language Ruby. Ses attributs sont identiques, hormis un : script-interfaces.

Cet attribut est nécessaire, car en pratique Spring va créer un proxy qui implémentera cette ou ces interfaces, et le proxy délèguera les appels à la classe JRuby.

info Remarque : La classe JRuby n'est pas obligé de spécifier explicitement qu'elle implémente cet interface, le seul prérequis c'est qu'elle implémente les méthodes de l'interface ( même nom et mêmes paramètres ).
Tout comme le tag Groovy, elle prends comme filles les balises property et inline-script.

Exemple :
   <lang:jruby id="rubyMessenger" script-interfaces="be.hikage.spring.Mailer" >
        <lang:inline-script>
class RubyMailer
    def sendMail(destination, sujet, message)
        print destination + " " + sujet + " " + message
    end
end
        </lang:inline-script>
    </lang:jruby>

Le schéma JMS

Le schéma JMS permet de simplifier la configuration d'écouteur JMS ou JCA

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-2.5.xsd">

listener-container


jca-listener-container


Le schéma Aop

Le schéma Aop fournit un moyen de configurer des aspect, que ce soit avec Spring AOP ou via l'intégration AspectJ.

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

config


aspectj-autoproxy


scoped-proxy


Le schéma TX

Explication du schéma

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

advice


annotation-driven


jta-configuration-manager


Le schéma JEE

Explication du schéma

Voici la liste des Tags disponibles avec ce schéma :


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">

II-I. Namespace de Spring Web Service


Le schema OXM


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:oxm="http://www.springframework.org/schema/oxm"
  	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
						 http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-1.5.xsd">

Le schema SWS


Configuration

Afin de pouvoir utiliser le namespace, il est nécessaire de le déclarer de cette manière :
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:sws="http://www.springframework.org/schema/web-services"
  	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
						 http://www.springframework.org/schema/oxm http://www.springframework.org/schema/web-services/web-services-1.5.xsd">

IV. Conclusion



               Version PDF (Miroir)

Valid XHTML 1.1!Valid CSS!

Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -