5.rabbitmq--通配符模式Topics

rabbitmq--通配符模式Topics

topic模式也称为主题模式，其实他相对于routing模式最大的好处就是他多了一种匹配模式的路由，怎么理解匹配呢，其实就相当于我们之前正则的.*这种，不过他的匹配机制可能不是这种（其实除了匹配规则外，他的作用就和routing模式一样 ），而他的工作流程图如下：

OK！ 先说一下他的匹配规则：

绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况： 
①*（星号）仅代表一个单词 
②#（井号）代表任意个单词

示例：

以上图为例：

*.orange.* :  匹配以 任意一个单词字符开头中间包含 .orange. 以任意一个单词字符结尾 的字符串。比如 a.orange.b, sdfsd.orange.fdsfsdf 等（注意是一个单词）。

lay.# ：只要一lay.开头的都匹配，他可以匹配lay.a, lay.a.b, lay.b.c等。

这样是不是很方便，比如我们想将log的发给q1队列，其他的发给q2，那么我们只需要定义log.#、或者log.*,那么你发送给q1队列的数据就是log日志的消息。

 package com.maozw.mq.topic;

 import com.maozw.mq.config.RabbitConfig;
 import com.rabbitmq.client.Channel;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.amqp.rabbit.connection.Connection;
 import org.springframework.amqp.rabbit.connection.ConnectionFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

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

 import static org.apache.log4j.varia.ExternallyRolledFileAppender.OK;

 /**
  * work 模式
  * 两种分发： 轮询分发 + 公平分发
  * 轮询分发：消费端：自动确认消息；boolean autoAck = true;
  * 公平分发: 消费端：手动确认消息 boolean autoAck = false; channel.basicAck(envelope.getDeliveryTag(),false);
  *
  * @author MAOZW
  * @Description: 商品
  * @date 2018/11/26 15:06
  */
 @RestController
 @RequestMapping("/topic")
 public class TopicProducer {
     private static final Logger LOGGER = LoggerFactory.getLogger(TopicProducer.class);
     @Autowired
     RabbitConfig rabbitConfig;

     public static final String EXCHANGE_TOPIC = "EXCHANGE_TOPIC";
     private static final String[] routingKeys = {"commodity.add", "commodity.update", "commodity.select", "commodity.delete"};

     @RequestMapping("/send")
     public String send() throws IOException, TimeoutException {
         Connection connection = null;
         Channel channel = null;
         try {
             ConnectionFactory connectionFactory = rabbitConfig.connectionFactory();
             connection = connectionFactory.createConnection();
             channel = connection.createChannel(false);

             /**
              * 申明交换机 以及type
              */
             channel.exchangeDeclare(EXCHANGE_TOPIC, "topic");
             /**
              * 发送消息
              * 每个消费者 发送确认消息之前，消息队列不会发送下一个消息给消费者，一次只处理一个消息
              * 自动模式无需设置下面设置
              */
             int prefetchCount = 1;
             channel.basicQos(prefetchCount);

             String Hello = ">>>> Hello EXCHANGE_TOPIC <<<<";
             String message = Hello;
             for (String routingKey : routingKeys) {
                 channel.basicPublish(EXCHANGE_TOPIC, routingKey, null, message.getBytes());
             }
             LOGGER.info("生产消息： " + message);
             return "OK";
         } catch (Exception e) {

         } finally {
             connection.close();
             channel.close();
             return OK;
         }
     }
 }

 package com.maozw.mq.topic;

 import com.maozw.mq.config.RabbitConfig;
 import com.rabbitmq.client.AMQP;
 import com.rabbitmq.client.Channel;
 import com.rabbitmq.client.DefaultConsumer;
 import com.rabbitmq.client.Envelope;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.amqp.rabbit.connection.Connection;
 import org.springframework.amqp.rabbit.connection.ConnectionFactory;

 import java.io.IOException;

 /**
  * @author MAOZW
  * @Description: ${todo}
  * @date 2018/11/26 15:06
  */

 public class TopicConsumer {
     private static final Logger LOGGER = LoggerFactory.getLogger(TopicConsumer.class);
     public static final String EXCHANGE_TOPIC = "EXCHANGE_TOPIC";
     private static final String[] routingKeys = {"commodity.add", "commodity.update", "commodity.delete"};

     public static void main(String[] args) throws IOException {
         ConnectionFactory connectionFactory = RabbitConfig.getConnectionFactory();
         Connection connection = connectionFactory.createConnection();
         Channel channel = connection.createChannel(false);
         /**
          * 创建队列申明
          */
         boolean durable = true;
         channel.queueDeclare(RabbitConfig.QUEUE_TOPIC, durable, false, false, null);
         /**
          * 绑定队列到交换机
          */
         channel.queueBind(RabbitConfig.QUEUE_TOPIC, EXCHANGE_TOPIC, "commodity.add");

         /**
          * 改变分发规则
          */
         channel.basicQos(1);
         DefaultConsumer consumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 super.handleDelivery(consumerTag, envelope, properties, body);
                 System.out.println("[1] 接口数据 ： " + new String(body, "utf-8"));
                 try {
                     Thread.sleep(300);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     System.out.println("[1] done!");
                     //消息应答：手动回执，手动确认消息
                     channel.basicAck(envelope.getDeliveryTag(), false);
                 }
             }
         };
         //监听队列
         /**
          * autoAck 消息应答
          *  默认轮询分发打开：true ：这种模式一旦rabbitmq将消息发送给消费者，就会从内存中删除该消息，不关心客户端是否消费正常。
          *  使用公平分发需要关闭autoAck:false  需要手动发送回执
          */
         boolean autoAck = false;
         channel.basicConsume(RabbitConfig.QUEUE_TOPIC, autoAck, consumer);
     }

 }

 package com.maozw.mq.topic;

 import com.maozw.mq.config.RabbitConfig;
 import com.rabbitmq.client.AMQP;
 import com.rabbitmq.client.Channel;
 import com.rabbitmq.client.DefaultConsumer;
 import com.rabbitmq.client.Envelope;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.amqp.rabbit.connection.Connection;
 import org.springframework.amqp.rabbit.connection.ConnectionFactory;

 import java.io.IOException;

 /**
  * @author MAOZW
  * @Description: ${todo}
  * @date 2018/11/26 15:06
  */

 public class TopicConsumer2 {
     private static final Logger LOGGER = LoggerFactory.getLogger(TopicConsumer2.class);
     public static final String EXCHANGE_TOPIC = "EXCHANGE_TOPIC";
     private static final String[] routingKeys = {"commodity.add", "commodity.update", "commodity.delete", "commodity.select"};

     public static void main(String[] args) throws IOException {
         ConnectionFactory connectionFactory = RabbitConfig.getConnectionFactory();
         Connection connection = connectionFactory.createConnection();
         Channel channel = connection.createChannel(false);
         /**
          * 创建队列申明
          */
         boolean durable = true;
         channel.queueDeclare(RabbitConfig.QUEUE_TOPIC2, durable, false, false, null);

         /**
          * 绑定队列到交换机
          */
         channel.queueBind(RabbitConfig.QUEUE_TOPIC2, EXCHANGE_TOPIC, "commodity.*");

         /**
          * 改变分发规则
          */
         channel.basicQos(1);
         DefaultConsumer consumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 super.handleDelivery(consumerTag, envelope, properties, body);
                 System.out.println("[2] 接口数据 ： " + new String(body, "utf-8"));
                 try {
                     Thread.sleep(200);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     System.out.println("[2] done! ");
                     //消息应答：手动回执，手动确认消息
                     channel.basicAck(envelope.getDeliveryTag(), false);
                 }
             }
         };
         //监听队列
         /**
          * autoAck 消息应答
          *  默认轮询分发打开：true ：这种模式一旦rabbitmq将消息发送给消费者，就会从内存中删除该消息，不关心客户端是否消费正常。
          *  使用公平分发需要关闭autoAck:false  需要手动发送回执
          */
         boolean autoAck = false;
         channel.basicConsume(RabbitConfig.QUEUE_TOPIC2, autoAck, consumer);
     }
 }