public boolean isOpen(){
    synchronized(this.monitor){
        return this.shutdownCause == null;
    }
}

/**
 * 声明一个交换器
 * @param exchange 交换器名称
 * @param type 交换器类型，常见的如 fanout、direct、topic
 * @param durable 设置是否持久化, true 表示持久化, 反之是非持久化, 持久化可以将交换器存盘, 在服务器重启的时候不会丢失相关信息
 * @param autoDelete 设置是否自动删除, true 表示自动删除, 自动删除的前提是至少有一个队列或者交换器与这个交换器绑定, 之后所有与这个交换器绑定的队列或交换器都于此解绑, 注意不能错误的把这个参数理解为"当与此交换器连接的客户端都断开时, RabbitMQ 会自动删除本交换器"
 * @param internal 设置是否内置的, true 表示是内置的交换器, 客户端程序无法直接发送消息到这个交换器中, 只能通过交换器路由到交换器这个方式
 * @param arguments 其他一些结构化参数, 比如 alternate-exchange
 * @return 需要等待服务器的返回(服务器会返回Exchange.Declare-Ok这个AMQP命令)
 */
Exchange.DeclareOk exchangeDeclare(String exchange,
                                        String type,
                                        boolean durable,
                                        boolean autoDelete,
                                        boolean internal,
                                        Map<String, Object> arguments) throws IOException;

/**
 * 基本同 exchangeDeclare，无返回值。不推荐使用，因为声明完交换器后，但是服务器还并未完成交换器的创建，此时紧接着使用就会发生异常。
 */
... exchangeDeclareNoWait...

/**
 * 检测响应的交换器是否存在，存在则正常返回；如果不存在则抛出异常：404 channel exception，同时 Channel 也会被关闭
 * @param name 交换器名称
 */
Exchange.DeclareOk exchangeDeclarePassive(String name) throws IOException;

/**
 * 删除交换器
 * @param exchange 交换器名称
 * @param ifUnused true 设置是否在交换器没有被使用的情况下删除
 */
Exchange.DeleteOk exchangeDelete(String exchange, boolean ifUnused) throws IOException;

void exchangeDeleteNoWait(String exchange, boolean ifUnused) throws IOException;

/**
 * Declare a queue
 * @param queue 队列的名称
 * @param durable 设置是否持久化, true 表示队列为持久化, 持久化的队列会存盘, 在服务器重启的时候会保证不丢失相关信息
 * @param exclusive 设置是否排他, true 表示队列为排他的, 如果一个队列被设置为排他队列, 该队列仅对首次声明它的连接可见, 并在连接断开时自动删除, (这里需要注意三点:1.排他队列是基于连接Connection可见的, 同一个连接的不同信道Channel是可以同时访问同一连接创建的排他队列;"首次"是指如果一个连接己经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同;即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除，这种队列适用于一个客户端同时发送和读取消息的应用场景)
 * @param autoDelete 设置是否自动删除。为true 则设置队列为自动删除。自动删除的前提是, 至少有一个消费者连接到这个队列，之后所有与这个队列连接的消费者都断开时，才会自动删除。不能把这个参数错误地理解为: "当连接到此队列的所有客户端断开时，这个队列自动删除"，因为生产者客户端创建这个队列，或者没有消费者客户端与这个队列连接时，都不会自动删除这个队列。
 * @param arguments 设置队列的其他一些参数, 如 x-message-ttl 等
 * @return 需要等待服务器的返回(服务器会返回Exchange.Declare-Ok这个AMQP命令)
 */
Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                            Map<String, Object> arguments) throws IOException;

/**
 * 基本同 exchangeDeclare ，无返回值。不推荐使用，因为声明完交换器后，但是服务器还并未完成交换器的创建，此时紧接着使用就会发生异常。
 */
void queueDeclareNoWait(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                            Map<String, Object> arguments) throws IOException;

/**
 * 检测响应的队列是否存在，存在则正常返回；如果不存在则抛出异常：404 channel exception，同时 Channel 也会被关闭
 * @param queue 队列的名称
 */
Queue.DeclareOk queueDeclarePassive(String queue) throws IOException;    

/**
 * 删除队列
 * @param queue 队列的名称
 * @param ifUnused true 设置是否在交换器没有被使用的情况下删除
 * @param ifEmpty true 表示队列为空的情况下才能删除
 */
Queue.DeleteOk queueDelete(String queue, boolean ifUnused, boolean ifEmpty) throws IOException;

void queueDeleteNoWait(String queue, boolean ifUnused, boolean ifEmpty) throws IOException;

/**
 * 清空队列中的内容
 * @param queue 队列的名称
 */
Queue.PurgeOk queuePurge(String queue) throws IOException;

/**
 * 绑定队列到交换器
 * @param queue 队列名
 * @param exchange 交换器名称
 * @param routingKey 路由 key 或者绑定 key
 * @param arguments 一些参数
 */
Queue.BindOk queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments) throws IOException;

void queueBindNoWait(String queue, String exchange, String routingKey, Map<String, Object> arguments) throws IOException;

/**
 * 解除绑定队列到交换器
 * @param queue 队列名
 * @param exchange 交换器名称
 * @param routingKey 路由 key 或者绑定 key
 */
Queue.UnbindOk queueUnbind(String queue, String exchange, String routingKey) throws IOException;

/**
 * 绑定交换器到交换器
 * @param destination 目标交换器
 * @param source 源交换器
 * @param routingKey 路由 key 或者绑定 key
 * @param arguments 一些参数
 */
