Apres avoir fait une petite présentation des aspects essentiel de Spring Integration nous allons dans cette articles donner des exemples concret d’utilisation.

Spring Integration étant au départ conçu pour une configuration XML des composants, nous offre depuis la version 4.1 avec un JDK 1.8 la possibilité d’écrire des configurations en pure Java et avec les lambda expressions.

Exemple 01 : dans cet exemple nous allons voir comment créer un nouveau projet Spring Integration en utilisant une application Spring Boot , l’application AllXML est une configuration full Xml des composant SI

L’application simulera la réception d’un message une transformation simple du contenu du message puis l’envoi vers la sortie standard.

• Création d’un nouveau Projet Spring Boot avec Spring Integration comme

En utilisant Spring Tools Suite créé un nouveau Sarter Project:

Choisir la dépendance « Integration » :

Puis Next -> Finish.

Le fichier pom.xml de configuration Maven est comme suit:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>akl.spring.integration</groupId>
      <artifactId>SpringIntegrationbegin</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
      <name>SpringIntegrationbegin</name>
      <description>si evo</description>
      <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.8.RELEASE</version>
            <relativePath/> <!--lookup parent from repository -->
      </parent>
      <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
      </properties>
      <dependencies>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-integration</artifactId>
            </dependency>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-test</artifactId>
                  <scope>test</scope>
            </dependency>
      </dependencies>
      <build>
            <plugins>
                 <plugin>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                  </plugin>
            </plugins>
      </build>
</project>

Voilà la suite d’intégration que nous allons utiliser:

Nous envoyons en premier un texte sur le composant Gateway qui servira de point d’entrée et qui créera pour nous le message et l’enverra sur le Channel « toTrasform » a la sortie de ce Channel se trouve un transformer qui effectuera une modification simple et a son tour transmettra le message via le Channel end vers un Service Activator qui affichera le message sur le STDOUT.

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AllXml {

public static void main(String [] args) throws Exception {

ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("AllXmlConfig.xml");

System.out.println(context.getBean(PrintInterfaceService.class).print("hello"));

context.close();

}

public static interface PrintInterfaceService{

String print(String text);

}

}

Explication des points important:

ligne 9: Récupération du context : nous créerons par la suite la définition de l’enchainement cité si dessus via une configuration XML, c’est cette configuration que recuperera spring est deposera dans la variable context.

ligne 11: l’interface PrintInterfaceService est la gateway qui recevra comme argument un String est retournera un String sur sont channel output.

ligne 17: Définition de la Gateway qui est une interface que nous allons associé au composant Gateway via la configuration Xml.

Configuration XML.

Pour définir les différents composants de notre application Spring Integration nous allons créer un fichier XML avec les names space suivants:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:int="http://www.springframework.org/schema/integration"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-4.3.xsd">
<int:gateway 
    service-interface="akl.spring.integration.allxml.AllXml$PrintInterfaceService" 
    default-request-channel="toTransformer"/>
<int:channel id="toTransformer"/>
<int:transformer 
    input-channel="toTransformer" 
    output-channel="end" 
    expression="payload + payload"/>
<int:channel id="end"/>
<int:service-activator 
    input-channel="end"
    expression="payload.toUpperCase()"/>
</beans>

Les namespaces : il est possible d’ajouter ou de supprimer selon le besoin (et si les dépendances dans le pom.xml  son correcte) les names spaces en utilisant l’onglet Namespace sur Spring Tool Suite.

Détaillons a présent le contenu de notre fichier de configuration:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:int="http://www.springframework.org/schema/integration"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-4.3.xsd">

Contient les namespace qu’utilisera Spring pour associé chaque balise a son correspondant Spring integration.

<int:gateway service-interface= »akl.spring.integration.allxml.AllXml$PrintInterfaceService »

default-request-channel= »toTransformer »/>

 

<int:xxx : signifie que nous allons utiliser le namespace xmlns:int qui correspond au composant Spring Integration

<int:gateway: signifie qu’il s’agit du composant Gateway.

service-interface : on spécifie ici l’interface qui définit la Gateway avec comme valeur le nom et l’emplacement de l’interface.

default-request-channel=« toTransformer: La sortie standard de notre Gateway. Sur quelle Channel le résultat doit être déposé ici il s’agit du Channel toTransform.

<int:channel id= »toTransformer »/>: Définition d’un Channel du nom « toTransformer »

<int:transformer input-channel= »toTransformer » output-channel= »end » expression= »payload + payload »/>:

Définition d’un tranformer dont l’entrée est connecté au Channel « toTransformer » l’output du channel est l’input du Transformer. Et dont la sortie est branché sur le channel « end », l’opération de transformation est défini par l’élément expression dont la valeur rend un payload deux fois.

 

<int:channel id= »end »/> : définition d’un Channel end

 

<int:service-activator input-channel= »end » expression= »payload.toUpperCase() »/>

Le service-activator est brancher par son entrée sur la sortie du Channel « end » et contient une opération de transformation qui prend un payload est le met en majuscule.

Resultat de l’éxécution: HELLOHELLO