2020-12-02RabbitMQ

一、初识MQ和RabbitMQ

1、MQ介绍
MQ全称为Message Queue，即消息队列中间件。通常用于不同系统之间的通信。使用消息队列的以下优点：异步处理任务，应用解耦，削峰填谷。

（1）异步处理任务
如图，在同步的情况下，下一步操作必须等待上一步操作完成后再进行，用户在使用订单系统时则需要920ms，而使用MQ，用户发送数据后到MQ后即可在数据库进行存储，然后就可以给用户进行反馈，这个过程可能只要几十ms。后续三个消费者系统在到MQ中获取数据进行操作，也可以在这300ms内同时进行操作。相对之下，等几个系统调用玩返回响应和发送到ＭＱ后即响应，应用所需的时间差距极大，这样就提升用户体验和系统吞吐量。

（2）、应用解耦
如图，订单系统若使用RPC直接远程调用其他方法，则需要在订单系统内编写调用方法的代码，若后续要在远程一同增减其他功能，则就需要在订单系统进行大量代码修改。但使用ＭＱ后，订单数据只需要传递数据，增减系统只是通过MQ取得数据进行相关操作，降低了系统耦合性，提高了可维护性。

（3）削峰填谷
如图，一般来说，一个tomcat的并发访问量为300-500，优化后可达到2000，但是也存在并发量远远高于系统处理能力的风险，而使用MQ后，MQ的单机吞吐量为万级，就可以解决这个问题。MQ先把数据存储下来，并限制消费消息的速度为系统的最大并发量。这样一来，高峰期产生的数据会被存在在 MQ 中，高峰就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做“填谷”，提高了系统稳定性。

2、实现MQ的方式

主流方式大致有两种：AMQP、JMS

（1）AMQP：是一种协议，类比HTTP协议。它不从API层进行限定，而是直接定义网络交换的数据格式，所以可以跨语言实现。
（2）JMS：它是Java消息服务（JavaMessage Service）应用程序接口，Java平台中关于面向消息中间件（MOM）的API，所以只能使用java实现。

3、RabbitMQ是MQ的一种
常见MQ产品包括RabbitMQ、RocketMQ、ActiveMQ、Kafka等。RabbitMQ使用erlong语言开发，单机吞吐量为万级，这一点不如RocketMQ和Kafka（十万级），它的优点在于消息延迟低，并发能力强，性能好，社区活跃，管理界面丰富，综合能力强劲。

官方网站：http://www.rabbitmq.com/
（1）安装
使用docker直接拉取rabbitMQ，但是要注意拉取带有managerment标签的版本，这样才会有管理中心

docker pull rabbitmq:management

运行docker，向外映射暴露5672和15672端口

docker run -d -p 5672:5672 -p 15672:15672 --name myrabbitMQ 263c941f71ea

访问15672端口，登陆密码和账号默认为guest

（2）RabibitMQ基础结构

	Broker：接收和分发消息的应用
	Virtual Host：虚拟分组,类似于数据库中的不同库
	Connection：publisher／consumer 和 broker 之间的 TCP 连接
	Channel：信道，类似于线程池
	Exchange：交换机分发消息到queue 中去
	Queue：存储消息的消息队列，等待 consumer 取走
	Binding：exchange 和 queue 之间的虚拟连接

（3）工作模式
RabbitMQ 提供了 6 种工作模式：simple模式，work queues，Publish/Subcribe 发布订阅模式，Routing路由模式，topic自定义主题模式，RPC远程调用（不太算 MQ）。

二、rabbitMQ基础使用

1.工作模式案例测试
（1）、简单模式
即只有一个消费者和一个生产者，一个消息队列

定义两个工程，分别是provider和consumer，导入依赖

<dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>5.6.0</version>
</dependency>

定义provider类和consumer类，如果只是在类中定义main方法进行测试，可能会报错，这是因为maven工程没有编译java文件，需要使用maven插件手动编译。

错误: 找不到或无法加载主类 com.zs.Provider

