在线教育平台-day05-消息队列

1. 页面发布

业务流程如下：
1、管理员进入管理界面点击“页面发布”，前端请求cms页面发布接口。
2、cms页面发布接口执行页面静态化，并将静态化页面(html文件)存储至GridFS中。
3、静态化成功后，向消息队列发送页面发布的消息。
页面发布的最终目标是将页面发布到服务器。
通过消息队列将页面发布的消息发送给各各服务器。
3、消息队列负责将消息发送给各各服务器上部署的Cms Client(Cms客户端)。
在服务器上部署Cms Client(Cms客户端)，客户端接收消息队列的通知。
4、每个接收到页面发布消息的Cms Client从GridFS获取Html页面文件，并将Html文件存储在本地服务器。
CmsClient根据页面发布消息的内容请求GridFS获取页面文件，存储在本地服务器。

2. RabbitMQ研究

2.1 介绍

2.1.1 RabbitMQ

MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message
Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开
发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com/
开发中消息队列通常有如下应用场景：
1、任务异步处理。
将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。
2、应用程序解耦合
MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

市场上还有哪些消息队列？
ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。
为什么使用RabbitMQ呢？
1、使得简单，功能强大。
2、基于AMQP协议。
3、社区活跃，文档完善。
4、高并发性能好，这主要得益于Erlang语言。
5、Spring Boot默认已集成RabbitMQ

2.1.2 其它相关知识

AMQP,即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。

2.2 快速入门

2.2.1 工作原理

组成部分说明如下：

• Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。
• Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。
• Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。
• Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。
• Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。

消息发布接收流程：
-----发送消息-----
1、生产者和Broker建立TCP连接。
2、生产者和Broker建立通道。
3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。
4、Exchange将消息转发到指定的Queue（队列）
----接收消息-----
1、消费者和Broker建立TCP连接
2、消费者和Broker建立通道
3、消费者监听指定的Queue（队列）
4、当有消息到达Queue时Broker默认将消息推送给消费者。
5、消费者接收到消息。

2.2.2 下载安装 略

2.2.3 Hello World

2.2.3.1 搭建环境

1. java client
   生产者和消费者都属于客户端，rabbitMQ的java客户端如下：
   参考 ：https://github.com/rabbitmq/rabbitmq-java-client/
2. 创建maven工程
   创建生产者工程和消费者工程，分别加入RabbitMQ java client的依赖。

• test-rabbitmq-producer：生产者工程
• test-rabbitmq-consumer：消费者工程

	<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
     <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>

2.2.3.2 生产者

public class Producer01 {

  private static final Logger LOGGER = LoggerFactory.getLogger(Producer01.class);
  private static final String QUEUE = "helloworld";

  public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = null;
    Channel channel = null;
    try {
      // 1.创建与rabbitmq的TCP连接
      ConnectionFactory connectionFactory = new ConnectionFactory();
      connectionFactory.setHost("localhost");
      connectionFactory.setPort(5672);
      connectionFactory.setUsername("guest");
      connectionFactory.setPassword("guest");
      // rabbitmq默认虚拟机名称为"/",虚拟机相当于一个独立的mq服务器
      connectionFactory.setVirtualHost("/");
      connection = connectionFactory.newConnection();

      // 2.创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
      channel = connection.createChannel();

      /** 3. 声明队列
       * queue:队列名称
       * durable：是否持久化，true的时候重启服务的时候保留队列
       * exclusive: 是否独占此连接
       * autoDelete: 队列不再使用的时候是否自动删除
       * arguments: 队列参数
       */
      channel.queueDeclare(QUEUE, true, false, false, null);

      // 4.发送消息
      String msg = "Hello World之消息队列" + System.currentTimeMillis();
      /**
       * exchange:交换机名称,如没有指定,使用Default Exchange
       * routingKey:消息路由key,用于Exchange将消息转化到指定消息队列
       * props:消息包含属性
       * body:消息体
       */
      channel.basicPublish("", QUEUE, null, msg.getBytes());
      System.out.println("Msg is " + msg);
    } catch (Exception e) {
      LOGGER.error("send msg", e);
    } finally {
      if (channel != null) {
        channel.close();
      }
      if (connection != null) {
        connection.close();
      }
    }
  }
}

