Java程序员如何理解并使用RabbitMQ(二),从底层出发讲解MQ消息中间件的经典的七种工作模式

继上文 Java程序员如何理解并使用RabbitMQ(二),从底层出发讲解MQ消息中间件的经典的七种工作模式

Java程序员如何理解并使用RabbitMQ(二),从底层出发讲解MQ消息中间件的经典的七种工作模式_第1张图片

不多笔笔


Routing路由模式

  1. 队列和交换机的绑定,在订阅模式中可以任意绑定,但是在路由模式中不再可以任意绑定,而是要指定一个RoutingKey(路由key)
  2. 消息的发送在向交换机(Exchange)发送消息时候,也必须指定消息的RoutingKey
  3. Exchange(交换机)不再把消息交给每一个绑定的队列,而是根据消息的Routing Key进行判断,只有队列的RoutingKey和消息的RoutingKey完全一致,才会接受消息

本模式和订阅模式的区别:
订阅模式是只要消息发到交换机,队列绑定了这个交换机,就能够接收到消息,但在一些使用场景下,即使绑定了这个交换机也要分情况将消息给到不同的队列,而这个标识,就是Routing路由,即RoutingKey。例如产生了error的消息,将error的消息发送到持有error的routing key 的队列,产生了info,waring,debug等的消息则发送到相应的其他队列

流程说明:

  1. 生产者生产消息,并把消息发送到交换机(Exchange),并指定一个routing key
  2. 交换机(Exchange)接受生产者的消息,然后把消息递交给和routing key完全匹配的队列(记住这个完全匹配)
  3. 第一个消费者在队列指定需要routing key为error的消息
    第二个消费者在队列指定需要routing key为info,waring,debug的消息

生产者生产消息

/**
 * 路由模式的交换机类型为:direct
 */
public class Producer {
     //交换机名称
    static final String DIRECT_EXCHAGE = "direct_exchange";
    //队列名称
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //队列名称
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";public static void main(String[] args) throws Exception {
     //创建连接(不变的步骤1)
        Connection connection = ConnectionUtil.getConnection();// 创建通道(不变的步骤2)
        Channel channel = connection.createChannel();/**
         * 声明交换机(需要交换机的模式下不变的步骤3)
         * 参数1:交换机名称
         * 参数2:交换机类型,fanout、topic、direct、headers
         * 说明 :本模式(RoutingKey路由模式下交换机的类型为direct)
         */
        channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);// 声明(创建)队列
        /**
         * 按照参数说明填写队列属性
         * 参数1:队列名称
         * 参数2:是否定义持久化队列
         * 参数3:是否独占本次连接
         * 参数4:是否在不使用的时候自动删除队列
         * 参数5:队列其它参数
         */
        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);//队列绑定交换机,(记得交换机比如绑定队列,队列才能接受消费消息,交换机不具备存储功能,没有绑定队列的交换机一旦发送消息消息就丢失了)
        channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHAGE, "insert");
        channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHAGE, "update");// 发送信息1,
        String message = "新增了商品。路由模式;routing key 为 insert " ;
        /**
         * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
         * 参数2:路由key,简单模式可以传递队列名称
         * 参数3:消息其它属性
         * 参数4:消息内容
         */
        channel.basicPublish(DIRECT_EXCHAGE, "insert", null, message.getBytes());
        System.out.println("已发送消息:" + message);// 发送信息2,
        message = "修改了商品。路由模式;routing key 为 update" ;
        /**
         * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
         * 参数2:路由key,简单模式可以传递队列名称
         * 参数3:消息其它属性
         * 参数4:消息内容
         */
        channel.basicPublish(DIRECT_EXCHAGE, "update", null, message.getBytes());
        System.out.println("已发送消息:" + message);// 关闭资源
        channel.close();
        connection.close();
    }
}

消费者1消费消息

