ActiveMQ入门

最新推荐文章于 2020-09-29 17:29:39 发布

AutumnWind0420

最新推荐文章于 2020-09-29 17:29:39 发布

阅读量250

点赞数

CC 4.0 BY-SA版权

分类专栏： JMS

本文链接：https://blog.youkuaiyun.com/py_1990_04_20/article/details/106835714

JMS 专栏收录该内容

1 篇文章

订阅专栏

这篇博客介绍了ActiveMQ的基本概念，包括点对点模型和发布/订阅模型，并详细讲解了JMS公共接口。此外，还涵盖了ActiveMQ的安装启动、使用方法，特别是如何在Spring中整合ActiveMQ，以及点对点Queue和发布/订阅Topic的示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ActiveMQ入门

ActiveMQ是JMS规范的一种实现

ActiveMQ的消息形式

Java消息服务应用程序结构支持两种模型：

1.点对点模型(基于队列)

每个消息只能有一个消费者。消息的生产者和消费者之间没有时间上的相关性。可以由多个发送者，但只能被一个消费者消费。

一个消息只能被一个接受者接受一次
生产者把消息发送到队列中(Queue)，这个队列可以理解为电视机频道(channel)
在这个消息中间件上有多个这样的channel
接受者无需订阅，当接受者未接受到消息时就会处于阻塞状态

2. 发布者/订阅者模型（基于主题的）

每个消息可以有多个消费者。生产者和消费者之间有时间上的相关性。订阅一个主题的消费者只能消费自它订阅之后发布的消息。

允许多个接受者，类似于广播的方式
生产者将消息发送到主题上(Topic)
接受者必须先订阅

注：持久化订阅者：特殊的消费者，告诉主题，我一直订阅着，即使网络断开，消息服务器也记住所有持久化订阅者，如果有新消息，也会知道必定有人回来消费。

关于持久化订阅者和持久化消息的概念

JMS公共接口

JMS 公共	点对点域	发布/订阅域
ConnectionFactory	QueueConnectionFactory	TopicConnectionFactory
Connection	QueueConnection	TopicConnection
Destination	Queue	Topic
Session	QueueSession	TopicSession
MessageProducer	QueueSender	TopicPublisher
MessageConsumer	QueueReceiver	TopicSubscriber

ConnectionFactory：连接工厂是客户用来创建连接的对象，例如ActiveMQ提供的ActiveMQConnectionFactory。
Connection：JMS Connection封装了JMS 客户端到JMS Provider 的连接与JMS提供者之间的一个虚拟的连接。
Destination：消息的目的地，是用来指定生产的消息的目标和它消费的消息的来源的对象。
Session： JMS Session是生产和消费消息的一个单线程上下文。会话用于创建消息的生产者（producer），消费者（consumer），消息（message）等，会话,是一个事务性的上下文。消息的生产和消费不能包含在同一个事务中。
MessageProducer：由Session 对象创建的用来发送消息的对象
MessageConsumer：由Session 对象创建的用来发送消息的对象

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

StreamMessage – Java原始值的数据流
MapMessage–一套名称-值对
TextMessage–一个字符串对象
ObjectMessage–一个序列化的 Java对象
BytesMessage–一个字节的数据流

ActiveMQ安装启动访问

安装

主机安装JDK
ActiveMQ部署在一个Jetty容器中直接解压即可

进入apache-activemq-5.12.0/bin

启动：./activemq start
关闭：./activemq stop
查看：./activemq status

访问Broker

http://IP:8161/admin
输入用户:admin，密码:admin

503错误解决，把主机名添加到hosts中

ActiveMQ的使用

添加pom依赖

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
    <version>5.11.2</version>
</dependency>

点对点Queue

生产者Producer

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

public class QueueProducerTest {

	@Test
	public void testQueueProducer() throws Exception {
		// 1. 创建连接工厂对象ConnectionFactory，需要指定ip及端口号
		// 参数brokerURL即服务器的ip加端口号
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
				"tcp://192.168.110.129:61616");
		// 2. 使用ConnectionFactory对象创建connection对象
		Connection connection = connectionFactory.createConnection();
		
		// 3. 开启连接
		connection.start();
		
		// 4. 创建Session对象
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		
		// 5. 使用Session创建一个Destination对象，此处创建Queue即队列
		Queue queue = session.createQueue("test-queue");
		
		// 6. 创建一个Producer
		MessageProducer messageProducer = session.createProducer(queue);
		
