消息中间件RabbitMQ26_RabbitMQ的工作模式4

一、Work queues 工作队列模式

　1、模式说明

　　

• Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息（只有一个消费者能取到消息）。
• 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

　2、代码编写

　　Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多个消费者同时对消费消息的测试。

　　1. 生产者发送消息：

package com.itheima.producer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_WorkQueues {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue
        //如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);

        //6、发送10条消息给Queue
        for (int i = 1; i <= 10; i++) {
            String body =i+"hello rabbitmq...";
            channel.basicPublish("","work_queues",null,body.getBytes());
        }

        //7、释放资源
        channel.close();
        connection.close();
    }
}

　　2. 消费者接受消息：

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_WorkQueues1 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        channel.queueDeclare("work_queues",true,false,false,null);

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
            }
        };
        channel.basicConsume("work_queues",true,consumer);

        //关闭资源？不要
    }
}

　　　复制一份Consumer_WorkQueues1消费者代码类名为：Consumer_WorkQueues2

　　3. 启动两个消费者，控制台无输出内容，RabbitMQ能看到两个消费者：

　　　

 　　4.启动生产者，两个消费者控制台输出消费数据：

　　　

　　　

　3、小结

　　1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

　　2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。

二、Pub/Sub 订阅模式 

　1、模式说明

　　

　　在订阅模型中，多了一个 Exchange 角色，而且过程略有变化：

• P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
• C：消费者，消息的接收者，会一直等待消息到来
• Queue：消息队列，接收消息、缓存消息
• Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
  • Fanout：广播，将消息交给所有绑定到交换机的队列
  • Direct：定向，把消息交给符合指定routing key 的队列
  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

　　　Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！

　2、代码编写

　　1. 生产者发送消息

package com.itheima.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_PubSub {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建交换机
        /**
         * exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
         *      exchange：交换机名称
         *      type：交换机类型
         *              DIRECT("direct")：定向
         *              FANOUT("fanout")：扇形（广播），发送消息到每一个与之绑定的队列
         *              TOPIC("topic")：通配符
         *              HEADERS("headers")：参数匹配
         *      durable：是否持久化
         *      autoDelete：是否自动删除
         *      internal：内部使用，一般设为false
         *      arguments：参数
         */
        String exchangeName="test_fanout";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);

        //6、创建队列
        String queue1Name="test_fanout_queue1";
        String queue2Name="test_fanout_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);

        //7、绑定交换机和队列
        /**
        *   queueBind(String queue, String exchange, String routingKey)
         *          queue：队列名称
         *          exchange：交换机名称
         *          routingKey：路由键，绑定规则
         *                      如果交换机的类型为fanout，则routingkey设置为""
         */
        //写到这，执行一下main方法，会发现RabbitMQ管控台Queue中多了两个队列，Exchange中多了一个交换机，并且交换机绑定了这两个队列
        channel.queueBind(queue1Name,exchangeName,"");
        channel.queueBind(queue2Name,exchangeName,"");

        //8、发送消息
        String body="日志信息：张三调用了findAll方法...日志级别：info...";
        channel.basicPublish(exchangeName,"",null,body.getBytes());
        
        //9、释放资源
        channel.close();
        connection.close();
    }
}

　　执行main方法，查看RabbitMQ管控台：

　　　

　　　

　　　

　　2. 消费者接收消息

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_PubSub1 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_fanout_queue1";
        String queue2Name="test_fanout_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印到控制台...");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);

        //关闭资源？不要
    }
}

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_PubSub2 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_fanout_queue1";
        String queue2Name="test_fanout_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息保存到数据库...");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);

        //关闭资源？不要
    }
}

　　执行Consumer_PubSub1，控制台输出数据，然后执行Consumer_PubSub2，控制台也输出内容：

　　　

　　　

　3、小结

　　1. 交换机需要与队列进行绑定，绑定之后，一个消息可以被多个消费者都收到。
　　2. 发布订阅模式与工作队列模式的区别：

• • 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
  • 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
  • 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机

三、Routing 路由模式

　1、模式说明：

• 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）
• 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey
• Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息

　　

　　图解：

• • P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
  • C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息

　2、代码编写

　　1. 生产者发送消息

