springboot整合activemq实现传递对象简单例子

文章目录

• 导入activemq依赖

• 配置activemq.yml配置

• activemq简单示例

一、导入activemq依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-activemq</artifactId>
    <version>5.14.5</version>
</dependency>
<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-pool</artifactId>
  <version>5.14.5</version>
</dependency>
<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>activemq-spring</artifactId>
  <version>5.14.5</version>
</dependency>
<dependency>
  <groupId>org.apache.activemq</groupId>
  <artifactId>artemis-jms-client</artifactId>
  <version>2.3.0</version>
</dependency>

千万不要这样引入

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
    <version>5.15.8</version>
</dependency>

二、配置yml配置

server:
  port: 8080

spring:
  activemq:
    broker-url: tcp://127.0.0.1:61616
    user: admin
    password: admin
    packages:
    trust-all: true #配置白名单，可能会失效，不行就在接收方配置

三、简单例子-PTP

1.调用接口对消息做处理

Product文件

@Component
public class ProducerImpl implements Producer {
    @Autowired
    JmsMessagingTemplate jmsMessagingTemplate;

    /**
     *
     * @param destinationName 目的地
     * @param message   发送消息的内容
     */
    @Override
    public void sendMsg(String destinationName, Users message) {
        //创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://localhost:61616");
        MessageProducer producer = null;
        Session session = null;
        Connection connection = null;
        try {
            //创建连接
            connection = connectionFactory.createConnection();
            //开启连接
            connection.start();
            //创建一个session对象
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

            Queue queue = session.createQueue(destinationName);
            //创建一个序列化消息
            ObjectMessage objectMessage = session.createObjectMessage(message);
            producer = session.createProducer(queue);
            producer.send(objectMessage);
        } catch (JMSException e) {
            e.printStackTrace();
        }finally {
            //关闭连接
            try {
                producer.close();
                session.close();
                connection.close();
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

 Consumer文件

package com.goodmap.gxun.service.activemq.impl;

import com.goodmap.gxun.pojo.Users;
import com.goodmap.gxun.service.activemq.Consumer;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQObjectMessage;
import org.springframework.stereotype.Component;

import javax.jms.*;


@Component
public class ConsumerImpl implements Consumer {
    // ConnectionFactory ：连接工厂，JMS 用它创建连接
    ConnectionFactory connectionFactory;
    // Connection ：JMS 客户端到JMS Provider 的连接
    Connection connection = null;
    // Session： 一个发送或接收消息的线程
    Session session = null;
    // Destination ：消息的目的地;消息发送给谁.
    Destination destination;
    // 消费者，消息接收者
    MessageConsumer consumer = null;
    //消费者，接受对象
    ActiveMQObjectMessage msg = null;;
//    @JmsListener(destination = "test.queue")//使用JMSListener 监听Producer的消息
    @Override
    public String reveived(String queueName) {
        connectionFactory = new ActiveMQConnectionFactory("admin", "admin", "tcp://localhost:61616");
//        配置activemq白名单
        ((ActiveMQConnectionFactory) connectionFactory).setTrustAllPackages(true);
        try {
            connection = connectionFactory.createConnection();
            connection.start();
            /**
             * param1 boolean 是否支持事务
             * param2 1、Session.AUTO_ACKNOWLEDGE：为自动确认，客户端发送和接收消息不需要做额                    外的工作。
             *
             * 2、Session.CLIENT_ACKNOWLEDGE：为客户端确认。客户端接收到消息后，必须调用javax.jms.Message的acknowledge方法。jms服务器才会删除消息。
             *
             * 3、DUPS_OK_ACKNOWLEDGE：允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重复确认。在需要考虑资源使用时，这种模式非常有效。
             *
             * 4、SESSION_TRANSACTED
             */
            session = connection.createSession(Boolean.FALSE,Session.AUTO_ACKNOWLEDGE);
            destination = session.createQueue(queueName);
            consumer = session.createConsumer(destination);
            System.out.println("开始");
            while (true) {
                // 设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                msg = (ActiveMQObjectMessage) consumer.receive(5000);
                if (null != msg) {
                Users users1 = (Users) msg.getObject();
                System.out.println("收到消息" + users1);
                }else break;
            }
            System.out.println("结束");
        } catch (JMSException e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection) {
                    connection.close();
                }
                if (session != null) {
                    session.close();
                }
                if (consumer != null) {
                    consumer.close();
                }

            } catch (Throwable ignore) {
            }
        }
        return "";

    }
}

 Controller文件

package com.goodmap.gxun.controller;

import com.goodmap.gxun.pojo.Users;
import com.goodmap.gxun.service.activemq.Consumer;
import com.goodmap.gxun.service.activemq.Producer;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
@Api(tags = "消息队列")
@RequestMapping("activemq")
public class ActivemqController {
    @Autowired
    Producer producer;
    @Autowired
    Consumer consumer;
    @GetMapping("/send")
    @ApiOperation("发送消息队列")
    public void sendMessage(){
        Users users = new Users();
        users.setName("王老板");
        users.setPassword("123");
        System.out.println(users);
        producer.sendMsg("test.queue",users);
    }
    @GetMapping("/recevice")
    @ApiOperation("接受消息队列")
    public String receviceMessage(){
        String  me = consumer.reveived("test.queue");
        return "";
    }
}

 我用的swagger测试的