Einführung in die Spring-Integration

1. Einleitung

In diesem Artikel werden die Kernkonzepte der Federintegration hauptsächlich anhand kleiner, praktischer Beispiele vorgestellt.

Spring Integration bietet viele leistungsstarke Komponenten, die die Interkonnektivität von Systemen und Prozessen innerhalb einer Unternehmensarchitektur erheblich verbessern können.

Es verkörpert einige der besten und beliebtesten Designmuster und hilft Entwicklern, das Rollen ihrer eigenen zu vermeiden.

Wir werden uns die spezifischen Anforderungen ansehen, die diese Bibliothek in einer Unternehmensanwendung erfüllt, und warum sie für einige ihrer Alternativen ratsam ist. Wir werden uns auch einige verfügbare Tools ansehen, um die Entwicklung von Spring Integration-basierten Anwendungen weiter zu vereinfachen.

2. Setup

 org.springframework.integration spring-integration-core 4.3.5.RELEASE   org.springframework.integration spring-integration-file 4.3.5.RELEASE  

Sie können die neuesten Versionen von Spring Integration Core und die Unterstützung für Spring Integration-Dateien von Maven Central herunterladen.

3. Das Messaging-Muster

Eines der grundlegenden Muster in dieser Bibliothek ist Messaging. Das Muster konzentriert sich auf Nachrichten - diskrete Nutzdaten von Daten, die über vordefinierte Kanäle von einem Ursprungssystem oder -prozess zu einem oder mehreren Systemen oder Prozessen gelangen.

In der Vergangenheit war das Muster der flexibelste Weg, um mehrere unterschiedliche Systeme so zu integrieren, dass:

  • Die an der Integration beteiligten Systeme sind fast vollständig entkoppelt
  • Ermöglicht es den an der Integration beteiligten Teilnehmersystemen, völlig unabhängig von den Protokollen, Formatierungen oder anderen Implementierungsdetails zu sein
  • Fördert die Entwicklung und Wiederverwendung von Komponenten, die an der Integration beteiligt sind

4. Messaging-Integration in Aktion

Betrachten wir ein grundlegendes Beispiel , das eine MPEG-Videodatei aus einem bestimmten Ordner in einen anderen konfigurierten Ordner kopiert:

@Configuration @EnableIntegration public class BasicIntegrationConfig{ public String INPUT_DIR = "the_source_dir"; public String OUTPUT_DIR = "the_dest_dir"; public String FILE_PATTERN = "*.mpeg"; @Bean public MessageChannel fileChannel() { return new DirectChannel(); } @Bean @InboundChannelAdapter(value = "fileChannel", poller = @Poller(fixedDelay = "1000")) public MessageSource fileReadingMessageSource() { FileReadingMessageSource sourceReader= new FileReadingMessageSource(); sourceReader.setDirectory(new File(INPUT_DIR)); sourceReader.setFilter(new SimplePatternFileListFilter(FILE_PATTERN)); return sourceReader; } @Bean @ServiceActivator(inputChannel= "fileChannel") public MessageHandler fileWritingMessageHandler() { FileWritingMessageHandler handler = new FileWritingMessageHandler(new File(OUTPUT_DIR)); handler.setFileExistsMode(FileExistsMode.REPLACE); handler.setExpectReply(false); return handler; } }

Der obige Code konfiguriert einen Dienstaktivator, einen Integrationskanal und einen Adapter für eingehende Kanäle.

Wir werden jeden dieser Komponententypen in Kürze genauer untersuchen. Die Annotation @EnableIntegration bezeichnet diese Klasse als Spring Integration-Konfiguration.

Beginnen wir mit unserem Spring Integration-Anwendungskontext:

public static void main(String... args) { AbstractApplicationContext context = new AnnotationConfigApplicationContext(BasicIntegrationConfig.class); context.registerShutdownHook(); Scanner scanner = new Scanner(System.in); System.out.print("Please enter q and press  to exit the program: "); while (true) { String input = scanner.nextLine(); if("q".equals(input.trim())) { break; } } System.exit(0); }

Die oben beschriebene Hauptmethode startet den Integrationskontext. Es akzeptiert auch die Eingabe von " q " -Zeichen über die Befehlszeile, um das Programm zu beenden. Lassen Sie uns die Komponenten genauer untersuchen.

5. Komponenten der Federintegration

5.1. Botschaft

Die Schnittstelle org.springframework.integration.Message definiert die Spring-Nachricht: die Einheit der Datenübertragung in einem Spring-Integrationskontext.

public interface Message { T getPayload(); MessageHeaders getHeaders(); }

Es definiert Accessoren für zwei Schlüsselelemente:

  • Nachrichtenkopfzeilen, im Wesentlichen ein Schlüsselwertcontainer, der zum Übertragen von Metadaten verwendet werden kann, wie in der Klasse org.springframework.integration.MessageHeaders definiert
  • Die Nachrichtennutzlast, dh die tatsächlichen Daten, deren Wert übertragen werden soll - in unserem Anwendungsfall ist die Videodatei die Nutzlast

5.2. Kanal

Ein Kanal in Spring Integration (und in der Tat EAI) ist die grundlegende Installation in einer Integrationsarchitektur. Es ist die Pipe, über die Nachrichten von einem System an ein anderes weitergeleitet werden.

Sie können sich das als eine wörtliche Pipe vorstellen, über die ein integriertes System oder ein integrierter Prozess Nachrichten an andere Systeme senden (oder von diesen empfangen) kann.

Kanäle in Spring Integration gibt es je nach Bedarf in verschiedenen Varianten. Sie sind weitgehend konfigurierbar und können sofort ohne benutzerdefinierten Code verwendet werden. Sollten Sie jedoch benutzerdefinierte Anforderungen haben, steht ein robustes Framework zur Verfügung.

