ActiveMQ的简单使用

最新推荐文章于 2024-01-15 22:11:21 发布

沙滩上的漫步者

最新推荐文章于 2024-01-15 22:11:21 发布

阅读量425

点赞数

分类专栏：杂记

本文链接：https://blog.youkuaiyun.com/Alano1994/article/details/93916542

版权

杂记专栏收录该内容

2 篇文章

订阅专栏

Apache ActiveMQ是Apache出品的消息中间件，本文介绍了ActiveMQ的基本概念、安装过程以及常用对象。讲解了JMS（Java Message Service）的点对点和发布/订阅两种消息模式。此外，还提及了ActiveMQ整合Spring的配置以及Kafka的分布式流处理平台特性。

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

1 ActiveMQ介绍

1.1 什么是ActiveMQ

ActiveMQ是Apache出品的一个消息中间件，常用的消息对列主要有ActiveMQ，RabbitMQ，Kafka等，队列的主要作用是消除高并发访问高峰，加快网站的响应速度。在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景

1.2 JMS介绍

JMS的全称是Java Message Service，即Java消息服务。用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息，并进行发送，对应的消费者在接收到对应的消息后去完成对应的业务逻辑。

对于消息的传递有两种类型：

一种是点对点的，即一个生产者和一个消费者一一对应；
- 一个生产者向一个特定的队列发布消息，一个消费者从该队列中读取消息。这里，生产者知道消费者的队列，并直接将消息发送到消费者的队列。这种模式被概括为：只有一个消费者将获得消息。生产者不需要在接收者消费该消息期间处于运行状态，接收者也同样不需要在消息发送时处于运行状态。每一个成功处理的消息都由接收者签收。
另一种是发布/订阅模式，即一个生产者产生消息并进行发送后，可以由多个消费者进行接收。
- 支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。这种模式被概括为：多个消费者可以获得消息.在发布者和订阅者之间存在时间依赖性。发布者需要建立一个订阅（subscription），以便客户能够购订阅。订阅者必须保持持续的活动状态以接收消息。

2 ActiveMQ的安装

2.1 下载

进入http://activemq.apache.org/下载ActiveMQ

1561640870612

2.2 安装

安装步骤：

第一步：安装jdk，需要jdk1.7以上版本

第二步：解压缩activeMQ的压缩包。

第三步：进入bin目录。

启动：[root@localhost bin]# ./activemq start

停止：[root@localhost bin]# ./activemq stop

注意：如果ActiveMQ整合spring使用不要使用activemq-all-5.12.0.jar包。建议使用5.11.2

第四步：访问后台管理。

http://ip地址:8161/admin

用户名：admin

密码：admin

3 常用对象介绍

ConnectionFactory 接口（连接工厂）

用户用来创建到JMS提供者的连接的被管对象。JMS客户通过可移植的接口访问连接，这样当下层的实现改变时，代码不需要进行修改。管理员在JNDI名字空间中配置连接工厂，这样，JMS客户才能够查找到它们。根据消息类型的不同，用户将使用队列连接工厂，或者主题连接工厂。

Connection 接口（连接）

连接代表了应用程序和消息服务器之间的通信链路。在获得了连接工厂后，就可以创建一个与JMS提供者的连接。根据不同的连接类型，连接允许用户创建会话，以发送和接收队列和主题到目标。

Destination 接口（目标）

目标是一个包装了消息目标标识符的被管对象，消息目标是指消息发布和接收的地点，或者是队列，或者是主题。JMS管理员创建这些对象，然后用户通过JNDI发现它们。和连接工厂一样，管理员可以创建两种类型的目标，点对点模型的队列，以及发布者／订阅者模型的主题。

MessageConsumer 接口（消息消费者）

由会话创建的对象，用于接收发送到目标的消息。消费者可以同步地（阻塞模式），或异步（非阻塞）接收队列和主题类型的消息。

MessageProducer 接口（消息生产者）

由会话创建的对象，用于发送消息到目标。用户可以创建某个目标的发送者，也可以创建一个通用的发送者，在发送消息时指定目标。

