👩🏼‍🤝‍👩🏻 🎯 🙆🏻 Mehrfachverbindung IBM MQ mit Spring 🎓 👨🏻‍🚒 🧜🏿

Ich werde ein Beispiel geben, wie mehrere Endpunkte für die Verbindung mit IBM MQ konfiguriert werden.

Tor:

Lesen aus mehreren Warteschlangen mit demselben Namen, die sich jedoch auf verschiedenen Hosts / Warteschlangenmanagern befinden
Schreiben Sie eine Antwort auf einen zufällig definierten Knoten

0. Nehmen wir an, Sie haben MQ bereits bereitgestellt oder verwenden das eines anderen.

1. Wir laden Abhängigkeiten in das Projekt:

Maven

<dependency>
    <groupId>com.ibm.mq</groupId>
    <artifactId>mq-jms-spring-boot-starter</artifactId>
    <version>2.3.3</version>
</dependency>

gradle

compile group: 'com.ibm.mq', name: 'mq-jms-spring-boot-starter', version: '2.3.3'

2. Erstellen Sie eine Konfiguration, geben Sie die Verbindungsparameter Ihrer Punkte ein (haben Sie diese bereits erstellt?). Wir verwenden ein Array, sodass so viele Verbindungen bestehen können, wie Sie möchten.

mq:
  servers:
    - queueManager: QM1
      channel: DEV.ADMIN.SVRCONN
      connName: ibmmq.ru(1414)
      user: admin
      password: passw0rd
    - queueManager: QM2
      channel: DEV.ADMIN.SVRCONN
      connName: ibmmq.ru(1415)
      user: admin
      password: passw0rd
  queue1: QUEUE1
  queue2: QUEUE2

3. Erstellen Sie Klassen zum Lesen dieser Eigenschaften:

import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "mq")
@EqualsAndHashCode(callSuper = false)
@Data
public class MqConfig {
    private List<ConnectionConfiguration> servers;
    private String queue1;
    private String queue2;

}

import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = false)
public class ConnectionConfiguration {
    String queueManager;
    String channel;
    String connName;
    String user;
    String password;
}

4. Erstellen Sie einen Listener:

