Spring Boot 通过JMS方式集成TongLinkQ

1.maven依赖：

   在TongLinkQ安装根目录下找到TLQ8\java\lib目录，TongJMS.jar就是项目需要使用的jar包。

 2.建立连接主要参数值获取：

   在TongLinkQ安装目录找到TLQ8\etc，tlqjdni.conf打开，可以看到配置

    连接地址 ：tmqiAddressList

    连接工厂名称：FactoryName

   JNDI消息名称：JndiQueueName

   三个变量对应的值就是创建连接所需要的参数。

3.代码编写

   参数配置类

package com.framework.jms.tonglink;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author kz
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EdiTongLinkConfig {
    // 连接地址
    private String url;
    // 连接工厂名称
    private String factoryName;
    // JNDI消息名称
    private String jndiQueueName;

}

连接配置类

package com.framework.jms.tonglink;

import com.framework.core.exception.ErrorCode;
import com.framework.core.exception.ServerException;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Properties;

/**
 * <p> Description : TongLink连接配置类 </p >
 * <p> Author : kz </p >
 * <p> Create Time : 2023/2/22 17:00 </p>
 * <p> Author Email: <a>kz</a> </p>
 */
@Slf4j
@Data
public class EdiTongLinkConnection {

    private Connection connection;

    private Queue queue;

    /**
     * @param mqConfigEntity
     * @author: kz
     * @date: 2023/3/20 19:36
     * @description: 返回连接属性实体
     */
    public EdiTongLinkConnection(EdiTongLinkConfig mqConfigEntity) throws ServerException {
        checkConfig(mqConfigEntity);
        Properties prop = new Properties();
        String tcf = "tongtech.jms.jndi.JmsContextFactory";
        String url = mqConfigEntity.getUrl();
        prop.put("java.naming.factory.initial", tcf);
        prop.put("java.naming.provider.url", url);
        try {
            Context ictx = new InitialContext(prop);
            ConnectionFactory cf1 = (ConnectionFactory) ictx.lookup(mqConfigEntity.getFactoryName());
            connection = cf1.createConnection();
            queue = (Queue) ictx.lookup(mqConfigEntity.getJndiQueueName());
        } catch (NamingException | JMSException e) {
            log.error("create connection error", e);
            throw new ServerException(e.getMessage());
        }
        log.info("connection created");
    }

    private void checkConfig(EdiTongLinkConfig mqConfigEntity) throws ServerException {
        if (StringUtils.isEmpty(mqConfigEntity.getFactoryName())) {
            throw new ServerException(ErrorCode.FACTORY_NAME_ERROR);
        }
        if (StringUtils.isEmpty(mqConfigEntity.getUrl())) {
            throw new ServerException(ErrorCode.URL_ERROR);
        }
        if (StringUtils.isEmpty(mqConfigEntity.getJndiQueueName())) {
            throw new ServerException(ErrorCode.QUEUE_NAME_ERROR);
        }
    }

    /**
     * @return: void
     * @author: kz
     * @date: 2023/3/20 19:36
     * @description: 关闭连接
     */
    public void closeConnection() {
        try {
            connection.close();
            log.info("connection closed");
            connection = null;
        } catch (JMSException e) {
            log.error("close connection error", e);
        }
    }
}

消费者基础对象

package com.framework.jms.tonglink;

import com.framework.jms.ibm.EdiConsumerHelper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

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

/**
 * <p> Description : 消费者基础对象 </p >
 * <p> Author : kz </p >
 * <p> Create Time : 2023/2/24 17:00 </p >
 * <p> Author Email: < a href=" ">kz</ a> </p >
 */
@Slf4j
@Data
public class EdiTongLinkConsumer {

    private EdiTongLinkConnection ch;
    private MessageConsumer consumer;

