Spring zapewnia obsługę integracji aplikacji w ramach korporacyjnych za pomocą rozszerzenia o nazwie Spring Integration . Podstawowym celem jest ułatwienie aplikacji z różnymi domenami biznesowymi; technologie działają na rzecz interoperacyjności horyzontalnej w całym przedsiębiorstwie. Dodaje lekkie przesyłanie wiadomości i integrację z zewnętrznymi systemami i usługami przy użyciu struktury adaptera. Ten artykuł ma na celu zapewnienie podstawowej wiedzy na temat integracji Spring i tego, jak rozciąga się ona na model programowania Spring.
Przegląd
Aplikacje komercyjne to nic innego jak rozwiązania problemów stawianych przez jednostki biznesowe. Skala i złożoność problemów określa, czy rozwiązanie ma skalę przedsiębiorstwa, czy tylko kilka linijek kodu. Problem z aplikacją korporacyjną polega na tym, że czasami część rozwiązania jest już dostępna przy użyciu starszych technologii, których przebudowa od zera do nowszych technologii może nie być opłacalna, niezależnie od tego, czy jest to nowy sprzęt, czy oprogramowanie. Jest to typowy problem ze starszymi aplikacjami. Dlatego możemy tworzyć nowsze komponenty, które współpracują z istniejącym systemem. To jest integracja aplikacji . Na tym jednak problem się nie kończy. Nie jest łatwo tworzyć komponenty, które bezproblemowo współpracują z istniejącymi komponentami bez nakładania zbędnych ograniczeń na wzajemną wydajność. Istnieje poważny problem, którym należy się zająć, aby bezproblemowa integracja wielu komponentów. Spring Integration uwzględnia te problemy i zapewnia programistom środowisko do kodowania w celu łatwej integracji. Spring identyfikuje typowe wzorce i wykonuje swoją pracę przy niewielkiej interwencji programistów.
Luźne sprzęgło
Ponieważ rozwiązanie musi wykorzystywać wiele części, każda część musi mieć oddzielne problemy w możliwie luźno powiązany sposób. Ewolucja jednego komponentu nie może powodować poważnych konsekwencji konstrukcyjnych i konserwacyjnych dla innego. Całkowicie odsprzężona sytuacja nie nadaje się do integracji, nie można też zaakceptować ścisłego sprzężenia. Dlatego gra polega na zaprojektowaniu komponentu w sposób możliwie luźno powiązany. Istnieje kilka sposobów na ograniczenie sprzężenia w aplikacji Spring:wstrzykiwanie zależności lub architektura sterowana zdarzeniami . Architektura sterowana zdarzeniami to szerokie pojęcie i ma bardzo delikatną różnicę między architekturą opartą na wiadomościach lub MOM. Chociaż technicznie nie są one takie same, w tym celu możemy tutaj używać tych terminów zamiennie. Dla purystów podstawowa różnica między zdarzeniami kierowanymi a komunikatami polega na tym, że wiadomości są kierowane do odbiorców, podczas gdy zdarzenia są niekierowane; w przeciwnym razie ich wdrożenie prawie nie ma wyraźnego rozgraniczenia. Nie zagłębiajmy się w to tutaj; zamiast tego skupmy się na tym, jak architektura sterowana zdarzeniami jest wykorzystywana w Spring Integration.
Integracja sprężynowa sterowana zdarzeniami
W architekturze sterowanej zdarzeniami złożona aplikacja jest podzielona na kilka składników usług. Te komponenty wchodzą w interakcje poprzez zdarzenia generowane przez inne komponenty, które są nazywane wydawcą z wydarzeń. Inne komponenty, które są zainteresowane tym konkretnym wydarzeniem, subskrybują je i podejmują w odpowiedzi odpowiednie działania. Zasadniczo jest to model pracy nad wydarzeniami wydawca-subskrybent.
Zdarzeniem jest konkretna zmiana stanu. Jak wspomniano, wydarzenie jest wysyłany do zainteresowanych stron, a subskrybenci zdarzenia mogą zdecydować się na odpowiedź, dostarczając usługę, taką jak wykonanie procesu biznesowego, opublikowanie innego zdarzenia lub być może całkowite zignorowanie go. Oznacza to, że po opublikowaniu wydarzenia nie mają żadnej odpowiedzialności za reakcję subskrybentów. Jest to scenariusz oddzielony, a architektura sterowana zdarzeniami wykorzystuje takie luźne scenariusze sprzężenia. Luźne połączenie jest szczególnie odpowiednie do wykonywania przepływu pracy w czasie rzeczywistym, którego wymaga Spring Integration.
Komponenty integracji wiosennej
Jako rozszerzenie frameworka Spring, Spring Integration zasadniczo dodaje trzy komponenty:komunikaty, kanały komunikatów i punkty końcowe. Twórcy Spring Integration rozpoznali powszechny wzorzec podobieństw do współdziałania różnych architektur, domen i technologii na arenie korporacyjnej. Dlatego też, wprowadzając przesyłanie komunikatów za pośrednictwem komponentu z wykorzystaniem potoków i filtrów, model ten stał się podstawą integracji aplikacji. Komponenty filtra zużywają lub wytwarzają komunikaty, podczas gdy potoki, zwane kanałami w Spring Integration opisuje przepływ komunikatów między filtrami.
W grę wchodzi wiele zawiłości. Aby uzyskać więcej informacji, skorzystaj z łączy w sekcji Referencje. Zamiast tego skupmy się na prostej implementacji z DirectChannel .
Szybki przykład
Przykład z Listingu 1 to aplikacja Spring BOOT, która implementuje integrację Spring z DirectChannel . W tym przypadku kanał wiadomości służy do oddzielenia punktów końcowych wydawcy i subskrybenta. Kanał wiadomości służy do nawiązywania połączenia z komponentami filtra i adaptera. Przykład jest dość prosty i wykorzystuje DirectChannel z modelami komunikacji wydawca-subskrybent i punkt-punkt. Zauważ, że kod jest szczątkową i prostą implementacją ilustrującą ideę 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>
Lista 1: pom.xml, zależności Spring BOOT dla rozwiązania 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;
}
}
Lista 2: Tweet.java, klasa modelu
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;
}
}
Lista 3: TweetPublisher.java, wypełnia dane tweetów
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());
}
}
Lista 4: Tweeter.java, klasa wydawcy
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");
}
}
Lista 5: TweetReader.java, klasa subskrybenta
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);
}
}
Lista 6: SpringIntegrationApplication.java, główna klasa aplikacji
Wniosek
Zwróć uwagę, że Spring Integration oferuje znacznie więcej niż pokazano tutaj. To tylko wierzchołek góry lodowej. Pominięto ważne szczegóły. Więcej informacji na ten temat można znaleźć w dokumentacji Spring; linki podano poniżej. Spring Integration ma zalety, takie jak Inversion of Control (IoC), programowanie zorientowane aspektowo w celu rozwiązania problemów przekrojowych oraz inne podstawowe zalety Spring Framework. Spring Integration idzie dalej. Deweloperzy Spring Integration nie muszą wiedzieć, jak, kiedy i gdzie znajdują się dane. Framework obsługuje sposób wykonywania logiki biznesowej poprzez manewrowanie komunikatem przez odpowiednie komponenty. Oprócz zwykłego schematu konfiguracji XML, startery Spring BOOT dostarczają wymagane zależności do uruchomienia kodu bez obaw o zależności.
Referencje
- Przegląd integracji wiosennej
- Integracja wiosenna
