RabbitMQ学习总结

RabbitMQ

简介

消息中间件

什么是中间件呢？

　　非底层操作系统软件，非业务应用软件，不是直接给最终用户使用的，不能直接给客户带来价值的软件统称为中间件。

什么是消息中间件?

　　消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。

JMS

　　java消息服务(Java Message Service)即JMS，是一个Java平台中关于面向消息中间件的api，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

AMQP

　　AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制。

常见消息中间件

activeMQ（支持多语言，实现jms1.1，j2ee1.4规范），RabbitMQ（支持更多语言，基于AMQP规范），kafka(高吞吐量，分布式，分区,O(1)磁盘顺序提供消息持久化)。

 

RabbitMQ入门

安装及配置

RabbitMQ是建立在强大的Erlang OTP平台上，因此安装Rabbit MQ的前提是安装Erlang。

一、下载安装Erlang OTP

otp_win64_20.2.exe

Erlang 下载地址 ：http://www.erlang.org/downloads

二、下载安装RabbitMQ

rabbitmq-server-3.7.0.exe

下载地址 ：http://www.rabbitmq.com/install-windows.html

三、配置Erlang环境变量

配置ERLANG_HOME，值为安装路径

变量：ERLANG_HOME 值：D:\Program Files\erl9.2

path：D:\Program Files\erl9.2\bin

四、配置RabbitMQ环境变量

配置RABBIMQ_HOME，值为安装路径

变量：RABBIMQ_HOME值：D:\Program Files\RabbitMQ Server\rabbitmq_server-3.7.0

path：D:\Program Files\RabbitMQ Server\rabbitmq_server-3.7.0\sbin

五、测试Erlang和RabbitMQ是否安装成功

erlang

dos下输入erl，可看到版本信息，说明Elang安装成功。

RabbitMQ

开启插件

rabbitmq_managemen是管理后台的插件、我们要开启这个插件才能通过浏览器访问登录页面。

进入到sbin目录下：

rabbitmq-plugins enable rabbitmq_managemen

看到 enabled 3plugins表示插件安装成功。

启服务

进入到sbin目录下：

 

rabbitmq-server start

访问RabbitMQ管理页面

开启浏览器访问http://localhost:15672

SpringBoot整合RabbitMQ

简单模式

创建两个项目一个发送，另一个接收。

 

发送者（生产者）

1、添加依赖

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.cloud</groupId>

<artifactId>spring-cloud-starter-parent</artifactId>

<version>Brixton.SR3</version>

<type>pom</type>

<scope>import</scope>

</dependency>

</dependencies>

</dependencyManagement>

 

<dependencies>

<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>

<!-- MQ依赖 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-amqp</artifactId>

</dependency>

</dependencies>

 

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

2、程序入口

 

@SpringBootApplication

@EnableAutoConfiguration

public class SendApplication {

public static void main(String[] args) {

SpringApplication.run(SendApplication.class, args);

}

 

}

3、properties配置

 

server.port=8080

server.contextPath=/sender

spring.application.name=servera

#rabbit配置

spring.rabbitmq.host=127.0.0.1

spring.rabbitmq.port=5672

spring.rabbitmq.username=guest

spring.rabbitmq.password=guest

spring.rabbitmq.virtual-host=/

4、配置队列（注解）

 

@Configuration

public class MQConfiguration {

@Bean

public Queue queue() {

return new Queue("MyQueue");

}

}

5、发送消息

 

@Component

public class MySender {

@Autowired

private AmqpTemplate template;

 

public void send() {

template.convertAndSend("queue4", "消息");

}

}

6、测试接口

 

@RestController

public class TestRabbitMQ {

 

@Autowired

private MySender sender;

 

@RequestMapping("/sender")

public void sender() {

sender.send();

}

 

}

接收者（消费者）

1、添加依赖

同生产者一致！

2、程序入口

同生产者一致！

3、properties配置

同生产者一致！

4、接收消息

 

@Component

public class Receive {

 

@RabbitListener(queues = "MyQueue") // 监听器监听指定的Queue

public void process(String str) {

System.out.println("Receive:" + str);

}

 

}

