Printemps de Configuration pour JMS (Websphere MQ SSL, Tomcat, JNDI, Non IBM JRE)

Je pense que j'ai enfin compris comment tirer cette off... en voici une brève description des étapes à suivre. Si vous avez besoin de plus de détails, laissez-moi savoir.

Pré-reqs:
Websphere MQ Server installé (au moins v 8.0.0.2)
Configurer le QM, SSL et non-SSL canaux, créer Qs et toutes ces bonnes choses dont vous avez besoin.
Inutile de dire, vous avez besoin de Websphere MQ pots. Être conscient de tous les restrictions de licences.

Étape 1: Obtenir la connexion directe de travail sans SSL, pas de JNDI. Vous aurez besoin d'utiliser ces haricots à configurer en fonction de votre printemps JMS auditeurs et JMS Modèles etc.

<bean id="mq-jms-cf-sandbox"
   class="org.springframework.jms.connection.SingleConnectionFactory">
    <property name="targetConnectionFactory">
    <ref bean="mqQueueConnectionFactory" />
    </property>
</bean>
<bean id="mqQueueConnectionFactory" class="com.ibm.mq.jms.MQQueueConnectionFactory">
   <property name="hostName" value="localhost" />
   <property name="port" value="1414" />
   <property name="queueManager" value="QM_SANDBOX" />
   <property name="transportType" value="1" />
   <property name="channel" value="NON_SSL_CHANNEL" />
 </bean>
 <bean id="jms-destination-sandbox" class="com.ibm.mq.jms.MQQueue">
   <constructor-arg value="SANDBOX_Q" />
    <property name="baseQueueManagerName">
    <value>QM_SANDBOX</value>
    </property>
    <property name="baseQueueName">
    <value>SANDBOX_Q</value>
    </property>
</bean>

Étape 2: Obtenir la connexion directe de travail avec SSL, pas de JNDI. J'ai trouvé cette mise en place un peu délicat.

2a. Depuis que j'ai été en utilisant un non-IBM JRE, je devais m'assurer que les spécifications de chiffrement & suites de chiffrement nécessaires pour être configuré selon les mappages spécifié ici:
http://www-01.ibm.com/support/docview.wss?uid=swg1IV66840

De toute évidence, cela signifie que nous sommes au moins d'avoir Websphere MQ mis à niveau vers 8.0.0.2. Dans mon cas, j'ai utilisé ECDHE_RSA_AES_256_GCM_SHA384 sur le canal SSL et configuré le jms les haricots dans l'application à utiliser TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, comme suit:

<bean id="mq-jms-cf-sandbox"
    class="org.springframework.jms.connection.SingleConnectionFactory">
    <property name="targetConnectionFactory">
        <ref bean="mqQueueConnectionFactory" />
    </property>
</bean>
<bean id="mqQueueConnectionFactory" class="com.ibm.mq.jms.MQQueueConnectionFactory">
  <property name="hostName" value="localhost" />
  <property name="port" value="1414" />
  <property name="queueManager" value="QM_SANDBOX" />
  <property name="transportType" value="1" />
  <property name="channel" value="SSL_CHANNEL" />
  <property name="SSLCipherSuite" value="TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"/>
</bean>
<bean id="jms-destination-sandbox" class="com.ibm.mq.jms.MQQueue">
<constructor-arg value="SANDBOX_Q" />
    <property name="baseQueueManagerName">
       <value>QM_SANDBOX</value>
    </property>
    <property name="baseQueueName">
       <value>SANDBOX_Q</value>
    </property>
</bean>

2b. Créer des certificats, des fichiers de clés (kdbs), l'échange de certificats, etc. Il y a beaucoup de façons de le faire. Mais sachez que vous aurez besoin de ranger les mots de passe, l'étiquette de la clé pour le gestionnaire de file d'attente doit être "ibmwebspheremqqmgr" – "tous en minuscules, sans espaces, (sans les guillemets), l'étiquette de la clé doit être comme" ibmwebspheremquserid " – " tous en minuscules, sans espaces, (sans les guillemets), où le nom d'utilisateur est le nom d'utilisateur qui exécute le serveur tomcat. Si vous avez besoin de plus d'informations sur exactement comment je l'ai fait à l'aide de auto-signé certs, laissez-moi savoir.

2c. Maintenant, vous devez obtenir la JVM que tomcat fonctionne, pour lire vos fichiers de clés. Il existe de nombreuses façons, mais voici comment j'ai fait:
Créer un setenv.fichier bat dans le dossier bin de tomcat, avec le contenu suivant (débogage SSL est facultatif)

set JAVA_OPTS="-Djavax.net.ssl.trustStore=C:\path-to-keystore\key.jks" "-Djavax.net.ssl.trustStorePassword=topsecret" "-Djavax.net.ssl.keyStore=C:\path-to-keystore\key.jks" "-Djavax.net.ssl.keyStorePassword=topsecret" "-Djavax.net.debug=ssl" "-Dcom.ibm.mq.cfg.useIBMCipherMappings=false"

2d. Démarrer tomcat à l'aide de la commande suivante:

catalina.bat run > ..\logs\tomcat.log 2>&1 

