Comment tirer parti de Printemps de l'Intégration dans un monde réel JMS architecture distribuée?

Pour le scénario suivant, je suis à la recherche de vos avis et conseils sur les meilleures pratiques:

Dans un système distribué (principalement basé sur Java) avec:

  • nombreux (différents) 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 autonome de traitement des nœuds (en cours d'exécution sur plusieurs machines distantes, l'informatique, les opérations coûteuses de différents types, comme spécifié par le JMS message de la charge utile)

Comment mieux appliquer la JMS soutien fourni par le Spring Integration cadre de découpler les clients de la de nœuds de travail? Lors de la lecture par le biais de la documentation de référence et quelques premières expériences, il ressemble à la configuration d'un JMS entrant adaptateur intrinsèquement nécessitent l'utilisation d'un abonné, qui, dans un découplé scénario n'existe pas.

Petite note de côté: la communication doit se produire via JMS, messages texte (à l'aide d'une structure de données JSON pour l'avenir de l'extensibilité).

OriginalL'auteur ngeek | 2010-06-10

  1. 4

    Ce n'est pas vraiment répondre à votre question, mais assurez-vous que vous regardez dans les Apache Camel pour la connexion de 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 un ActiveMQ file d'attente pour les messages, les transforme, et les met sur 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 est nécessaire à notre Printemps application à feu vers le haut de Chameau et de commencer le traitement des messages.

    Merci, à dos de Chameau est bien sûr également une option, mais ne serait-ce pas demander plus de configuration généraux ou est-ce faisable?
    Je ne pense pas que c'est trop de la configuration de frais généraux. J'ai mis à jour ma réponse avec un exemple.
    Vrai, cela semble en effet très concis. Merci de poster plus de détails.

    OriginalL'auteur Edward Dale

  2. 3

    Ici, c'est le Printemps de l'Intégration, j'ai été à venir jusqu'à aujourd'hui, si vous trouvez des choses qui pourraient être améliorées, nous vous invitons à suivre.

    Sur le côté client, les messages peuvent être envoyés et reçus par l'intermédiaire d'un SimpleMessagingGateway:

    <?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 de la configuration sur le nœud de traitement côté ressemble (veuillez consulter les commentaires en ligne pour plus d'explications sur le Printemps de l'Intégration des éléments):

    <?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>

    OriginalL'auteur ngeek

  3. 1

    Demandez-vous si le Printemps Intégration peut être utilisé pour mettre en œuvre un protocole pont? Alors la réponse est oui, et n'est donc, tout simplement.

    Je ne suis pas sûr que cela permettrait de résoudre mon scénario: d'un côté une application client doit être configuré pour utiliser un canal entrant carte à la main dans les messages dans la file d'attente JMS, et sur un nœud de traitement est configuré pour utiliser un sortant de l'adaptateur pour le ramasser et de le traiter.
    Je suppose que vous avez voulu dissocier les protocoles. Les applications client serait en grande partie inchangée, à l'exception de communiquer à une application intégrée avec leur protocole de choix WS, REPOS, etc). L'application de transition serait à son tour l'ensemble de ces demandes dans JMS demandes de vos nœuds de travail de la consommer sur une compétition avec un schéma de consommation.
    C'est vrai dans le meilleur des cas, le client ne devrait pas avoir de savoir quelque chose au sujet du protocole. Pourriez-vous donner des précisions à la meilleure façon de faire de l'utilisation du pont de modèle dans le scénario décrit? Merci.

    OriginalL'auteur Paul McKenzie