ActiveMQ入门+简单应用

最新推荐文章于 2023-07-10 15:59:52 发布

努力的程序员先生

最新推荐文章于 2023-07-10 15:59:52 发布

阅读量210

点赞数

分类专栏： Java编程文章标签： ActiveMQ

本文链接：https://blog.csdn.net/qq_39636602/article/details/94502671

版权

Java编程专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、消息中间件概述

消息中间件产生的背景：
　　在客户端与服务器进行通讯时，客户端调用后，必须等待服务器对象完成处理返回结果才能继续执行。
　　客户端与服务器对象的生命周期紧密耦合，客户端进程和服务器对象进程都都必须正常运行;如果由于服务器对象崩溃或者网络故障导致用户的请求不可达,客户端会收到异常。
　　点对点通信: 客户端的一次调用只发送给某个单独的目标对象。
什么是消息中间件？
　　面向消息的中间件(MessageOrlented MiddlewareMOM)较好的解决了以上问题。发送者将消息发送给消息服务器，消息服务器将消感存放在若干队列中，在合适的时候再将消息转发给接收者。
　　这种模式下，发送和接收是异步的，发送者无需等待; 二者的生命周期未必相同: 发送消息的时候接收者不一定运行，接收消息的时候发送者也不一定运行;一对多通信: 对于一个消息可以有多个接收者。
　　PS：消息中间件默认是异步通讯，基于生产者消费者模式，类似于多线程通讯中的wait()、notify()模型。

二、JMS介绍

什么是JMS？
JMS是java的消息服务，JMS的客户端之间可以通过JMS服务进行异步的消息传输。
什么是消息模型？
消息模型即点对点和发布订阅模型。
1. Point-to-Point(P2P) — 点对点
  1. P2P模式图：
  2. 涉及到的概念：
    1.消息队列（Queue）。
    2.发送者(Sender)。
    3.接收者(Receiver)。
    每个消息都被发送到一个特定的队列，接收者从队列中获取消息。队列保留着消息，直到他们被消费或超时。
  3. P2P的特点：
    1.每个消息只有一个消费者（Consumer）(即一旦被消费，消息就不再在消息队列中)。
    2.发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有正在运行，它不会影响到消息被发送到队列。
    3.接收者在成功接收消息之后需向队列应答成功。
    如果你希望发送的每个消息都应该被成功处理的话，那么你需要P2P模式。
  4. 应用场景：
    A用户与B用户发送消息。
2. Publish/Subscribe(Pub/Sub)— 发布订阅
  1. Pub/Sub模式图：
  2. 涉及到的概念：
    1.主题（Topic）
    2.发布者（Publisher）
    3.订阅者（Subscriber）
    客户端将消息发送到主题。多个发布者将消息发送到Topic,系统将这些消息传递给多个订阅者。
  3. Pub/Sub的特点：
    1.每个消息可以有多个消费者。
    2.发布者和订阅者之间有时间上的依赖性。针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息，而且为了消费消息，订阅者必须保持运行的状态。
    3.为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。
    如果你希望发送的消息可以不被做任何处理、或者被一个消息者处理、或者可以被多个消费者处理的话，那么可以采用Pub/Sub模型。
  4. 消息的消费：
    JMS的消费者可以通过两种方式来消费消息：
    1.同步：
    订阅者或接收者调用receive方法来接收消息，receive方法在能够接收到消息之前（或超时之前）将一直阻塞。
    2.异步：
    订阅者或接收者可以注册为一个消息监听器。当消息到达之后，系统自动调用监听器的onMessage方法。
  5. 应用场景：
    用户注册、订单修改库存、日志存储等。
    1.用户注册传统模式与消息队列模式比较图：
    
    2.互联网电商的订单修改库存系统使用消息中间件模式图：

三、MQ产品的分类