2.2.3.3 消费者

public class Consumer01 {

  private static final Logger LOGGER = LoggerFactory.getLogger(Consumer01.class);
  private static final String QUEUE = "helloworld";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 1.创建与rabbitmq的TCP连接
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    Connection connection = connectionFactory.newConnection();
    //2.创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
    Channel channel = connection.createChannel();
    /** 3. 声明队列
     * queue:队列名称
     * durable：是否持久化，true的时候重启服务的时候保留队列
     * exclusive: 是否独占此连接
     * autoDelete: 队列不再使用的时候是否自动删除
     * arguments: 队列参数
     */
    channel.queueDeclare(QUEUE, true, false, false, null);

    // 4.定义消费方法
    DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
      /**
       * 消费者接受消息调用此方法
       * @param consumerTag 消费者标签,
       * @param envelope 信封,封装消息id,消息routingKey,交换机和重传标准
       * @param properties 消息属性
       * @param body 消息体
       * @throws IOException
       */
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
          byte[] body) throws IOException {
        // 交换机
        String exchange = envelope.getExchange();
        // 路由key
        String routingKey = envelope.getRoutingKey();
        // 消息id
        long deliveryTag = envelope.getDeliveryTag();
        String msg = new String(body, "UTF-8");
        System.out.println(exchange + "-" + routingKey + "-" + deliveryTag + "-" + "msg");
      }
    };

    /**
     * 监听队列
     * queue: 队列名称
     * autoAck: 是否自动回复,true表示消息接收到自动向mq回复接收到 ,mq接收到会删除消息,false表示需要手动删除消息
     * callback : 消费消息的方法,消费者接收到消息后调用此方法
     */
    channel.basicConsume(QUEUE, true, defaultConsumer);
  }
}

2.2.3.4 总结

• 1、发送端操作流程
  1）创建连接
  2）创建通道
  3）声明队列
  4）发送消息
• 2、接收端
  1）创建连接
  2）创建通道
  3）声明队列
  4）监听队列
  5）接收消息
  6）ack回复

2.3 工作模式

RabbitMQ有以下几种工作模式 ：
1、Work queues
2、Publish/Subscribe
3、Routing
4、Topics
5、Header
6、RPC

2.3.1 Work queues

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。
应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
测试：
1、使用入门程序，启动多个消费者。
2、生产者发送多个消息。
结果：
1、一条消息只会被一个消费者接收；
2、rabbit采用轮询的方式将消息是平均发送给消费者的；
3、消费者在处理完某条消息后，才会收到下一条消息。

2.3.2 Publish/subscribe

发布订阅模式：
1、每个消费者监听自己的队列。
2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收
到消息

2.3.2.1代码

案例: 用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法.

• 生产者
  声明Exchange_fanout_inform交换机。
  声明两个队列并且绑定到此交换机，绑定时不需要指定routingkey
  发送消息时不需要指定routingkey

public class Producer02_publish {

  //队列名称
  private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
  // 交换机
  private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

  public static void main(String[] args) {
    Connection connection = null;
    Channel channel = null;
    try {
      // 创建一个与MQ的连接
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("127.0.0.1");
      factory.setPort(5672);
      factory.setUsername("guest");
      factory.setPassword("guest");
      factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
      //创建一个连接
      connection = factory.newConnection();

      //创建与交换机的通道，每个通道代表一个会话
      channel = connection.createChannel();

      //声明交换机 String exchange, BuiltinExchangeType type
      /**
       * 参数明细
       * 1、交换机名称
       * 2、交换机类型，fanout、topic、direct、headers
       */
      channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);

      //声明队列
      // (String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object > arguments)
      /**
       * 参数明细：
       * 1、队列名称
       * 2、是否持久化
       * 3、是否独占此队列
       * 4、队列不用是否自动删除
       * 5、参数
       */
      channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
      channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);