Pour arrêter, appuyez simplement sur ctrl+c (windows). Selon la manière dont vous le faites, assurez-vous que setenv.chauve-souris est utilisé lors du démarrage. Ou utiliser JAVA_OPTS pour définir le fichier de clés propriétés.

2e. Vérifiez que le en utilisant le canal SSL fonctionne.

Étape 3: Obtenir une connexion JNDI de travail avec des non-SSL, JNDI
Il y a beaucoup de était de mettre en place JNDI sur tomcat. Voici comment j'ai fait: au Sein de l'application web créer un fichier META-INF/Context.xml avec le contenu suivant:

<Resource
   name="jms/qcf_sandbox"
   auth="Container"
   type="com.ibm.mq.jms.MQQueueConnectionFactory"
   factory="com.ibm.mq.jms.MQQueueConnectionFactoryFactory"
   description="JMS Queue Connection Factory for sending messages"
   HOST="localhost"
   PORT="1414"
   CHAN="NON_SSL_CHANNEL"
   TRAN="1"
   QMGR="QM_SANDBOX"/>
<Resource
   name="jms/SandboxQ"
   auth="Container"
   type="com.ibm.mq.jms.MQQueue"
   factory="com.ibm.mq.jms.MQQueueFactory"
   description="JMS Queue"
   QU="SANDBOX_Q"/>

Maintenant dans votre ressort de config, au lieu de le diriger configurations, tout ce que vous avez à faire est de:

<jee:jndi-lookup id="mq-jms-cf-sandbox" jndi-name="java:/comp/env/jms/qcf_sandbox" resource-ref="false" />
<jee:jndi-lookup id="jms-destination-sandbox" jndi-name="java:/comp/env/jms/SandboxQ" resource-ref="false" />

Noter que pour des raisons de concision, je n'ai tout simplement pas utiliser des références de ressources. Dans le cas où vous le faites, il ya quelques étapes supplémentaires qui sont droits de l'avant.

Étape 4: Maintenant, la dernière étape consiste à utiliser un canal SSL et JNDI. En supposant que vous avez fait à l'étape 2, c'est facile. Modifier la META-INF/Context.xml avec le contenu suivant:

<Resource
   name="jms/qcf_sandbox"
   auth="Container"
   type="com.ibm.mq.jms.MQQueueConnectionFactory"
   factory="com.ibm.mq.jms.MQQueueConnectionFactoryFactory"
   description="JMS Queue Connection Factory for sending messages"
   HOST="localhost"
   PORT="1414"
   CHAN="SSL_CHANNEL"
   TRAN="1"
   QMGR="QM_SANDBOX"
   SCPHS="TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"/>
<Resource
   name="jms/SandboxQ"
   auth="Container"
   type="com.ibm.mq.jms.MQQueue"
   factory="com.ibm.mq.jms.MQQueueFactory"
   description="JMS Queue"
   QU="SANDBOX_Q"/>

Remarque la ligne avec SCPHS="TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384". Si vous avez besoin de définir d'autres paramètres, voir la "Forme Courte" colonne dans ce lien:
https://www.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.ref.dev.doc/q111800_.htm%23jm10910_?lang=en

Espérons que tout cela fonctionne pour vous. Bonne chance!

Une fois que cette configuration fonctionne, l'envoi de messages est assez simple. Mais c'est la façon dont vous pouvez écouter un message dans une file d'attente à l'aide de Printemps JMS
Référence: https://docs.spring.io/spring/docs/current/spring-framework-reference/html/jms.html

Étape 1: Utiliser le Printemps DefaultMessageListenerContainer et configurer vos haricots dans un fichier xml comme (spring-beans.xml):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"      
    "http://www.springframework.org/dtd/spring-beans.dtd">

   <!-- this is the Message Driven POJO (MDP) -->
   <bean id="messageListener" class="jmsexample.ExampleListener" />

   <!-- and this is the message listener container -->
   <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
       <property name="connectionFactory" ref="mq-jms-cf-sandbox"/>
       <property name="destination" ref="jms-destination-sandbox"/>
       <property name="messageListener" ref="messageListener" />
   </bean>

</beans>

Étape 2: Ajouter ceci à votre web.xml

<context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/context/spring-beans.xml</param-value>
 </context-param>

<listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Étape 3: Écrire un Message Auditeur classe comme ceci:

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class ExampleListener implements MessageListener {

    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println(((TextMessage) message).getText());
            }
            catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
        }
        else {
            throw new IllegalArgumentException("Message must be of type TextMessage");
        }
    }
}

Alternativement, au lieu de l'étape 3, si vous êtes à l'aide de spring integration, vous pouvez faire quelque chose comme ça:

<int:channel id="jms-inbound"/>
    <int-jms:message-driven-channel-adapter
        id="jms-inbound-adapter" container="jmsContainer" channel="jms-inbound" 
        extract-payload="true" acknowledge="transacted" 
        message-converter="messagingMessageConverter" />

<beans:bean id="messagingMessageConverter" class="org.springframework.jms.support.converter.MessagingMessageConverter">
    </beans:bean>

OriginalL'auteur code4kix