ActiveMQ_点对点队列(二)

最新推荐文章于 2020-12-09 06:44:07 发布
最新推荐文章于 2020-12-09 06:44:07 发布
阅读量97 收藏
点赞数
文章标签： json java 测试
 
一、本文章包含的内容
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;
 
//http://www.coderli.com/junit-spring-test-applicationcontext/
 
/**
  * 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());
     }
}

 

 

 

 

 

 





weixin_34356138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ActiveMQ路由配置方式
12-01
使用Camel配置ActiveMQ路由的实践方式
ActiveMQ消息队列的介绍
qq_40714770的博客
08-10 431
一、消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构。是大型分布式系统不可缺少的中间件。 目前在生产环境，使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等。 二、消息队列应用场景 以下介绍消息队列在实际应用中常用的使用场景。异步处理，...
javax.jms.JMSException: Failed to build body from content. Serializable class not available to broke
那些疯狂到以为自己能够改变世界的人，才能真正改变世界！
04-26 6536
ActiveMQ发消息成功，控制台报错。 javax.jms.JMSException: Failed to build body from content. Serializable class not available to broker. Reason: java.lang.ClassNotFoundException: com.ceair.shopping.handler.transf
activeMQ_spring_Demo.zip_DEMO_activemq_activemq spring_rowbv3
09-21
ActiveMQ是一款功能强大的开源消息代理，支持多种协议，如OpenWire、STOMP、AMQP、MQTT等，适用于多种应用场景，包括点对点和发布/订阅模式的消息传递。其特性包括：高可用性、持久化、事务处理、安全控制以及丰富的...
activemq_cpp动态库
最新发布
09-29
ActiveMQ的核心功能是作为消息代理，它接收、存储和转发消息，提供点对点和发布/订阅两种消息模式。它支持事务处理、持久化、高可用性集群以及网络故障恢复，确保了消息的可靠传输。此外，ActiveMQ还提供了丰富的...
zis.rar_active MQ_activemq_java activeMQ_java 转发
09-20
ActiveMQ支持点对点（Queue）和发布/订阅（Topic）两种模型，分别适用于一对一通信和一对多广播。 消息转发的核心在于配置和编程逻辑。在ActiveMQ中，可以通过设置路由策略实现消息的转发。例如，使用Virtual ...
activeMQ_spring简单案例(含XML配置)
03-24
在点对点模式中，消息由一个生产者发送到队列，然后由一个消费者接收；而在发布/订阅模式中，消息被发布到主题，多个订阅者可以接收到消息。 接下来，我们看看如何在Spring中配置ActiveMQ。Spring框架提供了一套...
activemq-cpp-library-3.6.0-src.tar.gz_C# ActiveMQ_activemq_activ
09-22
4. **消息模式**：ActiveMQ支持多种消息模式，如点对点（Queue）、发布/订阅（Topic）、请求/响应（Request/Reply）等。这些模式适应了不同场景下的通信需求，如可靠的单次传递、广播或者分布式计算。 5. **高级...
获取activemq 队列所有数据_ActiveMQ的应用
weixin_39997300的博客
12-09 1188
ActiveMQ 应用1 ActiveMQ 常用 API 简介下述 API 都是接口类型,由定义在 javax.jms 包中.是 JMS 标准接口定义.1.1ConnectionFactory链接工厂, 用于创建链接的工厂类型.1.2Connection链接. 用于建立访问 ActiveMQ 连接的类型, 由链接工厂创建.1.3Session会话, 一次持久有效有状态的访问. 由链接创建.1.4D...
错误: Failed to build body from content. Serializable class not available to broker.
时间静止
08-01 2778
在编写JMS相关业务时,程序报:javax.jms.JMSException: Failed to build body from content. Serializable class not available to broker. Reason: java.lang.ClassNotFoundException: com.bjsxt.demo.Users 解决方法一 常见的解决方法如下: ...
ActiveMQ常见错误二:javax.jms.JMSException: Unknown data type: 47
漫天雪_昆仑巅
06-30 1万+
Java连接ActiveMQ时报错： javax.jms.JMSException: Unknown data type: 47 at org.apache.activemq.util.JMSExceptionSupport.create(JMSExceptionSupport.java:72) at org.apache.activemq.ActiveMQConnection.sy
activeMQ连接错误--- javax.jms.JMSException: Could not connect to broker URL: tcp://192.168.217.129:61616
热门推荐
qq_38622941的博客
11-27 1万+
最近在学习activeMQ时，启动本地项目过程中遇到了连接错误，我是在linux虚拟机上开启的active MQ服务，通过本地程序进行测试，控制台错误信息如下： Exception in thread "main" javax.jms.JMSException: Could not connect to broker URL: tcp://192.168.217.129:61616. Reas...
ActiveMq 常见错误：This class is not trusted to be serialized as ObjectMessage payload
梦想攻城狮的博客
08-18 1704
报错信息： javax.jms.JMSException: Failed to build body from content. Serializable class not available to broker. Reason: java.lang.ClassNotFoundException: Forbidden class com.yy.pojo.User! This class is not trusted to be serialized as ObjectMessage payload. Pl
关于JMS自定义消息不被信任导致javax.jms.JMSException: Failed to build body from content.
E__V__A__N__的博客
10-09 2233
在使用Jms（版本5.14.5，在5.12.0版本之下没有此问题）jmsQueueTemplate.convertAndSend(JMS_QUEUE_NAME, messageT) 发送消息时，在ObjectMessage放入自己定义的对象报错： javax.jms.JMSException: Failed to build body from content. Serializable cla...
javax.jms.JMSException: Failed to build body from bytes. Reason: java.io.IOException
goodbaby728的专栏
05-16 6233
使用activeMQ发送ObjectMessage类型时，遇到javax.jms.JMSException: Failed to build body from bytes. Reason: java.io.IOException类型错误，经过一番折腾，终于解决。详情如下： 本项目所用的activeMQ版本为5.8.0，所要实现的publisher与subscriber分属两个不同的applic
Active MQ 传输 ObjectMessage 异常
weixin_30258027的博客
09-23 261
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory"> <property name="brokerURL" value="tcp://localhost:61616"/> <!-- 如果传输的对象是O...
Apache ActiveMQ：强大的开源消息队列及JMS应用解析
5. **高性能集群和协议支持**：它支持多种传输协议，如在进程内通信（in-VM）、网络通信，以及集群和点对点模式，确保了系统的高可用性和性能。 6. **持久化选项**：ActiveMQ提供了通过JDBC进行高速消息持久化的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值