RabbitMQ消费端消费机制
一、确认机制
第一种
public static void getMessage() throws Exception {
Connection connection = ConnectionUtil.getConnection();
final Channel channel = connection.createChannel();
// channel.queueDeclare(ConnectionUtil.QUEUE_NAME,true,false,false,null);
DefaultConsumer deliverCallback = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println(new String(body, "UTF-8"));
//表示消息消费成功
System.out.println("消息消费成功");
//手工确认，第一个参数是消息的id,第二个参数是批量标识（ture标识批量）
//channel.basicAck(envelope.getDeliveryTag(),false);
}
};
//消费，消息从ready状态，变成unacked状态
//channel.basicConsume(ConnectionUtil.QUEUE_NAME, deliverCallback);
//消费自动确认，一旦选择这种模式，消费发送到消费端，不管消息是否被消费端正常消费，都会将队列中的消息删除掉
channel.basicConsume(ConnectionUtil.QUEUE_NAME,true, deliverCallback);
//手工确认
channel.basicConsume(ConnectionUtil.QUEUE_NAME,false, deliverCallback);
}
第二种 springboot 注解方式
在配置类定义监听器容器工厂，设置手工确认
//监听器容器工厂
@Bean
public SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory(){
SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory = new SimpleRabbitListenerContainerFactory();
//首先将连接工厂注入进来
simpleRabbitListenerContainerFactory.setConnectionFactory(connectionFactory());
//设置手工确认
simpleRabbitListenerContainerFactory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
return simpleRabbitListenerContainerFactory;
}
消费端监听队列
//containerFactory指定监听器容器，来决定监听器是否自动确认
@RabbitListener(queues = "queue4",containerFactory = "simpleRabbitListenerContainerFactory")
public void get(String message ){
System.out.println(new String(message.getBody(),"utf-8"));
System.out.println("消费者1");
}
第三种 javabean方式
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(){
SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer();
simpleMessageListenerContainer.setConnectionFactory(connectionFactory());
//设置消息监听器
simpleMessageListenerContainer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
try {
System.out.println(new String(message.getBody(),"utf-8"));
System.out.println("消息监听器-javaconfig");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
});
//添加要监听的队列名集合
simpleMessageListenerContainer.addQueueNames("queue4","queue1");
//添加要监听的队列
//simpleMessageListenerContainer.addQueues(new Queue("queue4"));
//设置手工确认
//simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
return simpleMessageListenerContainer;
}
二、拒绝机制
//containerFactory指定监听器容器，来决定监听器是否自动确认
@RabbitListener(queues = "queue4",containerFactory = "simpleRabbitListenerContainerFactory")
public void getMessage(Message message, Channel channel) throws IOException {
//这里可以用fastjson解序列化
System.out.println(new String(message.getBody(),"utf-8"));
//根据库存业务操作决定消息确认或者退回
if(repertoryOp()){
//channel根据消息配置中的id确认消息，第二个参数表示，是否是批量处理。
//如果是批量处理，可以再多少条之后，提交一次即可，保证最后一笔消息id被提交，前面的也就相当于提交了。
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
System.out.println("消息确认");
}else{
//消息退回
//这个可以批量退回
//第一个参数：消息id,第二个参数：是否批量退回，第三个参数：是否退回消息队列（否则丢弃）
channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
//单条退回
//channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
System.out.println("消息退回");
}
System.out.println("消费者4");
}
private boolean repertoryOp(){
return true;
}
三、消息预取
一般正常多个消费端消费队列时，会默认采用轮询机制，把所有队列中的消息直接平均分配到各个消费端。这个时候，有可能不同的消费端消费能力不同，造成有的消费端很快消费完，别的消费端迟迟消费不完的情况。
注意：这种方式，队列中的消息，是直接压到消费端，队列中不存在消息。
对于这种情况，可以采用消息预取的机制，每次消费端从队列中预取一定数量的消息，处理完后再次预取一定量消息再次消费。这时候，消费端只能采用手工确认的方式。
这里生产者模拟生产一百条消息：
public static void sendByExchange(String message) throws Exception {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
//生产者适合创建交换机和绑定，至于队列在生产者或者消费者创建都可以
// 声明exchange
// channel.exchangeDeclare(ConnectionUtil.EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
channel.exchangeDeclare("te", BuiltinExchangeType.FANOUT);
//声明队列
// 第二个参数表示队列是否持久化（跟消息持久化不同），
// 第三个参数表示是否是排他队列，表示这个队列只能绑定在这个链接上。
// 第四个参数，表示是否队列为空时删除，一般结合第三个参数为ture使用true
// 第五个参数为队列配置参数集合
channel.queueDeclare("queue4", true, false, false, null);
// channel.queueDeclare(ConnectionUtil.QUEUE_NAME, true, false, false, null);
//交换机和队列绑定
channel.queueBind("queue4","te", "direct.key");
// channel.queueBind(ConnectionUtil.QUEUE_NAME, ConnectionUtil.EXCHANGE_NAME, "test");
// channel.basicPublish(ConnectionUtil.EXCHANGE_NAME, "", null,
// message.getBytes());
for(int i = 0; i < 100; i++){
channel.basicPublish("te", "direct.key", null,
(message + i).getBytes());
System.out.println("发送的信息为:" + message + i);
}
channel.close();
connection.close();
}
消费端有两个消费者消费消息：
消费者1
public static void getMessage() throws Exception {
Connection connection = ConnectionUtil.getConnection();
final Channel channel = connection.createChannel();
DefaultConsumer deliverCallback = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println(new String(body, "UTF-8"));
//表示消息消费成功
System.out.println("消费者1消费消息成功");
//手工确认，第一个参数是消息的id,第二个参数是批量标识（ture标识批量）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
//手工确认
channel.basicConsume("queue4",false, deliverCallback);
}
消费者2
public static void getMessage() throws Exception {
Connection connection = ConnectionUtil.getConnection();
final Channel channel = connection.createChannel();
DefaultConsumer deliverCallback = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
//模拟较长时间的业务逻辑
Thread.sleep(50);
System.out.println(new String(body, "UTF-8"));
//表示消息消费成功
System.out.println("消费者2消费消息成功");
//手工确认，第一个参数是消息的id,第二个参数是批量标识（ture标识批量）
channel.basicAck(envelope.getDeliveryTag(),false);
}
};
//手工确认
channel.basicConsume("queue4",false, deliverCallback);
}
执行结果：
会发现队列中没有消息的任何状态，消费者1会分配到50个消息（0,2,4,6~98）,消费者2也会分配到50个消息（1,3,5,…99）.但是消费者2会执行较长时间，而消费者1会很快消费完。
如果消费者中增加预取处理：
//消息预取
channel.basicQos(1);
会发现消费者1会直接消费掉99条消息，而消费者2只消费一条消息。能够很好充分利用消费端消费能力。
springboot设置消息预取：
@Bean
public SimpleRabbitListenerContainerFactory
simpleRabbitListenerContainerFactory(ConnectionFactory connectionFactory){
SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory =
new SimpleRabbitListenerContainerFactory();
simpleRabbitListenerContainerFactory.setConnectionFactory(connectionFactory);
//手动确认消息
simpleRabbitListenerContainerFactory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
//设置消息预取的数量
simpleRabbitListenerContainerFactory.setPrefetchCount(1);
return simpleRabbitListenerContainerFactory;
}
关于这个预取的数量如何设置呢？
我们发现 如果设置为1 能极大的利用客户端的性能（我消费完了就可以赶紧消
费下一条 不会导致忙的很忙 闲的很闲） 但是， 我们每消费一条消息 就要通知一次rabbitmq 然后再取出新的消息， 这样对于rabbitmq的性能来讲 是非常不合理的 所以这个参数要根据业务情况设置。
这里发现预取的数据量从1~2500条，性能越高，可靠性越低，中间值为500。
一般预取一定的数量消息，然后批量确认。