Message 接口（消息）

是在消费者和生产者之间传送的对象，也就是说从一个应用程序创送到另一个应用程序。一个消息有三个主要部分：

Session 接口（会话）

表示一个单线程的上下文，用于发送和接收消息。由于会话是单线程的，所以消息是连续的，就是说消息是按照发送的顺序一个一个接收的。会话的好处是它支持事务。如果用户选择了事务支持，会话上下文将保存一组消息，直到事务被提交才发送这些消息。在提交事务之前，用户可以使用回滚操作取消这些消息。一个会话允许用户创建消息生产者来发送消息，创建消息消费者来接收消息。

4 消息的使用

添加依赖

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

1:queue

创建生产者

@Test
	public void testQueueProducer() throws Exception {
		// 第一步：创建ConnectionFactory对象，需要指定服务端ip及端口号。
		//brokerURL服务器的ip及端口号
		ConnectionFactory connectionFactory = new 					ActiveMQConnectionFactory("tcp://192.168.25.168:61616");
		// 第二步：使用ConnectionFactory对象创建一个Connection对象。
		Connection connection = connectionFactory.createConnection();
		// 第三步：开启连接，调用Connection对象的start方法。
		connection.start();
		// 第四步：使用Connection对象创建一个Session对象。
		//第一个参数：是否开启事务。true：开启事务，第二个参数忽略。
		//第二个参数：当第一个参数为false时，才有意义。消息的应答模式。1、自动应答2、手动应答。一般是自动应答。
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		// 第五步：使用Session对象创建一个Destination对象（topic、queue），此处创建一个Queue对象。
		//参数：队列的名称。
		Queue queue = session.createQueue("test-queue");
		// 第六步：使用Session对象创建一个Producer对象。
		MessageProducer producer = session.createProducer(queue);
		// 第七步：创建一个Message对象，创建一个TextMessage对象。
		/*TextMessage message = new ActiveMQTextMessage();
		message.setText("hello activeMq,this is my first test.");*/
		TextMessage textMessage = session.createTextMessage("hello activeMq,this is my first test.");
		// 第八步：使用Producer对象发送消息。
		producer.send(textMessage);
		// 第九步：关闭资源。
		producer.close();
		session.close();
		connection.close();
	
    }

创建消费者

publicclass QueueConsumer {
 
     public static void main(String[]args) {
         //创建一连接工厂
         ConnectionFactory connectionFactory  = new ActiveMQConnectionFactory("tcp://192.168.25.168:61616");
         try {
              //创建一个连接
              Connection connection = connectionFactory.createConnection();
              //打开连接
              connection.start();
              //创建一个回话
              Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
              //创建一个目的地Destination
              Queue queue = session.createQueue("test-queue");
              //创建一个消费者
              MessageConsumer consumer = session.createConsumer(queue);
             while(true) {
                  //设置接收者接收消息的时间，为了便于测试，这里定为100s
                  Messagemessage =consumer.receive(100000);
                  if (message !=null) {
                       System.out.println(message);
                   }else {
                      //超时结束
                      break;
                   }
              }
              consumer.close();
              session.close();
              connection.close();
         } catch (Exceptione) {
              e.printStackTrace();
         }
        
     }
}

2:Topic

创建生产者