public class Provider {
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置端口号
        connectionFactory.setPort(5672);
        //设置管理平台用户名
        connectionFactory.setUsername("guest");
        //设置管理用户密码
        connectionFactory.setPassword("guest");
        //设置ip地址
        connectionFactory.setHost("192.168.183.123");
        //设置虚拟机，若不设置，默认为/
        connectionFactory.setVirtualHost("/zs");
        //建立连接
        Connection connection = connectionFactory.newConnection();
        System.out.println(1);
        //创建chennel
        Channel channel = connection.createChannel();
        //创建queue
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        String queuename = "hello";
        channel.queueDeclare(queuename, true, false, false, null);
        //发送消息
        String body = "hello world";
        //basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)
        channel.basicPublish("",queuename,null,body.getBytes());
        channel.close();
        connection.close();
    }

声明队列参数解析：
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        1. queue：队列名称
        2. durable:是否持久化，当mq重启之后，还在
        3. exclusive：
            * 是否独占。只能有一个消费者监听这队列
            * 当Connection关闭时，是否删除队列
        4. autoDelete:是否自动删除。true，则当没有Consumer时，自动删除掉
        5. arguments：各种参数。
发送消息参数解析：
 basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
        2. routingKey：路由名称
        3. props：配置信息
        4. body：发送消息数据

public class Comsumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置端口号
        connectionFactory.setPort(5672);
        //设置管理平台用户名
        connectionFactory.setUsername("guest");
        //设置管理用户密码
        connectionFactory.setPassword("guest");
        //设置ip地址
        connectionFactory.setHost("192.168.183.123");
        //设置虚拟机，若不设置，默认为/
        connectionFactory.setVirtualHost("/zs");
        //建立连接
        Connection connection = connectionFactory.newConnection();
        //创建chennel
        Channel channel = connection.createChannel();
        //创建queue
        //queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        String name = "hello";
        channel.queueDeclare(name, true, false, false, null);
        //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("方法调用了");
                System.out.println(new String(body));
            }
        };
       channel.basicConsume(name,defaultConsumer);

        //basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)

    }
}

创建消费者解析：
new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {}
	   handleDelivery为回调方法，当收到消息后，会自动执行该方法
            1. consumerTag：标识
            2. envelope：获取一些信息，交换机，路由key...
            3. properties:配置信息
            4. body：数据

（2）work queues
多个消费端共同消费同一个队列中的消息，代码与简单模式一致，只是定义了多个消费者。

（3）发布订阅模式——fanout 广播模式
即一个生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收
到消息，扇形传播

public class provider3 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setPort(5672);
        connectionFactory.setHost("192.168.183.123");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        String QUEUE_1_NAME = "fount_queue1";
        String QUEUE_2_NAME = "fount_queue2";
        String EXCHANGE_NAME = "exchangename";
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT,true,false,false,null);
        channel.queueDeclare(QUEUE_1_NAME, true, false, false, null);
        channel.queueDeclare(QUEUE_2_NAME, true, false, false, null);

        channel.queueBind(QUEUE_1_NAME, EXCHANGE_NAME, "");
        channel.queueBind(QUEUE_2_NAME, EXCHANGE_NAME, "");
        for (int i = 0; i < 10; i++) {
            String body = "work....."+i;
            channel.basicPublish(EXCHANGE_NAME, "", null, body.getBytes());
        }

        channel.close();
        connection.close();
    }
}

绑定参数解析：
queueBind(String queue, String exchange, String routingKey)
       1. queue：队列名称
        2. exchange：交换机名称
        3. routingKey：路由键，绑定规则
            如果交换机的类型为fanout ，routingKey设置为""
 声明交换机解析：
 exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
   1. exchange:交换机名称
    2. type:交换机类型
        DIRECT("direct"),：定向
        FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
        TOPIC("topic"),通配符的方式
        HEADERS("headers");参数匹配
    3. durable:是否持久化
    4. autoDelete:自动删除
    5. internal：内部使用。 一般false
    6. arguments：参数

消费者同上。
（4）Routing路由模式
队列与交换机的绑定通过指定一个RoutingKey（路由key）实现，通过匹配Routingkey进行绑定，交换机的类型为：Direct

