Spring ger stöd för applikationsintegration över företagsramverk genom att använda en tillägg som heter Spring Integration . Det primära målet är att underlätta applikationer med olika affärsdomäner; teknologier arbetar mot horisontell interoperabilitet i hela företaget. Den lägger till lätta meddelanden och integration med externa system och tjänster med hjälp av ett adapterramverk. Den här artikeln syftar till att ge en grundläggande förståelse för Spring Integration och hur den sträcker sig över Spring-programmeringsmodellen.
Översikt
Kommersiella applikationer är inget annat än lösningar på problem från affärsenheter. Storleken och komplexiteten på problemen avgör om lösningen är av företagsskala eller bara några rader kod. Problemet med företagsapplikationen är att ibland är en del av lösningen redan tillgänglig med hjälp av äldre teknologier som kanske inte är kostnadseffektiva att bygga om från början för att matcha nyare teknologier, vare sig det är ny hårdvara eller mjukvara. Detta är ett typiskt problem med äldre applikationer. Därför är det vi kan göra att skapa nyare komponenter som samverkar med det befintliga systemet. Detta är applikationsintegration . Problemet slutar dock inte där. Det är inte särskilt lätt att skapa komponenter som fungerar sömlöst med befintliga komponenter utan att lägga onödiga begränsningar på varandras effektivitet. Det finns ett allvarligt övervägande som måste tas upp för sömlös integrering av flera komponenter. Spring Integration tar hänsyn till dessa frågor och ger en miljö för utvecklare att koda för enkel integration. Spring identifierar de vanliga inblandade mönstren och gör jobbet med lite utvecklarens inblandning.
Lös koppling
Eftersom lösningen måste använda flera delar måste varje del ha separata problem på ett så löst kopplat sätt som möjligt. Utvecklingen av en komponent får inte medföra allvarliga konstruktions- och underhållskonsekvenser för en annan. En fullständigt frikopplad situation är inte lämplig för integration, och en tät koppling är inte heller acceptabel. Därför är spelet att designa komponenten på ett sätt så löst kopplat som möjligt. Det finns ett par sätt att minska kopplingen i en Spring-applikation:beroendeinjektion eller händelsedriven arkitektur . Händelsedriven arkitektur är ett brett begrepp och har en mycket fin skillnad mellan meddelandestyrd arkitektur, eller MOM. Även om de inte är samma tekniskt, för detta ändamål kan vi använda termerna omväxlande här. Bara för puristens skull är den grundläggande skillnaden mellan händelsestyrda och budskapsdrivna att meddelanden har riktat mottagare medan händelser är oriktade; annars har deras genomförande knappast någon tydlig gränsdragning. Låt oss inte gå in på det här; låt oss istället fokusera på hur händelsedriven arkitektur används med Spring Integration.
Händelsedriven vårintegration
I händelsestyrd arkitektur är en komplex applikation uppdelad i flera tjänstekomponenter. Dessa komponenter interagerar via händelser som genereras av andra komponenter, som kallas utgivaren av händelser. Andra komponenter som är intresserade av just den händelsen prenumererar på den och vidtar lämpliga åtgärder som svar. Detta är i huvudsak modellen för utgivare och prenumeranter för att arbeta med evenemang.
En specifik förändring i tillstånd är en händelse. Som sagt, en händelse skickas till intresserade och eventprenumeranterna kan välja att svara genom att tillhandahålla en tjänst som att exekvera en affärsprocess, publicera ett annat event eller kanske helt ignorera det. Det betyder att händelserna, när de väl har publicerats, inte har något ansvar för prenumeranternas svar. Detta är ett frikopplat scenario och händelsedriven arkitektur utnyttjar sådana lösa kopplingsscenarier. Lös koppling är särskilt lämplig för att utföra arbetsflöden i realtid som Spring Integration kräver.
Fjäderintegreringskomponenter
Som en förlängning av Spring-ramverket lägger Spring Integration i princip till tre komponenter:meddelanden, meddelandekanaler och slutpunkter. Spring Integration-utvecklare insåg det gemensamma mönstret av likheter för att samverka mellan olika arkitekturer, domäner och teknologier på företagsarenan. Därför, genom att introducera meddelanden genom komponent med hjälp av rör och filter, blev denna modell grunden för applikationsintegration. Filterkomponenterna förbrukar eller producerar meddelandena medan rören, kallade kanaler i Spring Integration, beskriver meddelandeflödet mellan filter.
Det finns många krångligheter inblandade. Se länkarna i avsnittet Referenser för mer information. Låt oss här istället fokusera på en enkel implementering med DirectChannel .
Ett snabbt exempel
Exemplet i lista 1 är en Spring BOOT-applikation som implementerar Spring Integration med DirectChannel . Här används meddelandekanalen för att frikoppla utgivarens och prenumerantens slutpunkter. Meddelandekanalen används för att upprätta förbindelse med filter- och adapterkomponenterna. Exemplet är ganska enkelt och använder DirectChannel med utgivare-prenumerant och punkt-till-punkt kommunikationsmodeller. Observera att koden är rudimentär och en enkel implementering för att illustrera idén med Spring Integration.
<?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>
Anteckning 1: pom.xml, Spring BOOT-beroenden för en Spring Integration-lösning
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;
}
}
Anteckning 2: Tweet.java, modellklass
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;
}
}
Anteckning 3: TweetPublisher.java, fyller i tweetdata
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());
}
}
Anteckning 4: Tweeter.java, förlagsklass
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");
}
}
Anteckning 5: TweetReader.java, prenumerantklass
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);
}
}
Anteckning 6: SpringIntegrationApplication.java, huvudapplikationsklass
Slutsats
Observera att det finns mycket mer med Spring Integration än vad som visas här. Det är bara toppen av isberget. Viktiga detaljer är utelämnade. Se vårens dokumentation för mer information om detta; länkar finns nedan. Spring Integration har fördelar, såsom Inversion of Control (IoC), aspektorienterad programmering för att hantera övergripande problem och andra kärnfördelar med Spring Framework till sitt förfogande. Spring Integration tar det längre. Utvecklare av Spring Integration behöver inte veta om hur, när och var data finns. Ramverket hanterar hur affärslogiken ska exekveras genom att manövrera meddelandet genom lämpliga komponenter. Bortsett från ett vanligt XML-konfigurationsschema, tillhandahåller Spring BOOT starters de nödvändiga beroenden för att starta kod direkt med lite oro över beroenden.
Referenser
- Översikt över vårintegration
- Vårintegration