ActiveMQ入门示例

最新推荐文章于 2024-09-04 15:08:12 发布

全绽开发工程师

最新推荐文章于 2024-09-04 15:08:12 发布

阅读量300

点赞数

分类专栏： ActiveMQ 文章标签： activemq java

本文链接：https://blog.csdn.net/qq_40438427/article/details/108185059

版权

ActiveMQ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

自行从官网下载包并解压，示例使用的是5.16.0版本
在这里插入图片描述
进入bin目录

通过cmd窗口输入activemq.bat start启动服务
在这里插入图片描述

启动成功后可以通过localhost:8161/admin 进去AM管理后台，默认账号密码:admin/admin
在这里插入图片描述

登录后台的账号密码配置文件：conf/users.properties
在这里插入图片描述

ActiveMQ介绍
MQ是消息中间件，是一种在分布式系统中应用程序借以传递消息的媒介，常用的有ActiveMQ，RabbitMQ，kafka。ActiveMQ是Apache下的开源项目，完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。
特点：
1、支持多种语言编写客户端
2、对spring的支持，很容易和spring整合
3、支持多种传输协议：TCP,SSL,NIO,UDP等
4、支持AJAX
消息形式：
1、点对点（queue）
2、一对多（topic）

maven配置

<!--activeMQ start-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
    <version>2.0.4.RELEASE</version>
    <type>pom</type>
</dependency>
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-pool</artifactId>
    <version>5.7.0</version>
</dependency>
<!--activeMQ end-->

queue发送/接收demo

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

import javax.jms.*;

public class ActiveMQTest {

    @Test
    public void queueSendTest() throws Exception{
        //1、创建工厂连接对象，需要制定ip和端口号
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://127.0.0.1:61616");
        //2、使用连接工厂创建一个连接对象
        Connection connection = connectionFactory.createConnection();
        //3、开启连接
        connection.start();
        //4、使用连接对象创建会话（session）对象
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
        Queue queue = session.createQueue("test-queue");
        //6、使用会话对象创建生产者对象
        MessageProducer producer = session.createProducer(queue);
        //7、使用会话对象创建一个消息对象
        TextMessage textMessage = session.createTextMessage("hello!test-queue");
        //8、发送消息
        producer.send(textMessage);
        //9、关闭资源
        producer.close();
        session.close();
        connection.close();
    }