      //交换机和队列绑定String queue, String exchange, String routingKey
      /**
       * 参数明细
       * 1、队列名称
       * 2、交换机名称
       * 3、路由key
       */
      channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");
      channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_FANOUT_INFORM, "");
      //发送消息
      for (int i = 0; i < 10; i++) {
        String message = "inform to user" + i;
        //向交换机发送消息 String exchange, String routingKey, BasicProperties props,byte[] body
        /**
         * 参数明细
         * 1、交换机名称，不指令使用默认交换机名称 Default Exchange
         * 2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消
         息将发到此队列
         * 3、消息属性
         * 4、消息内容
         */
        channel.basicPublish(EXCHANGE_FANOUT_INFORM, "", null, message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
    } catch (IOException e) {
      e.printStackTrace();
    } catch (TimeoutException e) {
      e.printStackTrace();
    } finally {
      if (channel != null) {
        try {
          channel.close();
        } catch (IOException e) {
          e.printStackTrace();
        } catch (TimeoutException e) {
          e.printStackTrace();
        }
      }
      if (connection != null) {
        try {
          connection.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }

}

• 邮件消费者

public class Consumer02_subscribe_email {

  //队列名称
  private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  // 交换机
  private static final String EXCHANGE_FANOUT_INFORM = "exchange_fanout_inform";

  public static void main(String[] args) throws IOException, TimeoutException {
    //创建一个与MQ的连接
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("127.0.0.1");
    factory.setPort(5672);
    factory.setUsername("guest");
    factory.setPassword("guest");
    factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
    //创建一个连接
    Connection connection = factory.newConnection();
    //创建与交换机的通道，每个通道代表一个会话
    Channel channel = connection.createChannel();
    
    //声明交换机 String exchange, BuiltinExchangeType type
    /**
     * 参数明细
     * 1、交换机名称
     * 2、交换机类型，fanout、topic、direct、headers
     */
    channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
    
    //声明队列
    // channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map < String, Object > arguments)
    /**
     * 参数明细：
     * 1、队列名称
     * 2、是否持久化
     * 3、是否独占此队列
     * 4、队列不用是否自动删除
     * 5、参数
     */
    channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
    //交换机和队列绑定String queue, String exchange, String routingKey
    /**
     * 参数明细
     * 1、队列名称
     * 2、交换机名称
     * 3、路由key
     */
    channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");

    //定义消费方法
    DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope,
          AMQP.BasicProperties properties, byte[] body) throws IOException {
        long deliveryTag = envelope.getDeliveryTag();
        String exchange = envelope.getExchange();
        //消息内容
        String message = new String(body, "utf-8");
        System.out.println(message);
      }
    };
    /**
     * 监听队列String queue, boolean autoAck,Consumer callback
     * 参数明细
     * 1、队列名称
     * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
     为false则需要手动回复
     * 3、消费消息的方法，消费者接收到消息后调用此方法
     */
    channel.basicConsume(QUEUE_INFORM_EMAIL, true, defaultConsumer);
  }

}

• 短信消费者

2.3.2.2 思考

1、publish/subscribe与work queues有什么区别。
区别：
1）work queues不用定义交换机，而publish/subscribe需要定义交换机。
2）publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认
交换机)。
3）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑
定到默认的交换机 。
相同点：
所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。
2、实质工作用什么 publish/subscribe还是work queues。
建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换
机。

2.3.3 Routing

路由模式：
1、每个消费者监听自己的队列，并且设置routingkey。
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。

2.3.3.1 代码

• 生产者
  声明exchange_routing_inform交换机。
  声明两个队列并且绑定到此交换机，绑定时需要指定routingkey
  发送消息时需要指定routingkey

public class Producer03_routing {

  //队列名称
  private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
  // 交换机
  private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

