Spring poskytuje podporu pro integraci aplikací napříč podnikovými frameworky pomocí rozšíření nazvaného Spring Integration . Primárním cílem je usnadnit aplikace s různými obchodními doménami; technologie směřují k horizontální interoperabilitě napříč celým podnikem. Přidává lehké zasílání zpráv a integraci s externími systémy a službami pomocí rámce adaptéru. Tento článek si klade za cíl poskytnout základní pochopení Spring Integration a toho, jak se rozšiřuje na Spring programovací model.
Přehled
Komerční aplikace nejsou nic jiného než řešení problémů, které představují obchodní jednotky. Velikost a složitost problémů určuje, zda se jedná o řešení podnikového rozsahu nebo jen několik řádků kódu. Problém s podnikovou aplikací je v tom, že někdy je již k dispozici část řešení využívající starší technologie, jejichž přestavba od nuly tak, aby odpovídala novějším technologiím, nemusí být nákladově efektivní, ať už jde o nový hardware nebo software. Toto je typický problém se staršími aplikacemi. Co tedy můžeme udělat, je vytvořit novější komponenty, které budou spolupracovat se stávajícím systémem. Toto je integrace aplikací . Tím však problém nekončí. Není příliš snadné vytvořit komponenty, které hladce spolupracují se stávajícími komponentami, aniž by se zbytečně omezovala jejich efektivita. Existuje vážná úvaha, kterou je třeba řešit pro bezproblémovou integraci více komponent. Spring Integration zvažuje tyto problémy a poskytuje vývojářům prostředí pro kódování pro snadnou integraci. Spring identifikuje běžné vzorce a provede tuto práci s malým zásahem vývojářů.
Uvolněná spojka
Vzhledem k tomu, že řešení musí používat více částí, každá část musí mít samostatné zájmy, a to co možná nejvíce volně propojeným způsobem. Vývoj jedné součásti nesmí mít vážné důsledky pro konstrukci a údržbu jiné součásti. Situace úplného oddělení není vhodná pro integraci ani není přijatelné těsné spojení. Proto je ve hře navrhnout komponent způsobem co nejvolněji propojeným. Existuje několik způsobů, jak omezit propojení v aplikaci Spring:vkládání závislostí nebo architektura řízená událostmi . Architektura řízená událostmi je široký pojem a má velmi jemný rozdíl mezi architekturou řízenou zprávou nebo MOM. Ačkoli nejsou technicky stejné, pro tento účel zde můžeme termíny používat zaměnitelně. Jen kvůli puristům, základní rozdíl mezi událostmi řízenými a řízenými zprávami je ten, že zprávy směrují příjemce, zatímco události nejsou řízeny; jinak má jejich realizace jen stěží jasné vymezení. Nezabývejme se zde; místo toho se zaměřme na to, jak se architektura řízená událostmi využívá s integrací Spring.
Událostmi řízená jarní integrace
V architektuře řízené událostmi je složitá aplikace rozdělena do několika komponent služeb. Tyto komponenty interagují prostřednictvím událostí generovaných jinými komponentami, které se nazývají vydavatel událostí. Ostatní složky, které se o danou událost zajímají, se k ní přihlásí a v reakci na to podniknou příslušné kroky. Toto je v podstatě model práce na událostech vydavatel-odběratel.
Konkrétní změna stavu je událost. Jak bylo uvedeno, událost je zaslána zainteresovaným stranám a předplatitelé události se mohou rozhodnout odpovědět poskytnutím služby, jako je provedení obchodního procesu, zveřejnění jiné události nebo ji možná úplně ignorovat. To znamená, že události po zveřejnění nenesou žádnou odpovědnost za reakci předplatitelů. Toto je oddělený scénář a architektura řízená událostmi využívá takové scénáře volné vazby. Volná spojka je zvláště vhodná k provádění pracovního toku v reálném čase, který vyžaduje Spring Integration.
Komponenty pro integraci pružin
Jako rozšíření frameworku Spring přidává Spring Integration v podstatě tři komponenty:zprávy, kanály zpráv a koncové body. Vývojáři Spring Integration rozpoznali společný vzorec podobností pro vzájemnou spolupráci mezi různými architekturami, doménami a technologiemi v podnikové aréně. Proto se zavedením zasílání zpráv prostřednictvím komponent pomocí potrubí a filtru stal tento model základem pro integraci aplikací. Komponenty filtru spotřebovávají nebo vytvářejí zprávy, zatímco kanály, označované jako kanály v Spring Integration popisuje tok zpráv mezi filtry.
Je v tom mnoho složitostí. Další podrobnosti naleznete v odkazech v sekci Reference. Zde se místo toho zaměřme na jednoduchou implementaci pomocí DirectChannel .
Rychlý příklad
Příklad ve výpisu 1 je aplikace Spring BOOT, která implementuje Spring Integration s DirectChannel . Zde se kanál zpráv používá k oddělení koncových bodů vydavatele a předplatitele. Kanál zpráv se používá k navázání spojení s komponentami filtru a adaptéru. Příklad je docela přímočarý a používá DirectChannel s modely komunikace vydavatel-předplatitel a point-to-point. Všimněte si, že kód je základní a jednoduchá implementace pro ilustraci myšlenky jarní integrace.
<?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>
Zápis 1: pom.xml, závislosti Spring BOOT pro řešení Spring Integration
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;
}
}
Zápis 2: Tweet.java, modelová třída
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;
}
}
Zápis 3: TweetPublisher.java, vyplní data tweetů
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());
}
}
Zápis 4: Tweeter.java, třída vydavatele
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");
}
}
Zápis 5: TweetReader.java, třída předplatitelů
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);
}
}
Zápis 6: SpringIntegrationApplication.java, hlavní aplikační třída
Závěr
Všimněte si, že Spring Integration má mnohem více, než je zde znázorněno. Je to jen špička ledovce. Důležité detaily jsou vynechány. Další podrobnosti naleznete v dokumentaci pružiny; odkazy jsou uvedeny níže. Spring Integration má výhody, jako je Inversion of Control (IoC), aspektově orientované programování pro řešení průřezových problémů a další základní výhody Spring Frameworku, které má k dispozici. Jarní integrace to posouvá dále. Vývojáři Spring Integration nepotřebují vědět o tom, jak, kdy a kde se data nacházejí. Rámec se stará o to, jak má být prováděna obchodní logika, pomocí manévrování se zprávou prostřednictvím příslušných komponent. Kromě běžného konfiguračního schématu XML poskytují spouštěče Spring BOOT požadované závislosti pro spuštění kódu bez obav ze závislostí.
Odkazy
- Přehled jarní integrace
- Jarní integrace