Um die Spring-Integration zu lernen, habe ich das vom Spring-Projekt bereitgestellte Beispiel verstanden und neu implementiert + arrangiert. Dieser Artikel ist ein Memorandum. Das Beispiel ist im folgenden Git registriert. spring-integration-sample
Zuallererst grundlegende Hallo Welt. Die Version von Spring Integration ist übrigens "4.3.10.RELEASE".
In helloworld sind zwei Funktionen implementiert.
Zuerst habe ich versucht, es gemäß dem Beispiel zu implementieren, aber da es als drittes nicht genug verstanden wurde Ich habe auch eine Kombination der beiden Funktionen implementiert.
(1) hello world
Da es sich um README handelt, implementiert Hello World einen einfachen Nachrichtenfluss wie folgt.
message -> channel -> serviceactivator -> queuechannel
Wir werden uns von nun an mit der Implementierung befassen.
helloWorldDemo.xml 1-3 sind leicht zu verstehen. Definieren Sie einfach die Channel- und Service Avtivator-Komponenten als Beans.
Wenn Sie mit dieser Definition die `send``` -Methode von inputChannel (MessageChannel) aufrufen, wird der Prozess an den ServiceActivator (HelloWorldService.seyHello-Methode) `delegiert. Zu. Dann tritt das Rückgabeergebnis der `sayHello``` -Methode in den Ausgabekanal ein.
<channel id="inputChannel"/> <!-- 1 -->
<channel id="outputChannel"> <!-- 2 -->
<queue capacity="10"/>
</channel>
<beans:bean id="sampleService"
class="org.ek.sample.helloworld.HelloWorldService"/> <!-- 3 -->
<service-activator input-channel="inputChannel"
output-channel="outputChannel"
ref="sampleService"
method="sayHello"/> <!-- 4 -->
Der Code für die Main-Klasse lautet wie folgt.
Lesen Sie die XML-Datei in Schritt 1 und erstellen Sie eine `ApplicationContext```-Installation. Danach ist _Channel_ getBean (2,3), und wie oben erwähnt ist `` `inputChannel.send```` `ServiceActivator```` sayHello Delegieren Sie die Verarbeitung an die Methode (4). Wenn die Verarbeitung abgeschlossen ist, wird der Wert in outputChannel eingegeben, sodass Sie den return-Wert mit `` `ouputChannel.receive.getPayload``` abrufen können. Hier werden die erfassten Inhalte standardmäßig an den Logger übergeben und ausgegeben. (Fünf)
Darüber hinaus scheint es solche zu geben, die den Wert von Channel erhalten können, und solche, die nur zum Senden bestimmt sind, und "PollableChannel" erbt "MessageChannel" und dann "Receive" Sie können den Wert erhalten, weil Sie die Methode definieren und MessageChannel eine Sendespezialität zu sein scheint.
public static void main(String[] args) {
@SuppressWarnings("resource")
AbstractApplicationContext context = new ClassPathXmlApplicationContext(
"/META-INF/spring/integration/helloWorldDemo.xml", HelloWorldMain.class); // 1
MessageChannel inputChannel = context.getBean("inputChannel", MessageChannel.class); // 2
PollableChannel outputChannel = context.getBean("outputChannel", PollableChannel.class); // 3
inputChannel.send(new GenericMessage<String>("World")); // 4
logger.info("==> HelloWorldDemo: " + outputChannel.receive(0).getPayload()); // 5
ServiceActivator wird weggelassen, aber die `` `sayHello``` -Methode war so einfach wie das Hinzufügen einer kleinen Zeichenfolge des Arguments String und das Zurückgeben. Übrigens ist es POJO, und es erbt oder implementiert nichts.
(2) Polling
Eine Anwendung, die die Systemzeit zweimal alle 20 Sekunden (20000 Millisekunden) abfragt und abruft und zur Standardausgabe an den Logger weiterleitet.
delay.xml Dieses Mal habe ich nicht ganz verstanden, was das Tag "Inbound-Channel-Adapter" kann und warum das Tag "Executor" definiert werden muss, also ist es ein bisschen. Ich habe xsd gesehen. Ich weiß nur, wie man xsd auf einfache Weise liest, aber ist es ungefähr in der folgenden Form? (Wenn Sie einen Fehler machen, weisen Sie bitte auf jemanden hin)
Intervall-Trigger```, `Cron-Trigger```), und Sie können eine auswählen. Wenn nichts angegeben ist, scheint es sich um einen Intervall-Trigger zu handeln.task: executer``` definiert eine `ThreadPoolTaskExecutor```-Instanz mit konfigurierbarer Poolgröße, Warteschlangenkapazität, Keep Alive und Verweigerung von Richtlinienwerten. Dieses Tag muss nicht unbedingt Bean-definiert sein (wenn die Einstellungen standardmäßig gut sind), und die Anwendung funktioniert auch dann, wenn das Tag gelöscht wird.<int:inbound-channel-adapter expression="T(java.lang.System).currentTimeMillis()" channel="logger">
<int:poller fixed-delay="20000" max-messages-per-poll="2" />
</int:inbound-channel-adapter> <!-- 1 -->
<int:logging-channel-adapter id="logger" logger-name="org.springframework.integration.samples.helloworld"/>
<task:executor id="executor" queue-capacity="20" pool-size="5-20"/> <!-- 2 -->
Dieses Mal wird abgefragt, sodass die Hauptklasse nur den Kontext lesen muss. Danach wird das Protokoll so lange ausgegeben, bis der Logger die Anwendung stoppt.
public static void main(String[] args) throws Exception{
new ClassPathXmlApplicationContext("META-INF/spring/integration/delay.xml");
}
(3) polling + hello world
Allein damit würde ich nur die Beispielimplementierung sehen, also habe ich auch ein Formular implementiert, in dem der durch Abfrage erhaltene Inhalt an ServiceActivator gesendet und das endgültige Protokoll ausgegeben wird (ein Formular, das die beiden bisher kombiniert). Obwohl es den Anschein hat, dass das, was ich implementieren könnte, viel Verschwendung enthält, ist dies die Grenze meines bisherigen Wissens. Lassen Sie es uns neu machen, wenn wir mehr lernen.
delay_hello_world.xml
Ich habe es geschafft, indem ich die beiden bisher hinzugefügt habe, aber tatsächlich hat es nicht funktioniert, wenn ich es nur hinzugefügt habe, also musste ich es ein wenig arrangieren. Zuallererst das `Bohnen``` Tag von 1. Polling und Hello World haben hier eine etwas andere Granularität (Definition von xmlns), daher ist es notwendig, sie abzugleichen. Außerdem wird int: zu den in der HelloWorld-Anwendung verwendeten Tags channel``` und `` service-activator``` hinzugefügt.
Als nächstes definierte ich einen neuen `` `QueueChannel``` namens bridgeChannel von 2. Ich habe mich gefragt, ob das Tag "Inbound-Channel-Adapter" intern "MessageChannel.send" aufruft (ich habe dies noch nicht überprüft), also habe ich dem outputChannel einen neuen Kanal hinzugefügt. Ich habe beschlossen, einen Wert daraus in der Klasse "Main" zu nehmen und ihn an "inputChannel.send" zu übergeben.
<?xml version="1.0" encoding="UTF-8"?>
<!-- 1 -->
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-4.3.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.3.xsd"
xmlns:int="http://www.springframework.org/schema/integration"
xmlns:task="http://www.springframework.org/schema/task">
<int:inbound-channel-adapter expression="'World! time is ' + T(java.lang.System).currentTimeMillis()" channel="bridgeChannel">
<int:poller fixed-delay="2000" max-messages-per-poll="2" />
</int:inbound-channel-adapter>
<!-- 2 -->
<int:channel id="bridgeChannel">
<int:queue capacity="2"/>
</int:channel>
<int:channel id="inputChannel"/>
<int:channel id="outputChannel">
<int:queue capacity="10"/>
</int:channel>
<int:service-activator input-channel="inputChannel"
output-channel="outputChannel"
ref="sampleService"
method="sayHello"/>
<bean id="sampleService" class="org.ek.sample.helloworld.HelloWorldService"/>
</beans>
Main sieht so aus. Es fühlt sich so an, als würde ich immer wieder das bekommen, was ich auf dem Brautkanal erhalten habe, während ich (wahr) bin, um weiter abzufragen. Nun, es funktioniert wie erwartet, dies ist also das erste Verständnis von Spring Integration.
private static Logger logger = Logger.getLogger(PollingHelloWorld.class);
public static void main(String[] args) {
@SuppressWarnings("resource")
AbstractApplicationContext context =
new ClassPathXmlApplicationContext("/META-INF/spring/integration/delay_hello_world.xml");
PollableChannel bridgeChannel = context.getBean("bridgeChannel", PollableChannel.class);
MessageChannel inputChannel = context.getBean("inputChannel", MessageChannel.class);
PollableChannel outputChannel = context.getBean("outputChannel", PollableChannel.class);
while(true) {
Message<?> msg = bridgeChannel.receive(0);
if(msg != null) {
String str = (String) msg.getPayload() ;
inputChannel.send(new GenericMessage<String>(str));
logger.info("==> Demo: " + outputChannel.receive(0).getPayload());
}
}
}