RabbitMQ（常用）
　　是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP。也正是如此，使的它变的非常重量级，更适合于企业级的开发。同时实现了一个经纪人(Broker)构架，这意味着消息在发送给客户端时先在中心队列排队。对路由(Routing)，负载均衡(Load balance)或者数据持久化都有很好的支持。
Redis
　　是一个Key-Value的NoSQL数据库，开发维护很活跃，虽然它是一个Key-Value数据库存储系统，但它本身支持MQ功能，所以完全可以当做一个轻量级的队列服务来使用。对于RabbitMQ和Redis的入队和出队操作，各执行100万次，每10万次记录一次执行时间。测试数据分为128Bytes、512Bytes、1K和10K四个不同大小的数据。实验表明：入队时，当数据比较小时Redis的性能要高于RabbitMQ，而如果数据大小超过了10K，Redis则慢的无法忍受；出队时，无论数据大小，Redis都表现出非常好的性能，而RabbitMQ的出队性能则远低于Redis。
ZeroMQ
　　号称最快的消息队列系统，尤其针对大吞吐量的需求场景。ZMQ能够实现RabbitMQ不擅长的高级/复杂的队列，但是开发人员需要自己组合多种技术框架，技术上的复杂度是对这MQ能够应用成功的挑战。ZeroMQ具有一个独特的非中间件的模式，你不需要安装和运行一个消息服务器或中间件，因为你的应用程序将扮演了这个服务角色。你只需要简单的引用ZeroMQ程序库，可以使用NuGet安装，然后你就可以愉快的在应用程序之间发送消息了。但是ZeroMQ仅提供非持久性的队列，也就是说如果down机，数据将会丢失。其中，Twitter的Storm中使用ZeroMQ作为数据流的传输。
ActiveMQ（常用）
　　是Apache下的一个子项目。类似于ZeroMQ，它能够以代理人和点对点的技术实现队列。同时类似于RabbitMQ，它少量代码就可以高效地实现高级应用场景。
Jafka/Kafka（常用）
　　Kafka是Apache下的一个子项目，是一个高性能跨语言分布式Publish/Subscribe消息队列系统，而Jafka是在Kafka之上孵化而来的，即Kafka的一个升级版。具有以下特性：快速持久化，可以在O(1)的系统开销下进行消息持久化；高吞吐，在一台普通的服务器上既可以达到10W/s的吞吐速率；完全的分布式系统，Broker、Producer、Consumer都原生自动支持分布式，自动实现负载均衡；支持Hadoop数据并行加载，对于像Hadoop的一样的日志数据和离线分析系统，但又要求实时处理的限制，这是一个可行的解决方案。Kafka通过Hadoop的并行加载机制来统一了在线和离线的消息处理。Apache Kafka相对于ActiveMQ是一个非常轻量级的消息系统，除了性能非常好之外，还是一个工作良好的分布式系统。

PS：RabbitMQ、ZeroMQ、ActiveMQ均支持常用的多种语言客户端 C++、Java、.Net,、Python、 Php、 Ruby等。
　　其他一些队列列表HornetQ、Apache Qpid、Sparrow、Starling、Kestrel、Beanstalkd、Amazon SQS不再一一分析。

四、ActiveMQ的使用

window环境下安装 ActiveMQ：
ActiveMQ部署其实很简单，和所有Java一样，要跑java程序就必须先安装JDK并配置好环境变量，这个很简单。
然后解压下载的apache-activemq---*-bin.zip压缩包到一个目录，得到解压后的目录结构如下图：

进入bin目录，发现有win32和win64两个文件夹，这2个文件夹分别对应windows32位和windows64位操作系统的启动脚本。

XP系统直接点击上述图片中的activemq.bat，若不是XP，则根据计算机运算位数选择相应目录，进入后点击相同文件，出现下图的关键字“access”表示运行成功。

ActiveMQ默认启动到8161端口，启动完了后在浏览器地址栏输入：http://localhost:8161/admin 要求输入用户名密码，默认用户名密码为admin、admin，这个用户名密码是在conf/users.properties中配置的。输入用户名密码后便可看到如下图的ActiveMQ控制台界面了。

实现点对点通讯模式：
使用ActiveMQ完成点对点（p2p）通讯模式。

创建maven项目，引入依赖：

<dependencies>
	<dependency>
		<groupId>org.apache.activemq</groupId>
		<artifactId>activemq-core</artifactId>
		<version>5.7.0</version>
	</dependency>
</dependencies>

生产者模式代码实现：

package chauncy.producter;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