import javax.jms.MessageListener;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class MqListener implements MessageListener {

    @SneakyThrows
    @Override
    public void onMessage(@Payload javax.jms.Message message) {
        log.info("  <" + message + ">");
        //TODO:      
    }

5. Konfigurieren! Wir bestimmen die connectionFactors für jedes Element des Arrays aus yml-Eigenschaften. Wir erstellen ein Vorlagenblatt zum Senden von Nachrichten, zu dessen Eingabe wir die erstellten Verbindungen einspeisen. Wir erstellen Listener-Fabriken, an deren Eingabe wir auch die erstellten connectionFactories verwenden.


import com.fasterxml.jackson.databind.ObjectMapper;
import com.ibm.mq.jms.MQConnectionFactory;
import com.ibm.msg.client.wmq.WMQConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.*;
import org.springframework.jms.connection.CachingConnectionFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.support.QosSettings;
import org.springframework.jms.support.converter.MappingJackson2MessageConverter;
import org.springframework.jms.support.converter.MessageConverter;
import org.springframework.jms.support.converter.MessageType;
import org.springframework.jms.support.converter.SimpleMessageConverter;

import javax.jms.*;
import java.util.*;

import static javax.jms.DeliveryMode.NON_PERSISTENT;
import static javax.jms.Session.CLIENT_ACKNOWLEDGE;

@Configuration
@EnableJms
@Slf4j
public class MqConfiguration {

    @Autowired
    MqConfig mqConfig;

    @Autowired
    private JmsListenerEndpointRegistry registry;

//  ,       connectionFactories
    @Bean
    public List<JmsListenerContainerFactory> myFactories(
            @Qualifier("myConnFactories") 
            List<CachingConnectionFactory> connectionFactories,
            MqListener mqListener) {
        List<JmsListenerContainerFactory> factories = new ArrayList<>();
        connectionFactories.forEach(connectionFactory -> {
            DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
            factory.setConnectionFactory(connectionFactory);
            factory.setSessionAcknowledgeMode(CLIENT_ACKNOWLEDGE);

            QosSettings qosSettings = new QosSettings();
            qosSettings.setDeliveryMode(NON_PERSISTENT);
            factory.setReplyQosSettings(qosSettings);

            SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
            endpoint.setId("myJmsEndpoint-"+ UUID.randomUUID());
            endpoint.setDestination(mqConfig.getQueue1());
            endpoint.setMessageListener(mqListener);
            registry.registerListenerContainer(endpoint, factory);

            factories.add(factory);
        });
        return factories;
    }
//     ,      
    @Bean
    @Qualifier("myJmsTemplates")
    public List<JmsTemplate> jmsTemplates(
            @Qualifier("myConnFactories") 
            List<CachingConnectionFactory> connectionFactories) {
        return getJmsTemplates(new ArrayList<ConnectionFactory>(connectionFactories));
    }

    public List<JmsTemplate> getJmsTemplates(List<ConnectionFactory> connectionFactories) {
        List<JmsTemplate> jmsTemplates = new ArrayList<>();
        for (ConnectionFactory connectionFactory : connectionFactories) {
            JmsTemplate jmsTemplate = new JmsTemplate();
            jmsTemplate.setConnectionFactory(connectionFactory);
            jmsTemplate.setMessageConverter(new SimpleMessageConverter());
            jmsTemplate.setDefaultDestinationName(mqConfig.getQueue2());
            jmsTemplate.setDeliveryMode(NON_PERSISTENT);
            jmsTemplate.setDeliveryPersistent(false);
            jmsTemplate.setExplicitQosEnabled(true);
            jmsTemplates.add(jmsTemplate);
        }
        return jmsTemplates;
    }

//       yml-
    @Bean
    @Qualifier("myConnFactories")
    public List<CachingConnectionFactory> connectionFactories() throws JMSException {
        List<CachingConnectionFactory> factories = new ArrayList<>();

        for (ConnectionConfiguration server : mqConfig.getServers()) {
            CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
            MQConnectionFactory cf = new MQConnectionFactory();
            cachingConnectionFactory.setTargetConnectionFactory(cf);
            cf.setQueueManager(server.getQueueManager());
            cf.setChannel(server.getChannel());
            cf.setConnectionNameList(server.getConnName());
            cf.setStringProperty(WMQConstants.USERID, server.getUser());
            cf.setStringProperty(WMQConstants.PASSWORD, server.getPassword());
            cf.setStringProperty("XMSC_WMQ_CONNECTION_MODE", "1");

            factories.add(cachingConnectionFactory);
        }
        return factories;
    }

}

endpoint.setMessageListener (mqListener);

Hier geben wir den Listener an (der in Schritt 4 erstellt wurde), um die Aktionen beim Empfang einer Nachricht zu bestimmen.

6. Erstellen wir eine Service-Schicht, in der beispielsweise nach dem Senden einer Antwort eine Logik vorhanden ist.

import javax.jms.TextMessage;

public interface MqService {

    void sendToMq(TextMessage msg);

}

import javax.jms.TextMessage;
import org.springframework.jms.JmsException;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class MqServiceImpl implements MqService {

    @Autowired
    private MqConfig mqConfig;

    @Autowired
    @Qualifier("myJmsTemplates")
    List<JmsTemplate> jmsTemplates;


    @Override
    public void sendToMq(TextMessage msg ) {
        //- 
        //     /  .
        int maxIndex = jmsTemplates.size()-1; //    - ""
        int randomNumber = (int) Math.round(Math.random() * maxIndex);
        jmsTemplates.get(randomNumber).convertAndSend(mqConfig.getQueue2(), msg);
    }
}

7. Fügen Sie das Senden der Antwort an den Listener hinzu:

    @Autowired
    MqService mqService;

    @SneakyThrows
    @Override
    public void onMessage(@Payload javax.jms.Message message) {
        log.info("  <" + message + ">");
        mqService.sentToMq((TextMessage) message);
    }

Voila, du bist fertig, du kannst es überprüfen.

Mehrfachverbindung IBM MQ mit Spring

More articles: