activeMq学习

最新推荐文章于 2021-05-26 11:02:00 发布

weixin_33719619

最新推荐文章于 2021-05-26 11:02:00 发布

阅读量158

点赞数

文章标签：网络 java json

原文链接：http://www.cnblogs.com/qizhushangshu/p/6972256.html

版权

一、activeMq有两种消息模式

1、点对点的消息模式

点对点的模式主要建立在一个队列上面，当连接一个列队的时候，发送端不需要知道接收端是否正在接收，可以直接向ActiveMQ发送消息，发送的消息，将会先进入队列中，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在activemq服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端，多个接收端，但是一条消息，只会被一个接收端给接收到，哪个接收端先连上ActiveMQ，则会先接收到，而后来的接收端则接收不到那条消息

2、订阅模式

订阅/发布模式，同样可以有着多个发送端与多个接收端，但是接收端与发送端存在时间上的依赖，就是如果发送端发送消息的时候，接收端并没有监听消息，那么ActiveMQ将不会保存消息，将会认为消息已经发送，换一种说法，就是发送端发送消息的时候，接收端不在线，是接收不到消息的，哪怕以后监听消息，同样也是接收不到的。这个模式还有一个特点，那就是，发送端发送的消息，将会被所有的接收端给接收到，不类似点对点，一条消息只会被一个接收端给接收到。

二、项目介绍

所需要工具和框架需要apache-activemq-5.9.0

项目框架采用springmvc

三、代码实现

1、消息生产者

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"  
    xmlns:jms="http://www.springframework.org/schema/jms"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd     
        http://www.springframework.org/schema/context     
        http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://www.springframework.org/schema/jms  
        http://www.springframework.org/schema/jms/spring-jms-4.0.xsd  
        http://activemq.apache.org/schema/core  
        http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd"> 
    <context:component-scan base-package="com.cc.activemq.mq" />
    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码 -->
    <amq:connectionFactory id="amqConnectionFactory"
        brokerURL="tcp://localhost:61616" userName="admin" password="admin" />
    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    <!-- Spring JmsTemplate 的消息生产者 start -->

    <!-- 定义JmsTemplate的Queue类型 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅），即队列模式 -->
        <property name="pubSubDomain" value="false" />
    </bean>
    <!-- 定义JmsTemplate的Topic类型 -->
    <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <constructor-arg ref="connectionFactory" />
        <!-- pub/sub模型（发布/订阅） -->
        <property name="pubSubDomain" value="true" />
    </bean>

    <!--Spring JmsTemplate 的消息生产者 end -->
</beans>

点对点模式

package com.cc.activemq.mq.producer.queue;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

@Component("queueSender")
public class QueueSender1 {
    /**
     * 通过Qualifier注入对象bean
     */
    @Autowired
    @Qualifier("jmsQueueTemplate")
    private JmsTemplate jmsTemplate;