    @Test
    public void queueReceiveTest() throws Exception{
        //1、创建工厂连接对象，需要制定ip和端口号
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://127.0.0.1:61616");
        //2、使用连接工厂创建一个连接对象
        Connection connection = connectionFactory.createConnection();
        //3、开启连接
        connection.start();
        //4、使用连接对象创建会话（session）对象
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
        Queue queue = session.createQueue("test-queue");
        //6、使用会话对象创建生产者对象
        MessageConsumer consumer = session.createConsumer(queue);
        //7、向consumer对象中设置一个messageListener对象，用来接收消息
        consumer.setMessageListener(new MessageListener() {

            @Override
            public void onMessage(Message message) {
                if(message instanceof TextMessage){
                    TextMessage textMessage = (TextMessage)message;
                    try {
                        System.out.println(textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //8、程序等待接收用户消息
        System.in.read();
        //9、关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

在这里插入图片描述
topic的发送与接收

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

import javax.jms.*;

/**
 * activemq测试
 *
 * @author yuanxiyang
 * @date 2020/7/23 17:30
 **/
public class ActiveMQTest {

    @Test
    public void topicSendTest() throws Exception{
        //1、创建工厂连接对象，需要制定ip和端口号
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://127.0.0.1:61616");
        //2、使用连接工厂创建一个连接对象
        Connection connection = connectionFactory.createConnection();
        //3、开启连接
        connection.start();
        //4、使用连接对象创建会话（session）对象
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
        Topic topic = session.createTopic("test-topic");
        //6、使用会话对象创建生产者对象
        MessageProducer producer = session.createProducer(topic);
        //7、使用会话对象创建一个消息对象
        TextMessage textMessage = session.createTextMessage("hello!test-topic");
        //8、发送消息
        producer.send(textMessage);
        //9、关闭资源
        producer.close();
        session.close();
        connection.close();

    }

    @Test
    public void topicReceiveTest() throws Exception{
        //1、创建工厂连接对象，需要制定ip和端口号
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://127.0.0.1:61616");
        //2、使用连接工厂创建一个连接对象
        Connection connection = connectionFactory.createConnection();
        //3、开启连接
        connection.start();
        //4、使用连接对象创建会话（session）对象
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //5、使用会话对象创建目标对象，包含queue和topic（一对一和一对多）
        Topic topic = session.createTopic("test-topic");
        //6、使用会话对象创建生产者对象
        MessageConsumer consumer = session.createConsumer(topic);
        //7、向consumer对象中设置一个messageListener对象，用来接收消息
        consumer.setMessageListener(new MessageListener() {

            @Override
            public void onMessage(Message message) {
                if(message instanceof TextMessage){
                    TextMessage textMessage = (TextMessage)message;
                    try {
                        System.out.println(textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //8、程序等待接收用户消息
        System.in.read();
        //9、关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

在这里插入图片描述
接着运行两个消费者

但是发现刚才发送的topic消息并没有没消费，这是因为正常情况下topic消息不会被服务器持久化，所以需要先运行消费者，再运行生产者。

可以看到有两个消费者消费了topic消息

需要注意的是：生产/消费的默认连接端口为61616，而不是8161，8161是后台管理的端口.

Topic和Queue是ActiveMQ两种消息模式。Topic用于消息订阅，属于一对多；Queue用于消息处理，属于一对一。
分别从工作模式、有无状态、传递完整性、处理效率四个方面比较
工作模式： Topic是“订阅-发布”模式，如果当前没有订阅者，消息将会被丢弃，如果有多个订阅者，那么这些订阅者都会受到消息；Queue是“负载均衡”模式，如果当前没有消费者，消息不会被丢弃；如果有多个消费者，那么一条消息也只能发送给一个消费者，并且要求消费者ack信息。
有无状态： Topic无状态；Queue 数据默认会在mq服务器上以文件的形式存储，比如activemq一般保存在$AMQ_HOME\data\kr-store\data下面，也可以配置成DB存储。
传递完整性： Topic模式如果没有订阅，消息就会被丢弃。Queue消息不会被丢弃。
处理效率：由于消息会随着订阅者的数量进行复制，所以处理性能会随着订阅者的增加而明显降低，并且还要结合不同的消息协议自身的性能差异；Queue模式由于一条消息只能被一个消费者消费，所以就算消费者再多，性能也不会有明显降低，当然不同的消息协议的具体性能也是有差异的。

摘自：https://blog.csdn.net/L_Mcode/article/details/100847461

怎么在springboot中使用？
activemq配置类

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.jms.core.JmsTemplate;

import javax.jms.Queue;

@Configuration
public class ActiveMQConfig {

    @Value("${spring.activemq.broker-cm-url}")
    private String brokercmurl;

    /**
     * JMS 队列的模板类
     * connectionFactory() 为 ActiveMQ 连接工厂
     */
    @Bean
    public ActiveMQConnectionFactory connectioncmFactory(){
        return new ActiveMQConnectionFactory(brokercmurl);
    }

    @Bean
    public JmsTemplate jmsQueueTemplate(){
        return new JmsTemplate(connectioncmFactory());
    }

    @Bean
    public DefaultJmsListenerContainerFactory jmsTopicListenerContainerFactory() {

        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();

        factory.setConnectionFactory(connectioncmFactory());
        //true为topic，false为queue
        factory.setPubSubDomain(false);
        factory.setConcurrency("3-10");
        factory.setRecoveryInterval(1000L);
        return factory;
    }

    @Bean(name = "jmsQueueListenerContainerFactory")
    public DefaultJmsListenerContainerFactory jmsQueueListenerContainerFactory(@Qualifier(value = "connectioncmFactory") ActiveMQConnectionFactory connectioncmFactory){
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();

        factory.setConnectionFactory(connectioncmFactory);
        //true为topic，false为queue
        factory.setPubSubDomain(false);
        factory.setConcurrency("3-10");
        factory.setRecoveryInterval(1000L);
        return factory;
    }
}

接收消息的服务


import com.alibaba.fastjson.JSONObject;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.net.URLDecoder;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Service
public class HandleReceiveMsgServiceImpl {
    /*
        监听jmsQueueListenerContainerFactory中的analysisQueue
    */
    @JmsListener(destination = "analysisQueue",containerFactory = "jmsQueueListenerContainerFactory")
    public void receiveUserStr(String jsonStr){
        //业务处理
    }
}

发送消息的服务


import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.jms.Queue;
import java.util.HashMap;
import java.util.Map;

@Service
public class ActiveMQServiceImpl extends BaseService {

    private static final Logger logger = LoggerFactory.getLogger(ActiveMQServiceImpl.class);

    @Resource
    private JmsTemplate jmsQueueTemplate;
    
    public void sendMsg(String jsonStr){
        jmsQueueTemplate.convertAndSend("analysisQueue", jsonStr);
    }
}