package com.itheima.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_Routing {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建交换机
        String exchangeName="test_direct";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);

        //6、创建队列
        String queue1Name="test_direct_queue1";
        String queue2Name="test_direct_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);

        //7、绑定交换机和队列
        //队列1绑定 error
        channel.queueBind(queue1Name,exchangeName,"error");
        //队列1绑定 info error warning
        channel.queueBind(queue2Name,exchangeName,"info");
        channel.queueBind(queue2Name,exchangeName,"error");
        channel.queueBind(queue2Name,exchangeName,"warning");

        //8、发送消息
        String body="日志信息：张三调用了findAll方法...日志级别：info...";
        channel.basicPublish(exchangeName,"info",null,body.getBytes());

        //9、释放资源
        channel.close();
        connection.close();
    }
}

　　　执行main方法，可以看到只有队列2有消息，队列1没有消息

　　　　

　　　　

　　2. 消费者接收消息

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_Routing1 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_direct_queue1";
        String queue2Name="test_direct_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息存储到数据库...");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);

        //关闭资源？不要
    }
}

　　　执行main方法，可以看到控制台无数据输出

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_Routing2 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_direct_queue1";
        String queue2Name="test_direct_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印到控制台...");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);

        //关闭资源？不要
    }
}

　　　执行main方法，控制台打印数据：

　　　　

　3、小结

• Routing模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。
• 交换机类型要是Direct。

四、Topics 通配符模式

　1、模式说明

• Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
• Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
• 通配符规则：# 匹配一个或多个词，* 匹配不多不少恰好1个词，例如：item.# 能够匹配 item.insert.abc 或者 item.insert，item.* 只能匹配 item.insert

　　

　　

　　图解：

• • 红色 Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
  • 黄色 Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配

　2、代码编写

　　1. 生产者发送消息

package com.itheima.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_Topics {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建交换机
        String exchangeName="test_topic";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);

        //6、创建队列
        String queue1Name="test_topic_queue1";
        String queue2Name="test_topic_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);

        //7、绑定交换机和队列
        //routing key 系统的名称.日志的级别
        //需求：所有error级别的日志存入数据库，所有order系统的日志存入数据库
        channel.queueBind(queue1Name,exchangeName,"#.error");
        channel.queueBind(queue1Name,exchangeName,"order.*");
        channel.queueBind(queue2Name,exchangeName,"*.*");

        //8、发送消息
        String body="日志信息：张三调用了findAll方法...日志级别：info...";
        channel.basicPublish(exchangeName,"order.info",null,body.getBytes());

        //9、释放资源
        channel.close();
        connection.close();
    }
}

　　　执行main方法，RabbitMQ管控台查看队列消息及交换机绑定队列信息：

　　　　

 　　　　

　　2. 消费者接收消息

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_Topics1 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_topic_queue1";
        String queue2Name="test_topic_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息存储到数据库...");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);

        //关闭资源？不要
    }
}

　　执行main方法，控制台打印结果：

　　　

package com.itheima.consumer;

import com.rabbitmq.client.*;
import java.io.IOException;

public class Consumer_Topics2 {

    public static void main(String[] args) throws Exception{
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2、设置参数
        factory.setHost("192.168.240.132");//ip 默认值是localhost
        factory.setPort(5672);//端口    默认值是5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值是/
        factory.setUsername("heima");//用户名  默认值是guest
        factory.setPassword("heima");//密码   默认值是guest

        //3、创建连接    Connection
        Connection connection = factory.newConnection();

        //4、创建Channel
        Channel channel = connection.createChannel();

        //5、创建队列Queue，可以不写
        String queue1Name="test_topic_queue1";
        String queue2Name="test_topic_queue2";

        //6、接收消息
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印到控制台...");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);

        //关闭资源？不要
    }
}

　　执行main方法，控制台打印结果：

　　　

　3、小结

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

五、工作模式总结

　1、简单模式 HelloWorld
　　一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。

　2、工作队列模式 Work Queue
　　一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。

　3、发布订阅模式 Publish/subscribe
　　需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定（routing key为""），当发送消息到交换机后，交换机会将消息发送到绑定的队列。

　4、路由模式 Routing
　　需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。

　5、通配符模式 Topic
　　需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。