RabbitMQ之Work Wueues（四）

Producer

package workqueues;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Send1 {

    private static final String QUEUE_NAME = "workqueue";
    public static void main(String[] args) {
        foo();
    }

    private static void foo() {
        try{
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            boolean durable = true;  //指定消息是否需要持久化，避免rebbitMq挂掉之后消息丢失
            channel.queueDeclare(QUEUE_NAME, durable, false, false, null);
            String dots = "";
            for(int i=0; i < 10; i++) {
                dots += ".";
                String message = "helloworld" + dots + dots.length();
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println("Send:"+message);
            }
            channel.close();
            connection.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

Consumer1

package workqueues;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv2 {
    private static final String QUEUE_NAME = "workqueue";
    public static void main(String[] args) {
        foo();
    }
    
    private static void foo() {
        try{
            int hashCode = Recv2.class.hashCode();
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            //同时处理的待ack的请求的数量
            int prefetchCount = 3;
            channel.basicQos(prefetchCount);
            //关闭autoAck，表示请求处理完需要Consumer显示的发送应答，否则MQ认为消息未得到处理，后续会发给其他人处理
            boolean autoAck = false;
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                        byte[] body) throws IOException {
                    String message = new String(body,"UTF-8");
                    doWork(message);
                    //设定每处理完一条消息都要发送ack，只有发送完ack的，rabbitMq才会认为得到正确处理，否则会发送给其它人
                    channel.basicAck(envelope.getDeliveryTag(), autoAck);
                }
            };
            //设定需要显示发送ack
            channel.basicConsume(QUEUE_NAME, autoAck, consumer);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
    private static void doWork(String task) {
        System.out.println("Received task:"+task);
        for(char ch : task.toCharArray()) {
            if(ch == '.') {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("task done:"+task);
    }
}

其中几个主要参数：

　　durable：表示是否需要持久化消息，其主要是为了避免rabbitMQ崩溃的时候消息丢失，所以设置为持久化，mq会把未处理的消息写到磁盘。

　　autoack：指定mq client是否自动应答ack（消息处理确认），实际上我们应该将autoack设置成false，等Consumer处理完消息后显示的调用函数向mq 发送ack，表示这条消息已经得到正确处理。

　　　　　　  如果Consumer正在处理一条消息的时候挂了，那么mq没有收到应答，则会将这条消息发给这个queue上的其它Consumer来进行处理。

　　prefetchCount：Consumer同时处理的待应答的消息的数量，如果设置成1则相当于负载均衡，每个人同时只会处理一条消息。处理完之后才会收到下一条消息。

　　　　　　　　　 假如设置成3，那么每个Consumer同一时间最多可以处理3条消息。上面测试代码设置为3.

测试结果

Producer

Send:helloworld.1
Send:helloworld..2
Send:helloworld...3
Send:helloworld....4
Send:helloworld.....5
Send:helloworld......6
Send:helloworld.......7
Send:helloworld........8
Send:helloworld.........9
Send:helloworld..........10

C1

　　Received task:helloworld.1

task done:helloworld.1
Received task:helloworld..2
task done:helloworld..2
Received task:helloworld...3
task done:helloworld...3
Received task:helloworld.......7
task done:helloworld.......7
Received task:helloworld........8
task done:helloworld........8
Received task:helloworld..........10
task done:helloworld..........10

C2

Received task:helloworld....4
task done:helloworld....4
Received task:helloworld.....5
task done:helloworld.....5
Received task:helloworld......6
task done:helloworld......6
Received task:helloworld.........9
task done:helloworld.........9

　　备注：先运行Producer代码，然后运行Consumer代码（运行两次。即两个实例，分别命名为C1，C2）

结果分析

　　Producer生产任务1，2，3，4，5，6，7，8，9，10

　　C1处理任务1，2，3，7，8，10

·　  C2处理任务4，5，6，9

　　基本符合同一时间最多处理三条消息的设置，假设在C1处理10的时候将C1进程强杀掉，那么mq会把10发送给C2进行处理