Exchange.BindOk exchangeBind(String destination, String source, String routingKey, Map<String, Object> arguments) throws IOException;

void exchangeBindNoWait(String destination, String source, String routingKey, Map<String, Object> arguments) throws IOException;

/**
 * 解除绑定交换器到交换器
 * @param destination 目标交换器
 * @param source 源交换器
 * @param routingKey 路由 key 或者绑定 key
 */
Exchange.UnbindOk exchangeUnbind(String destination, String source, String routingKey) throws IOException;

/**
 * 发送消息
 * @param exchange 交换器的名称，指明消息需要发送到哪个交换器中。如果设置为空字符串，则消息会被发送到 RabbitMQ 默认的交换器中。
 * @param routingKey 路由键，交换器根据路由键将消息存储到相应的队列之中。
 * @param mandatory true if the 'mandatory' flag is to be set。
 * @param immediate true if the 'immediate' flag is to be。
 * @param props 消息的基本属性集，其包含14个属性成员，分别有 contentType、contentEncoding、headers、deliveryMode、priority、correlationId、replyTo、expiration、messageId、private Date timestamp、type、userId、appId、clusterId。
 * @param body 消息体(payload)，真正需要发送的消息。
 */
void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body)
    throws IOException;

public interface Consumer {

    void handleConsumeOk(String consumerTag);

    void handleCancelOk(String consumerTag);

    void handleCancel(String consumerTag) throws IOException;

    /**
     * 当 Channel 或者 Connection 关闭的时候会调用。
     */
    void handleShutdownSignal(String consumerTag, ShutdownSignalException sig);

    void handleRecoverOk(String consumerTag);

    void handleDelivery(String consumerTag, Envelope envelope,
                        AMQP.BasicProperties properties, byte[] body) throws IOException;
}

public interface Channel extends ShutdownNotifier, AutoCloseable {

    /**
     * 启动一个消费者，并返回服务端生成的消费者标识
     * @param queue 队列名
     * @param autoAck 设置是否自动确认。建议设成 false，即不自动确认。
     * @param consumerTag 消费者标签，用来区分多个消费者
     * @param noLocal 设置为true则表示不能将同一个 Connection 中生产者发送的消息传送给这个 Connection 的消费者
     * @param exclusive 设置是否排他
     * @param arguments 设置消费者的其他参数
     * @param deliverCallback 当一个消息发送过来后的回调接口
     * @param cancelCallback 当一个消费者取消订阅时的回调接口;取消消费者订阅队列时除了使用{@link Channel#basicCancel}之外的所有方式都会调用该回调方法
     * @param shutdownSignalCallback 当 channel/connection 关闭后回调
     */
    String basicConsume(String queue, boolean autoAck, String consumerTag,
     boolean noLocal, boolean exclusive, Map<String, Object> arguments, 
     DeliverCallback deliverCallback, CancelCallback cancelCallback, 
     ConsumerShutdownSignalCallback shutdownSignalCallback) throws IOException;

}

boolean autoAck = false;
channel.basicQos(64);
channel.basicConsume(QUEUE_NAME, autoAck, "myCunsumerTag", new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("recv message: " + new String(body));
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        channel.basicAck(envelope.getDeliveryTag(), false);
    }
});

/**
 * 拉消息
 * @param queue 队列名
 * @param 设置是否自动确认。建议设成 false，即不自动确认。
 */
GetResponse basicGet(String queue, boolean autoAck) throws IOException;

GetResponse response = channel.basicGet(QUEUE_NAME, false);
System.out.println(new String(response.getBody()));
channel.basicAck(response.getEnvelope().getDeliveryTag(), false);

/**
 * 拒绝消息 
 * @param deliveryTag 消息的编号
 * @param requeue true: RabbitMQ 会重新将这条消息存入队列，以便可以发送给下一个订阅的消费者，false：立即把消息从队列中移除，而不会把它发送给新的消费者。
 */
void basicReject(long deliveryTag, boolean requeue) throws IOException;

/**
 * 批量拒绝消息
 * @param deliveryTag 消息的编号
 * @param multiple true: 表示拒绝 deliveryTag 编号之前所有未被当前消费者确认的消息；false: 和 basicReject 一样，拒绝编号为 deliveryTag 的一条消息
 * @param requeue true: RabbitMQ 会重新将这条消息存入队列，以便可以发送给下一个订阅的消费者，false：立即把消息从队列中移除，而不会把它发送给新的消费者。
 */
void basicNack(long deliveryTag, boolean multiple, boolean requeue) throws IOException;

Basic.RecoverOk basicRecover() throws IOException;

/**
 * 用来请求 RabbitMQ 重新发送还未被确认的消息。
 * @param requeue true：未被确认的消息会被重新加入到队列中，这样对于同一条消息来说，可能会被分配给与之前不同的消费者;false：那么消息会被分配给予之前相同的消费者。默认是 true。
 */
Basic.RecoverOk basicRecover(boolean requeue) throws IOException;

channel.close();
conn.close();

// addShutdownListener
conn.addShutdownListener(new ShutdownListener() {
    @Override
    public void shutdownCompleted(ShutdownSignalException cause) {
        System.out.println("断开连接");
        if(cause.isHardError()){
            Connection c1 = (Connection) cause.getReference();
            if(!cause.isInitiatedByApplication()){
                Method method = cause.getReason();
            }
        } else {
            Channel c2 = (Channel) cause.getReference();
        }
    }
});