RabbiitMQ 消息丢失问题

    String basicConsume(String queue, boolean autoAck, Consumer callback) 
throws IOException;
     String basicConsume(String queue, Consumer callback) 
throws IOException;

1. 当我们在作为消费者调用 basicConsume 方法的时候，如果我们设置了autoAck为true，那么在消费者接收到消息之后，rabbitmq会自动删除这个消息，此时如果我们在callback方法里面的处理逻辑有异常或者处理失败，我们想重新消费这条消息的时候就无法消费了，此时就认为消息丢失了。
2. 那么有没有方法解决这个问题，可以在设置的时候actoAck=false或者调用不含autoAck的basicConsume方法。此时消息如果没有被主动确认的话，那么休息会进入unacked的状态。当我们重置连接的时候消息又会回到ready的状态。下面代码演示这个过程。

3. import com.rabbitmq.client.Connection;
   import com.rabbitmq.client.ConnectionFactory;
   
   import java.io.IOException;
   import java.util.concurrent.TimeoutException;
   
   public class ConnectionUtil {
       private static ConnectionFactory factory = new ConnectionFactory();
       final static String QUEUE_NAME = "hello";
       static  final  String EXCHANGE_NAME = "exchange";
   
       static {
           factory.setUsername("guest");
           factory.setPassword("guest");
           factory.setHost("127.0.0.1");
           factory.setPort(5672);
           factory.setVirtualHost("/");
       }
   
       public static Connection getConnection() throws IOException, TimeoutException {
           return factory.newConnection();
       }
   }
   
   
   import com.rabbitmq.client.Channel;
   import com.rabbitmq.client.Connection;
   
   import java.io.IOException;
   import java.util.concurrent.TimeoutException;
   
   import static com.org.xcyz.mq.rabbitmq.ConnectionUtil.EXCHANGE_NAME;
   import static com.org.xcyz.mq.rabbitmq.ConnectionUtil.QUEUE_NAME;
   
   public class Producer {
       public static void sendByExchange(String msg) throws IOException, TimeoutException {
           Connection connection = ConnectionUtil.getConnection();
           Channel channel = connection.createChannel();
           channel.queueDeclare(QUEUE_NAME, true, false, false, null);
           channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
           channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
           channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());
           System.out.println("发送的信息为:" + msg);
           channel.close();
           connection.close();
       }
   
       public static void main(String[] args) throws IOException, TimeoutException {
           Producer.sendByExchange("Hello world");
       }
   }
   
   
   
   import com.rabbitmq.client.AMQP;
   import com.rabbitmq.client.Channel;
   import com.rabbitmq.client.Connection;
   import com.rabbitmq.client.DefaultConsumer;
   import com.rabbitmq.client.Envelope;
   
   import java.io.IOException;
   
   
   public class Consumer {
   
       public static void getMessage() throws Exception{
           Connection connection = ConnectionUtil.getConnection();
           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"));
                   try {
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       return;
                   }
                   channel.basicAck(envelope.getDeliveryTag(),false);
               }
   
           };
           channel.basicConsume(ConnectionUtil.QUEUE_NAME,deliverCallback);
       }
   
       public static void main(String[] args) throws Exception {
           Consumer.getMessage();
       }
   
   }

   4. 首先调用生产者产生消息，然后在consumer中设置sleep一秒钟替代处理逻辑，当逻辑有异常的时候直接返回，当逻辑没有异常的时候调用channel.basicAck(envelope.getDeliveryTag(),false);去主动确认消息消费成功