    public EdiTongLinkConsumer(EdiTongLinkConfig mqConfigEntity) {
        ch = new EdiTongLinkConnection(mqConfigEntity);
        log.info("created connection factory");
        try {
            Session session = ch.getConnection().createSession(false, Session.AUTO_ACKNOWLEDGE);
            consumer = session.createConsumer(ch.getQueue());
            ch.getConnection().start();
        } catch (JMSException e) {
            log.error("create consumer error", e);
        }
        log.info("consumer created");
    }

    /**
     * @return: java.lang.String
     * @author: kz
     * @date: 2023/4/10 17:06
     * @description: 接收消息
     */
    public String receive() {
        boolean continueProcessing = true;
        while (continueProcessing) {
            try {
                Message receivedMessage = consumer.receive();
                if (receivedMessage == null) {
                    log.info("No message received from this endpoint");
                    continueProcessing = false;
                } else {
                    return new EdiConsumerHelper().getStringMessage(receivedMessage);
                }
            } catch (JMSRuntimeException | JMSException jmsex) {
                log.error("receiveMsg error", jmsex);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {

                }
                return null;
            }
        }
        return null;
    }

    /**
     * @return: void
     * @author: kz
     * @date: 2023/4/10 17:05
     * @description: 关闭连接
     */
    public void close() {
        if (Objects.isNull(consumer)) {
            return;
        }
        try {
            consumer.close();
            ch.closeConnection();
        } catch (JMSException e) {
            log.error("close error", e);
        }
        consumer = null;
        ch = null;
    }

    /**
     * @param i
     * @return: java.lang.String
     * @author: kz
     * @date: 2023/4/10 17:05
     * @description: 限时接收消息
     */
    public String receiveWithTimeOut(int i) {
        Message receivedMessage = null;
        try {
            receivedMessage = consumer.receive(i);
        } catch (JMSException e) {
            log.error("receive message error", e);
        }
        if (receivedMessage == null) {
            log.info("No message received from this endpoint");
        } else {
            return new EdiConsumerHelper().getStringMessage(receivedMessage);
        }
        return null;
    }
}

生产者基础对象

package com.framework.jms.tonglink;

import com.framework.core.exception.ServerException;
import lombok.extern.slf4j.Slf4j;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
import java.util.Objects;

/**
 * <p> Description : 生产者基础对象 </p >
 * <p> Author : kz </p >
 * <p> Create Time : 2023/2/24 17:00 </p >
 * <p> Author Email: < a href=" ">kz</ a> </p >
 */
@Slf4j
public class EdiTongLinkProducer {

    private EdiTongLinkConnection ch;
    private MessageProducer producer;
    private Session session;

    /**
     * @param mqConfigEntity
     * @author: kz
     * @date: 2023/3/14 13:35
     * @description: 创建生产者
     */
    public EdiTongLinkProducer(EdiTongLinkConfig mqConfigEntity) throws ServerException {
        ch = new EdiTongLinkConnection(mqConfigEntity);
        log.info("created connection factory");
        try {
            session = ch.getConnection().createSession(false, Session.AUTO_ACKNOWLEDGE);
            producer = session.createProducer(ch.getQueue());
        } catch (JMSException e) {
            log.error("create consumer error", e);
        }
        log.info("consumer created");
    }

    /**
     * @param message
     * @return: void
     * @author: kz
     * @date: 2023/3/14 13:36
     * @description: 发送消息
     */
    public void send(String message) {
        log.debug("Publishing messages.");
        try {
            Message textMessage = session.createTextMessage(message);
            producer.send(textMessage);
        } catch (JMSException e) {
            log.error("发送失败", e);
        }
    }

    /**
     * @return: void
     * @author: kz
     * @date: 2023/3/14 13:36
     * @description: 关闭连接
     */
    public void close() {
        if (Objects.isNull(producer)) {
            return;
        }
        try {
            producer.close();
            ch.getConnection().close();
        } catch (JMSException e) {
            log.error("close error", e);
        }
        producer = null;
        ch = null;
    }
}

创建完成后，通过实例化生产者，消费者，可直接调用send和receive方法发送和接收消息