@Test
	public void testTopicProducer() throws Exception {
		// 第一步：创建ConnectionFactory对象，需要指定服务端ip及端口号。
		// brokerURL服务器的ip及端口号
		ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.168:61616");
		// 第二步：使用ConnectionFactory对象创建一个Connection对象。
		Connection connection = connectionFactory.createConnection();
		// 第三步：开启连接，调用Connection对象的start方法。
		connection.start();
		// 第四步：使用Connection对象创建一个Session对象。
		// 第一个参数：是否开启事务。true：开启事务，第二个参数忽略。
		// 第二个参数：当第一个参数为false时，才有意义。消息的应答模式。1、自动应答2、手动应答。一般是自动应答。
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		// 第五步：使用Session对象创建一个Destination对象（topic、queue），此处创建一个topic对象。
		// 参数：话题的名称。
		Topic topic = session.createTopic("test-topic");
		// 第六步：使用Session对象创建一个Producer对象。
		MessageProducer producer = session.createProducer(topic);
		// 第七步：创建一个Message对象，创建一个TextMessage对象。
		/*
		 * TextMessage message = new ActiveMQTextMessage(); message.setText(
		 * "hello activeMq,this is my first test.");
		 */
		TextMessage textMessage = session.createTextMessage("hello activeMq,this is my topic test");
		// 第八步：使用Producer对象发送消息。
		producer.send(textMessage);
		// 第九步：关闭资源。
		producer.close();
		session.close();
		connection.close();
	
    }

创建消费者

@Test
     public void testTopicConsumer() throws Exception {
         // 第一步：创建一个ConnectionFactory对象。
         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.168:61616");
         // 第二步：从ConnectionFactory对象中获得一个Connection对象。
         Connection connection = connectionFactory.createConnection();
         // 第三步：开启连接。调用Connection对象的start方法。
         connection.start();
         // 第四步：使用Connection对象创建一个Session对象。
         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
         // 第五步：使用Session对象创建一个Destination对象。和发送端保持一致topic，并且话题的名称一致。
         Topic topic = session.createTopic("test-topic");
         // 第六步：使用Session对象创建一个Consumer对象。
         MessageConsumer consumer = session.createConsumer(topic);
         // 第七步：接收消息。
         consumer.setMessageListener(new MessageListener() {
 
              @Override
              public void onMessage(Message message) {
                   try {
                       TextMessage textMessage = (TextMessage) message;
                       String text = null;
                       // 取消息的内容
                       text = textMessage.getText();
                       // 第八步：打印消息。
                       System.out.println(text);
                   } catch (JMSException e) {
                       e.printStackTrace();
                   }
              }
         });
         System.out.println("topic的消费端03。。。。。");
         // 等待键盘输入
         System.in.read();
         // 第九步：关闭资源
         consumer.close();
         session.close();
         connection.close();
     
     }

5 ActiveMQ整合Spring

引用相关的jar包。

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
</dependency>
<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
</dependency>

配置Activemq整合spring。配置ConnectionFactory

<?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.25.168:61616" />
	</bean>
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="targetConnectionFactory" />
	</bean>
</beans>

配置生产者

使用JMSTemplate对象。发送消息。

在spring容器中配置Destination。

<?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.25.168:61616" />
	</bean>
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="targetConnectionFactory" />
	</bean>
	<!-- 配置生产者 -->
	<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
		<property name="connectionFactory" ref="connectionFactory" />
	</bean>
	<!--这个是队列目的地，点对点的 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg>
			<value>spring-queue</value>
		</constructor-arg>
	</bean>
	<!--这个是主题目的地，一对多的 -->
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg value="topic" />
	</bean>
</beans>

代码测试
- 生产者

@Test
	public void testQueueProducer() throws Exception {
		// 第一步：初始化一个spring容器
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-activemq.xml");
		// 第二步：从容器中获得JMSTemplate对象。
		JmsTemplate jmsTemplate = applicationContext.getBean(JmsTemplate.class);
		// 第三步：从容器中获得一个Destination对象
		Queue queue = (Queue) applicationContext.getBean("queueDestination");
		// 第四步：使用JMSTemplate对象发送消息，需要知道Destination
		jmsTemplate.send(queue, new MessageCreator() {
			
			@Override
			public Message createMessage(Session session) throws JMSException {
				TextMessage textMessage = session.createTextMessage("spring activemq test");
				return textMessage;
			}
		});
	}

-----消费者
public class MyMessageListener implements MessageListener {

