JMS 消息中间件之 ActiveMQ 使用。。。

最新推荐文章于 2024-05-01 19:17:00 发布

冉冉_大魔王

最新推荐文章于 2024-05-01 19:17:00 发布

阅读量1k

点赞数 15

文章标签： java 队列

本文链接：https://blog.csdn.net/ranrandamowang/article/details/114867134

版权

简介：消息中间件

消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统建设的集成。通过消息传递和消息排队模型，它可以在分布式环境下扩展进
程间的通信。对于消息中间件，常见的角色大致也就有 Producer（生产者）、 Consumer（消
费者）

；常见消息中间件产品：

activeMQ: RabbitMQ ZeroMQ Kafka

JMS 简介

jms (java messagin service) 是 java 平台上有关面向消息中件的技术规范，它便于消息系统中的java应用程序进行消息交换，

并且通过提供标准的产生，发送，接受消息的接口简化企业应用开发。’

JMS 本身只定义一系列的接口规范，是一种与厂商无关的api 用来访问消息收发关系系统，JMS 提供厂商无关的访问方法，以访问消息收发服务。许多
厂商目前都支持 JMS，包括 IBM 的 MQSeries、 BEA 的 Weblogic JMS service 和 Progress 的
SonicMQ，这只是几个例子。 JMS 使您能够通过消息收发服务（有时称为消息中介程序或
路由器）从一个 JMS 客户机向另一个 JML 客户机发送消息。消息是 JMS 中的一种类型对
象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息
主体则携带着应用程序的数据或有效负载。

JMS定义了5 种不同的消息正文格式，以及调用的消息类型允许你发送并接收以一
些不同形式的数据，提供现有消息格式的一些级别的兼容性

TextMessage ------------- 字符串对象

MapMessage -------------- 一套名称-值对

ObjectMessage ------------ 一个序列化java对象

BytesMessage ------------- 一个字节数据流

StreamMessage ------------ java 原始值数据流

JMS 消息传递类型：：

对于消息的传递有两种类型：
一种是点对点的，即一个生产者和一个消费者一一对应；

另一种是发布/ 订阅模式，即一个生产者产生消息并进行发送后，可以由多个消费者进行接收。

ActiveMQ 下载安装：

http://activemq.apache.org/

将 apache-activemq-5.12.0-bin.tar.gz 上传至服务器
（2）解压此文件

tar zxvf apache-activemq-5.12.0-bin.tar.gz

（3）为 apache-activemq-5.12.0 目录赋权

chmod 777 apache-activemq-5.12.0

（4）进入 apache-activemq-5.12.0\bin 目录
（5）赋与执行权限

chmod 755 activemq
-------------------------------------- 知识点小贴士 --------------------------
linux 命令 chmod 755 的意思
chmod 是 Linux 下设置文件权限的命令，后面的数字表示不同用户或用户组的权限。
一般是三个数字：
第一个数字表示文件所有者的权限
第二个数字表示与文件所有者同属一个用户组的其他用户的权限
第三个数字表示其它用户组的权限。
权限分为三种：读（r=4），写（w=2），执行（x=1）。综合起来还有可读可执行（rx=5=4+1）、
可读可写（rw=6=4+2）、可读可写可执行(rwx=7=4+2+1)。
所以， chmod 755 设置用户的权限为：
1.文件所有者可读可写可执行 --7
2.与文件所有者同属一个用户组的其他用户可读可执行 --5

3.其它用户组可读可执行 --5

1.3.3 启动

./activemq start

http://============:8161/ 即可进入 ActiveMQ 管理页面（active 默认端口8161）

输入用户名和密码均为 admin

点对点消息列表：

列表各列信息含义如下：
Number Of Pending Messages ：等待消费的消息这个是当前未出队列的数量。

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

Messages Enqueued ：进入队列的消息进入队列的总数量,包括出队列的

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

JMS 入门小 Demo

点对点模式：

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

（1）创建工程 jmsDemo ，引入依赖