		// 7.创建一个Message对象
		TextMessage textMessage = session.createTextMessage("This is my first point to point queue message!");
		
		// 8.使用Producer发送消息
		messageProducer.send(textMessage);
		
		// 9.关闭资源
		messageProducer.close();
		session.close();
		connection.close();
	}
}

消费者Consumer

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

public class QueueComsumerTest {

	@Test
	public void testQueueComsumer() throws Exception {
		// 1.创建连接工厂ConnectionFactory
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
				"tcp://192.168.110.129:61616");
		// 2.创建连接
		Connection connection = connectionFactory.createConnection();
		
		// 3.启动
		connection.start();
		
		// 4.创建session
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		
		// 5.创建destination，注意名称要与生产端一致
		Queue queue = session.createQueue("test-queue");
		
		// 6.创建消费者
		MessageConsumer comsumer = session.createConsumer(queue);
		
		// 7.接受消息，这里是对某一个Destination做监听，即test-queue
		comsumer.setMessageListener(new MessageListener() {
			
			@Override
			public void onMessage(Message message) {
				
				if(message instanceof TextMessage) {
					TextMessage text = (TextMessage) message;
					try {
						String myMsg = text.getText();
						// 8.打印消息This is my first point to point queue message!
						System.out.println(myMsg);
					} catch (JMSException e) {
						e.printStackTrace();
					}
				}
				
			}
			
		});
		
		// 9.等待键盘输入，不让进程退出
		System.in.read();
		
		// 10.关闭资源
		comsumer.close();
		session.close();
		connection.close();
	}
}

演示：

运行Producer
运行Consumer

发布于订阅Topic

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

public class TopicProducerTest {
	@Test
	public void testQueueProducer() throws Exception {
		// 1. 创建连接工厂对象ConnectionFactory，需要指定ip及端口号
		// 参数brokerURL即服务器的ip加端口号
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
				"tcp://192.168.110.129:61616");
		// 2. 使用ConnectionFactory对象创建connection对象
		Connection connection = connectionFactory.createConnection();
		
		// 3. 开启连接
		connection.start();
		
		// 4. 创建Session对象
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		
		// 5. 使用Session创建一个Destination对象，此处创建话题Topic
		Topic topic = session.createTopic("test-topic");
		
		// 6. 创建一个Producer
		MessageProducer messageProducer = session.createProducer(topic);
		
		// 7.创建一个Message对象
		TextMessage textMessage = session.createTextMessage("This is my first topic message!");
		
		// 8.使用Producer发送消息
		messageProducer.send(textMessage);
		
		// 9.关闭资源
		messageProducer.close();
		session.close();
		connection.close();
	}
}

消费者Consumer

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

public class TopicComsumerTest {
	@Test
	public void testQueueComsumer() throws Exception {
		// 1.创建连接工厂ConnectionFactory
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
				"tcp://192.168.110.129:61616");
		// 2.创建连接
		Connection connection = connectionFactory.createConnection();
		
		// 3.启动
		connection.start();
		
		// 4.创建session
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		
		// 5.创建destination，注意名称要与生产端一致
		Topic topic = session.createTopic("test-topic");
		
		// 6.创建消费者
		MessageConsumer comsumer = session.createConsumer(topic);
		
		// 7.接受消息，这里是对某一个Destination做监听，即test-topic
		comsumer.setMessageListener(new MessageListener() {
			
			@Override
			public void onMessage(Message message) {
				
				if(message instanceof TextMessage) {
					TextMessage text = (TextMessage) message;
					try {
						String myMsg = text.getText();
						// 8.打印消息This is my first point to point queue message!
						System.out.println(myMsg);
					} catch (JMSException e) {
						e.printStackTrace();
					}
				}
				
			}
			
		});
		System.out.println("消费者01...");
		// 9.等待键盘输入，不让进程退出
		System.in.read();
		
		// 10.关闭资源
		comsumer.close();
		session.close();
		connection.close();
	}
}

演示：
topic是与时间相关的，要先启动消费者，再启动生产者，不然演示不成功。这里不讨论持久化订阅者。

启动消费者01

启动消费者02（只需要改一下代码）

查看activemq
启动生产者
查看消费者01

查看消费者02

查看activemq

Spring整合ActiveMQ

生产者

测试类

import javax.annotation.Resource;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-activemq-send.xml")
public class ActiveMQProducer {
	