Punkt-zu-Punkt- Kanäle (P2P) werden verwendet, um 1-zu-1-Kommunikationsleitungen zwischen Systemen oder Komponenten herzustellen. Eine Komponente veröffentlicht eine Nachricht im Kanal, damit eine andere sie abholen kann. An jedem Ende des Kanals kann sich nur eine Komponente befinden.

Wie wir gesehen haben, ist das Konfigurieren eines Kanals so einfach wie das Zurückgeben einer Instanz von DirectChannel :

@Bean public MessageChannel fileChannel1() { return new DirectChannel(); } @Bean public MessageChannel fileChannel2() { return new DirectChannel(); } @Bean public MessageChannel fileChannel3() { return new DirectChannel(); }

Hier haben wir drei separate Kanäle definiert, die alle durch den Namen ihrer jeweiligen Getter-Methoden gekennzeichnet sind.

Publish-Subscribe- Kanäle (Pub-Sub) werden verwendet, um eine Eins-zu-Viele-Kommunikationsleitung zwischen Systemen oder Komponenten herzustellen. Auf diese Weise können wir auf allen drei direkten Kanälen veröffentlichen, die wir zuvor erstellt haben.

Nach unserem Beispiel können wir den P2P-Kanal durch einen Pub-Sub-Kanal ersetzen:

@Bean public MessageChannel pubSubFileChannel() { return new PublishSubscribeChannel(); } @Bean @InboundChannelAdapter(value = "pubSubFileChannel", poller = @Poller(fixedDelay = "1000")) public MessageSource fileReadingMessageSource() { FileReadingMessageSource sourceReader = new FileReadingMessageSource(); sourceReader.setDirectory(new File(INPUT_DIR)); sourceReader.setFilter(new SimplePatternFileListFilter(FILE_PATTERN)); return sourceReader; } 

Wir haben jetzt den Adapter für eingehende Kanäle für die Veröffentlichung in einem Pub-Sub-Kanal konvertiert. Auf diese Weise können wir die Dateien, die aus dem Quellordner gelesen werden, an mehrere Ziele senden.

5.3. Brücke

Eine Bridge in Spring Integration wird verwendet, um zwei Nachrichtenkanäle oder Adapter zu verbinden, wenn sie aus irgendeinem Grund keine direkte Verbindung herstellen können.

In our case, we can use a bridge to connect our Pub-Sub channel to three different P2P channels (because P2P and Pub-Sub channels can't be connected directly):

@Bean @BridgeFrom(value = "pubSubFileChannel") public MessageChannel fileChannel1() { return new DirectChannel(); } @Bean @BridgeFrom(value = "pubSubFileChannel") public MessageChannel fileChannel2() { return new DirectChannel(); } @Bean @BridgeFrom(value = "pubSubFileChannel") public MessageChannel fileChannel3() { return new DirectChannel(); }

The above bean configuration now bridges the pubSubFileChannel to three P2P channels. The @BridgeFrom annotation is what defines a bridge and can be applied to any number of channels that need to subscribe to the Pub-Sub channel.

We can read the above code as “create a bridge from the pubSubFileChannel to fileChannel1, fileChannel2, and fileChannel3 so that messages from pubSubFileChannel can be fed to all three channels simultaneously.”

5.4. Service Activator

The Service Activator is any POJO that defines the @ServiceActivator annotation on a given method. This allows us to execute any method on our POJO when a message is received from an inbound channel, and it allows us to write messages to an outward channel.

In our example, our service activator receives a file from the configured input channel and writes it to the configured folder.

5.5. Adapter

The Adapter is an enterprise integration pattern-based component that allows one to “plug-in” to a system or data source. It is almost literally an adapter as we know it from plugging into a wall socket or electronic device.

It allows reusable connectivity to otherwise “black-box” systems like databases, FTP servers and messaging systems such as JMS, AMQP, and social networks like Twitter. The ubiquity of the need to connect to these systems means that adapters are very portable and reusable (in fact there's a small catalog of adapters, freely available and ready to use by anyone).

Adapters fall into two broad categories — inbound and outbound.

Let's examine these categories in the context of the adapters in use in our sample scenario:

Inbound adapters, as we have seen, are used to bring in messages from the external system (in this case a filesystem directory).

Our inbound adapter configuration consists of:

  • An @InboundChannelAdapter annotation that marks the bean configuration as an adapter — we configure the channel to which the adapter will feed its messages (in our case, an MPEG file) and a poller, a component which helps the adapter poll the configured folder at the specified interval
  • A standard Spring java configuration class that returns a FileReadingMessageSource, the Spring Integration class implementation that handles filesystem polling

Outbound adapters are used to send messages outwards. Spring Integration supports a large variety of out-of-the-box adapters for various common use cases.

6. Conclusion

Wir haben einen grundlegenden Anwendungsfall mit Spring Integration untersucht, der die Java-basierte Konfiguration der Bibliothek und die Wiederverwendbarkeit der verfügbaren Komponenten demonstriert.

Spring Integration Code kann als eigenständiges Projekt in JavaSE sowie als Teil eines größeren Projekts in einer Jakarta EE-Umgebung bereitgestellt werden. Es konkurriert zwar nicht direkt mit anderen EAI-zentrierten Produkten und Mustern wie Enterprise Service Buses (ESBs), ist jedoch eine praktikable und leichte Alternative zur Lösung vieler der gleichen Probleme, für deren Lösung ESBs entwickelt wurden.

Den Quellcode für diesen Artikel finden Sie im Github-Projekt.