/**   
 * @classDesc: 功能描述(使用点对点通信生产者模式)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class Producter {
	
	private static final String USERNAME="admin";
	private static final String PASSWORD="admin";
	private static final String BROKERURL="tcp://127.0.0.1:61616";
	private static final String QUEUENAME="myQueue";
	
	public static void main(String[] args) throws JMSException {
		start();
	}
	
	static	public void start() throws JMSException{
		//ConnectionFactory ：连接工厂，JMS 用它创建连接
		ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(USERNAME,PASSWORD,BROKERURL);
		//创建JMS客户端到JMS Provider 的连接
		Connection connection = activeMQConnectionFactory.createConnection();
		//启动连接
		connection.start();
		//Session： 一个发送或接收消息的线程 |第一个参数：是否要事务；第二个参数，jms设置消息的可靠性，示例为：自动签收
		Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
		//设置队列名称，创建队列，队列名称就是入口。
		Queue queue = session.createQueue(QUEUENAME);
		//创建一个生产者
		MessageProducer producer = session.createProducer(queue);
		//设置不持久化
		producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
		//发送一条消息
		for (int i = 1; i <= 5; i++) {
			sendMsg(session, producer, i);
		}
		//设置存放消息队列内容
		//TextMessage textMessage = session.createTextMessage("hello world");
		//producer.send(textMessage);
		session.close();
		//关闭连接
		connection.close();
		System.out.println("消息队列存放内容成功！");
	}
	
	/**
	 * 在指定的会话上，通过指定的消息生产者发出一条消息
	 * 
	 * @param session
	 *            消息会话
	 * @param producer
	 *            消息生产者
	 */
	public static void sendMsg(Session session, MessageProducer producer, int i) throws JMSException {
		// 创建一条文本消息
		TextMessage message = session.createTextMessage("Hello ActiveMQ！" + i);
		// 通过消息生产者发出消息
		producer.send(message);
	}

}

消费者模式代码实现：

package chauncy.consumer;

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

import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * @classDesc: 功能描述(使用点对点通信消费者模式)  
 * @author: ChauncyWang  
 * @version: 1.0
 */
public class Consumer {
	private static final String USERNAME="admin";
	private static final String PASSWORD="admin";
	private static final String BROKERURL="tcp://127.0.0.1:61616";
	private static final String QUEUENAME="myQueue";
	
	public static void main(String[] args) throws JMSException {
		receiver();
	}
	
	static public void receiver() throws JMSException{
		//ConnectionFactory ：连接工厂，JMS 用它创建连接
		ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(USERNAME,PASSWORD,BROKERURL);
		//创建JMS客户端到JMS Consumer 的连接
		Connection connection = activeMQConnectionFactory.createConnection();
		//启动连接
		connection.start();
		//Session： 一个发送或接收消息的线程 |第一个参数：是否要事务；第二个参数，jms设置消息的可靠性，示例为：自动签收
		Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
		//设置队列名称，创建队列，队列名称就是入口。
		Queue queue = session.createQueue(QUEUENAME);
		//创建一个消费者，消息接收者
		MessageConsumer consumer = session.createConsumer(queue);
		while (true) {
			TextMessage message = (TextMessage) consumer.receive();
			if (message != null) {
				System.out.println("收到消息：" + message.getText());
				session.commit();
			} else
				break;
		}
		session.close();
		connection.close();
	}
}

JMS消息可靠机制：
ActiveMQ消息签收机制：
客戶端成功接收一条消息的标志是一条消息被签收，成功应答。
消息的签收情形分两种：
1. 带事务的session（生产者和消费者都需要commit否则不会提交也不会消费）：
  如果session带有事务，并且事务成功提交，则消息被自动签收。如果事务回滚，则消息会被再次传送。
2. 不带事务的session：
  不带事务的session的签收方式，取决于session的配置。
Activemq支持以下三种签收模式：
1. Session.AUTO_ACKNOWLEDGE 消息自动签收。(注：这种方式不安全，在并发情况下可能出现消息被重复签收。)
2. Session.CLIENT_ACKNOWLEDGE 客戶端调用acknowledge方法手动签收（为了保证分布式情况下mq的幂等性，建议使用手动签收模式）
  textMessage.acknowledge();//手动签收