public class Consumer1 {
     public static void main(String[] args) throws Exception {
     
    	//创建链接
        Connection connection = ConnectionUtil.getConnection();// 创建频道
        Channel channel = connection.createChannel();//声明交换机
        channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);// 声明(创建)队列
        /**
         * 参数1:队列名称
         * 参数2:是否定义持久化队列
         * 参数3:是否独占本次连接
         * 参数4:是否在不使用的时候自动删除队列
         * 参数5:队列其它参数
         */
        channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);//队列绑定交换机
        channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHAGE, "insert");//创建消费者;并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
     
            @Override
            /**
             * consumerTag 消息者标签,在channel.basicConsume时候可以指定
             * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
     
                //路由key
                System.out.println("路由key为:" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为:" + envelope.getExchange());
                //消息id
                System.out.println("消息id为:" + envelope.getDeliveryTag());
                //收到的消息
                System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
            }
        };
        //监听消息
        /**
         * 参数1:队列名称
         * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
         * 参数3:消息接收到后回调
         */
        channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, consumer);
    }
}

消费者2消费消息

public class Consumer2 {
     public static void main(String[] args) throws Exception {
     
        Connection connection = ConnectionUtil.getConnection();// 创建频道
        Channel channel = connection.createChannel();//声明交换机
        channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);// 声明(创建)队列
        /**
         * 参数1:队列名称
         * 参数2:是否定义持久化队列
         * 参数3:是否独占本次连接
         * 参数4:是否在不使用的时候自动删除队列
         * 参数5:队列其它参数
         */
        channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE, true, false, false, null);//队列绑定交换机
        channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHAGE, "update");//创建消费者;并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
     
            @Override
            /**
             * consumerTag 消息者标签,在channel.basicConsume时候可以指定
             * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
     
                //路由key
                System.out.println("路由key为:" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为:" + envelope.getExchange());
                //消息id
                System.out.println("消息id为:" + envelope.getDeliveryTag());
                //收到的消息
                System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
            }
        };
        //监听消息
        /**
         * 参数1:队列名称
         * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
         * 参数3:消息接收到后回调
         */
        channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE, true, consumer);
    }
}

结果 :
启动所有的消费者后,使用生产者发送消息,在消费者对应的控制台输出对应routing key的队列消息。达到按照交换机和routing key接收消息的效果

小结 : RoutingKey路由模式要求队列必须再绑定交换机的时候指定routingkey,消息会根据routingkey转发到响应的队列


Topics通配符模式

**概念:**了解过routingkey路由模式之后,会知道这种模式也会有许多不足,如果交换机的routingkey有如下几种:
insert,update,delete,select四种。假设我想像update/insert/delete发送消息,但是不发给select。如果只用routingkey路由模式这时候就非常麻烦了。。。有没有一种方式可以在匹配routingkey的过程中,可以同时匹配多个的情况。。。答案是肯定的。这就是第五种模式 – Topics通配符模式

在使用的过程中,routingkey一般是由一个或者多个单词组成,多个单词之间以“ . “分隔,例如:insert.update.delete

通配符规则:
#:匹配一个或者多个词
*:只匹配一个

举个栗子:
insert.# : 能够匹配insert.update.delete或者insert.update(只要以insert开头的key都匹配)
insert.*:只能匹配insert.update
当然也可以匹配以。。。结尾的
#.select:只要以.select结尾的routingkey都会被匹配

生产者
使用topic类型的Exchange,发送消息的routing key有3种: item.insert、item.update、item.delete:

/**
 * 通配符Topic的交换机类型为:topic
 */
public class Producer {
     //交换机名称
    static final String TOPIC_EXCHAGE = "topic_exchange";
    //队列名称
    static final String TOPIC_QUEUE_1 = "topic_queue_1";
    //队列名称
    static final String TOPIC_QUEUE_2 = "topic_queue_2";public static void main(String[] args) throws Exception {
     //创建连接
        Connection connection = ConnectionUtil.getConnection();// 创建频道
        Channel channel = connection.createChannel();/**
         * 声明交换机
         * 参数1:交换机名称
         * 参数2:交换机类型,fanout、topic、topic、headers
         */
        channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
​
​
        // 发送信息
        String message = "新增了商品。Topic模式;routing key 为 item.insert " ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.insert", null, message.getBytes());
        System.out.println("已发送消息:" + message);// 发送信息
        message = "修改了商品。Topic模式;routing key 为 item.update" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
        System.out.println("已发送消息:" + message);// 发送信息
        message = "删除了商品。Topic模式;routing key 为 item.delete" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes());
        System.out.println("已发送消息:" + message);// 关闭资源
        channel.close();
        connection.close();
    }
}

