一、本文章包含的内容
1、列举了ActiveMQ中通过Queue方式发送、消费队列的代码（普通文本、json/xml字符串、对象数据）
2、spring+activemq方式
 
二、配置信息
1、activemq的pom.xml信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--activemq  Begin-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jms</artifactId>
           <version>${spring.version}</version>
       </dependency>
       <!-- <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-messaging</artifactId>
            <version>${spring.version}</version>
        </dependency>-->
       <dependency>
           <groupId>org.apache.activemq</groupId>
           <artifactId>activemq-all</artifactId>
           <version>5.14.0</version>
       </dependency>
       <!--activemq  End-->

2、activemq的配置文件：spring-jms.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!-- 启用spring mvc 注解 -->
   <context:component-scan base-package="org.soa.test.activemq"/>
 
   <!-- 配置JMS连接工厂 -->
   <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
       <property name="brokerURL" value="failover:(tcp://192.168.146.129:61616)" />
       <!--解决接收消息抛出异常：javax.jms.JMSException: Failed to build body from content. Serializable class not available to broke-->
       <property name="trustAllPackages" value="true"/>
       <!-- 是否异步发送 -->
       <property name="useAsyncSend" value="true" />
   </bean>
 
   <!--   Queue模式 Begin -->
 
   <!-- 定义消息队列（Queue） -->
   <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
       <!-- 设置消息队列的名字 -->
       <constructor-arg>
           <value>defaultQueueName</value>
       </constructor-arg>
   </bean>
 
   <!-- 配置JMS模板，Spring提供的JMS工具类，它发送、接收消息。（Queue） -->
   <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
       <property name="connectionFactory" ref="connectionFactory" />
       <property name="defaultDestination" ref="queueDestination" />
       <property name="pubSubDomain" value="false"/>
       <!--接收超时时间-->
       <!--<property name="receiveTimeout" value="10000" />-->
   </bean>
   <!--   Queue模式 End -->

三、队列发送端及测试程序

1、发送代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package org.soa.test.activemq.queues;
 
import org.soa.test.activemq.StudentInfo;
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;
 
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import java.util.List;
 
/**
 * Created by JamesC on 16-9-22.
 */
@Component
public class ProduceMsg {
 
    @Autowired
    private JmsTemplate jmsTemplate;
 
    /**
     * 向指定队列发送消息
     */
    public void sendMessage(Destination destination, final String msg) {
        System.out.println("向队列" + destination.toString() + "发送了消息------------" + msg);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }
 
    /**
     * 向默认队列发送消息(默认队列名称在bean：queueDestination配置）
     */
    public void sendMessage(final String msg) {
        //queue://queue1
        String destination = jmsTemplate.getDefaultDestination().toString();
        System.out.println("向队列" + destination + "发送了消息------------" + msg);
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }
 
    /**
     * 向默认队列发送消息
     */
    public void sendMessageConvertAndSend(final Object msg) {
 
        String destination = jmsTemplate.getDefaultDestination().toString();
        System.out.println("向队列" + destination + "发送了消息------------" + msg);
        //使用内嵌的MessageConverter进行数据类型转换，包括xml(JAXB)、json(Jackson)、普通文本、字节数组
        jmsTemplate.convertAndSend(destination, msg);
    }
 
    /**
     * 向指定队列发送消息
     */
    public void sendStudentInfo(Destination destination, final StudentInfo msg) {
        System.out.println("向队列" + destination.toString() + "发送了消息------------" + msg);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createObjectMessage(msg);
            }
        });
    }
}

2、测试程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package org.soa.test.activemq.queues;
 