测试

启动两个服务，调用测试接口进行测试。

对象支持

springboot以及完美的支持对象的发送和接收，不需要格外的配置。

 

//发送者

public void send(User user) {

System.out.println("Sender object: " + user.toString());

this.rabbitTemplate.convertAndSend("object", user);

}

 

...

 

//接受者

@RabbitHandler

public void process(User user) {

System.out.println("Receiver object : " + user);

}

竞争模式

创建两个接收者，监听同一个队列。两者争抢资源。

 

 

@Component

public class Receive {

 

@RabbitListener(queues = "MyQueue") // 监听器监听指定的Queue

public void process(String str) {

System.out.println("Receive:" + str);

}

 

}

 

@Component

public class ReceiveB {

 

@RabbitListener(queues = "MyQueue") // 监听器监听指定的Queue

public void process(String str) {

System.out.println("ReceiveB:" + str);

}

 

}

广播模式（Fanout Exchange）

　　Fanout 就是我们熟悉的发布订阅模式，给Fanout交换机发送消息，绑定了这个交换机的所有队列都收到这个消息。

 

1、队列、交换机配置

配置队列，配置交换机，绑定交换机。

 

@Configuration

public class FanoutRabbitConfig {

 

@Bean

public Queue AMessage() {

return new Queue("fanout.A");

}

 

@Bean

public Queue BMessage() {

return new Queue("fanout.B");

}

 

@Bean

public Queue CMessage() {

return new Queue("fanout.C");

}

 

@Bean

FanoutExchange fanoutExchange() {

return new FanoutExchange("fanoutExchange");

}

 

@Bean

Binding bindingExchangeA(Queue AMessage,FanoutExchange fanoutExchange) {

return BindingBuilder.bind(AMessage).to(fanoutExchange);

}

 

@Bean

Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {

return BindingBuilder.bind(BMessage).to(fanoutExchange);

}

 

@Bean

Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) {

return BindingBuilder.bind(CMessage).to(fanoutExchange);

}

 

}

2、发送者

 

public void send() {

String context = "hi, fanout msg ";

System.out.println("Sender : " + context);

this.rabbitTemplate.convertAndSend("fanoutExchange","", context);

}

3、接收者

接收者不变，可以加多个接收者

 

@Component

public class Receive {

 

@RabbitListener(queues = "fanout.B")

public void process(String str) {

System.out.println("Receive:" + str);

}

 

}

主题模式（Topic Exchange）

1、队列、交换机配置

配置队列，配置交换机，绑定交换机。

 

final static String message = "topic.A";

final static String messages = "topic.B";

 

@Bean

public Queue queueMessage() {

return new Queue(TopicRabbitConfig.message);

}

 

@Bean

public Queue queueMessages() {

return new Queue(TopicRabbitConfig.messages);

}

//新建一个交换机

@Bean

TopicExchange exchange() {

return new TopicExchange("topicExchange");

}

//绑定队列到交换机上,路由模式，需要完整匹配topic.message，才能接受

@Bean

Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {

return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");

}

//前缀匹配到topic.即可接受

@Bean

Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {

return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");

}

2、发送者

 

public void send() {

String context = "hi, i am message all";

System.out.println("Sender : " + context);

this.rabbitTemplate.convertAndSend("topicExchange", "topic.1", context);

}

 

public void send1() {

String context = "hi, i am message 1";

System.out.println("Sender : " + context);

this.rabbitTemplate.convertAndSend("topicExchange", "topic.message", context);

}

 

public void send2() {

String context = "hi, i am messages 2";

System.out.println("Sender : " + context);

this.rabbitTemplate.convertAndSend("topicExchange", "topic.messages", context);

}

3、接收者

 

@Component

@RabbitListener(queues = "topic.A")

public class TopicReceiver {

@RabbitHandler

public void process(String message) {

System.out.println("Topic Receiver1 : " + message);

}

 

}

 

@Component

@RabbitListener(queues = "topic.B")

public class TopicReceiver2 {

@RabbitHandler

public void process(String message) {

System.out.println("Topic Receiver2 : " + message);

}

}