Qu'est-ce que l'intégration Spring ?

Spring prend en charge l'intégration d'applications dans les frameworks d'entreprise à l'aide d'une extension appelée Spring Integration . L'objectif principal est de faciliter les applications avec divers domaines d'activité ; les technologies contribuent à l'interopérabilité horizontale dans toute l'entreprise. Il ajoute une messagerie légère et une intégration avec des systèmes et services externes à l'aide d'un cadre d'adaptateur. Cet article vise à fournir une compréhension de base de l'intégration Spring et de son extension au modèle de programmation Spring.

Aperçu

Les applications commerciales ne sont que des solutions aux problèmes posés par les unités commerciales. L'ampleur et la complexité des problèmes déterminent si la solution est à l'échelle de l'entreprise ou se limite à quelques lignes de code. Le problème avec l'application d'entreprise est que, parfois, une partie de la solution est déjà disponible en utilisant des technologies plus anciennes qui peuvent ne pas être rentables à reconstruire à partir de zéro pour correspondre aux technologies plus récentes, qu'il s'agisse de nouveau matériel ou logiciel. Il s'agit d'un problème typique des applications héritées. Par conséquent, ce que nous pouvons faire, c'est créer de nouveaux composants qui interagissent avec le système existant. C'est l'intégration d'applications . Cependant, le problème ne s'arrête pas là. Il n'est pas très facile de créer des composants qui fonctionnent de manière transparente avec des composants existants sans imposer de restrictions inutiles sur l'efficacité de l'autre. Il y a une considération sérieuse qui doit être prise en compte pour une intégration transparente de plusieurs composants. Spring Integration prend en compte ces problèmes et fournit un environnement permettant aux développeurs de coder pour une intégration facile. Spring identifie les modèles communs impliqués et fait le travail avec peu d'intervention des développeurs.

Couplage desserré

Étant donné que la solution doit utiliser plusieurs parties, chaque partie doit avoir des préoccupations distinctes de la manière la plus lâche possible. L'évolution d'un composant ne doit pas avoir d'incidences sérieuses sur la conception et la maintenance d'un autre. Une situation de découplage complet n'est pas adaptée à l'intégration, et un couplage étroit n'est pas non plus acceptable. Par conséquent, le jeu consiste à concevoir le composant d'une manière aussi lâche que possible. Il existe plusieurs façons de réduire le couplage dans une application Spring :injection de dépendances ou architecture pilotée par les événements . L'architecture pilotée par les événements est un terme large et présente une différence très fine entre l'architecture pilotée par les messages ou MOM. Bien qu'ils ne soient pas les mêmes techniquement, à cette fin, nous pouvons utiliser les termes de manière interchangeable ici. Juste pour le plaisir du puriste, la différence fondamentale entre les événements et les messages est que les messages ont des destinataires dirigés alors que les événements ne sont pas dirigés. sinon, leur mise en œuvre n'a guère de démarcation claire. N'entrons pas dans cela ici; Concentrons-nous plutôt sur la façon dont l'architecture pilotée par les événements est utilisée avec Spring Integration.

Intégration Spring basée sur les événements

Dans une architecture événementielle, une application complexe est décomposée en plusieurs composants de service. Ces composants interagissent via des événements générés par d'autres composants, appelés éditeur d'événements. D'autres composants intéressés par cet événement particulier s'y abonnent et prennent les mesures appropriées en réponse. Il s'agit essentiellement du modèle éditeur-abonné de travail sur les événements.

Un changement d'état spécifique est un événement. Comme indiqué, un événement est envoyé aux parties intéressées et les abonnés à l'événement peuvent choisir de répondre en fournissant un service tel que l'exécution d'un processus métier, la publication d'un autre événement ou, peut-être, l'ignorer complètement. Cela signifie que les événements, une fois publiés, n'ont aucune responsabilité sur la réponse des abonnés. Il s'agit d'un scénario découplé et l'architecture événementielle exploite ces scénarios de couplage lâche. Le couplage lâche est particulièrement adapté pour effectuer le flux de travail en temps réel requis par Spring Integration.

Composants d'intégration Spring

En tant qu'extension du framework Spring, Spring Integration ajoute essentiellement trois composants :les messages, les canaux de messages et les points de terminaison. Les développeurs de Spring Integration ont reconnu le modèle commun de similitudes pour interagir entre une architecture, un domaine et des technologies variés dans le domaine de l'entreprise. Par conséquent, en introduisant la messagerie via des composants utilisant des canaux et des filtres, ce modèle est devenu la base de l'intégration d'applications. Les composants du filtre consomment ou produisent les messages tandis que les canaux, appelés canaux dans Spring Integration, décrit le flux de messages entre les filtres.