   @Override
   public void onMessage(Message message) {
   	
   	try {
   		TextMessage textMessage = (TextMessage) message;
   		//取消息内容
   		String text = textMessage.getText();
   		System.out.println(text);
   	} catch (JMSException e) {
   		e.printStackTrace();
   	}

配置spring和Activemq整合

<?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.25.168:61616" />
	</bean>
	<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.SingleConnectionFactory">
		<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
		<property name="targetConnectionFactory" ref="targetConnectionFactory" />
	</bean>
	<!--这个是队列目的地，点对点的 -->
	<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg>
			<value>spring-queue</value>
		</constructor-arg>
	</bean>
	<!--这个是主题目的地，一对多的 -->
	<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
		<constructor-arg value="topic" />
	</bean>
	<!-- 接收消息 -->
	<!-- 配置监听器 -->
	<bean id="myMessageListener" class="com.taotao.search.listener.MyMessageListener" />
	<!-- 消息监听容器 -->
	<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="connectionFactory" />
		<property name="destination" ref="queueDestination" />
		<property name="messageListener" ref="myMessageListener" />
	</bean>
</beans>

Kafka

Kafka是一个分布式流处理平台有四个核心API

Producer API —Producer 消息的生产者
Consumer API ---- —Producer 消息的消费者
Stream API
Connector API

Consumer Group
包含一个或者多个Consumer，同一个消息只会被同一个消费组中一个消费者实例处理
不同的消费组可以同时消费同一条数据

Kafka架构图

1561642103016

topic: 主题表示某一种类别的消息（订阅的一个服务）Kafka流中记录都是以Topic作为一个分类去管理。

partition： 分区, 一种类别的消息会根据自定义的分片数量进行hash分片，没一个分片中会按照时间戳的顺序维持一个队列。
Record： Kafka流中的一则消息一般包含key、value、time stamp

Kafka是通过Topic对Record做分类管理，通常一个Topic会有0~n个订阅者订阅。一旦在订阅的Topic下产生新的Record，所有的订阅者都将消费该消息。对于每一个Topic底层Kafka集群都会以分区的形式存储

Kafka将按照’log.retention.hours’配置保留所有发布过来的Record无论该Record是否被消费。Record记录在规定的时间内 ”log.retention.hours”配置时间(默认1周168小时)是可以被消费者消费的，一旦操过规定时间内没有消费者消费Kafka中的消息，该消息会被系统自动清除。由于kafka的分布式磁盘存储，将数据长时间保留在磁盘中是没有太大问题的。

事实上kafka会记录每一个消费者消费的消息的offset偏移量，该偏移量是由客户端所控制的。正常情况下Consumer消费一则消息后对应该消费的者的偏移量会自动加1，但事实上消费者可以自由的控制offset偏移量来实现消息的重复消费，各个消费者之间相互不影响。

所有消息在Kafka集群中按照分区存储目的是为了针对海量数据的存储，一个Topic表示用户所关心的一类消息，Topic可以有很多的分区，因此无需担心海量日志的存储，其次每个分区运行在独立的机器上（broker），因此也会从某种意义上提升系统的并行度。

**leader：**Leader负责分区所有读取和写入的节点。每个节点随机选择的分区中的领导者。

Kafka消息的日志数据是通过分区的形式分布在各个server之上，每个服务器负责接收和处理用户请求。每一个分区都会在集群节点上设置副本，每个副本都有一个Leader和0~n个follower。Leader负责接收读写请求，所有的Follower负责备份主机的数据。如果leader宕机了，其中的Follower会自动的做选举，选举出Leader。每一台服务器在集群中都会扮演着其中某一个Partition数据的Leader也会扮演着其他Partition数据的Follower的角色。

生产者

消息的生产者负责生产消息到他们选择的Topic中去，由生产者决定消息存储到哪一个Topic中的哪一个Partition当中，可以在生产者那边定义一个负载均衡用于实现消息发送的负载均衡策略，如何实现负载均衡后续章节再进行讨论。

消费者

消费者是通过group的概念对自己做标记。因为不同的Group消费者之间相互独立。如果隶属于一个Group中有多个消费者，则消息会在多个消费者之间负载均衡的形式被发送给组内的消费者；如果不是在一个组内的消费者之间是广播形式发送。