  public static void main(String[] args) {
    Connection connection = null;
    Channel channel = null;
    try {
      //创建一个与MQ的连接
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("127.0.0.1");
      factory.setPort(5672);
      factory.setUsername("guest");
      factory.setPassword("guest");
      factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
      //创建一个连接
      connection = factory.newConnection();
      //创建与交换机的通道，每个通道代表一个会话
      channel = connection.createChannel();
      //声明交换机 String exchange, BuiltinExchangeType type
      /**
       * 参数明细
       * 1、交换机名称
       * 2、交换机类型，fanout、topic、direct、headers
       */
      channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
      
      //声明队列
      // channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map < String, Object > arguments)
      /**
       * 参数明细：
       * 1、队列名称
       * 2、是否持久化
       * 3、是否独占此队列
       * 4、队列不用是否自动删除
       * 5、参数
       */
      channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
      channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
      
      //交换机和队列绑定String queue, String exchange, String routingKey
      /**
       * 参数明细
       * 1、队列名称
       * 2、交换机名称
       * 3、路由key
       */
      channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_EMAIL);
      channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_SMS);
      //发送邮件消息
      for (int i = 0; i < 10; i++) {
        String message = "email inform to user" + i;
        //向交换机发送消息 String exchange, String routingKey, BasicProperties props,byte[] body
        /**
         * 参数明细
         * 1、交换机名称，不指令使用默认交换机名称 Default Exchange
         * 2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消
         息将发到此队列
         * 3、消息属性
         * 4、消息内容
         */
        channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_EMAIL, null, message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
      //发送短信消息
      for (int i = 0; i < 10; i++) {
        String message = "sms inform to user" + i;
        //向交换机发送消息 String exchange, String routingKey, BasicProperties props,byte[] body
        channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_SMS, null, message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
    } catch (IOException e) {
      e.printStackTrace();
    } catch (TimeoutException e) {
      e.printStackTrace();
    } finally {
      if (channel != null) {
        try {
          channel.close();
        } catch (IOException e) {
          e.printStackTrace();
        } catch (TimeoutException e) {
          e.printStackTrace();
        }
      }
      if (connection != null) {
        try {
          connection.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }

}

• 邮件消费者

public class Consumer03_routing_email {

  // 队列名称
  private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  // 队列
  private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

  public static void main(String[] args) throws IOException, TimeoutException {
    //创建一个与MQ的连接
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("127.0.0.1");
    factory.setPort(5672);
    factory.setUsername("guest");
    factory.setPassword("guest");
    factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
    //创建一个连接
    Connection connection = factory.newConnection();
    //创建与交换机的通道，每个通道代表一个会话
    Channel channel = connection.createChannel();
    //声明交换机 String exchange, BuiltinExchangeType type
    /**
     * 参数明细
     * 1、交换机名称
     * 2、交换机类型，fanout、topic、direct、headers
     */
    channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);

    //声明队列
    // channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map < String, Object > arguments)
    /**
     * 参数明细：
     * 1、队列名称
     * 2、是否持久化
     * 3、是否独占此队列
     * 4、队列不用是否自动删除
     * 5、参数
     */
    channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);

    //交换机和队列绑定String queue, String exchange, String routingKey
    /**
     * 参数明细
     * 1、队列名称
     * 2、交换机名称
     * 3、路由key
     */
    channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_EMAIL);
    //定义消费方法
    DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope,
          AMQP.BasicProperties properties, byte[] body) throws IOException {
        long deliveryTag = envelope.getDeliveryTag();
        String exchange = envelope.getExchange();
        //消息内容
        String message = new String(body, "utf-8");
        System.out.println(message);
      }
    };
    /**
     * 监听队列String queue, boolean autoAck,Consumer callback
     * 参数明细
     * 1、队列名称
     * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
     为false则需要手动回复
     * 3、消费消息的方法，消费者接收到消息后调用此方法
     */
    channel.basicConsume(QUEUE_INFORM_EMAIL, true, defaultConsumer);
  }
}

• 短信消费者

public class Consumer03_routing_sms {

  //队列名称
  private static final String QUEUE_INFORM_SMS = "queue_inform_sms";

  private static final String EXCHANGE_ROUTING_INFORM = "exchange_routing_inform";

