Spring biedt ondersteuning voor applicatie-integratie in enterprise frameworks door gebruik te maken van een extensie genaamd Spring Integration . Het primaire doel is het faciliteren van applicaties met diverse bedrijfsdomeinen; technologieën werken aan horizontale interoperabiliteit in de hele onderneming. Het voegt lichtgewicht messaging en integratie met externe systemen en services toe met behulp van een adapterframework. Dit artikel is bedoeld om een basisbegrip te geven van Spring Integration en hoe dit zich uitstrekt over het Spring-programmeermodel.
Overzicht
Commerciële toepassingen zijn niets anders dan oplossingen voor problemen van business units. De omvang en complexiteit van de problemen bepalen of de oplossing op bedrijfsschaal is of slechts een paar regels code. Het probleem met de bedrijfsapplicatie is dat soms een deel van de oplossing al beschikbaar is met behulp van oudere technologieën, die misschien niet kosteneffectief zijn om helemaal opnieuw op te bouwen om te passen bij nieuwere technologieën, of het nu nieuwe hardware of software is. Dit is een typisch probleem met legacy-applicaties. Daarom kunnen we nieuwere componenten maken die samenwerken met het bestaande systeem. Dit is applicatie-integratie . Daar houdt het probleem echter niet op. Het is niet zo eenvoudig om componenten te maken die naadloos samenwerken met bestaande componenten zonder onnodige beperkingen op te leggen aan elkaars efficiëntie. Er is een serieuze overweging die moet worden aangepakt voor een naadloze integratie van meerdere componenten. Spring Integration houdt rekening met deze problemen en biedt ontwikkelaars een omgeving om te coderen voor eenvoudige integratie. Spring identificeert de voorkomende patronen en doet het werk met weinig tussenkomst van ontwikkelaars.
Losse koppeling
Omdat de oplossing uit meerdere delen moet bestaan, moet elk deel op een zo losjes mogelijke manier afzonderlijke aandachtspunten hebben. De evolutie van het ene onderdeel mag geen ernstige gevolgen hebben voor het ontwerp en het onderhoud van het andere. Een volledig ontkoppelde situatie is niet geschikt voor integratie, en een strakke koppeling is evenmin acceptabel. Daarom is het de bedoeling om het onderdeel zo losjes mogelijk te ontwerpen. Er zijn een aantal manieren om koppeling in een Spring-toepassing te verminderen:afhankelijkheidsinjectie of gebeurtenisgestuurde architectuur . Gebeurtenisgestuurde architectuur is een brede term en heeft een heel klein verschil tussen berichtgestuurde architectuur of MOM. Hoewel ze technisch niet hetzelfde zijn, kunnen we voor dit doel de termen hier door elkaar gebruiken. Voor de purist:het fundamentele verschil tussen gebeurtenisgestuurd en berichtgestuurd is dat berichten gerichte ontvangers hebben, terwijl gebeurtenissen ongericht zijn; anders is er nauwelijks een duidelijke afbakening voor de uitvoering ervan. Laten we daar hier niet op ingaan; Laten we ons in plaats daarvan concentreren op hoe gebeurtenisgestuurde architectuur wordt gebruikt met Spring Integration.
Evenementgestuurde lente-integratie
In gebeurtenisgestuurde architectuur wordt een complexe applicatie opgesplitst in verschillende servicecomponenten. Deze componenten werken samen via gebeurtenissen die worden gegenereerd door andere componenten, die de uitgever worden genoemd van evenementen. Andere componenten die geïnteresseerd zijn in dat specifieke evenement, abonneren zich erop en ondernemen passende actie als reactie. Dit is in wezen het uitgever-abonnee-model om aan evenementen te werken.
Een specifieke toestandsverandering is een gebeurtenis. Zoals gezegd, een evenement wordt naar geïnteresseerde partijen gestuurd en de abonnees van het evenement kunnen ervoor kiezen om te reageren door een dienst aan te bieden, zoals het uitvoeren van een bedrijfsproces, het publiceren van een ander evenement of, misschien, het volledig negeren ervan. Dat betekent dat de evenementen, eenmaal gepubliceerd, geen enkele verantwoordelijkheid hebben over de respons van de abonnees. Dit is een ontkoppeld scenario en gebeurtenisgestuurde architectuur maakt gebruik van dergelijke losse koppelingsscenario's. Losse koppeling is met name geschikt om realtime werkstromen uit te voeren die Spring Integration vereist.
Verenintegratiecomponenten
Als uitbreiding van het Spring-framework voegt Spring Integration in feite drie componenten toe:berichten, berichtkanalen en eindpunten. Ontwikkelaars van Spring Integration herkenden het gemeenschappelijke patroon van overeenkomsten om samen te werken tussen verschillende architectuur, domeinen en technologieën in de enterprise-arena. Daarom werd dit model de basis voor applicatie-integratie door de introductie van berichten via een component met behulp van buizen en filters. De filtercomponenten consumeren of produceren de berichten terwijl de buizen, die kanalen worden genoemd, in Spring Integration beschrijft de berichtenstroom tussen filters.
Er zijn veel fijne kneepjes bij betrokken. Raadpleeg de koppelingen in de sectie Referenties voor meer informatie. Laten we ons hier in plaats daarvan concentreren op een eenvoudige implementatie met DirectChannel .
Een snel voorbeeld
Het voorbeeld in Listing 1 is een Spring BOOT-toepassing die Spring Integration implementeert met DirectChannel . Hier wordt het berichtenkanaal gebruikt om de eindpunten van de uitgever en de abonnee te ontkoppelen. Het berichtenkanaal wordt gebruikt om verbinding te maken met de filter- en adaptercomponenten. Het voorbeeld is vrij eenvoudig en gebruikt DirectChannel met publisher-abonnee en point-to-point communicatiemodellen. Merk op dat de code rudimentair is en een eenvoudige implementatie om het idee van Spring Integration te illustreren.
<?xml version="1.0" encoding="UTF-8"?>
<project
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>com.mano.example</groupId>
<artifactId>spring-integration</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>spring-integration</name>
<description>Demo project for Spring BOOT</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- look up 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>
Vermelding 1: pom.xml, Spring BOOT-afhankelijkheden voor een Spring Integration-oplossing
package com.mano.example.springintegration.model;
import java.util.Date;
public class Tweet {
private long tid;
private String text;
private Date time;
private String hashTag;
@Override
public String toString() {
return "Tweet{" +
"tid=" + tid +
", text='" + text + ''' +
", time=" + time +
", hashTag='" + hashTag + ''' +
'}';
}
public long getTid() {
return tid;
}
public void setTid(long tid) {
this.tid = tid;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
public String getUser() {
return hashTag;
}
public void setUser(String hashTag) {
this.hashTag = hashTag;
}
}
Vermelding 2: Tweet.java, modelklasse
package com.mano.example.springintegration.repo;
import com.mano.example.springintegration.model.Tweet;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@Component
public class TweetPublisher {
private static long id;
public List<Tweet> getTweets(){
List<Tweet> tweets = new ArrayList<>();
tweets.add(createTweet("Storms in Pacific","#weather"));
tweets.add(createTweet("what's up developers?","#dev"));
tweets.add(createTweet("Chinese delicacy in Amazon",
"#traveller"));
tweets.add(createTweet("inflation down by 2%","#stock"));
tweets.add(createTweet("save river","#environment"));
tweets.add(createTweet("New star found","#astronaut"));
tweets.add(createTweet("Learn math quickly","#tutor"));
tweets.add(createTweet("Save animals","#bovine"));
tweets.add(createTweet("stars are favorable now",
"#astro"));
tweets.add(createTweet("social unrest in the world",
"#concern"));
return tweets;
}
Tweet createTweet(String text, String hashTag){
Tweet tweet = new Tweet();
tweet.setTid(id++);
tweet.setUser(hashTag);
tweet.setText(text);
tweet.setTime(new Date());
return tweet;
}
}
Vermelding 3: TweetPublisher.java, vult tweetgegevens in
package com.mano.example.springintegration.pub;
import com.mano.example.springintegration.model.Tweet;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.support
.MessageBuilder;
import org.springframework.stereotype.Component;
@Component
public class Tweeter {
private DirectChannel channel;
@Value("#{tweetChannel}")
public void setChannel(DirectChannel channel) {
this.channel = channel;
}
public void sendTweetReaders(Tweet tweet) {
System.out.println("New Tweet - " + tweet.toString());
channel.send(MessageBuilder.withPayload(tweet)
.build());
}
}
Vermelding 4: Tweeter.java, uitgeversklasse
package com.mano.example.springintegration.sub;
import com.mano.example.springintegration.model.Tweet;
import org.springframework.integration
.MessageRejectedException;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.stereotype.Component;
@Component
public class TweetReader implements MessageHandler {
@Override
public void handleMessage(Message<?> message)
throws MessagingException {
Object payload = message.getPayload();
if (payload instanceof Tweet) {
receiveAndAcknowledge((Tweet) payload);
} else {
throw new MessageRejectedException(message,
"Unknown data type has been received.");
}
}
void receiveAndAcknowledge(Tweet tweet) {
System.out.println("Hi Tweeter, this is Reader #"
+ System.identityHashCode(this) +
"." + "Received tweet - " + tweet.toString()
+ "n");
}
}
Vermelding 5: TweetReader.java, abonneeklasse
package com.mano.example.springintegration;
import com.mano.example.springintegration.incoming
.TweetPublisher;
import com.mano.example.springintegration.model.Tweet;
import com.mano.example.springintegration.pub.Tweeter;
import com.mano.example.springintegration.sub.TweetReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure
.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.messaging.MessageChannel;
import java.util.List;
@SpringBootApplication
@ComponentScan(basePackages = "com.mano.example.springintegration")
public class SpringIntegrationApplication {
@Autowired
private TweetPublisher tweetPublisher;
@Autowired
private Tweeter tweeter;
@Autowired
private DirectChannel channel;
@Bean
public MessageChannel tweetChannel(){
return new DirectChannel();
}
@Bean
public CommandLineRunner commandLineRunner
(ApplicationContext context){
return args -> {
channel.subscribe(new TweetReader());
channel.subscribe(new TweetReader());
channel.subscribe(new TweetReader());
List<Tweet> tweets = tweetPublisher.getTweets();
for (Tweet tweet: tweets){
tweeter.sendTweetReaders(tweet);
}
};
}
public static void main(String[] args) {
SpringApplication.run(SpringIntegrationApplication
.class, args);
}
}
Vermelding 6: SpringIntegrationApplication.java, hoofdtoepassingsklasse
Conclusie
Merk op dat er veel meer is met Spring Integration dan hier wordt geïllustreerd. Het is slechts het topje van de ijsberg. Belangrijke details zijn weggelaten. Raadpleeg de Spring-documentatie voor meer informatie hierover; links worden hieronder gegeven. Spring Integration heeft voordelen, zoals Inversion of Control (IoC), aspectgeoriënteerd programmeren om transversale problemen aan te pakken en andere kernvoordelen van Spring Framework. Spring Integration gaat verder. Ontwikkelaars van Spring Integration hoeven niet te weten hoe, wanneer en waar de gegevens zich bevinden. Het raamwerk regelt hoe de bedrijfslogica moet worden uitgevoerd door het bericht door de juiste componenten te manoeuvreren. Afgezien van een regulier XML-configuratieschema, levert Spring BOOT starters de vereiste afhankelijkheden om code direct te starten met weinig zorgen over afhankelijkheden.
Referenties
- Overzicht voorjaarsintegratie
- Voorjaarsintegratie