SpringBoot集成RabbitMQ

SpringBoot集成RabbitMQ

跟着纯洁的微笑大佬一起学习的,有兴趣的可以搜一下

RabbitMQ介绍

RabbitMQ 是一个开源的 AMQP 实现，服务器端用 Erlang 语言编写，支持多种客户端，如 Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP 等，支持 AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。

AMQP（Advanced Message Queuing Protocol，高级消息队列协议）是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。

AMQP 的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。

相关概念

消息队列服务会有三个概念: 发消息者、队列、消息接收者. RabbitMQ在基本概念上多做了一层抽象,在发消息者和队列之间加入了交换器（Exchange）。这样发消息者和队列就没有直接联系，转而变成发消息者把消息给交换器，交换器根据调度策略再把消息再给队列。

  • 左侧 P 代表生产者，也就是往 RabbitMQ 发消息的程序
  • 中间即是 RabbitMQ，其中包括了交换机和队列。
  • 右侧 C 代表消费者，也就是往 RabbitMQ 拿消息的程序。

比较重要的概念有四个: 虚拟主机、交换机、队列和绑定.

  • 虚拟主机：一个虚拟主机持有一组交换机、队列和绑定，为什么需要多个虚拟主机呢？很简单，RabbitMQ 当中，用户只能在虚拟主机的粒度进行权限控制。因此，如果需要禁止 A 组访问 B 组的交换机/队列/绑定，必须为 A 和 B 分别创建一个虚拟主机，每一个 RabbitMQ 服务器都有一个默认的虚拟主机“/”。
  • 交换机：Exchange 用于转发消息，但是它不会做存储，如果没有 Queue bind 到 Exchange 的话，它会直接丢弃掉 Producer 发送过来的消息。
  • 绑定：也就是交换机需要和队列相绑定，这其中如上图所示，是多对多的关系。
交换机(Exchange)

交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存储消息，在启用 ack 模式后，交换机找不到队列，会返回错误。交换机有四种类型：Direct、topic、Headers and Fanout。

  • Direct：其类型的行为是“先匹配、再投送”，即在绑定时设定一个 routing_key，消息的 routing_key 匹配时，才会被交换器投送到绑定的队列中去。
  • Topic：按规则转发消息（最灵活）。
  • Headers：设置 header attribute 参数类型的交换机。
  • Fanout：转发消息到所有绑定队列。
Direct Exchange

Direct Exchange 是 RabbitMQ 默认的交换机模式，也是最简单的模式，根据 key 全文匹配去寻找队列。

第一个 X - Q1 就有一个 binding key，名字为 orange；X - Q2 就有 2 个 binding key，名字为 black 和 green。当消息中的路由键和这个 binding key 对应上的时候，那么就知道了该消息去到哪一个队列中。

注意：为什么 X 到 Q2 要有 black、green，2 个 binding key 呢，一个不就行了吗？这个主要是因为可能又有 Q3，而 Q3 只接收 black 的信息，而 Q2 不仅接收 black 的信息，还接收 green 的信息。

Topic Exchange

Topic Exchange 转发消息主要是根据通配符。在这种交换机下，队列和交换机的绑定会定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发消息。

在这种交换机模式下：

  • 路由键必须是一串字符，用句号（.）隔开，比如 agreements.us，或者 agreements.eu.stockholm 等；
  • 路由模式必须包含一个星号（*），主要用于匹配路由键指定位置的一个单词，比如，一个路由模式是这样子，agreements..b.*，那么就只能匹配路由键是这样子的，第一个单词是 agreements，第四个单词是 b；井号（#）就表示相当于一个或者多个单词，例如一个匹配模式是 agreements.eu.berlin.#，那么，以 agreements.eu.berlin 开头的路由键都是可以的。

具体代码发送的时候还是一样，第一个参数表示交换机，第二个参数表示 routing key，第三个参数即消息。如下：

rabbitTemplate.convertAndSend("testTopicExchange","key1.a.c.key2", " this is  RabbitMQ!");

Topic 和 Direct 类似, 只是匹配上支持了“模式”，在“点分”的 routing_key 形式中, 可以使用两个通配符:

  • * 表示一个词
  • # 表示零个或多个词
Headers Exchange

Headers 也是根据规则匹配，相较于 Direct 和 Topic 固定地使用 routing_key，headers 则是一个自定义匹配规则的类型。