  public static void main(String[] args) throws IOException, TimeoutException {
    //创建一个与MQ的连接
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("127.0.0.1");
    factory.setPort(5672);
    factory.setUsername("guest");
    factory.setPassword("guest");
    factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
    //创建一个连接
    Connection connection = factory.newConnection();
    //创建与交换机的通道，每个通道代表一个会话
    Channel channel = connection.createChannel();
    //声明交换机 String exchange, BuiltinExchangeType type
    /**
     * 参数明细
     * 1、交换机名称
     * 2、交换机类型，fanout、topic、direct、headers
     */
    channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);

    //声明队列
    // channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map < String, Object > arguments)
    /**
     * 参数明细：
     * 1、队列名称
     * 2、是否持久化
     * 3、是否独占此队列
     * 4、队列不用是否自动删除
     * 5、参数
     */
    channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);

    //交换机和队列绑定String queue, String exchange, String routingKey
    /**
     * 参数明细
     * 1、队列名称
     * 2、交换机名称
     * 3、路由key
     */
    channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_SMS);
    //定义消费方法
    DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope,
          AMQP.BasicProperties properties, byte[] body) throws IOException {
        long deliveryTag = envelope.getDeliveryTag();
        String exchange = envelope.getExchange();
        //消息内容
        String message = new String(body, "utf-8");
        System.out.println(message);
      }
    };
    /**
     * 监听队列String queue, boolean autoAck,Consumer callback
     * 参数明细
     * 1、队列名称
     * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
     为false则需要手动回复
     * 3、消费消息的方法，消费者接收到消息后调用此方法
     */
    channel.basicConsume(QUEUE_INFORM_SMS, true, defaultConsumer);
  }

}

2.3.3.2 思考

1、Routing模式和Publish/subscibe有啥区别？
Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。

2.3.4 Topics

主题模式：
1、每个消费者监听自己的队列，并且设置带通配符的routingkey。
2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。

2.3.4.1 代码

案例：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种
通知类型都接收的则两种通知都有效。

• 生产者

public class Producer04_topics {

  //队列名称
  private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
  // 交换机
  private static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";

  public static void main(String[] args) {
    Connection connection = null;
    Channel channel = null;
    try {
      //创建一个与MQ的连接
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("127.0.0.1");
      factory.setPort(5672);
      factory.setUsername("guest");
      factory.setPassword("guest");
      factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务 器
      //创建一个连接
      connection = factory.newConnection();
      //创建与交换机的通道，每个通道代表一个会话
      channel = connection.createChannel();

      //声明交换机 String exchange, BuiltinExchangeType type
      /**
       * 参数明细
       * 1、交换机名称
       * 2、交换机类型，fanout、topic、direct、headers
       */
      channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);

      //声明队列
      /**
       * 参数明细：
       * 1、队列名称
       * 2、是否持久化
       * 3、是否独占此队列
       * 4、队列不用是否自动删除
       * 5、参数
       */
      channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
      channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);

