RabbitMQ 三 Round-robin轮询分发
在上一节中我写了一个简单队列，由于简单队列不能满足现在的需要，所以要继续学习更深的知识
由于我们上一节做了一个简单队列，他有很多缺点，比如耦合性高，生产者一一对应消费者（如果我想有多个消费者消费消息，这个时候就不行了），队列名变更，这个时候生产者与消费者要同时变更。
workqueueus工作队列
模型
这个图的意思就是一个生产者把消息生产到队列中，两个消费者去消费他，甚至多个消费者消费他
Simple队列是一一对应的，在实际的开发中，生产者发送消息是毫不费力的，消费者一般是要和业务逻辑相结合的，这个时候消费者接受到消息后就需要处理，可能需要花费时间，这个时候队列就会挤压很多消息，既然这样就会出现多个消费者消费消息。
下面我们修上代码
首先是生产者
public class Send {
private static final String QUEUE_NAME="test_work_queue";
/** |----C1
* P-----Queue-----|
* |----C2
* @param s
*/
public static void main(String[] s) {
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false, false,false , null);
//发送消息
for(int i = 0;i < 50; i++){
String msg = "hello" + i;
channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
System.out.println("生产者发送的消息："+msg);
Thread.sleep(i*20);
}
channel.close();
connection.close();
}catch (IOException e){
e.printStackTrace();
}catch (TimeoutException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
}
}
接下来是消费者
public class Recv {
private static final String QUEUE_NAME = "test_work_queue";
public static void main(String[] s){
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false,false , false, null);
//定义一个消费者
Consumer consumer = new DefaultConsumer(channel){
//队列中有消息就触发这个方法。
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String msg = new String(body,"UTF-8");
System.out.println("Recv1："+msg);
try {
Thread.sleep(2000);
}catch (Exception e){
e.printStackTrace();
}
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);
}catch(Exception e){
e.printStackTrace();
}
}
}
然后是另一个消费者
public class Recv2 {
private static final String QUEUE_NAME = "test_work_queue";
public static void main(String[] s){
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false,false , false, null);
//定义一个消费者
Consumer consumer = new DefaultConsumer(channel){
//队列中有消息就触发这个方法。
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String msg = new String(body,"UTF-8");
System.out.println("Recv2："+msg);
try {
Thread.sleep(1000);
}catch (Exception e){
e.printStackTrace();
}
}
};
channel.basicConsume(QUEUE_NAME, true, consumer);
}catch(Exception e){
e.printStackTrace();
}
}
}
首相需要声明一下，我消费者一和消费者二是消费同一个队列的，但是消费者1消费完一个要2秒，消费者2消费完一个要1秒，按理说能者多劳，消费者二要消费的更多一点，但是事实是这样么。
我们看消费结果：
消费者一的结果（由于太多，这里只截取部分）：
Recv1：hello0
Recv1：hello2
Recv1：hello4
Recv1：hello6
Recv1：hello8
Recv1：hello10
Recv1：hello12
消费者二的结果：
Recv2：hello1
Recv2：hello3
Recv2：hello5
Recv2：hello7
Recv2：hello9
Recv2：hello11
Recv2：hello13
可以看出，他们是轮询消费，也就是说你消费一个，我消费一个，不会说我消费的快我消费的就多。
下面我们来说一下能者多劳的方式
这里说的能者多劳值得就是消费者一和消费者二都在消费，但是分谁的能力强，消费能力强的可以继续消费，消费能力弱的就要比消费能力消费能力强的差一些。他的原理如下图
下面直接上代码
下面是生产者
public static void main(String[] s) {
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false, false,false , null);
//每个消费者 发送消息确认之前，消息队列不发送下一个消息到消费者，一次只处理一个消息
//限制发送给同一个消费者 不得超过一条。
int prefetchCount = 1;
channel.basicQos(prefetchCount);
//发送消息
for(int i = 0;i < 50; i++){
String msg = "hello" + i;
channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
System.out.println("生产者发送的消息："+msg);
Thread.sleep(i*2);
}
channel.close();
connection.close();
}catch (IOException e){
e.printStackTrace();
}catch (TimeoutException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
}
下面是消费者
public static void main(String[] s){
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
final Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false,false , false, null);
channel.basicQos(1);
//定义一个消费者
Consumer consumer = new DefaultConsumer(channel){
//队列中有消息就触发这个方法。
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String msg = new String(body,"UTF-8");
System.out.println("Recv1："+msg);
try {
Thread.sleep(2000);
}catch (Exception e){
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
//自动应答改为false
Boolean autoAck = false;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}catch(Exception e){
e.printStackTrace();
}
}
下面是另一个消费者
public static void main(String[] s){
try{
//获取连接
Connection connection = ConnectionUtil.getConnection();
//获取通道
final Channel channel = connection.createChannel();
//声明队列
channel.queueDeclare(QUEUE_NAME, false,false , false, null);
channel.basicQos(1);
//定义一个消费者
Consumer consumer = new DefaultConsumer(channel){
//队列中有消息就触发这个方法。
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String msg = new String(body,"UTF-8");
System.out.println("Recv2："+msg);
try {
Thread.sleep(1000);
}catch (Exception e){
e.printStackTrace();
}
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
Boolean autoAck = false;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}catch(Exception e){
e.printStackTrace();
}
}
从结果看来，消费者2处理的要比消费者1多，证明我们上面的代码是没有问题的。