3. Session.DUPS_OK_ACKNOWLEDGE 不是必须签收，消息可能会重复发送。在第二次重新传送消息的时候，消息
  只有在被确认之后，才认为已经被成功地消费了。消息的成功消费通常包含三个阶段：客户接收消息、客户处理消息和消息被确认。在事务性会话中，当一个事务被提交的时候，确认自动发生。在非事务性会话中，消息何时被确认取决于创建会话时的应答模式（acknowledgement mode）。
PS：幂等性：就是不能重复，唯一主键。怎么保证分布式环境下mq的幂等性？1>使用手动签收模式。2>使用Message ID唯一主键进行区分。3>使用日志记录。

实现发布订阅通信模式：
发布订阅通信和点对点通信代码的代码区别：只是从session中创建的消息中间件不同，点对点创建Queue，发布订阅创建Topic。

生产者模式实现：

package chauncy.producter;

import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

/**   
 * @classDesc: 功能描述(使用发布订阅通信生产者模式)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class PublishProducter {
	private static final String USERNAME="admin";
	private static final String PASSWORD="admin";
	private static final String BROKERURL="tcp://127.0.0.1:61616";
	private static final String TOPICNAME="myTopic";
	
	public static void main(String[] args) throws JMSException {
		start();
	}
	
	static	public void start() throws JMSException{
		//ConnectionFactory ：连接工厂，JMS 用它创建连接
		ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(USERNAME,PASSWORD,BROKERURL);
		//创建JMS客户端到JMS Provider 的连接
		Connection connection = activeMQConnectionFactory.createConnection();
		//启动连接
		connection.start();
		//Session： 一个发送或接收消息的线程 |第一个参数：是否要事务，如果为true，每生产一个消息都需要进行commit一下；第二个参数，jms设置消息的可靠性，示例为：自动签收
		Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
		//创建一个主题
		Topic topic = session.createTopic(TOPICNAME);
		//创建一个生产者
		MessageProducer producer = session.createProducer(topic);
		//设置不持久化
		producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
		//发送一条消息
		for (int i = 1; i <= 5; i++) {
			sendMsg(session, producer, i);
		}
		//设置存放消息队列内容
		//TextMessage textMessage = session.createTextMessage("hello world");
		//producer.send(textMessage);
		session.close();
		//关闭连接
		connection.close();
		System.out.println("消息队列存放内容成功！");
	}
	
	/**
	 * 在指定的会话上，通过指定的消息生产者发出一条消息
	 * 
	 * @param session
	 *            消息会话
	 * @param producer
	 *            消息生产者
	 */
	public static void sendMsg(Session session, MessageProducer producer, int i) throws JMSException {
		// 创建一条文本消息
		TextMessage message = session.createTextMessage("Hello ActiveMQ！" + i);
		// 通过消息生产者发出消息
		producer.send(message);
		//session.commit();
	}
}

消费者模式实现：

package chauncy.consumer;

import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

/**   
 * @classDesc: 功能描述(使用发布订阅通信消费者模式)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class SubscribeConsumer {
	private static final String USERNAME="admin";
	private static final String PASSWORD="admin";
	private static final String BROKERURL="tcp://127.0.0.1:61616";
	private static final String TOPICNAME="myTopic";
	
	public static void main(String[] args) throws JMSException {
		receiver();
	}
	
	static public void receiver() throws JMSException{
		//ConnectionFactory ：连接工厂，JMS 用它创建连接
		ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(USERNAME,PASSWORD,BROKERURL);
		//创建JMS客户端到JMS Consumer 的连接
		Connection connection = activeMQConnectionFactory.createConnection();
		//启动连接
		connection.start();
		//Session： 一个发送或接收消息的线程 |第一个参数：是否要事务；第二个参数，jms设置消息的可靠性，示例为：自动签收
		Session session = connection.createSession(Boolean.FALSE, Session.CLIENT_ACKNOWLEDGE);
		//创建一个主题
		Topic topic = session.createTopic(TOPICNAME);
		//创建一个消费者，消息接收者
		MessageConsumer consumer = session.createConsumer(topic);
		while (true) {
			TextMessage message = (TextMessage) consumer.receive();
			if (message != null) {
				System.out.println("收到消息：" + message.getText());
				//session.commit();
				//手动签收方式需要手动应答
				message.acknowledge();
			} else
				break;
		}
		session.close();
		connection.close();
	}
}

SpringBoot整合ActiveMQ：
创建两个系统，一个系统充当生产者，一个系统充当消费者，模拟点对点模式进行一对一发送消息。

生产者系统实现：

创建maven工程，引入依赖：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.4.RELEASE</version>
	<relativePath /> <!-- lookup parent from repository -->
</parent>
<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	<java.version>1.8</java.version>
</properties>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<!-- spring boot web支持：mvc,aop... -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-activemq</artifactId>
	</dependency>
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>fastjson</artifactId>
		<version>1.2.58</version>
	</dependency>
</dependencies>
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

创建yml配置文件：

spring:
  activemq:
    broker-url: tcp://127.0.0.1:61616
    user: admin
    password: admin
queue: mySpringBootQueue

创建队列配置类QueueConfig：

package chauncy.config;

import javax.jms.Queue;

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QueueConfig {
	@Value("${queue}")
	private String queue;

	@Bean
	public Queue logQueue() {
		return new ActiveMQQueue(queue);
	}
}

创建生产者模式实现类Producter：

package chauncy.entity;

public class UserEntity {
	private Long id;
	private String name;
	private Integer age;

	public UserEntity(Long id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

}

package chauncy.producter;

import java.util.UUID;

import javax.jms.Queue;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;

import chauncy.entity.UserEntity;

/**
 * 
 * @classDesc: 功能描述(点对点通信模式生产者代码)
 * @author: ChauncyWang
 * @version: 1.0
 */
