RabbitMQ工作模式

上文：RabbitMQ生产者producer, consumer实现

代码地址： https://gitee.com/never_enough/rabbitmqtest

参考RabbitMQ官网： RabbitMQ Tutorials

1. Work queues 工作队列模式

参考官网：RabbitMQ Tutorials

• 工作模式是一个或者多个消费者共同消费一个队列中的消息；

• 队列中的每一个消息只可能被其中一个消费者消费；

简单比如，多个人吃一个蛋糕；

应用场景：对于消息任务很多的情况，可以使用工作队列提高任务处理的速度；

原理就是集群处理大量的消息；

下面再创建一个消费者：

循环发送多条消息，结果如下图：

2. Publish/Subscribe 发布订阅模式

2.1 修改RabbitMQConfig配置文件

	/**
     * fanout交换机名称  ( fanout: 广播)
     */
    public static final String FANOUT_EXCHANGE="fanoutExchange";

	 /**
     * 订阅队列1名称
     */
    public static final String SUB_QUEUE1="subQueue1";

    /**
     * 订阅队列2名称
     */
    public static final String SUB_QUEUE2="subQueue2";

	/**
     * 定义一个fanout交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

	/**
     * 定义一个订阅队列1
     * @return
     */
    @Bean
    public Queue subQueue1(){
        return new Queue(SUB_QUEUE1);
    }

    /**
     * 定义一个订阅队列2
     * @return
     */
    @Bean
    public Queue subQueue2(){
        return new Queue(SUB_QUEUE2);
    }

	/**
     * 定义一个队列和交换机的绑定
     *  广播： 由于交换机会把消息发送到所有绑定到这个交换机上的队列中，所有这种模式无需 ROUTINGKEY
     * @return
     */
    @Bean
    public Binding fanoutBinding1(){
        return BindingBuilder.bind(subQueue1()).to(fanoutExchange());
    }

    /**
     * 定义一个队列和交换机的绑定
     *  广播： 由于交换机会把消息发送到所有绑定到这个交换机上的队列中，所有这种模式无需 ROUTINGKEY
     * @return
     */
    @Bean
    public Binding fanoutBinding2(){
        return BindingBuilder.bind(subQueue2()).to(fanoutExchange());
    }
	

2.2 producer 发送广播消息

2.3 consumer 接收订阅的消息

2.4 测试

启动生产者服务后，发现控制台有100条尚未被消费：

下面再启动消费者服务：

这样同一条消息，两个订阅者就都能收到了

3. Routing 路由模式

路由模式：

跟订阅模式类似，只不过在订阅模式的基础上加上了类型，订阅模式是分发到所有绑定到交换机的队列，路由模式只分发到绑定在交换机上面指定路由键的队列。

3.1 配置RabbitMQConfig

	/**
     * direct交换机名称1
     */
    public static final String DIRECT_EXCHANGE1="directExchange1";

	/**
     * direct队列名称1
     */
    public static final String DIRECT_QUEUE1="directQueue1";

    /**
     * direct队列名称2
     */
    public static final String DIRECT_QUEUE2="directQueue2";

	/**
     * 定义一个direct交换机1
     * @return
     */
    @Bean
    public DirectExchange directExchange1(){
        return new DirectExchange(DIRECT_EXCHANGE1);
    }
	/**
     * 定义一个direct1队列
     * @return
     */
    @Bean
    public Queue directQueue1(){
        return new Queue(DIRECT_QUEUE1);
    }

    /**
     * 定义一个direct2队列
     * @return
     */
    @Bean
    public Queue directQueue2(){
        return new Queue(DIRECT_QUEUE2);
    }
	
	/**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding1(){
        return BindingBuilder.bind(directQueue1()).to(directExchange1()).with("error");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("info");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding3(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("error");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding4(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("warning");
    }

3.2 producer

启动producer服务，到控制台查看如下图：

可以发现有两个队列绑定到了这个交换机上：


队列2和队列1也分别有一条消息了。

3.3 consumer

4. Topic主题模式模糊匹配

主题模式和路由模式很像:

路由模式是精确匹配

主题模式是模糊匹配，更加灵活，更加强大；

主题模式的交换机类型是topic类型 通过通配符方式，消息路由到匹配的队列中。

• 匹配一个单词；

• 匹配零个或者多个单词；

4.1 配置RabbitMQConfig

	/**
     * topic队列名称1
     */
    public static final String TOPIC_QUEUE1="topicQueue1";
    /**
     * topic队列名称2
     */
    public static final String TOPIC_QUEUE2="topicQueue2";
    /**
     * TOPIC交换机名称
     */
    public static final String TOPIC_EXCHANGE="topicExchange";

    /**
     * 定义一个topic队列1
     * @return
     */
    @Bean
    public Queue topicQueue1(){
        return new Queue(TOPIC_QUEUE1);
    }
    /**
     * 定义一个topic队列2
     * @return
     */
    @Bean
    public Queue topicQueue2(){
        return new Queue(TOPIC_QUEUE2);
    }

    /**
     * 定义一个topic交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding1(){
        // * 匹配一个单词
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("*.orange.*");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding2(){
        // * 匹配一个单词
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("*.*.rabbit");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding3(){
        // # 匹配零个或者多个单词
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("lazy.#");
    }

4.2 producer

启动生产者服务，rabbitmq控制台查看如下：

交换机：

4.3 consumer

下面启动消费者服务：

4.4 其他routing key测试

然后可以把下面几种routing key分别测试一下：

参考rabbitMQ官网： example

参考学习视频： bilibili.com/video/BV13K4y1H7Zh?p=10