Il y a beaucoup de complexités impliquées. Reportez-vous aux liens dans la section Références pour plus de détails. Ici, concentrons-nous plutôt sur une implémentation simple avec DirectChannel .

Un exemple rapide

L'exemple de la liste 1 est une application Spring BOOT qui implémente Spring Integration avec DirectChannel . Ici, le canal de message est utilisé pour dissocier les points de terminaison de l'éditeur et de l'abonné. Le canal de message est utilisé pour établir une connexion avec les composants du filtre et de l'adaptateur. L'exemple est assez simple et utilise DirectChannel avec des modèles de communication éditeur-abonné et point à point. Notez que le code est rudimentaire et une implémentation simple pour illustrer l'idée de Spring Integration.

xml version="1.0" encoding="UTF-8" ?> <projet 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"> <modèleVersion>4.0.0Version du modèle> <identifiant de groupe>com.mano.examplegroupId> <ID d'artefact>spring-integrationartifactId> <version>Version 0.0.1-SNAPSHOT> <emballage>bocalemballage> <nom>spring-integrationnom> <description>Projet de démonstration pour Spring BOOTdescription> <parent> <identifiant de groupe>org.springframework.bootID de groupe> <ID d'artefact>spring-boot-starter-parentartifactId> <version>2.0.6.VERSIONversion> <cheminrelatif />  parent> <propriétés> <project.build.sourceEncoding> UTF-8 project.build.sourceEncoding> <project.reporting.outputEncoding> UTF-8 project.reporting.outputEncoding> <java.version>1.8version.java> propriétés> <dépendances> <dépendance> <identifiant de groupe>org.springframework.bootID de groupe> <ID d'artefact> spring-boot-starter-integration artifactId> dépendance> <dépendance> <identifiant de groupe>org.springframework.bootID de groupe> <ID d'artefact> spring-boot-starter-test artifactId> <portée>testerportée> dépendance> dépendances> <construire> <plugins> <plugin> <identifiant de groupe> org.springframework.boot groupId> <ID d'artefact> spring-boot-maven-plugin artifactId> plugin> plugins> construire>projet> 

 Liste 1 : pom.xml, dépendances Spring BOOT pour une solution d'intégration Spring
 
forfait  com.mano.example.springintegration.model ;importer java.util.Date;classe publique Tweet { longue conversation privée; privé Chaîne texte; privé Date heure; privé Chaîne hashTag; @Remplacer public Chaîne toString() { retourne "Tweet{" + "tid=" + jour + ", text='" + texte + ''' + ", temps=" + temps + ", hashTag='" + hashTag + ''' + '}'; } public long getTid() { retourner tid; } vide public setTid(long tid) { ceci .jour =marée ; } public String getText() { texte renvoyé; } vide public setText(String text) { ceci .texte =texte ; } public Date getTime() { heure de retour; } vide public setTime(Date heure) { ceci .temps =temps ; } public Chaîne getUser() { retourne le hashTag; } vide public setUser(String hashTag) { ceci .hashTag =hashTag ; }}
 

 Liste 2 : Tweet.java, classe modèle
 
paquet  com.mano.example.springintegration.repo;importer com.mano.example.springintegration.model.Tweet ;importer org.springframework.stereotype.Component;importer java.util.ArrayList ;importer java.util.Date ;importer java.util.List;@Componentclasse publique TweetPublisher { long statique privé identifiant; public List getTweets(){ List tweets =nouveau TableauListe<>(); tweets.add(createTweet("Orages dans le Pacifique" ,"#météo" )); tweets.add(createTweet("quoi de neuf développeurs ?" ,"#dev" )); tweets.add(createTweet("Délicatesse chinoise sur Amazon" , "#voyageur" )); tweets.add(createTweet("inflation en baisse de 2 %" ,"#stock" )); tweets.add(createTweet("save river" ,"#environnement" )); tweets.add(createTweet("Nouvelle étoile trouvée" ,"#astronaute" )); tweets.add(createTweet("Apprendre les maths rapidement" ,"#tuteur" )); tweets.add(createTweet("Sauvez les animaux" ,"#bovin" )); tweets.add(createTweet("les étoiles sont favorables maintenant" , "#astro" )); tweets.add(createTweet("troubles sociaux dans le monde" , "#inquiétude" )); retour tweets ; } Tweet createTweet(String text, String hashTag){ Tweet tweet =nouveau Tweet(); tweet.setTid(id ++); tweet.setUser(hashTag); tweet.setText(texte); tweet.setTime(nouveau Date()); retour tweeter ; }}
 

 Liste 3 : TweetPublisher.java, remplit les données de tweet
 
