ActiveMQ学习笔记(5)——使用Spring JMS收发消息

最新推荐文章于 2024-09-21 10:55:39 发布
最新推荐文章于 2024-09-21 10:55:39 发布
阅读量556 收藏 2
点赞数
分类专栏： activemq 文章标签： activemq

       ActiveMQ学习笔记(四)http://my.oschina.net/xiaoxishan/blog/380446 中记录了如何使用原生的方式从ActiveMQ中收发消息。可以看出，每次收发消息都要写许多重复的代码，Spring 为我们提供了更为方便的方式，这就是Spring JMS。我们通过一个例子展开讲述。包括队列、主题消息的收发相关的Spring配置、代码、测试。

       本例中，消息的收发都写在了一个工程里。

1.使用maven管理依赖包

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
< dependencies >
     < dependency >
         < groupId >junit</ groupId >
         < artifactId >junit</ artifactId >
         < version >4.12</ version >
         < scope >test</ scope >
     </ dependency >
     < dependency >
         < groupId >org.apache.activemq</ groupId >
         < artifactId >activemq-all</ artifactId >
         < version >5.11.0</ version >
     </ dependency >
     < dependency >
         < groupId >org.springframework</ groupId >
         < artifactId >spring-jms</ artifactId >
         < version >4.1.4.RELEASE</ version >
     </ dependency >
     < dependency >  
         < groupId >org.springframework</ groupId >  
         < artifactId >spring-test</ artifactId >  
         < version >4.1.4.RELEASE</ version >  
     </ dependency > 
</ dependencies >


2.队列消息的收发

2.1Spring配置文件
?
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
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< beans  xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">
 
     <!-- 配置JMS连接工厂 -->
     < bean  id = "connectionFactory"  class = "org.apache.activemq.ActiveMQConnectionFactory" >
         < property  name = "brokerURL"  value = "failover:(tcp://localhost:61616)"  />
     </ bean >
     
     <!-- 定义消息队列（Queue） -->
     < bean  id = "queueDestination"  class = "org.apache.activemq.command.ActiveMQQueue" >
         <!-- 设置消息队列的名字 -->
         < constructor-arg >
             < value >queue1</ value >
         </ constructor-arg >
     </ bean >
     
     <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
     < bean  id = "jmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "defaultDestination"  ref = "queueDestination"  />
         < property  name = "receiveTimeout"  value = "10000"  />
     </ bean >
     
     <!--queue消息生产者 -->
     < bean  id = "producerService"  class = "guo.examples.mq02.queue.ProducerServiceImpl" >
         < property  name = "jmsTemplate"  ref = "jmsTemplate" ></ property >
     </ bean >
 
     <!--queue消息消费者 -->
     < bean  id = "consumerService"  class = "guo.examples.mq02.queue.ConsumerServiceImpl" >
         < property  name = "jmsTemplate"  ref = "jmsTemplate" ></ property >
     </ bean >


2.2消息生产者代码

从下面的代码可以出，使用Spring JMS，可以减少重复代码（接口类ProducerService代码省略）。

?
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
package  guo.examples.mq02.queue;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.Session;
 
import  org.springframework.jms.core.JmsTemplate;
import  org.springframework.jms.core.MessageCreator;
 
public  class  ProducerServiceImpl  implements  ProducerService {
 
   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);
       }
     });
   }
 
/**
  * 向默认队列发送消息
  */
   public  void  sendMessage( final  String msg) {
     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  setJmsTemplate(JmsTemplate jmsTemplate) {
     this .jmsTemplate = jmsTemplate;
   }
 
}
2.3消息消费者代码
?
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
package  guo.examples.mq02.queue;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.TextMessage;
 
import  org.springframework.jms.core.JmsTemplate;
 
public  class  ConsumerServiceImpl  implements  ConsumerService {
 
     private  JmsTemplate jmsTemplate;
 