@Component
@EnableScheduling
public class Producter {

	@Autowired
	private JmsMessagingTemplate jmsMessagingTemplate;
	
	@Autowired
	private Queue queue;

	private int age = 18;

	@Scheduled(fixedDelay = 5000)
	public void send() {
		age++;
		UserEntity userEntity = new UserEntity(System.currentTimeMillis(), UUID.randomUUID().toString(), age);
		String jsonString = new JSONObject().toJSONString(userEntity);
		System.out.println("json:" + jsonString);
		jmsMessagingTemplate.convertAndSend(queue, jsonString);
	}
}

创建启动类进行启动：

package chauncy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class APP {
	public static void main(String[] args) {
		SpringApplication.run(APP.class, args);
	}
}

消费者系统实现：

创建maven工程，引入依赖：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.4.RELEASE</version>
	<relativePath /> <!-- lookup parent from repository -->
</parent>
<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	<java.version>1.8</java.version>
</properties>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<!-- spring boot web支持：mvc,aop... -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-activemq</artifactId>
	</dependency>
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>fastjson</artifactId>
		<version>1.2.58</version>
	</dependency>
</dependencies>
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

创建yml配置文件：

spring:
  activemq:
    broker-url: tcp://127.0.0.1:61616
    user: admin
    password: admin
queue: mySpringBootQueue
server: 
	port: 8081

创建消费者模式实现类Consumer：

package chauncy.entity;

public class UserEntity {
	private Long id;
	private String name;
	private Integer age;

	public UserEntity(Long id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "UserEntity [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	
}

package chauncy.consumer;

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;

import chauncy.entity.UserEntity;

/**   
 * @classDesc: 功能描述(点对点通信模式消费者代码)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
@Component
public class Consumer {
	
	@JmsListener(destination="${queue}")
	public void receive(String msg){
		System.out.println(msg);
		UserEntity userEntity = new JSONObject().parseObject(msg,UserEntity.class);
		System.out.println(userEntity.toString());
	}
}

创建启动类进行启动：

package chauncy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class APP {
	public static void main(String[] args) {
		SpringApplication.run(APP.class, args);
	}
}

注：MQ的原理就是底层使用socket的tcp模式通讯，类似于多线程的wait()、notify()，生产一个消费一个。

努力的程序员先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ActiveMQ入门+简单应用

一、消息中间件概述消息中间件产生的背景：　　在客户端与服务器进行通讯时.客户端调用后，必须等待服务对象完成处理返回结果才能继续执行。　　客户与服务器对象的生命周期紧密耦合,客户进程和服务对象进程都都必须正常运行;如果由于服务对象崩溃或者网络故障导致用户的请求不可达,客户会受到异常。　　点对点通信: 客户的一次调用只发送给某个单独的目标对象。什么是消息中间件？　　面向消息的中间件(Me...
复制链接

扫一扫