<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-client</artifactId>
<version>5.13.4</version>
</dependency>

1.1消息生产者

（2）创建类 QueueProducer main 方法代码如下 // 编写消息生产者代码

//1.创建连接工厂
ConnectionFactory connectionFactory=new
ActiveMQConnectionFactory("tcp://000.000.00.000:61616");

//2.获取连接
Connection connection = connectionFactory.createConnection();
//3.启动连接
connection.start();
//4.获取 session (参数 1：是否启动事务,参数 2：消息确认模式)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.创建队列对象
Queue queue = session.createQueue("test-queue");
//6.创建消息生产者
MessageProducer producer = session.createProducer(queue);
//7.创建消息
TextMessage textMessage = session.createTextMessage("hello world");
//8.发送消息
producer.send(textMessage);
//9.关闭资源
producer.close();
session.close();
connection.close();

上述代码中第 4 步创建 session 的两个参数：
第 1 个参数是否使用事务
第 2 个参数消息的确认模式
 AUTO_ACKNOWLEDGE = 1 自动确认
 CLIENT_ACKNOWLEDGE = 2 客户端手动确认
 DUPS_OK_ACKNOWLEDGE = 3 自动批量确认
 SESSION_TRANSACTED = 0 事务提交并确认

运行后通过 ActiveMQ 管理界面查询

1.2消息消费者
创建类 QueueConsumer ， main 方法代码如下：

//1.创建连接工厂
ConnectionFactory connectionFactory=new
ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
//2.获取连接
Connection connection = connectionFactory.createConnection();
//3.启动连接
connection.start();
//4.获取 session (参数 1：是否启动事务,参数 2：消息确认模式)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.创建队列对象
Queue queue = session.createQueue("test-queue");
//6.创建消息消费
MessageConsumer consumer = session.createConsumer(queue);