paquet  com.mano.example.springintegration.pub;importer com.mano.example.springintegration.model.Tweet ;importer org.springframework.beans.factory.annotation.Value;importer org.springframework.integration.channel.DirectChannel;importer org.springframework.integration.support .MessageBuilder;importer org.springframework.stereotype.Component;@Componentclasse publique Tweeter { privé DirectChannel canal; @Value("#{tweetChannel}" ) vide public setChannel (canal DirectChannel) { ceci .canal =canal ; } vide public sendTweetReaders(Tweet tweet) { System.out  .println("Nouveau Tweet - " + tweet.toString()); canal .send(MessageBuilder.withPayload (tweet) .build()); }}
 

 Liste 4 : Tweeter.java, classe d'éditeur
 
paquet  com.mano.example.springintegration.sub;importer com.mano.example.springintegration.model.Tweet ;importer org.springframework.integration .MessageRejectedException ;importer org.springframework.messaging.Message ;importer org.springframework.messaging.MessageHandler;importer org.springframework.messaging.MessagingException ;importer org.springframework.stereotype.Component;@Componentclasse publique TweetReader implémente MessageHandler { @Override vide public handleMessage(Message message) lance MessagingException { Charge utile de l'objet =message.getPayload(); si (charge utile instanceof Tweet) { receiveAndAcknowledge((Tweet) charge utile); } autrement { jeter nouveau MessageRejectedException(message, "Un type de données inconnu a été reçu." ); } } annuler receiveAndAcknowledge(Tweet tweet) { System.out  .println("Salut Tweeter, c'est le lecteur #" + System.identityHashCode (ceci ) + "." + "Tweet reçu - " + tweet.toString() + "n" ); }}
 

 Liste 5 : TweetReader.java, classe d'abonné
 
forfait  com.mano.example.springintegration ;importer com.mano.example.springintegration.incoming .TweetPublisher ;importer com.mano.example.springintegration.model.Tweet ;importer com.mano.example.springintegration.pub.Tweeter ;importer com.mano.example.springintegration.sub.TweetReader ;importer org.springframework.beans.factory.annotation.Autowired ;importer org.springframework.boot.CommandLineRunner;importer org.springframework.boot.SpringApplication;importer org.springframework.boot.autoconfigure .SpringBootApplication;importer org.springframework.context.ApplicationContext;importer org.springframework.context.annotation.Bean;importer org.springframework.context.annotation.ComponentScan;importer org.springframework.integration.channel.DirectChannel;importer org.springframework.messaging.MessageChannel;importer java.util.List;@SpringBootApplication@ComponentScan(basePackages ="com.mano.example.springintegration" )classe publique SpringIntegrationApplication { @Autowired privé TweetPublisher tweetPublisher; @Autowired privé Tweeter tweeter; @Autowired privé DirectChannel canal; @Bean public MessageChannel tweetChannel(){ retourner nouveau CanalDirect(); } @Bean public CommandLineRunner commandLineRunner (contexte ApplicationContext){ retour args -> { canal .subscribe(nouveau TweetReader()); canal .subscribe(nouveau TweetReader()); canal .subscribe(nouveau TweetReader()); Liste tweets =tweetPublisher .getTweets(); pour (Tweet tweet :tweets){ tweeter .sendTweetReaders(tweet); } } ; } vide statique public main(String[] args) { SpringApplication.exécuter (SpringIntegrationApplication .classe , arguments); }}
 

 Liste 6 : SpringIntegrationApplication.java, classe d'application principale
 
Conclusion
 

 Notez qu'il y a beaucoup plus avec Spring Integration qu'illustré ici. Ce n'est que la pointe de l'iceberg. Des détails importants sont omis. Reportez-vous à la documentation de Spring pour plus de détails à ce sujet; les liens sont donnés ci-dessous. Spring Integration présente des avantages, tels que l'inversion de contrôle (IoC), une programmation orientée aspect pour répondre aux préoccupations transversales et d'autres avantages essentiels de Spring Framework à sa disposition. Spring Integration va plus loin. Les développeurs de Spring Integration n'ont pas besoin de savoir comment, quand et où se trouvent les données. Le cadre gère la façon dont la logique métier doit être exécutée en manœuvrant le message à travers les composants appropriés. Outre un schéma de configuration XML standard, les démarreurs Spring BOOT fournissent les dépendances requises pour démarrer le code de front sans se soucier des dépendances.
 
Références
 
 
Présentation de l'intégration Spring
 
Intégration printanière