[纯原生方式] RabbitMq入门-2 RabbitMq API实现 工作队列-轮询分发 (你消费一个，我消费一个)

注意：虽然这里没有明确定义交换机Exchange
但发送到了系统内置的默认交换机上，名称为""，routingKey直接定义为队列的名称 ( 生产和消费者队列名称一样 )，后期再看交换机几章，就会理解
  

 为什么会出现工作队列

前提:我们应用程序在使用消息系统的时候,一般生产者 P 生产消息是毫不费力的(发送消息即可),
而消费者接收完消息 后需要处理,会耗费一定的时间,这时候,就有可能导致很多消息堆积在队列里面,一个消费者有可能不够用 
 
那么怎么让消费者同时处理多个消息呢? 在同一个队列上创建多个消费者,让他们相互竞争,这样消费者就可以同时处理多条消息了 
 
使用任务队列的优点之一就是可以轻易的并行工作。如果我们积压了好多工作，我们可以通过增加工作者（消费者）
来解决这一问题，使得系统的伸缩性更加容易。  

轮询分发
轮询机制是你一个，我一个轮询分发机制，比如我有50个消息，
无论C1、C2的消费处理能力如何，最后他们都会按照你一个我一个的方式都拿到25个消息消费，
这就是所谓的轮询，轮着来的意思。

注意：代码和简单队列的代码一样，只是队列名称换了，增加多个消费者，并且添加了睡眠时间的设置(测试效果使用而已)

简单队列的代码编写，可参考博文 [纯原生方式] RabbitMq入门-1 RabbitMq API实现 简单队列_rabbitmq api 创建队列-优快云博客

1 生产者代码

package work_lunxun;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import util.RabbitmqConnection;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class Send {
    private static final String queue_name="work_queue_Round_robin_test";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取一个连接
        Connection connection = RabbitmqConnection.getConnection();

        //从连接中获取一个通道
        Channel channel = connection.createChannel();

        //是否持久化
        Boolean durable=false;
        //是否排外的
        Boolean exclusive=false;
        //是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除
        Boolean autoDelete=false;
        Map<String, Object> arguments=null;
        //创建队列声明
        channel.queueDeclare(queue_name,durable,exclusive,autoDelete,arguments);

        for (int i = 0; i <50 ; i++) {
            String msg="hello-"+i;
            //默认情况下代理服务器端是存在一个""名字的exchange的,
            String exchange="";
            //路由键
            String routingKey=queue_name;
            AMQP.BasicProperties props=null;
            //发送消息
            channel.basicPublish(exchange,routingKey,props,msg.getBytes());

            Thread.sleep(i*10);
        }

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

2 消费者代码,同样的代码，多粘几次，注意Thread.sleep改成不同的，方便测试

package work_lunxun;

import com.rabbitmq.client.*;
import util.RabbitmqConnection;

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class Recv_1 {
    private static final String queue_name="work_queue_Round_robin_test";
    public static void main(String[] args) throws IOException, TimeoutException {
        // 获取连接
        Connection connection = RabbitmqConnection.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        //是否持久化
        Boolean durable=false;
        //是否排外的
        Boolean exclusive=false;
        //是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除
        Boolean autoDelete=false;
        Map<String, Object> arguments=null;
        //创建队列声明 ，主要为了防止消息接收者先运行此程序，队列还不存在时创建队列。
        channel.queueDeclare(queue_name,durable,exclusive,autoDelete,arguments);

        //定义消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //获取到达消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//                System.out.println(consumerTag);
//                System.out.println(envelope);
//                System.out.println(properties);
                System.out.println(new String(body, "utf-8"));

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //消费者确认,
        // true:表示自动确认，消费者收到了消息（不管是否成功消费）就会立即从rabbitmq队列中删除
        // false:表示手动确认，消费者获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，
        // 如果消费者一直没有反馈，那么该消息将一直处于不可用状态，并且服务器会认为该消费者已经挂掉，不会再给其
        // 发送消息，直到该消费者反馈
        boolean autoAck=true;
        //监听队列
        channel.basicConsume(queue_name,autoAck,defaultConsumer);
    }
}

运行结果分析:
consumer1业务停顿1秒，consumer2业务停顿2秒，按常理consumer1应该多消费点消息，因为处理得快，
但是实际情况是consumer1和consumer2把消息你一个我一个的平分了，
这就是轮询分发机制，无论快慢，轮着来