//7.监听消息
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message message) {
TextMessage textMessage=(TextMessage)message;
try {
System.out.println("接收到消息： "+textMessage.getText());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
//8.等待键盘输入
System.in.read(); // 防止程序运行结束
//9.关闭资源
consumer.close();
session.close();
connection.close();

执行后看到控制台输出；接收到消息：hello world

2.2 发布/订阅模式

2.1消息生产者

创建类 TopicProducer ， main 方法代码如下：

//1.创建连接工厂
ConnectionFactory connectionFactory=new
ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
//2.获取连接
Connection connection = connectionFactory.createConnection();
//3.启动连接
connection.start();
//4.获取 session (参数 1：是否启动事务,参数 2：消息确认模式)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.创建主题对象
Topic topic = session.createTopic("test-topic");
//6.创建消息生产者
MessageProducer producer = session.createProducer(topic);
//7.创建消息
TextMessage textMessage = session.createTextMessage("欢迎世界");
//8.发送消息
producer.send(textMessage);

//9.关闭资源
producer.close();
session.close();
connection.close();

运行效果如下

2.2.2 消息消费者
创建类 TopicConsumer ,main 方法代码如下：

//1.创建连接工厂
ConnectionFactory connectionFactory=new
ActiveMQConnectionFactory("tcp://192.168.25.135:61616");
//2.获取连接
Connection connection = connectionFactory.createConnection();
//3.启动连接
connection.start();
//4.获取 session (参数 1：是否启动事务,参数 2：消息确认模式)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.创建主题对象
//Queue queue = session.createQueue("test-queue");
Topic topic = session.createTopic("test-topic");
//6.创建消息消费
MessageConsumer consumer = session.createConsumer(topic);

//7.监听消息
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message message) {
TextMessage textMessage=(TextMessage)message;
try {
System.out.println("接收到消息： "+textMessage.getText());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
//8.等待键盘输入
System.in.read();
//9.关闭资源
consumer.close();
session.close();
connection.close();

2.2.3 运行测试
同时开启 2 个以上的消费者，再次运行生产者，观察每个消费者控制台的输出，会发现
每个消费者会接收到消

Spring 整合 JMS 简单demo ;

点对点模式

消息生产者：

创建工程 springjms_producer，在 POM 文件中引入 SpringJms 、 activeMQ 以及单元测
试相关依赖
（2）在 src/main/resources 下创建 spring 配置文件 applicationContext-jms-producer.xml

<context:component-scan base-package="cn.demo"></context:component-scan>

<bean id="targetConnectionFactory"
class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://000.000.00.000:61616"/>
</bean>

<bean id="connectionFactory"
class="org.springframework.jms.connection.SingleConnectionFactory">

<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
</bean>

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">

<property name="connectionFactory" ref="connectionFactory"/>

</bean>

<bean id="queueTextDestination"
class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="queue_text"/>
</bean>

（3）在 cn.demo 包下创建消息生产者类

@Component
public class QueueProducer {
@Autowired
private JmsTemplate jmsTemplate;
@Autowired
private Destination queueTextDestination;
/**
* 发送文本消息
* @param text
*/
public void sendTextMessage(final String text){
jmsTemplate.send(queueTextDestination, new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage(text);

}
});
}
}

（4）单元测试
在 src/test/java 创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-jms-producer.xml")
public class TestQueue {
@Autowired
private QueueProducer queueProducer;
@Test
public void testSend(){
queueProducer.sendTextMessage("SpringJms-点对点");
}
}

消息消费者

（1）创建工程 springjms_consumer，在 POM 文件中引入依赖（同上一个工程）
（2）创建配置文件 applicationContext-jms-consumer-queue.xml

<bean id="targetConnectionFactory"

class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://000.000.00.000:61616"/>
</bean>

<bean id="connectionFactory"
class="org.springframework.jms.connection.SingleConnectionFactory">

<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
</bean>

<bean id="queueTextDestination"
class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="queue_text"/>
</bean>

<bean id="myMessageListener" class="cn.demo.MyMessageListener"></bean>

<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queueTextDestination" />
<property name="messageListener" ref="myMessageListener" />
</bean>

（3）编写监听类

public class MyMessageListener implements MessageListener {

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

（4）创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-jms-consumer-queue.xm
l")
public class TestQueue {
@Test
public void testQueue(){
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}

发布/订阅模式

消息生产者
（1）在工程 springjms_producer 的 applicationContext-jms-producer.xml 增加配置

<bean id="topicTextDestination"
class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="topic_text"/>
</bean>

（2）创建生产者类

@Component
public class TopicProducer {
@Autowired
private JmsTemplate jmsTemplate;
@Autowired
private Destination topicTextDestination;
/**
* 发送文本消息
* @param text
*/
public void sendTextMessage(final String text){
jmsTemplate.send(topicTextDestination, new MessageCreator() {

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

（3）编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-activemq-producer.xml
")
public class TestTopic {
@Autowired
private TopicProducer topicProducer;
@Test
public void sendTextQueue(){
topicProducer.sendTextMessage();
}

消息消费者
（1）在 activemq-spring-consumer 工程中创建配置文件
applicationContext-jms-consumer-topic.xml

<bean id="targetConnectionFactory"
class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.25.135:61616"/>
</bean>

<bean id="connectionFactory"
class="org.springframework.jms.connection.SingleConnectionFactory">

<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
</bean>

<bean id="topicTextDestination"
class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="topic_text"/>
</bean>

<bean id="myMessageListener" class="cn.demo.MyMessageListener"></bean>

<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="topicTextDestination" />

（2）编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext-jms-consumer-topic.xm
l")
public class TestTopic {
@Test
public void testTopic(){
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}

冉冉_大魔王

关注

15
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
JMS 消息中间件之 ActiveMQ 使用。。。

简介：消息中间件消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统建设的集成。通过消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见的角色大致也就有 Producer（生产者）、 Consumer（消费者）；常见消息中间件产品： activeMQ:RabbitMQZeroMQKafkaJMS 简介 jms (java messagin service) 是 java...
复制链接

扫一扫