     /**
      * 接受消息
      */
     public  void  receive(Destination destination) {
         TextMessage tm = (TextMessage) jmsTemplate.receive(destination);
         try  {
             System.out.println( "从队列"  + destination.toString() +  "收到了消息：\t"
                     + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
     public  void  setJmsTemplate(JmsTemplate jmsTemplate) {
         this .jmsTemplate = jmsTemplate;
     }
 
}


2.4队列消息监听

接受消息的时候，可以不用2.3节中的方式，Spring JMS同样提供了消息监听的模式，下面给出对应的配置和代码。

Spring配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!-- 定义消息队列（Queue），我们监听一个新的队列，queue2 -->
     < bean  id = "queueDestination2"  class = "org.apache.activemq.command.ActiveMQQueue" >
         <!-- 设置消息队列的名字 -->
         < constructor-arg >
             < value >queue2</ value >
         </ constructor-arg >
     </ bean >
     
     <!-- 配置消息队列监听者（Queue），代码下面给出，只有一个onMessage方法 -->
     < bean  id = "queueMessageListener"  class = "guo.examples.mq02.queue.QueueMessageListener"  />
     
     <!-- 消息监听容器（Queue），配置连接工厂，监听的队列是queue2，监听器是上面定义的监听器 -->
     < bean  id = "jmsContainer"
         class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "destination"  ref = "queueDestination2"  />
         < property  name = "messageListener"  ref = "queueMessageListener"  />
     </ bean >

监听类代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package  guo.examples.mq02.queue;
 
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.MessageListener;
import  javax.jms.TextMessage;
 
public  class  QueueMessageListener  implements  MessageListener {
         //当收到消息时，自动调用该方法。
     public  void  onMessage(Message message) {
         TextMessage tm = (TextMessage) message;
         try  {
             System.out.println( "ConsumerMessageListener收到了文本消息：\t"
                     + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
}



3.主题消息收发

     在使用Spring JMS的时候，主题（Topic）和队列消息的主要差异体现在JmsTemplate中"pubSubDomain"是否设置为True。如果为True，则是Topic；如果是false或者默认，则是queue。

?
1
< property  name = "pubSubDomain"  value = "true"  />


3.1Spring配置
?
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
<!-- 定义消息主题（Topic） -->
     < bean  id = "topicDestination"  class = "org.apache.activemq.command.ActiveMQTopic" >
         < constructor-arg >
             < value >guo_topic</ value >
         </ constructor-arg >
     </ bean >
     <!-- 配置JMS模板（Topic），pubSubDomain="true"-->
     < bean  id = "topicJmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "defaultDestination"  ref = "topicDestination"  />
         < property  name = "pubSubDomain"  value = "true"  />
         < property  name = "receiveTimeout"  value = "10000"  />
     </ bean >
     <!--topic消息发布者 -->
     < bean  id = "topicProvider"  class = "guo.examples.mq02.topic.TopicProvider" >
         < property  name = "topicJmsTemplate"  ref = "topicJmsTemplate" ></ property >
     </ bean >
     <!-- 消息主题监听者 和 主题监听容器 可以配置多个，即多个订阅者 -->
     <!-- 消息主题监听者(Topic) -->
     < bean  id = "topicMessageListener"  class = "guo.examples.mq02.topic.TopicMessageListener"  />
     <!-- 主题监听容器 （Topic） -->
     < bean  id = "topicJmsContainer"
         class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >
         < property  name = "connectionFactory"  ref = "connectionFactory"  />
         < property  name = "destination"  ref = "topicDestination"  />
         < property  name = "messageListener"  ref = "topicMessageListener"  />
     </ bean >
3.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
package  guo.examples.mq02.topic;
 
import  javax.jms.Destination;
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.Session;
 
import  org.springframework.jms.core.JmsTemplate;
import  org.springframework.jms.core.MessageCreator;
 
public  class  TopicProvider {
 
     private  JmsTemplate topicJmsTemplate;
 
     /**
      * 向指定的topic发布消息
      * 
      * @param topic
      * @param msg
      */
     public  void  publish( final  Destination topic,  final  String msg) {
 
         topicJmsTemplate.send(topic,  new  MessageCreator() {
             public  Message createMessage(Session session)  throws  JMSException {
                 System.out.println( "topic name 是"  + topic.toString()
                         +  "，发布消息内容为:\t"  + msg);
                 return  session.createTextMessage(msg);
             }
         });
     }
 
     public  void  setTopicJmsTemplate(JmsTemplate topicJmsTemplate) {
         this .topicJmsTemplate = topicJmsTemplate;
     }
 
}
3.3消息订阅者（监听）
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  guo.examples.mq02.topic;
 
import  javax.jms.JMSException;
import  javax.jms.Message;
import  javax.jms.MessageListener;
import  javax.jms.TextMessage;
/**
  *和队列监听的代码一样。
  */
public  class  TopicMessageListener  implements  MessageListener {
 
     public  void  onMessage(Message message) {
         TextMessage tm = (TextMessage) message;
         try  {
             System.out.println( "TopicMessageListener \t"  + tm.getText());
         }  catch  (JMSException e) {
             e.printStackTrace();
         }
     }
 
}


4.测试

4.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
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
106
107
108
109
110
111
112
113
114
package  guo.examples.mq02;
 
import  javax.jms.Destination;
 
import  guo.examples.mq02.queue.ConsumerService;
import  guo.examples.mq02.queue.ProducerService;
import  guo.examples.mq02.topic.TopicProvider;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.beans.factory.annotation.Qualifier;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
  * 测试Spring JMS
  * 
  * 1.测试生产者发送消息
  * 
  * 2. 测试消费者接受消息
  * 
  * 3. 测试消息监听
  * 
  * 4.测试主题监听
  *
  */
@RunWith (SpringJUnit4ClassRunner. class )
// ApplicationContext context = new
// ClassPathXmlApplicationContext("applicationContext.xml");
@ContextConfiguration ( "/applicationContext.xml" )
public  class  SpringJmsTest {
 
     /**
      * 队列名queue1
      */
     @Autowired
     private  Destination queueDestination;
 
     /**
      * 队列名queue2
      */
     @Autowired
     private  Destination queueDestination2;
 
     /**
      * 主题 guo_topic
      */
     @Autowired
     @Qualifier ( "topicDestination" )
     private  Destination topic;
 
     /**
      * 主题消息发布者
      */
     @Autowired
     private  TopicProvider topicProvider;
 
     /**
      * 队列消息生产者
      */
     @Autowired
     @Qualifier ( "producerService" )
     private  ProducerService producer;
 
     /**
      * 队列消息生产者
      */
     @Autowired
     @Qualifier ( "consumerService" )
     private  ConsumerService consumer;
 
     /**
      * 测试生产者向queue1发送消息
      */
     @Test
     public  void  testProduce() {
         String msg =  "Hello world!" ;
         producer.sendMessage(msg);
     }
 
     /**
      * 测试消费者从queue1接受消息
      */
     @Test
     public  void  testConsume() {
         consumer.receive(queueDestination);
     }
 
     /**
      * 测试消息监听
      * 
      * 1.生产者向队列queue2发送消息
      * 
      * 2.ConsumerMessageListener监听队列，并消费消息
      */
     @Test
     public  void  testSend() {
         producer.sendMessage(queueDestination2,  "Hello China~~~~~~~~~~~~~~~" );
     }
 
     /**
      * 测试主题监听
      * 
      * 1.生产者向主题发布消息
      * 
      * 2.ConsumerMessageListener监听主题，并消费消息
      */
     @Test
     public  void  testTopic()  throws  Exception {
         topicProvider.publish(topic,  "Hello T-To-Top-Topi-Topic!" );
     }
 
}
4.2 测试结果
?
1
2
3
4
5
6
topic name 是topic: //guo_topic ，发布消息内容为:    Hello T-To-Top-Topi-Topic!
TopicMessageListener   Hello T-To-Top-Topi-Topic!
向队列queue: //queue2 发送了消息------------Hello China~~~~~~~~~~~~~~~
ConsumerMessageListener收到了文本消息： Hello China~~~~~~~~~~~~~~~
向队列queue: //queue1 发送了消息------------Hello world!
从队列queue: //queue1 收到了消息： Hello world!

5.代码地址

http://pan.baidu.com/s/1gdvPpWf

everyong
关注
专栏目录
消息中间件ActiveMQ学习笔记
java
08-21 785
尚硅谷周阳老师讲解的消息中间件ActiveMQ入门
spring boot 学习笔记 （14）操作 ActiveMQ
bihansheng2010的博客
02-13 1930
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合、异步消息、流量削锋等问题，实现高性能、高可用、可伸缩和最终一致性架构，是大型分布式系统不可缺少的中间件。 目前在生产环境中使用较多的消息队列有 ActiveMQ、RabbitMQ、ZeroMQ、Kafka、MetaMQ、RocketMQ 等。 特性 异步性：将耗时的同步操作通过以发送消息的方式进行了异步化处理，减少了同步等待的时间。 ...
ActiveMQ学习笔记(五)——使用Spring JMS收发消息
spring123666的专栏
05-11 1752
ActiveMQ学习笔记(四)http://my.oschina.net/xiaoxishan/blog/380446 中记录了如何使用原生的方式从ActiveMQ中收发消息。可以看出，每次收发消息都要写许多重复的代码，Spring 为我们提供了更为方便的方式，这就是Spring JMS。我们通过一个例子展开讲述。包括队列、主题消息的收发相关的Spring配置、代码、测试。        本
linux jms 发送mq消息,ActiveMQ学习笔记(6)——JMS消息类型
weixin_36146690的博客
05-25 196
1.前言ActiveMQ学习笔记(四)——通过ActiveMQ收发消息http://my.oschina.net/xiaoxishan/blog/380446和ActiveMQ学习笔记(五)——使用Spring JMS收发消息http://my.oschina.net/xiaoxishan/blog/381209中，发送和接受的消息类型都是TextMessage，即文本消息(如下面的代码所示)。...
ActiveMQ学习笔记(6)——JMS消息类型
08-07 85
1.前言 ActiveMQ学习笔记(四)——通过ActiveMQ收发消息http://my.oschina.net/xiaoxishan/blog/380446和ActiveMQ学习笔记(五)——使用Spring JMS收发消息http://my.oschina.net/x...
ActiveMQ学习笔记(4)——通过ActiveMQ收发消息
everyong的博客
06-20 526
1.队列和主题  1.1概念         在MQ中，消息模型有两种，一种是队列（Queue），一种是主题（Topic）。队列是Point-To-Point的，队列中的消息，仅能被消费一次。主题是Pub/Sub模型，主题中的消息，可以由多个订阅者消费；订阅者只能消费它订阅以后的消息。这是遵循的JMS规范。  1.2收发消息对象创建过程       如上图所
使用Spring JMS收发消息
keketrtr的专栏
11-17 488
摘要: ActiveMQ学习笔记(四)http://my.oschina.net/xiaoxishan/blog/380446 中记录了如何使用原生的方式从ActiveMQ中收发消息。可以看出，每次收发消息都要写许多重复的代码，Spring 为我们提供了更为方便的方式，这就是Spring JMS。我们通过一个例子展开讲述。包括队列、主题消息的收发相关的Spring配置、代码、测试。
spring整合JMS实现同步收发消息(基于ActiveMQ的实现)
08-28
本文将介绍如何使用 Spring 整合 JMS 实现同步收发消息，基于 ActiveMQ 的实现。 一、安装 ActiveMQ 首先，需要安装 ActiveMQ。下载最新的 ActiveMQ 安装包，解压到本地目录下。然后，双击 win32 或 win64 目录下...
ActiveMQ学习笔记(二) JMS与Spring
04-07
在本篇ActiveMQ学习笔记中，我们将探讨JMS（Java Message Service）与Spring框架的集成。JMS是一种标准API，用于在分布式环境中进行异步消息传递，而Spring框架则为开发人员提供了强大的依赖注入和管理服务的能力。...
JMS学习笔记(一)——JMS简介安装ActiveMQ
04-21
**JMS学习笔记(一)——JMS简介与ActiveMQ安装** Java消息服务（Java Message Service，简称JMS）是Java平台中用于企业级应用间异步通信的标准接口。它为应用程序提供了一种标准的方式，用来创建、发送、接收和读取...
Spring整合JMS——实现收发消息
11-04
本篇文章将详细探讨如何通过Spring框架整合JMS，特别是使用ActiveMQ作为消息代理来实现消息的收发功能。 首先，我们需要理解Spring对JMS的支持。Spring提供了`org.springframework.jms`包，包含了一系列接口和类，...
ActiveMQ结合Spring收发消息的示例代码
08-26
在本文中，我们将深入探讨如何将ActiveMQ与Spring框架整合，以便更高效、便捷地实现消息的收发。首先，ActiveMQ是Apache软件基金会开发的一个开源消息中间件，它支持多种消息协议，如JMS（Java消息服务），并提供...
ActiveMQ 的传输协议机制
z123456789XDW的博客
09-21 290
ActiveMQ 通过网络连接器这种连接机制来实现客户端与服务端之间的通信，ActiveMQ支持的传输协议在activeMQ 安装目录的 conf/activemq.xml中的<transportConnectors>标签之内。ActiveMQ 支持的 client 端和 broker 端的通讯协议有：TCP、NIO、UDP、SSL、Http(s)、VM。1、TCP 协议TCP 协议是...
基于Java语言的Git版本控制设计源码学习指南
09-25
该项目是针对Git版本控制的Java语言设计源码，包含88个文件，其中74个为XML配置文件，3个为Markdown文档，3个为Java源代码文件，2个为Git忽略文件，2个为属性文件，1个为授权文件，以及1个IntelliJ IDEA项目文件和1个Maven构建文件。此项目旨在帮助开发者深入理解Git在Java项目中的应用与实践。
基于国产自研的简洁易扩展warm-flow工作流设计源码
09-25
本项目为国产自研的warm-flow工作流设计源码，采用简洁的架构设计，仅需6张基础表，却能实现全面的功能。代码结构清晰，组件独立且易于扩展，非常适合中小型项目使用。源码包含215个文件，涵盖158个Java源文件、32个XML配置文件、7个SQL文件等，旨在为用户提供高效、灵活的工作流解决方案。
利用 TensorFlow 训练自己的目标识别器。(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-25
利用 TensorFlow 训练自己的目标识别器。本文内容来自于我的毕业设计，基于 TensorFlow 1.15.0，其他 TensorFlow 版本运行可能存在问题。.zip项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
基于PHP的雷劈网二维码生成器设计源码
09-25
该项目是一款基于PHP的雷劈网二维码生成器开源源码，总文件量达434个，涵盖340个PHP文件、14个HTML文件、12个CSS文件、9个JavaScript文件，以及其他C, C语言相关文件。软件由驰骋公司收购并维护，继续秉持开源精神。项目文档包括JPG、TTF、TPL、YAML、MD、PNG等多种格式，旨在提供便捷的二维码生成解决方案。支持项目持续发展，欢迎右上角star支持。
基于Java开发的Cloud HIS系统门诊挂号模块设计源码
09-25
本项目为基于Java语言的Cloud HIS系统门诊挂号模块设计源码，包含20个文件，包括8个Java源文件、3个XML配置文件、2个Markdown文件、1个Git忽略文件、1个JAR包文件、1个属性文件、1个LICENSE文件、1个Maven构建文件和1个YAML配置文件。该模块涵盖门诊挂号、病人挂号、就诊卡/身份证读取挂号以及病人档案录入等功能。
Spring整合JMS与ActiveMQ实现同步消息收发
"本文将详细介绍如何使用Spring框架与Java消息服务（JMS）进行整合，以实现基于ActiveMQ的消息同步发送和接收。首先，我们需要确保JDK版本在1.7或以上，然后下载并安装ActiveMQ。接着，我们将创建一个Maven项目，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值