	@Resource(name="jmsTemplate")
	private JmsTemplate jmsTemplate;
	
	@Resource(name="queueDestination")
	private Queue queue;
	
	@Resource(name="topicDestination")
	private Topic topic; 
	
	@Resource(name="topicDestination1")
	private Topic topic1; 
	
	@Test
	public void testProducer() {
		testSendQueue();
		testSendTopic();
		testSendTopic1();
	}
	
	@Test
	public void testSendQueue() {
		jmsTemplate.send(queue, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				// 消息体根据业务变化
				TextMessage message = session.createTextMessage("This is my first queue with spring 支持中文!");
				return message;
			}
			
		});
	}
	
	@Test
	public void testSendTopic() {
		
		jmsTemplate.send(topic, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				// 消息体根据业务变化
				TextMessage message = session.createTextMessage("This is my first topic with spring 支持中文!");
				return message;
			}
			
		});
		
	}
	
	@Test
	public void testSendTopic1() {
		
		jmsTemplate.send(topic1, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				// 消息体根据业务变化
				TextMessage message = session.createTextMessage("This is my first topic1 with spring 支持中文!");
				return message;
			}
			
		});
		
	}
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
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-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
	<!-- 真正的可以产生connection的connectionFactory，有JMS服务商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://192.168.110.129:61616"/>
	</bean>
	<!-- spring用于管理真正connectionFactory的connectionFactory -->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
	</bean>
	
	<!-- 发送 -->
	<!-- spring提供的JMS工具类 -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<property name="connectionFactory" ref="connectionFactory"/>
	</bean>
	<!-- 配置消息的Destination对象 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg name="name" value="myQueue"></constructor-arg>
	</bean>
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg name="name" value="myTopic"></constructor-arg>
	</bean>
		<bean id="topicDestination1" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg name="name" value="myTopic1"></constructor-arg>
	</bean>
</beans>

消费者

测试类（加载spring配置，阻塞即可）

import java.io.IOException;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-activemq-receive.xml")
public class ActiveMQComsumer {
	
	@Test
	public void testComsumer() throws IOException {
		System.in.read();
	}
}

监听器

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

public class MyQueueMessageListener implements MessageListener {
	@Override
	public void onMessage(Message message) {
		if(message instanceof TextMessage) {
			try {
				TextMessage text = (TextMessage) message;
				String msg = text.getText();
				System.out.println(msg);
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}

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

public class MyMessageListener implements MessageListener {
	@Override
	public void onMessage(Message message) {
		if(message instanceof TextMessage) {
			try {
				TextMessage text = (TextMessage) message;
				String msg = text.getText();
				System.out.println(msg);
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}

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

public class MyMessageListener1 implements MessageListener {
	@Override
	public void onMessage(Message message) {
		if(message instanceof TextMessage) {
			try {
				TextMessage text = (TextMessage) message;
				String msg = text.getText();
				System.out.println(msg);
			} catch (JMSException e) {
				e.printStackTrace();
			}
		}
	}
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
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-4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
	
	<!-- 真正的可以产生connection的connectionFactory，有JMS服务商提供 -->
	<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
		<property name="brokerURL" value="tcp://192.168.110.129:61616"/>
	</bean>
	<!-- spring用于管理真正connectionFactory的connectionFactory -->
	<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
		<property name="targetConnectionFactory" ref="targetConnectionFactory"/>
	</bean>
	
	<!-- 配置消息的Destination对象 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg name="name" value="myQueue"></constructor-arg>
	</bean>
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg name="name" value="myTopic"></constructor-arg>
	</bean>
	<bean id="topicDestination1" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg name="name" value="myTopic1"></constructor-arg>
	</bean>
	
	<!-- 接收 -->
	<!-- 配置监听器 -->
	<bean id="myQueueListener" class="com.yp.activemqSpring.MyQueueMessageListener"/>
	<bean id="myMessageListener" class="com.yp.activemqSpring.MyMessageListener"/>
	<bean id="myMessageListener1" class="com.yp.activemqSpring.MyMessageListener1"/>
	<!-- 消息监听容器 -->
	<bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="queueDestination" />
		<property name="messageListener" ref="myQueueListener" />
	</bean>
	<bean id="topicListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="topicDestination" />
		<property name="messageListener" ref="myMessageListener" />
	</bean>
	<bean id="topicListenerContainer1" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="topicDestination1" />
		<property name="messageListener" ref="myMessageListener1" />
	</bean>
</beans>