public class provider4 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setPort(5672);
        connectionFactory.setHost("192.168.183.123");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        String QUEUE_1_NAME = "route_queue1";
        String QUEUE_2_NAME = "route_queue2";
        String QUEUE_3_NAME = "route_queue3";
        String EXCHANGE_NAME = "exchangename1";
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT,true,false,false,null);
        channel.queueDeclare(QUEUE_1_NAME, true, false, false, null);
        channel.queueDeclare(QUEUE_2_NAME, true, false, false, null);
        channel.queueDeclare(QUEUE_3_NAME, true, false, false, null);
        String routingkey = "info";
        String routingkey2 = "warning";
        String routingkey3 = "error";
        channel.queueBind(QUEUE_1_NAME, EXCHANGE_NAME, routingkey);
        channel.queueBind(QUEUE_2_NAME, EXCHANGE_NAME, routingkey2);
        channel.queueBind(QUEUE_3_NAME, EXCHANGE_NAME, routingkey3);
        for (int i = 0; i < 10; i++) {
            if (i < 3) {
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey, null, body.getBytes());
            } else if (i<6 && i >= 3) {
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey2, null, body.getBytes());
            }else{
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey3, null, body.getBytes());
            }


        }

        channel.close();
        connection.close();
    }
}

（5）Topics通配符模式
Topic类型与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符。

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

例如：
item.#：能够匹配item.insert.abc 或者 item.insert

item.*：只能匹配item.insert

public class provider5 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setPort(5672);
        connectionFactory.setHost("192.168.183.123");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        String QUEUE_1_NAME = "topic_queue1";
        String QUEUE_2_NAME = "topic_queue2";
        String QUEUE_3_NAME = "topic_queue3";
        String EXCHANGE_NAME = "exchangename2";
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC,true,false,false,null);
        channel.queueDeclare(QUEUE_1_NAME, true, false, false, null);
        channel.queueDeclare(QUEUE_2_NAME, true, false, false, null);
        channel.queueDeclare(QUEUE_3_NAME, true, false, false, null);
        String routingkey = "info.*";
        String routingkey2 = "warning.#";
        String routingkey3 = "error.#";
        channel.queueBind(QUEUE_1_NAME, EXCHANGE_NAME, routingkey);
        channel.queueBind(QUEUE_1_NAME, EXCHANGE_NAME, routingkey2);
        channel.queueBind(QUEUE_2_NAME, EXCHANGE_NAME, routingkey2);
        channel.queueBind(QUEUE_3_NAME, EXCHANGE_NAME, routingkey3);
        for (int i = 0; i < 10; i++) {
            if (i < 3) {
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey, null, body.getBytes());
            } else if (i<6 && i >= 3) {
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey2, null, body.getBytes());
            }else{
                String body = "work....."+i;
                channel.basicPublish(EXCHANGE_NAME, routingkey3, null, body.getBytes());
            }


        }

        channel.close();
        connection.close();
    }

三、spring整合rabbitＭＱ

（１）、搭建环境
导入依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

（２）、配置配置文件

 <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"></context:property-placeholder>
    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}" username="${rabbitmq.username}" password="${rabbitmq.password}"
                               port="${rabbitmq.port}" virtual-host="${rabbitmq.virtual-host}"></rabbit:connection-factory>
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"></rabbit:admin>
    <rabbit:queue id="spring_queue" auto-declare="true" auto-delete="false" durable="true" name="spring_queue"></rabbit:queue>
    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>

    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>
    <rabbit:queue id="routing_queue1" name="routing_queue1" auto-declare="true"/>
    <rabbit:queue id="routing_queue2" name="routing_queue2" auto-declare="true"/>
    <rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>
    <rabbit:fanout-exchange name="fanout_exchange" id="fanoutExchange" durable="true" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="spring_fanout_queue_1" ></rabbit:binding>
            <rabbit:binding queue="spring_fanout_queue_1"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <rabbit:direct-exchange name="direct_exchange" id="directExchange" durable="true" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="routing_queue1" key="info"></rabbit:binding>
            <rabbit:binding queue="routing_queue2" key="error"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="heima.*" queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="heima.#" queue="spring_topic_queue_well"/>
            <rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>
    <!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"></rabbit:template>