    /**
     * </span> * Description: <br/>
     * 发送消息到指定的队列
     * 
     * @author chenchao
     * @date 2017年6月9日 12:18:22
     * @param queueName
     *            队列名称
     * @param message
     *            消息内容
     */
    public void send(String queueName, final String message) {
        jmsTemplate.send(queueName, new MessageCreator() {

            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }
}

订阅模式

package com.cc.activemq.mq.producer.topic;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

/**
 * ActiveMQ的topic/sub模式 Description: <br/>
 * Topic生产者发送消息到Topic
 * 
 * @author chenchao
 * @date 2017年6月9日 12:19:05
 * 
 */
@Component("topicSender")
public class TopicSender1 {
    @Autowired
    @Qualifier("jmsTopicTemplate")
    private JmsTemplate jmsTemplate;

    /**
     * 发送一条消息到指定的队列（目标）
     * 
     * @param queueName
     *            队列名称
     * @param message
     *            消息内容
     */
    public void send(String topicName, final String message) {
        jmsTemplate.send(topicName, new MessageCreator() {

            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }
}

controller调用

package com.cc.activemq.controller;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.cc.activemq.mq.producer.queue.QueueSender1;
import com.cc.activemq.mq.producer.topic.TopicSender1;
/**
 * Description: <br/>
 * 
 * @author chenchao
 * @date 2017年6月9日 14:03:03
 * 
 */
@Controller
@RequestMapping("activemq")
public class ActivemqController1 {
    @Resource
    private QueueSender1 queueSender;
    @Autowired
    private TopicSender1 topicSender;

    /**
     * 点对点模式 主要建立在一个队列上面，当连接一个列队的时候，发送端不需要知道接收端是否正在接收，可以直接向ActiveMQ发送消息，发送的消息，
     * 将会先进入队列中
     * ，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在activemq服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端
     * ，多个接收端，但是一条消息，只会被一个接收端给接收到，哪个接收端先连上ActiveMQ，则会先接收到，而后来的接收端则接收不到那条消息
     * 发送消息到队列 Queue队列：仅有一个订阅者会收到消息，消息一旦被处理就不会存在队列中
     * 
     * @param message
     * @return String
     */
    @ResponseBody
    @RequestMapping(value="queueSender",method=RequestMethod.GET,produces = "application/json; charset=utf-8")
    public String queueSender(@RequestParam("message")String message) {
        String opt = "";
        try {
            queueSender.send("test.queue", message);
            System.out.println(message);
            opt = message;
        } catch (Exception e) {
            opt = e.getCause().toString();
        }
        return opt;
    }

    /**
     * 订阅/发布模式，同样可以有着多个发送端与多个接收端，但是接收端与发送端存在时间上的依赖，就是如果发送端发送消息的时候，接收端并没有监听消息，
     * 那么ActiveMQ将不会保存消息
     * ，将会认为消息已经发送，换一种说法，就是发送端发送消息的时候，接收端不在线，是接收不到消息的，哪怕以后监听消息，同样也是接收不到的
     * 。这个模式还有一个特点，那就是，发送端发送的消息，将会被所有的接收端给接收到，不类似点对点，一条消息只会被一个接收端给接收到。
     * 
     * @param message
     * @return
     */
    @ResponseBody
    @RequestMapping("topicSender")
    public String topoicSender(@RequestParam("message") String message) {
        String opt = "";
        try {
            topicSender.send("test.topic", message);
            opt = "suc";
        } catch (Exception e) {
            opt = e.getCause().toString();
        }
        return opt;
    }
}

2、消息消费者

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:amq="http://activemq.apache.org/schema/core"  
    xmlns:jms="http://www.springframework.org/schema/jms"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans     
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd     
        http://www.springframework.org/schema/context     
        http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://www.springframework.org/schema/jms  
        http://www.springframework.org/schema/jms/spring-jms-4.0.xsd  
        http://activemq.apache.org/schema/core  
        http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd"> 
    <context:component-scan base-package="com.cc.activemq.mq" />
    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码 -->
    <amq:connectionFactory id="amqConnectionFactory"
        brokerURL="tcp://localhost:61616" userName="admin" password="admin" />
    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory"
        class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    <!-- 消息消费者 start -->

    <!-- 定义Queue监听器 -->
    <jms:listener-container destination-type="queue"
        container-type="default" connection-factory="connectionFactory"
        acknowledge="auto">
        <jms:listener destination="test.queue" ref="queueReceiver1" />
        <jms:listener destination="test.queue" ref="queueReceiver2" />
    </jms:listener-container>

    <!-- 定义Topic监听器 -->
    <jms:listener-container destination-type="topic"
        container-type="default" connection-factory="connectionFactory"
        acknowledge="auto">
        <jms:listener destination="test.topic" ref="topicReceiver1" />
        <jms:listener destination="test.topic" ref="topicReceiver2" />
    </jms:listener-container>

    <!-- 消息消费者 end -->
</beans>

点对点模式（消息队列模式）

package com.cc.activemq.mq.consumer.queue;

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

import org.springframework.stereotype.Component;

/** 
 * Description: <br/> 
 * 消息队列监听器
 * @author hetiewei 
 * @date 2017年6月9日 11:40:02
 * 
 */ 
@Component
public class QueueReceiver1 implements MessageListener{

    @Override
    public void onMessage(Message message) {
         try {
                System.out.println("QueueReceiver1接收到消息"+((TextMessage)message).getText());  
            } catch (JMSException e) {  
                e.printStackTrace();  
            } 
    }

}

package com.cc.activemq.mq.consumer.queue;

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

import org.springframework.stereotype.Component;

/** 
 * Description: <br/> 
 * 消息队列监听器
 * @author chenchao
 * @date 2017年6月9日 11:40:37
 * 
 */ 
@Component
public class QueueReceiver2 implements MessageListener{

    @Override
    public void onMessage(Message message) {
         try {
                 System.out.println("QueueReceiver2接收到消息"+((TextMessage)message).getText());
            } catch (JMSException e) {  
                e.printStackTrace();  
            } 
    }

}

订阅模式

package com.cc.activemq.mq.consumer.topic;

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

import org.springframework.stereotype.Component;
@Component
public class TopicReceiver1 implements MessageListener {

    @Override
    public void onMessage(Message message) {
         try {  
                System.out.println("TopicReceiver1接收到消息"+((TextMessage)message).getText());  
            } catch (JMSException e) {  
                e.printStackTrace();  
            }  
    }

}

package com.cc.activemq.mq.consumer.topic;

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

import org.springframework.stereotype.Component;
@Component
public class TopicReceiver2 implements MessageListener {

    @Override
    public void onMessage(Message message) {
         try {  
                System.out.println("TopicReceiver2接收到消息"+((TextMessage)message).getText());  
            } catch (JMSException e) {  
                e.printStackTrace();  
            }  
    }

}

四、消息展示

1、启动activemq

浏览器输入：http://localhost:8161/admin/ 默认用户名密码是admin admin 输入完成之后进入这个页面

Number Of Consumers 消费者 “这个是消费者端的消费者数量”

Number Of Pending Messages 等待消费的消息 “这个是当前未出队列的数量。可以理解为总接收数-总出队列数”

Messages Enqueued 进入队列的消息 “进入队列的总数量,包括出队列的。这个数量只增不减”

Messages Dequeued 出了队列的消息 “可以理解为是消费这消费掉的数量”

2、启动项目

首先启动消息生产者

然后我们打开activeMq的管理中心

3、发现未出队列数量和进入队列数量各增加到了1，这说明我们的消息正常进入了消息队列，还没有出去，下面我们启动消息消费者，项目启动完成时发现控制台已经打印出了日志。

然后我们再来看下activemq管理中心

发现消息出队列数量增加为1了，消息未出队数量减少为0了。说明我们服务正常

五、总结

这样就实现了消息的消费者与生产者的分离，后期我会为大家提供更好的文章，欢迎大家找茬，大家可以关注我的微信公众帐号骑猪上树这是我自己开发的微信机器人谢谢大家

这是项目的地址：https://github.com/gitChenchao/activemq

转载于:https://www.cnblogs.com/qizhushangshu/p/6972256.html

weixin_33719619

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
activeMq学习

一、activeMq有两种消息模式1、点对点的消息模式点对点的模式主要建立在一个队列上面，当连接一个列队的时候，发送端不需要知道接收端是否正在接收，可以直接向ActiveMQ发送消息，发送的消息，将会先进入队列中，如果有接收端在监听，则会发向接收端，如果没有接收端接收，则会保存在activemq服务器，直到接收端接收消息，点对点的消息模式可以有多个发送端，多个接收端，但是一条消息，只会被一...
复制链接

扫一扫