import com.alibaba.fastjson.JSON;
import org.apache.activemq.command.ActiveMQQueue;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.soa.test.activemq.StudentInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import javax.jms.Destination;
import java.util.Date;
 
 
/**
 * Created by JamesC on 16-9-22.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring-jms.xml")
public class ProduceMsgTest extends AbstractJUnit4SpringContextTests {
 
    @Autowired
    protected ApplicationContext ctx;
 
    /**
     * 队列名queue1  这里使用jms配置文件中的数据
     */
    @Autowired
    private Destination queueDestination;
 
    /**
     * 队列消息生产者
     */
    @Autowired
    private ProduceMsg produceMessage;
 
 
    //向默认队列发消息（文本）
    @Test
    public void produceMsg_DefaultQueue() {
        String msg = "这里是向默认队列发送的消息" + new Date().toString();
        produceMessage.sendMessage(msg);
    }
 
    //向默认队列发消息(Json字符串)
    @Test
    public void produceMsg_Json() {
        StudentInfo info = new StudentInfo();
        info.setId(1);
        info.setStdName("李磊");
        info.setStdNo("001");
        info.setEnterDate(new Date());  //队列存放的是时间戳
 
        String alibabaJson = JSON.toJSONString(info);
        produceMessage.sendMessage(alibabaJson);
    }
 
    //向默认队列发消息(使用convertAndSend发送对象）
    @Test
    public void produceMsg_ConvertAndSend() {
        StudentInfo info = new StudentInfo();
        info.setId(1);
        info.setStdName("李磊");
        info.setStdNo("001");
        info.setEnterDate(new Date());
 
        produceMessage.sendMessageConvertAndSend(info);
    }
 
    //向指定队列发消息(文本)
    @Test
    public void produceMsg_CustomQueue() {
        for (int i = 0; i < 20; i++) {
            ActiveMQQueue myDestination = new ActiveMQQueue("queueCustom");
            produceMessage.sendMessage(myDestination, "----发送消息给queueCustom");
        }
    }
 
    //向指定队列发消息(队列名称从XML读取)
    @Test
    public void produceMsg_XmlQueue() {
        for (int i = 0; i < 20; i++) {
            ActiveMQQueue destinationQueue = (ActiveMQQueue) applicationContext.getBean("queueDestination");
            produceMessage.sendMessage(destinationQueue, "----send my msg to queueXml");
        }
    }
 
    //向指定队列发消息(发送对象)
    @Test
    public void produceMsg_StudentInfo() {
 
        StudentInfo info = new StudentInfo();
        info.setId(1);
        info.setStdName("李磊");
        info.setStdNo("001");
        info.setEnterDate(new Date());
 
        ActiveMQQueue destination = new ActiveMQQueue("StudentInfo");
        produceMessage.sendStudentInfo(destination, info);
    }
}

四、队列消费端及测试程序

1、消费代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package org.soa.test.activemq.queues;
 
import org.soa.test.activemq.StudentInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.support.JmsUtils;
import org.springframework.stereotype.Component;
 
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;
 
/**
 * Created by JamesC on 16-9-22.
 */
@Component
public class ConsumeMsg {
    @Autowired
    private JmsTemplate jmsTemplate;
 
    /**
     * 接受消息
     */
    public String receive(Destination destination) {
        TextMessage tm = (TextMessage) jmsTemplate.receive(destination);
        String msg = "";
        try {
            msg = tm.getText();
            System.out.println("从队列" + destination.toString() + "收到了消息：\t" + msg);
 
        } catch (JMSException e) {
            e.printStackTrace();
            return "";
        }
        return msg;
    }
 
    /**
     * 接受消息
     */
    public StudentInfo receiveStudentInfo() {
        try {
            String destination = jmsTemplate.getDefaultDestination().toString();
            ObjectMessage msg=(ObjectMessage)jmsTemplate.receive(destination);
            return (StudentInfo)msg.getObject();
 
        } catch (JMSException e) {
            //检查性异常转换为非检查性异常
            throw JmsUtils.convertJmsAccessException(e);
        }
    }
 
    /**
     * 接受消息
     */
    public Object receiveConvertAndReceive() {
        String destination = jmsTemplate.getDefaultDestination().toString();
        Object msg = jmsTemplate.receiveAndConvert(destination);
        return msg;
    }
}

2、测试程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package org.soa.test.activemq.queues;
 
import org.apache.activemq.command.ActiveMQQueue;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.soa.test.activemq.StudentInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * Created by JamesC on 16-9-22.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring-jms.xml")
public class ConsumeMsgTest {
 
    @Autowired
    private ConsumeMsg consumeMsg;
 
    //从指定队列接收消息（文本)
    @Test
    public void receiveMsg() {
        //没有消息阻塞一段时间后会抛异常
        //java.lang.NullPointerException
        ActiveMQQueue destination = new ActiveMQQueue("defaultQueueName");
        consumeMsg.receive(destination);
    }
 
    //从指定队列接收消息（StudentInfo对象消息)
    @Test
    public void receiveStudentInfo() {
        StudentInfo msg = consumeMsg.receiveStudentInfo();
        System.out.println(msg.getStdName());
    }
 
    //从指定队列接收消息（Json对象)
    @Test
    public void receiveConvertAndReceive() {
 
        StudentInfo msg =(StudentInfo) consumeMsg.receiveConvertAndReceive();
        System.out.println(msg.getStdName());
    }
}