在队列与交换器绑定时，会设定一组键值对规则，消息中也包括一组键值对（headers 属性），当这些键值对有一对或全部匹配时，消息被投送到对应队列。

Fanout Exchange

Fanout Exchange 消息广播的模式，不管路由键或者是路由模式，会把消息发给绑定给它的全部队列，如果配置了 routing_key 会被忽略。

集成实践
  1. 引入依赖:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 配置文件:
spring:
  application:
    name: Spring-boot-rabbitmq
  rabbitmq:
    host: 39.105.167.131
    port: 5762
    username: guest
    password: guest
  1. 定义队列
@Configuration
public class RabbitConfig {
    @Bean
    public Queue Queue() {
        return new Queue("hello");
    }

}
  1. 发送者

@Component
public class MessageSender {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    private static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public void send(){
        String context = "hello " + format.format(new Date());
        System.out.println("Sender : " + context);
        this.rabbitTemplate.convertAndSend("Hello", context);
    }

}
  1. 接受者
@Component
@RabbitListener(queues = "hello")
public class MessageReceive {

    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver  : " + hello);
    }
}
  1. 测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMqHelloTest {

    @Autowired
    private MessageSender messageSender;

    @Test
    public void testMessageSend() throws InterruptedException {
        messageSender.send();
        Thread.sleep(1000);
    }
}

注意，发送者和接收者的 queue name 必须一致，不然不能接收。
执行测试方法,就可以发送消息了.

多方测试

一个发送者和 N 个接收者或者 N 个发送者和 N 个接收者会出现什么情况呢？

一对多发送:

新创建一个发送者和两个接受者:

发送者:

@Component
public class OneToManySender {

    @Autowired
    private AmqpTemplate rabbitmq;

    public void send(int i){
        String context = "OneToMany Spring Boot queue + " + " *********** " + i;
        System.out.println("Sender : " + context);
        rabbitmq.convertAndSend("oneToMany", context);
    }
}

接受者

@Component
@RabbitListener(queues = "oneToMany")
public class OneToManyReceive1 {

    @RabbitHandler
    public void process(String context){
        System.out.println("oneToMany 1 : " + context);
    }

}

@Component
@RabbitListener(queues = "oneToMany")
public class OneToManyReceive2 {

    @RabbitHandler
    public void process(String context){
        System.out.println("oneToMany 2 : " + context);
    }

}

测试:

@Autowired
private OneToManySender oneToManySender;

