Afin d'apprendre Spring Integration, j'ai compris l'exemple fourni par Spring Project et je l'ai réimplémenté + arrangé. Cet article est un mémorandum. L'exemple est enregistré dans le Git suivant. spring-integration-sample
Tout d'abord, bonjour le monde basique. À propos, la version de Spring Integration est `` 4.3.10.RELEASE ''.
Deux fonctions sont implémentées dans helloworld.
Tout d'abord, j'ai essayé de l'implémenter en fonction de l'échantillon, mais comme il n'était pas assez compris, comme le troisième J'ai également implémenté une combinaison des deux fonctions.
(1) hello world
Comme c'est README, hello world implémente un flux de messagerie simple comme suit.
message -> channel -> serviceactivator -> queuechannel
Nous allons regarder à l'intérieur de l'implémentation à partir de maintenant.
helloWorldDemo.xml
1-3 sont faciles à comprendre, définissez simplement les composants Channel et Service Avtivator comme des beans.
4 définit l'ensemble du flux et est défini par la balise service-activator ''. Avec cette définition, lorsque vous appelez la méthode send``` de ʻinputChannel (MessageChannel) , le processus est délégué à la `ServiceActivator (méthode HelloWorldService.seyHello)` `. À. Ensuite, le résultat de retour de la méthode `` sayHello '' entre dans outputChannel.
<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 -->
Le code de la classe Main est le suivant.
Lisez le fichier xml à l'étape 1 et créez une installation ApplicationContext. Après cela, Channel est `getBean``` (2,3), et comme mentionné ci-dessus,` `ʻinputChannel.send``` est` ServiceActivator `` sayHello Déléguez le traitement à la méthode (4). Lorsque le traitement est terminé, la valeur est entrée dans outputChannel, vous pouvez donc obtenir la valeur return avec ouputChannel.receive.getPayload. Ici, le contenu acquis est transmis à l'enregistreur et sorti en standard. (Cinq)
De plus, il semble qu'il y ait ceux qui peuvent obtenir la valeur par Channel et ceux qui ne sont que pour l'envoi, et PollableChannel '' hérite de MessageChannel '' puis de `` recevoir '' Vous pouvez obtenir la valeur parce que vous définissez la méthode, et `MessageChannel``` semble être une spécialité d'envoi.
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 est omis, mais la méthode `` sayHello '' était aussi simple que d'ajouter une petite chaîne de l'argument String et de retourner. Au fait, c'est POJO, et il n'hérite ni n'implémente quoi que ce soit.
(2) Polling
Une application qui interroge et acquiert l'heure système deux fois toutes les 20 secondes (20000 millisecondes) et la transmet à l'enregistreur pour une sortie standard.
delay.xml
Cette fois, je n'ai pas très bien compris ce que la balise inbound-channel-adapter peut faire, et pourquoi la balise executor doit être définie, donc c'est un peu. J'ai vu xsd. Je ne sais lire xsd que de manière simple, mais est-ce à peu près sous la forme suivante? (Si vous faites une erreur, veuillez indiquer quelqu'un)
inbound-channel-adapter doit avoir poller comme élément enfant à l'intérieur.interval-trigger, cron-trigger), et vous pouvez choisir l'un ou l'autre. Si rien n'est spécifié, cela semble être interval-trigger```.task: executer``` définit une instance` ThreadPoolTaskExecutor``` avec une taille de pool configurable, une capacité de file d'attente, un maintien en vie et des valeurs de politique de refus. Cette balise ne doit pas nécessairement être définie par le bean (si les paramètres sont bons par défaut), et l'application fonctionnera même si la balise est supprimée.<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 -->
Cette fois, c'est une interrogation, donc la classe Main a juste besoin de lire le contexte. Après cela, il continue de sortir le journal jusqu'à ce que l'enregistreur arrête l'application.
public static void main(String[] args) throws Exception{
new ClassPathXmlApplicationContext("META-INF/spring/integration/delay.xml");
}
(3) polling + hello world
Avec cela seul, je ne verrais que l'exemple d'implémentation, j'ai donc également implémenté un formulaire dans lequel le contenu obtenu par interrogation est envoyé à ServiceActivator et le journal final est sorti (un formulaire qui combine les deux jusqu'à présent). Bien qu'il semble qu'il y ait beaucoup de gaspillage dans ce que je pourrais mettre en œuvre, c'est la limite de mes connaissances jusqu'à présent. Refaisons-le si nous étudions plus.
delay_hello_world.xml
Je l'ai fait en ajoutant les deux jusqu'à présent, mais en fait cela n'a pas fonctionné si je l'ai simplement ajouté, donc j'ai dû l'arranger un peu. Tout d'abord, la balise beansde 1. Polling et Hello World ont une granularité légèrement différente (définition de xmlns) ici, il est donc nécessaire de les faire correspondre. Parallèlement à cela,int: `est ajouté aux balises` channel et `` `service-activator utilisées dans l'application HelloWorld.
Ensuite, j'ai défini un nouveau QueueChannel '' appelé bridgeChannel of 2. Je me suis demandé si la balise ```inbound-channel-adapter``` appelait en interne `MessageChannel.send (je n'ai pas vérifié jusqu'ici), j'ai donc ajouté un nouveau canal à outputChannel. J'ai décidé d'en prendre une valeur dans la classe `` `` Main et de la passer à inputChannel.send.
<?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 ressemble à ceci. J'ai l'impression de continuer à recevoir ce que j'ai reçu sur la brideChannel avec `` while (true) '' pour continuer à interroger. Eh bien, cela fonctionne comme prévu, c'est donc la première compréhension de 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());
}
}
}
Recommended Posts