【rabbitmq】【03】只能有一个消费端 网络断开时，消费端重连 com.rabbitmq.client.ShutdownSignalException: connection error

1.问题

-Consumer com.rabbitmq.client.QueueingConsumer@6a1f3d18 (amq.ctag-CGdkxm_gRfTzzoUGoQiatw) method handleDelivery for channel AMQChannel(amqp://rabbitmq@192.168.23.73:5672/redisv2,1) 
threw an exception for channel AMQChannel(amqp://rabbitmq@192.168.23.73:5672/redisv2,1)
com.rabbitmq.client.ShutdownSignalException: connection error
	at com.rabbitmq.client.QueueingConsumer.checkShutdown(QueueingConsumer.java:180)
	at com.rabbitmq.client.QueueingConsumer.handleDelivery(QueueingConsumer.java:132)
	at com.rabbitmq.client.impl.ConsumerDispatcher$5.run(ConsumerDispatcher.java:149)
	at com.rabbitmq.client.impl.ConsumerWorkService$WorkPoolRunnable.run(ConsumerWorkService.java:100)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
Caused by: java.net.SocketException: Connection timed out (Read failed)
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at java.io.BufferedInputStream.fill(BufferedInputStream.java:246)
	at java.io.BufferedInputStream.read(BufferedInputStream.java:265)
	at java.io.DataInputStream.readUnsignedByte(DataInputStream.java:288)
	at com.rabbitmq.client.impl.Frame.readFrom(Frame.java:91)
	at com.rabbitmq.client.impl.SocketFrameHandler.readFrame(SocketFrameHandler.java:164)
	at com.rabbitmq.client.impl.AMQConnection$MainLoop.run(AMQConnection.java:571)
	... 1 common frames omitted

2.可以通过windows防火墙限制端口模拟

3.解决demo 判断连接open时，重新建channel

package com.zhenzhen.demo.springboot;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.ShutdownSignalException;
import org.apache.commons.lang3.time.DateFormatUtils;
import redis.clients.jedis.exceptions.JedisDataException;

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

public class DemoConsumer {

    public static void main(String[] args) throws IOException, TimeoutException {

        System.out.println("项目启动"+ DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));

        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.23.73");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("rabbitmq");
        connectionFactory.setPassword("rabbitmq");
        connectionFactory.setVirtualHost("redisv2");

        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setTopologyRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);

        Connection connection =  connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "test-mq-exchange";
        String routingKey =  "test-mq-exchange-routingKey";
        String queueName = "test-mq-exchange-routingKey-queuq";


        QueueingConsumer consumer = getConsumer(exchangeName,routingKey,queueName,channel);


        while (true) {
            QueueingConsumer.Delivery delivery = null;
            try {
                delivery = consumer.nextDelivery();

                String message = new String(delivery.getBody());

                System.out.println(message);

                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            } catch (JedisDataException e) {
                //reids操作异常
                if (delivery != null) {
                    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
                }
                e.printStackTrace();

            } catch (ShutdownSignalException e) {

                try {
                    Thread.sleep(5000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }

                if(connection.isOpen()){
                    channel.close();
                    connection = connectionFactory.newConnection();
                    System.out.println("连接出现故障重新恢复");

                    try {
                        Thread.sleep(120000);
                        //等待连接彻底关闭
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }


                    channel = connection.createChannel();
                    consumer = getConsumer(exchangeName,routingKey,queueName,channel);
                }

                e.printStackTrace();
            } catch (Exception e) {
                //打印错误记录日志，分析恢复
                e.printStackTrace();
            }
        }

    }

    private static QueueingConsumer getConsumer(String exchangeName, String routingKey, String queueName, Channel channel) throws IOException {
        channel.exchangeDeclare(exchangeName, "topic", true, false, null);
        channel.queueDeclare(queueName, true, false, false, null);
        channel.queueBind(queueName, exchangeName, routingKey);

        QueueingConsumer consumer = new QueueingConsumer(channel);

        channel.basicQos(20);
        channel.basicConsume(queueName, false,consumer);
        return consumer;
    }
}