Comment tirer parti de L'intégration de Spring dans une architecture distribuée JMS?
pour le scénario suivant, je cherche vos conseils et conseils sur les pratiques exemplaires:
dans un système distribué (principalement basé sur Java) avec:
- de nombreuses applications client (Web-app, outils en ligne de commande, API REST)
- une centrale JMS courtier de messages (pour l'instant en faveur de l'utilisation de ActiveMQ)
- plusieurs nœuds de traitement autonomes (fonctionnant sur plusieurs machines distantes), le calcul des opérations coûteuses de différents types, comme spécifié par le JMS message de la charge utile)
Comment appliquer au mieux le soutien JMS fourni par le intégration de printemps cadre pour découpler les clients des noeuds de travailleurs? Lors de la lecture de la documentation de référence et de quelques premières expériences, il semble que la configuration D'un adaptateur d'arrivée JMS nécessite l'utilisation d'un abonné, qui dans un environnement découplé le scénario n'existe pas.
petite note latérale: la communication doit se faire via des messages texte JMS (en utilisant une structure de données JSON pour l'extensibilité future).
3 réponses
cela ne répond pas vraiment à votre question, mais assurez-vous de regarder dans Apache Camel pour connecter vos différents composants. Je l'ai trouvé extrêmement utile pour connecter une file d'attente JMS, jusqu'à un service web et l'intention de l'utiliser pour d'autres composants.
un exemple qui surveille une file D'attente ActiveMQ pour les messages, les transforme et les affiche dans un service web:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:camel="http://camel.apache.org/schema/spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring-2.3.0.xsd">
<bean id="callbackProcessor" class="com.package.CallbackProcessor"/>
<bean id="activemq" class="org.apache.camel.component.jms.JmsComponent">
<property name="connectionFactory" ref="jmsFactory" />
</bean>
<camel:camelContext id="camel">
<!-- Must put this in camel:endpoint because camel:from doesn't support property substitution -->
<camel:endpoint id="callbackQueue" uri="activemq:queue:${jms.callback-queue-name}"/>
<camel:route>
<camel:from ref="callbackQueue"/>
<camel:process ref="callbackProcessor"/>
<camel:to uri="http://dummy"/><!-- This will be replaced by the callbackProcessor with the callback URL in the message -->
</camel:route>
</camel:camelContext>
</beans>
c'est tout ce Qui nécessaire dans notre application de printemps pour allumer le chameau et commencer le traitement des messages.
Voici L'intégration de printemps que je suis venu avec aujourd'hui, si vous trouvez des choses qui pourraient être améliorées s'il vous plaît suivre.
du côté du client, les messages peuvent être envoyés et reçus via une passerelle simple:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:integration="http://www.springframework.org/schema/integration"
xmlns:jms="http://www.springframework.org/schema/integration/jms"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/integration/jms
http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration.xsd">
<import resource="integration-common.xml"/>
<!-- Communication Gateway for the Client (send/receive) -->
<bean id="gateway" class="org.springframework.integration.gateway.SimpleMessagingGateway">
<property name="requestChannel" ref="SenderChannel"/>
<property name="replyChannel" ref="InboundChannel"/>
<property name="replyTimeout" value="1000"/>
</bean><!-- TODO: could use integration:gateway -->
<!-- Sending out message to JMS request queue -->
<integration:channel id="SenderChannel"/>
<jms:outbound-channel-adapter
channel="SenderChannel"
destination="requestQueue" />
<!-- Listen to incoming messages on JMS reply queue -->
<integration:channel id="InboundChannel">
<integration:queue/>
</integration:channel>
<jms:message-driven-channel-adapter
destination="replyQueue"
channel="InboundChannel" />
</beans>
et la configuration du côté du noeud de traitement ressemble à (voir les commentaires en ligne pour plus d'explication des éléments D'intégration de ressort):
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:integration="http://www.springframework.org/schema/integration"
xmlns:jms="http://www.springframework.org/schema/integration/jms"
xmlns:stream="http://www.springframework.org/schema/integration/stream"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/integration/jms
http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd
http://www.springframework.org/schema/integration
http://www.springframework.org/schema/integration/spring-integration.xsd">
<import resource="integration-common.xml"/>
<!-- Read in Message Endpoint Service Activator classes -->
<context:component-scan base-package="sample.integration.jmsbasic"/>
<!-- Listen to incoming messages on the JMS request queue -->
<integration:channel id="jmsinToProcChannel"/>
<jms:message-driven-channel-adapter
destination="requestQueue"
channel="jmsinToProcChannel"/>
<!-- Delegate message to service implementation and take care of answer -->
<integration:service-activator
input-channel="jmsinToProcChannel"
ref="procService"
output-channel="jmsBackChannel" />
<!-- Send answer back to JMS reply queue -->
<integration:channel id="jmsBackChannel"/>
<jms:outbound-channel-adapter
channel="jmsBackChannel"
destination="replyQueue" />
</beans>
demandez-vous si L'intégration de ressorts peut être utilisée pour mettre en œuvre un protocole bridge ? Alors la réponse est oui, et le fait tout simplement.