1.RabbitMq

RabbitMq - Work 模式

一、什么是Work模式

　　如果有几个消息都需要处理，且每个消息的处理时间很长，仅有一个消费者，那么当它在处理一个消息的时候，其他消息就只有等待。

等待有时候是好的，但在程序中并不那么好，当队列中有多个消息待处理，将其分发给多个消费者，当一个消费者在处理的时候，有其他消费者继续消费队列中的消息，便缓解了等待的尴尬。

那么这篇文章将实现一个生产者，多个消费者的模式，实现任务分发：work模式，如图所示。

二、消息确认机制

问题：怎样保证消息不因消费者gg而丢失

处理一个消息可能会花一定的时间，万一还没处理完消费者就gg了…生产者一发送消息，便会将其标记为已删除，故最终的结果是：这条消息没有得到正确的处理。而且，指派给该消费者且尚未处理的所有消息都会gg。

解决策略：取消自动回复机制
为了解决消息的丢失问题，RabbitMQ提供了消息确认机制：message acknowledgments，一个消费者处理完成后，将会回传一个ack给生产者，以表示处理成功，这样生产者才可以将消息删除。

这样即使一个消费者gg了，没有回传ack，那么发送者便会重发消息到队列，如果这时候有其他的消费者服务该队列，那么便会从队列中取出消息并处理。这就保证了消息的不丢失。

自动回复机制：不管是否处理成功，还是失败，都会回复ack。

channel.basicConsume(QUEUE_NAME, true, consumer);

自动恢复机制默认是打开的，在接收端的代码最后：第二个参数为true，表示会自动回复，只要生产发送消息，就会标记删除。所以我们需要将自动回复设置为false。

boolean autoAck = false;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);

这样来保证消息不会因为消费者的gg而丢失了。

那么取消自动回复以后，我们需要手动回复一次：

channel.basicAck(envelope.getDeliveryTag(), false);

注意当前的消息确认机制只适用于同一个channel。
---------------------

application.yml

#############################################################
############## rabbitmq config ##############################
#############################################################
spring.rabbitmq.host: 127.0.0.1
spring.rabbitmq.port: 5672
spring.rabbitmq.username: admin
spring.rabbitmq.password: admin

package com.maozw.mq.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * @author MAOZW
 * @Description: Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
 * Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
 * Queue:消息的载体,每个消息都会被投到一个或多个队列。
 * Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
 * Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
 * vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
 * Producer:消息生产者,就是投递消息的程序.
 * Consumer:消息消费者,就是接受消息的程序.
 * Channel:消息通道,在客户端的每个连接里,可建立多个channel.
 * @date 2018/11/26 14:33
 */
@Configuration
public class RabbitConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(RabbitConfig.class);

    @Value("${spring.rabbitmq.host}")
    private String rabbitmqHost;

    @Value("${spring.rabbitmq.port}")
    private int rabbitmqPort;

    @Value("${spring.rabbitmq.username}")
    private String userName;

    @Value("${spring.rabbitmq.password}")
    private String password;


    public static final String EXCHANGE_A = "my-mq-exchange_A";
    public static final String EXCHANGE_B = "my-mq-exchange_B";
    public static final String EXCHANGE_C = "my-mq-exchange_C";


    public static final String QUEUE_A = "QUEUE_A";
    public static final String QUEUE_WORK = "QUEUE_WORK";
    public static final String QUEUE_C = "QUEUE_C";

    public static final String ROUTINGKEY_A = "spring-boot-routingKey_A";
    public static final String ROUTINGKEY_B = "spring-boot-routingKey_B";
    public static final String ROUTINGKEY_C = "spring-boot-routingKey_C";


    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setUsername(userName);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost("/vir_simple");
        connectionFactory.setPublisherConfirms(false);
        return connectionFactory;
    }

    public static ConnectionFactory getConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/vir_simple");
        connectionFactory.setPublisherConfirms(false);
        return connectionFactory;
    }
}

生产者

package com.maozw.mq.work;

import com.maozw.mq.config.RabbitConfig;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

/**
 * work 模式
 * 两种分发： 轮询分发 + 公平分发
 * 轮询分发：消费端：自动确认消息；boolean autoAck = true;
 * 公平分发: 消费端：手动确认消息 boolean autoAck = false; channel.basicAck(envelope.getDeliveryTag(),false);
 * @author MAOZW
 * @Description: ${todo}
 * @date 2018/11/26 15:06
 */
@RestController
@RequestMapping("/work")
public class WorkProducer {
    private static final Logger LOGGER = LoggerFactory.getLogger(WorkProducer.class);
    @Autowired
    RabbitConfig rabbitConfig;

    @RequestMapping("/send")
    public String send() throws IOException {
        ConnectionFactory connectionFactory = rabbitConfig.connectionFactory();
        Connection connection = connectionFactory.createConnection();
        Channel channel = connection.createChannel(false);
        //创建队列申明
        channel.queueDeclare(RabbitConfig.QUEUE_WORK, false, false, false, null);

        /**
         * 每个消费者 发送确认消息之前，消息队列不会发送下一个消息给消费者，一次只处理一个消息
         * 自动模式无需设置下面设置
         */
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        String Hello = ">>>> Hello Simple <<<<";
        for (int i = 0; i < 50; i++) {
            String message = Hello + i;
            channel.basicPublish("", RabbitConfig.QUEUE_WORK, null, message.getBytes());
            LOGGER.info("生产消息： " + message);
        }
        return "OK";
    }
}

消费者

package com.maozw.mq.work;

import com.maozw.mq.config.RabbitConfig;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;

import java.io.IOException;

/**
 * @author MAOZW
 * @Description: ${todo}
 * @date 2018/11/26 15:06
 */

public class WorkConsumer2 {
    private static final Logger LOGGER = LoggerFactory.getLogger(WorkConsumer2.class);

    public static void main(String[] args) throws IOException {
        ConnectionFactory connectionFactory = RabbitConfig.getConnectionFactory();
        Connection connection = connectionFactory.createConnection();
        Channel channel = connection.createChannel(false);
        //创建队列申明
        channel.queueDeclare(RabbitConfig.QUEUE_WORK, false, false, false, null);

        /**
         * 改变分发规则
         */
        channel.basicQos(1);

        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                System.out.println("[2] 接口数据 ： " + new String(body, "utf-8"));

                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[2] done!");
                    //消息应答：手动回执，手动确认消息
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        //监听队列
        /**
         * autoAck 消息应答
         *  默认轮询分发打开：true ：这种模式一旦rabbitmq将消息发送给消费者，就会从内存中删除该消息，不关心客户端是否消费正常。
         *  使用公平分发需要关闭autoAck:false  需要手动发送回执
         */
        boolean autoAck = false;
        channel.basicConsume(RabbitConfig.QUEUE_WORK,autoAck, consumer);
    }
    
}