@Test
public void oneToMany() throws InterruptedException {
    for (int i = 0; i < 100; i++) {
        oneToManySender.send(i);
    }
    Thread.sleep(10000l);
}
```> 注意,在进行测试的时候,必须先创建队列,也就是在RabbitConfig添加队列

![](https://img2018.cnblogs.com/blog/1224549/201901/1224549-20190125161753375-349710362.png)



> 得出的结论是: 一个发送者，N 个接收者，经过测试接收端均匀接收到消息，也说明接收端自动进行了均衡负载，也就是流量分发。

##### 多对多发送

复用前面的代码,再创建一个发送者.

@Component
public class ManyToMany {

@Autowired
private AmqpTemplate rabbitmqTemplate;

public void send(int i){
    String context = "ManyToMany Spring Boot queue + " + " *********** " + i;
    System.out.println("Sender3 : " + context);
    this.rabbitmqTemplate.convertAndSend("manyToMany", context);
}

}


其他代码不懂,测试如下:

@Autowired
private ManyToMany manyToMany;

@Test
public void manyToMany() throws InterruptedException {

    for (int i = 0; i < 100; i++) {
        oneToManySender.send(i);
        manyToMany.send(i);
    }
    Thread.sleep(10000l);
}

> 结论：发送端交替发送消息，接收端仍然会均匀接收到消息

##### 高级使用 - 对象的支持

SpringBoot已经完美的支持对象的发送和接受,不需要额外的配置.

发送者

@Component
public class ObjectSender {

@Autowired
private AmqpTemplate rabbitTemplate;

public void send(User user) {
	System.out.println("Sender object: " + user.toString());
	this.rabbitTemplate.convertAndSend("object", user);
}

}



接受者

@Component
@RabbitListener(queues = "object")
public class ObjectReceiver {

@RabbitHandler
public void process(User user) {
    System.out.println("Receiver object : " + user);
}

}


测试

@Autowired
private ObjectSender objectSend;

@Test
public void sendObject() throws InterruptedException {
User user = new User();
user.setName("王智");
user.setPass("123456");
objectSend.send(user);
Thread.sleep(1000l);
}

> 注意在配置文件中添加队列的注册(RabbitConfig类中)

@Bean
public Queue ObjectQueue() {
return new Queue("object");
}


##### Topic Exchange

Topic 是 RabbitMQ 中最灵活的一种方式，可以根据 routing_key 自由的绑定不同的队列。首先对 Topic 规则配置，这里使用两个队列来测试：

@Configuration
public class TopicRabbitConfig {

final static String message = "topic.message";
final static String messages = "topic.messages";

//定义队列
@Bean
public Queue queueMessage() {
    return new Queue(TopicRabbitConfig.message);
}

@Bean
public Queue queueMessages() {
    return new Queue(TopicRabbitConfig.messages);
}

//交换机
@Bean
TopicExchange exchange() {
    return new TopicExchange("exchange");
}

//将队列和交换机绑定
@Bean
Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {
    return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
}

@Bean
Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {
    return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
}

}

queueMessages 同时匹配两个队列，queueMessage 只匹配“topic.message”队列。

发送者:

@Component
public class TopicSender {

@Autowired
private AmqpTemplate rabbitTemplate;

public void send1() {
    String context = "hi, i am message 1";
    System.out.println("Sender : " + context);
    this.rabbitTemplate.convertAndSend("exchange", "topic.message", context);
}

public void send2() {
    String context = "hi, i am messages 2";
    System.out.println("Sender : " + context);
    this.rabbitTemplate.convertAndSend("exchange", "topic.messages", context);
}

}


接受者1:

@Component
@RabbitListener(queues = "topic.message")
public class TopicReceiver1 {

@RabbitHandler
public void process(String message) {
    System.out.println("Topic Receiver1  : " + message);
}

}

接受者2

@Component
@RabbitListener(queues = "topic.messages")
public class TopicReceiver2 {

@RabbitHandler
public void process(String message) {
    System.out.println("Topic Receiver2  : " + message);
}

}


测试:

@Autowired
private TopicSender topicSender;

@Test
public void topic1() throws Exception {
topicSender.send1();
Thread.sleep(1000l);
}

@Test
public void topic2() throws Exception {
topicSender.send2();
Thread.sleep(1000l);
}

测试topic1的时候会有两个接收者,测试topic2的时候只有一个接收者

##### Fanout Exchange

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

Fanout的配置类:

@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);
}

}


发送者:

@Configuration
public class FanoutSender {

@Autowired
private AmqpTemplate rabbitTemplate;

public void send() {
    String context = "hi, fanout msg ";
    System.out.println("Sender : " + context);
    this.rabbitTemplate.convertAndSend("fanoutExchange","", context);
}

}


接收者A:

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {
@RabbitHandler
public void process(String message) {
System.out.println("fanout Receiver A: " + message);
}
}

接收B:

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {
@RabbitHandler
public void process(String message) {
System.out.println("fanout Receiver B: " + message);
}
}

接收C

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {
@RabbitHandler
public void process(String message) {
System.out.println("fanout Receiver C: " + message);
}
}

测试:

@Autowired
private FanoutSender fanoutSender;

@Test
public void fanoutSender() throws Exception {
    fanoutSender.send();
    Thread.sleep(1000l);
}


> RabbitMQ 一个非常高效的消息队列组件，使用 RabbitMQ 可以方便的解耦项目之间的依赖，同时利用 RabbitMQ 的特性可以做很多的解决方案。Spring Boot 为 RabbitMQ 提供了支持组件 spring-boot-starter-amqp，加载的时候会自动进行配置，并且预置了 RabbitTemplate，可以让我们在项目中方便的调用。在测试使用的过程中发现，RabbitMQ 非常的灵活，可以使用各种策略将不同的发送者和接收者绑定在一起，这些特性在实际项目使用中非常的高效便利。

源码: https://github.com/MissWangLove/SpringBoot
posted @ 2019-01-28 09:18  庄子游世  阅读(5668)  评论(0)  编辑  收藏  举报