ActiveMQ_点对点队列(二)的更多相关文章

  1. SDUT-2132_数据结构实验之栈与队列二：一般算术表达式转换成后缀式

    数据结构实验之栈与队列二:一般算术表达式转换成后缀式 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 对于一个基于二元运 ...

  2. RabbitMQ 消息队列 二

    一:查看MQ的用户角色 rabbitmqctl list_users 二:添加新的角色,并授予权限 rabbitmqctl add_user xiaoyao 123456 rabbitmqctl se ...

  3. ActiveMQ笔记之点对点队列（Point-to-Point）

    1. 点对点通信 点对点是一种一对一通信方式,更像是有一个队列,一个人往队列里放消息,另一个人从队列中取消息,其最大的特点是一个消息只会被消费一次,即使有多个消费者同时消费,他们消费的也是不同的消息. ...

  4. day43-python消息队列二-queue模块

    Python提供了Queue模块来专门实现消息队列Queue对象 Queue对象实现一个fifo队列(其他的还有lifo.priority队列,这里不再介绍).queue只有maxsize一个构造参数 ...

  5. Sword 内核队列二

    #ifndef __GTC_FIFO_H_ #define __GTC_FIFO_H_ #ifndef GTC_MAX #define GTC_MAX(a,b) ((a) > (b) ? (a) ...

  6. 剖析nsq消息队列(二) 去中心化代码源码解析

    在上一篇帖子剖析nsq消息队列(一) 简介及去中心化实现原理中,我介绍了nsq的两种使用方式,一种是直接连接,还有一种是通过nslookup来实现去中心化的方式使用,并大概说了一下实现原理,没有什么难 ...

  7. linux网络编程之system v消息队列(二)

    今天继续学习system v消息队列,主要是学习两个函数的使用,开始进入正题: 下面则开始用代码来使用一下该发送函数: 在运行之前,先查看一下1234消息队列是否已经创建: 用上次编写的查看消息队列状 ...

  8. .net core使用rabbitmq消息队列 (二)

    之前有写过.net core集成使用rabbitmq的博文,见.net core使用rabbitmq消息队列,但是里面的使用很简单,而且还有几个bug,想改下,但是后来想了想,还是算了,之前使用的是. ...

  9. 数据结构实验之栈与队列二：一般算术表达式转换成后缀式（SDUT 2132）

    题目链接 #include <bits/stdc++.h> using namespace std; typedef long long ll; int ok(char ch, char ...

随机推荐

  1. libsvm Minist Hog 手写体识别（源码文件）

    以上是我上一篇文章中的代码实现,里面分别用了opencv中的SVM和LibSVM,opencv的SVM用起来更方便,但貌似内部其实也是基于Libsvm,同样的参数训练出来的结果是一致的,里面有Libs ...

  2. POJ 1696 Space Ant 【极角排序】

    题意:平面上有n个点,一只蚂蚁从最左下角的点出发,只能往逆时针方向走,走过的路线不能交叉,问最多能经过多少个点. 思路:每次都尽量往最外边走,每选取一个点后对剩余的点进行极角排序.(n个点必定能走完, ...

  3. Google Guava官方教程（中文版）

    Google Guava官方教程(中文版) 原文链接  译文链接 译者: 沈义扬,罗立树,何一昕,武祖  校对:方腾飞 引言 Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库, ...

  4. 创建简单的机器人模型smartcar

    前面我们使用的是已有的机器人模型进行仿真,这一节我们将建立一个简单的智能车机器人 smartcar,为后面建立复杂机器人打下基础. 一.创建硬件描述包. cd ~/catkin_ws/srcroscr ...

  5. .net(c#)提取多层嵌套的JSON

    Newtonsoft.Json.Net20.dll 下载请访问http://files.cnblogs.com/hualei/Newtonsoft.Json.Net20.rar 在.net 2.0中提 ...

  6. window.execScript的兼容性写法

    把探嗅浏览器的操作提前到代码加载的时候,在代码加载的时候就立刻进行一次判断,以便让globalEval返回一个包裹了正确逻辑的函数 var globalEval = (function(){ var ...

  7. 在Mac mini上安装 ESXi 5.5

    Mac mini 是 mid 2011 版本的, 安装原版ESXi 5.5 update 1 非常顺利, 没遇到任何问题. 提示: 1. 安装会初始化整个硬盘, 有数据要先备份 2. ESXi只使用有 ...

  8. HTTP下密码的安全传输、OAuth认证

    在复杂的web环境下,我们没有百分的把握保证信息在传输的过程中不被接货,那不是用明文如何告诉服务器自己的身份呢? 在一些高度通信安全的网络中,数据传输会使用HTTPS作为传输协议,但是通常情况下我们没 ...

  9. Linux shell的输入输出

    echo --echo命令可以显示文本行或变量,或者把字符串输入到文件 --echo [option] string -e 解析转义字符 例如:echo -e "nimenhao\nasfd ...

  10. Linux 守护进程三

    .打开telnet工具,登录服务器,登录校验成功以后, linux服务器会在终端和服务器之间,建立一个会话期session .在这个会话期中,默认启动一个shell程序 .在会话期中有n个进程组 sh ...