消费者1消费消息
接收两种类型的消息:更新商品和删除商品

public class Consumer1 {
     public static void main(String[] args) throws Exception {
     
        Connection connection = ConnectionUtil.getConnection();// 创建频道
        Channel channel = connection.createChannel();//声明交换机
        channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);// 声明(创建)队列
        /**
         * 参数1:队列名称
         * 参数2:是否定义持久化队列
         * 参数3:是否独占本次连接
         * 参数4:是否在不使用的时候自动删除队列
         * 参数5:队列其它参数
         */
        channel.queueDeclare(Producer.TOPIC_QUEUE_1, true, false, false, null);//队列绑定交换机
        channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.update");
        channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.delete");//创建消费者;并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
     
            @Override
            /**
             * consumerTag 消息者标签,在channel.basicConsume时候可以指定
             * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
     
                //路由key
                System.out.println("路由key为:" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为:" + envelope.getExchange());
                //消息id
                System.out.println("消息id为:" + envelope.getDeliveryTag());
                //收到的消息
                System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
            }
        };
        //监听消息
        /**
         * 参数1:队列名称
         * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
         * 参数3:消息接收到后回调
         */
        channel.basicConsume(Producer.TOPIC_QUEUE_1, true, consumer);
    }
}

消费者2消费消息
接收所有类型的消息:新增商品,更新商品和删除商品。

public class Consumer2 {
     public static void main(String[] args) throws Exception {
     
        Connection connection = ConnectionUtil.getConnection();// 创建频道
        Channel channel = connection.createChannel();//声明交换机
        channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);// 声明(创建)队列
        /**
         * 参数1:队列名称
         * 参数2:是否定义持久化队列
         * 参数3:是否独占本次连接
         * 参数4:是否在不使用的时候自动删除队列
         * 参数5:队列其它参数
         */
        channel.queueDeclare(Producer.TOPIC_QUEUE_2, true, false, false, null);//队列绑定交换机
        channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHAGE, "item.*");//创建消费者;并设置消息处理
        DefaultConsumer consumer = new DefaultConsumer(channel){
     
            @Override
            /**
             * consumerTag 消息者标签,在channel.basicConsume时候可以指定
             * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
             * properties 属性信息
             * body 消息
             */
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
     
                //路由key
                System.out.println("路由key为:" + envelope.getRoutingKey());
                //交换机
                System.out.println("交换机为:" + envelope.getExchange());
                //消息id
                System.out.println("消息id为:" + envelope.getDeliveryTag());
                //收到的消息
                System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
            }
        };
        //监听消息
        /**
         * 参数1:队列名称
         * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
         * 参数3:消息接收到后回调
         */
        channel.basicConsume(Producer.TOPIC_QUEUE_2, true, consumer);
    }
}

结果 :
启动所有消费者,然后使用生产者发送消息;在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息;到达按照需要接收的效果;并且这些routing key可以使用通配符。

小结 :
Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能;只是Topic在配置routing key 的时候可以使用通配符,显得更加灵活。

其余第六种第七种工作模式只做了解,实际开发中用的比较少。在这里就不做介绍了,有兴趣的猿们可以到官网大概了解下。。。

下期整理介绍下如何用Springboot整合RabbitMQ

敬爱与明天

Java程序员如何理解并使用RabbitMQ(二),从底层出发讲解MQ消息中间件的经典的七种工作模式_第2张图片

你可能感兴趣的:(RabbitMQ,交换机,队列,rabbitmq,java,中间件底层技术)