消息中间件RabbitMQ介绍

1.架构

生产者发送消息，将内容发送给rabbitMQ server(交换器接收，发送给指定队列，队列将消息)发送给消费者。

2.主要概念

Rabbitmq Server:也叫 broker server,它是一种传输服务。他的角色就是维护一条从 Producer到 Consumer的路线,保证数据能够按照指定的方式进行传输。

Producer:消息生产者,如图A、B、C,数据的发送方。消息生产者连接 Rabbitmq服务器然后将消息投递到 Exchange。

Consumer:消息消费者,如图1、2、3,数据的接收方。消息消费者订阅队列,Rabbitmq将 Queue中的消息发送到消息消费者。

Exchange:生产者将消息发送到 Exchange(交换器),由 Exchange:将消息路由到或多个 Queuer中(或者丢弃) T Exchange并不存儲消息。 Rabbitmq中的 Exchange有direct、 fanout、 topic、 headers四种类型,每种类型对应不同的路由规则。

Queue:(队列)是 Rabbitmq的内部对象,用于存储消息。消息消费者就是通过订阅队列来获取消息的, Rabbitmq中的消息都只能存储在 Queue中,生产者生产消息并最终投递到 Queue中,消费者可以从 Queue中获取消息并消费。多个消费者可以订阅同一个Queue,这时 Queue中的消息会被平均分推给多个消费者进行处理,而不是每个消费者都收到所有的消息并处理。

Routingkey:生产者在将消息发送给 Exchange的时候,一般会指定一个 routing key,来指定这个消息的路由规则,而这个 routing key需要与 Exchange Type及 binding key联合使用才能最终生效。在 Exchange Type与 binding key固定的情况下(在正常使用时般这些内容都是固定配置好的),我们的生产者就可以在发送消息给 Exchanger时,通过指定 routing key来决定消思流向哪里。 Rabbitmq:为 routing key i设定的长度制为255bytes.

Connection:(连接): Producer.和 Consumer都是通过TCP连接到 Rabbitmq Server的。以后我们可以看到,程序的起始处就是建立这个TCP连接。

Channels:(信道):它建立在上述的TCP连接中。数据流动都是在 Channel中进行的。也就是说,一般情況是程序起始建立TCP连接,第二步就是建立这个 Channel

Virtualhost:权限控制的基本单位,一个 Virtualhost里面有若干 Exchange和Messagequeue,以及指定被哪些user使用

3.三种模式

3.1直接模式

我们需要将消息发给唯一一个节点时使用这种模式,这是最简单的一种形式。
任何发送到 Direct Exchange的消息都会被转发到 Routekey中指定的 Queue。

使用默认的队列

3.1.1特点

1.一般情况可以使用 rabbitmq自带的 Exchange:"(该 Exchange的名字为空字符串,下文称其为 default Exchange)
2.这种模式下不需要将 Exchange进行任何绑定( binding)操作
3.消息传递时需要一个" Routekey",可以简单的理解为要发送到的队列名字。
4.如果 hosts中不存在 Routekey中指定的队列名,则该消息会被抛弃。
5.当有多个消费者等待时，会通过负载均衡按一定顺序接收生产者发送的内容。

3.1.2简单上手

（1）打开rabbitmq管理平台添加一个队列（rabbitmq在docker环境下的安装）

（2）建立maven工程依赖导入和yml配置

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <fastjson.version>1.2.51</fastjson.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>      
    </dependencies>

server:
  port: 8998
spring:
  rabbitmq:
    host: 你安装rabbitmq的ip

（3）product生产者建立

package com.diploma.rabbitmq;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitmqApplication.class)
public class ProductTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void sendMsg(){
        rabbitTemplate.convertAndSend("directModeTest","直接模式测试！");
    }
}

（4）消费者建立

package com.diploma.rabbitmq.customer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/*直连模式的消费者*/
@Component
@RabbitListener(queues = "directModeTest")//指定消费者处理那个queces的消息
public class DirectCustomer {
    @RabbitHandler
    public void getMsg(String msg){
        System.out.println("8999直接模式消费消息:"+msg);
    }
}

（5）运行sendMsg

3.2分裂模式

当我们需要将消息一次发给多个队列时,需要使用这种模式。
解释：生产者product产生消息，先将消息发送给exchange交换器，交换器将消息发送给和当前交换器相关联的队列queue,消费者再从指定queue中接收。

3.2.1简单上手

（1）打开监控平台添加三个序列和一个交换器

（2）生产者

 /*分裂模式*/
    @Test
    public void fanoutModeSendMsg(){
        rabbitTemplate.convertAndSend("fanoutExchanges","","分裂模式测试！");
    }

（3）消费者三个类

/*分裂模式消费者*/
@Component
@RabbitListener(queues = "fanoutModeTest1")//指定消费者处理那个queces的消息
public class fanoutCustomer1 {
    @RabbitHandler
    public void getMsg(String msg){
        System.out.println("fanoutModeTest1:"+msg);
    }
}

/*分裂模式消费者*/
@Component
@RabbitListener(queues = "fanoutModeTest2")//指定消费者处理那个queces的消息
public class fanoutCustomer2 {
    @RabbitHandler
    public void getMsg(String msg){
        System.out.println("fanoutModeTest2:"+msg);
    }
}

/*分裂模式消费者*/
@Component
@RabbitListener(queues = "fanoutModeTest3")//指定消费者处理那个queces的消息
public class fanoutCustomer3 {
    @RabbitHandler
    public void getMsg(String msg){
        System.out.println("fanoutModeTest3:"+msg);
    }
}

（3）测试

将建立的此modul运行，再运行测试的分裂模式方法fanoutModeSendMsg（）
结果：

3.1主题模式

主题模式在分裂模式基础上添加匹配规则。
简易原理：

3.3.1简单上手

(1)创建交换器并添加序列和序列的匹配规则（自己制定符合规则就好）

(2)启动消费者，启动分裂模式创建的消费者，即主程序

(3)创建生产者并启动

  /*主题模式*/
    @Test
    public void topicModeSendMsg(){
        rabbitTemplate.convertAndSend("topicExanges","#.xyz","分裂模式测试！");
    }

(4)结果输出