      //发送邮件消息
      for (int i = 0; i < 10; i++) {
        String message = "email inform to user" + i;
        //向交换机发送消息 String exchange, String routingKey, BasicProperties props,   byte[] body
        /**
         * 参数明细
         * 1、交换机名称，不指令使用默认交换机名称 Default Exchange
         * 2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消
         息将发到此队列
         * 3、消息属性
         * 4、消息内容
         */
        channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.email", null,
            message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
      //发送短信消息
      for (int i = 0; i < 10; i++) {
        String message = "sms inform to user" + i;
        channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms", null,
            message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
      //发送短信和邮件消息
      for (int i = 0; i < 10; i++) {
        String message = "sms and email inform to user" + i;
        channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms.email", null,
            message.getBytes());
        System.out.println("Send Message is:'" + message + "'");
      }
    } catch (IOException e) {
      e.printStackTrace();
    } catch (TimeoutException e) {
      e.printStackTrace();
    } finally {
      if (channel != null) {
        try {
          channel.close();
        } catch (IOException e) {
          e.printStackTrace();
        } catch (TimeoutException e) {
          e.printStackTrace();
        }
      }
      if (connection != null) {
        try {
          connection.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

• 消费者
  队列绑定交换机指定通配符：
  统配符规则：
  中间以“.”分隔。
  符号#可以匹配多个词，符号*可以匹配一个词语。

//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
//声明交换机
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//绑定email通知队列
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,"inform.#.email.#");
//绑定sms通知队列
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,"inform.#.sms.#");

2.3.4.2 思考

1、本案例的需求使用Routing工作模式能否实现？
使用Routing模式也可以实现本案例，共设置三个 routingkey，分别是email、sms、all，email队列绑定email和all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。
Topic模式更多加强大，它可以实现Routing、publish/subscirbe模式的功能。

2.3.5 Headers

header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配队列。
案例：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种通知类型都接收的则两种通知都有效。

• 生产者

Map<String, Object> headers_email = new Hashtable<String, Object>();
headers_email.put("inform_type", "email");
Map<String, Object> headers_sms = new Hashtable<String, Object>();
headers_sms.put("inform_type", "sms");
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_HEADERS_INFORM,"",headers_sms);

String message = "email inform to user"+i;
Map<String,Object> headers = new Hashtable<String, Object>();
headers.put("inform_type", "email");//匹配email通知消费者绑定的header
//headers.put("inform_type", "sms");//匹配sms通知消费者绑定的header
AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder();
properties.headers(headers);
//Email通知
channel.basicPublish(EXCHANGE_HEADERS_INFORM, "", properties.build(), message.getBytes());

• 消费者

channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS);
Map<String, Object> headers_email = new Hashtable<String, Object>();
headers_email.put("inform_email", "email");
//交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
//指定消费队列
channel.basicConsume(QUEUE_INFORM_EMAIL, true, consumer);

2.3.6 RPC模式

RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：
1、客户端即是生产者就是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
3、服务端将RPC方法 的结果发送到RPC响应队列
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

2.4 整合springboot

2.4.1 依赖

	<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>

2.4.2 配置

1. 配置application.yml

server:
  port: 44000
spring:
  application:
	name: test‐rabbitmq‐producer
  rabbitmq:
	host: 127.0.0.1
	port: 5672
	username: guest
	password: guest
	virtualHost: /

2. 定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。
   本例配置Topic交换机。

@Configuration
public class RabbitmqConfig {

  // 消息队列
  public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
  public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
  // 交换机
  public static final String EXCHANGE_TOPICS_INFORM = "exchange_topics_inform";

  /**
   * 交换机配置 ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
   *
   * @return the exchange
   */
  @Bean(EXCHANGE_TOPICS_INFORM)
  public Exchange EXCHANGE_TOPICS_INFORM() {
    //durable(true)持久化，消息队列重启后交换机仍然存在
    return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
  }

  //声明队列
  @Bean(QUEUE_INFORM_SMS)
  public Queue QUEUE_INFORM_SMS() {
    return new Queue(QUEUE_INFORM_SMS);
  }

  //声明队列
  @Bean(QUEUE_INFORM_EMAIL)
  public Queue QUEUE_INFORM_EMAIL() {
    return new Queue(QUEUE_INFORM_EMAIL);
  }

  /**
   * channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#"); 绑定队列到交换机 . *
   *
   * @param queue    the queue
   * @param exchange the exchange
   * @return the binding
   */
  @Bean
  public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
      @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
  }

  @Bean
  public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
      @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
  }
}

3. 生产者

@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot {

  @Autowired
  private RabbitTemplate rabbitTemplate;

  @Test
  public void testSendByTopics() {
    for (int i = 0; i < 5; i++) {
      String message = "sms email inform to user" + i;
      rabbitTemplate
          .convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM, "inform.sms.email", message);
      System.out.println("Send Message is:'" + message + "'");
    }
  }

}

4. 消费者

@Component
public class ReceiveHandler {

  //监听email队列
  @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
  public void receive_email(String msg, Message message, Channel channel) {
    System.out.println(msg);
  }

  //监听sms队列
  @RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
  public void receive_sms(String msg, Message message, Channel channel) {
    System.out.println(msg);
  }
}