（３）使用rabbitTemplate发送消息

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application.xml")
public class Simpletest {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void testSimple() {
        rabbitTemplate.convertAndSend("spring_queue","hello");
    }
    @Test
    public void testFanout1() {
        rabbitTemplate.convertAndSend("fanout_exchange","","fount信息发出了");
    }
    @Test
    public void testrouting1() {
        rabbitTemplate.convertAndSend("direct_exchange","info","Routing中的info信息发出了");
    }
    @Test
    public void testrouting2() {
        rabbitTemplate.convertAndSend("direct_exchange","error","Routing中的error信息发出了");
    }
    @Test
    public void testtopic1() {
        rabbitTemplate.convertAndSend("spring_topic_exchange","heima.*","topic中的heima.*信息发出了");
    }
    @Test
    public void testtopic2() {
        rabbitTemplate.convertAndSend("spring_topic_exchange","heima.#","topic中的heima.#信息发出了");
    }
    @Test
    public void testtopic3() {
        rabbitTemplate.convertAndSend("spring_topic_exchange","itcast.#","topic中的itcast.#信息发出了");
    }
}

（４）配置消费端

 <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"></context:property-placeholder>
    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}" username="${rabbitmq.username}" password="${rabbitmq.password}"
                               port="${rabbitmq.port}" virtual-host="${rabbitmq.virtual-host}"></rabbit:connection-factory>
    <!--配置监听器-->
    <bean id="springQueueListener" class="com.itheima.rabbitmq.listener.SpringQueueListener"/>
    <bean id="fanoutListener1" class="com.itheima.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.itheima.rabbitmq.listener.FanoutListener2"/>
    <bean id="topicListenerStar" class="com.itheima.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell" class="com.itheima.rabbitmq.listener.TopicListenerWell"/>
    <bean id="topicListenerWell2" class="com.itheima.rabbitmq.listener.TopicListenerWell2"/>
    <bean id="routingLIsternner1" class="com.itheima.rabbitmq.listener.RoutingLIsternner1"></bean>
    <bean id="routingLIsternner2" class="com.itheima.rabbitmq.listener.RoutingLIsternner2"></bean>
    <!--绑定需要监听的消息队列-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"></rabbit:listener>
        <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"></rabbit:listener>
        <rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"></rabbit:listener>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"></rabbit:listener>
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"></rabbit:listener>
        <rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
        <rabbit:listener ref="routingLIsternner1" queue-names="routing_queue1"/>
        <rabbit:listener ref="routingLIsternner2" queue-names="routing_queue2"/>
    </rabbit:listener-container>

（５）编写监听器
监听器需要实现MessageListener接口，重写onMessage方法

public class RoutingLIsternner2 implements MessageListener {
    public void onMessage(Message message) {
        System.out.println(message);
    }
}

四、springboot整合rabbitＭＱ

1、编写生产者
（1）配置文件

spring:
  rabbitmq:
    host: 192.168.183.123
    username: guest
    password: guest
    port: 5672
    virtual-host: /

（2）定义队列、交换机、绑定等对象
此处的Exchange 、Queue 、Binding 均为org.springframework.amqp.core包下的类

@Configuration
public class RabbitMQConfiguration {
    private static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";
    public static final String ITEM_QUEUE = "item_queue";

    //创建Exchange对象,命名item_queue以便绑定时注入
    @Bean("item_topic_exchange")
    public Exchange exchange() {
        return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
    }
    //Queue
    @Bean("item_queue")
    public Queue queue() {
        return QueueBuilder.durable(ITEM_QUEUE).build();
    }
    //绑定Exchange对象和Queue
    @Bean
    public Binding bind(@Qualifier("item_queue") Queue queue,
                        @Qualifier("item_topic_exchange") Exchange exchange ) {
        return BindingBuilder.bind(queue).to(exchange).with("info.#").noargs();
    }
}

（3）发送消息

	@Autowired
	RabbitTemplate rabbitTemplate;
	@Test
	void contextLoads() {
		rabbitTemplate.convertAndSend("item_topic_exchange","info.55.33","无内鬼，可以交易");
	}

2、编写消费端
（1）、配置文件
（2）、配置监听器

@Component
public class Mylistener {

    @RabbitListener(queues = "item_queue")
    public void listen(String message){
        System.out.println(message);
    }
}

注意：在spring和springboot整合时，需要先创建这个队列后再连接队列，否则会出现找不到队列的错误。