RabbitMQ的模式介绍

已于 2022-05-12 11:38:28 修改
阅读量144 收藏
点赞数
分类专栏： spring-boot框架基础配置 文章标签： rabbitmq
于 2021-06-03 17:59:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L1569850979/article/details/117520515
版权

RabbitMQ的模式介绍

图注解释
P：生产者
C：消费者
X：交换机

  • 入门级程序
    生产者->队列->消费者
    在这里插入图片描述
    下面开始简单生产者、消费者的消息发送与接收入，工作原理如下图
    在这里插入图片描述
    1.引入jar包
  <!--rabbitmq-->
		<dependency>
			<groupId>com.rabbitmq</groupId>
			<artifactId>amqp-client</artifactId>
			<version>4.1.0</version>
		</dependency>

2.生产者代码示例

/**
 * 生产者
 */
public class ProducerConfig {


    /**
     * 简单模式生产
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 是否删除，当没有consumer时，自动删除
         *
         */
        //创建队列(如果没有一个名字叫hello-world的队列，则会创建该队列，如果有则不会创建)
        channel.queueDeclare("hello_world", true, false, false, null);
        /**
         * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称
         * props 配置信息
         * body：发送消息数据
         */
        String body = "你好" + 1;
        //发送消息
        channel.basicPublish("", "hello_world", null, body.getBytes());
        channel.close();
        conn.close();
    }
}

代码运行结果可以在RabbitMQ的可视化界面看到一个相关队列
在这里插入图片描述
3.消息已经生成开始消费者准备消费消息（消费者）示例：

/**
 * 消费者
 */
public class ConsumerConfig {


    /**
     * 简单模式的消费
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 是否删除，当没有consumer时，自动删除
         *
         */
        //创建队列(如果没有一个名字叫hello-world的队列，则会创建该队列，如果有则不会创建)
        channel.queueDeclare("hello_world",true,false,false,null);


        //接收消息
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法
            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("envelope:"+envelope);
                System.out.println("routingkey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对象
         */
          channel.basicConsume("hello_world",true,consumer);
    }
}

执行结果可以看出消息被消费的：
在这里插入图片描述
在这里插入图片描述

  • Work queues工作队列模式
    1.模式说明
    在这里插入图片描述
    work Queues :与入门程序的简单模式想比，多了一个或一些消费端，多个消费端共同消费同一个队列的消息（提高了消息的消费速率）
    应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
    1.生产者代码示例
 public class ProducerWorkQueues {




    /**
     * 工作队列
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 是否删除，当没有consumer时，自动删除
         *
         */
        //创建队列(如果没有一个名字叫hello-world的队列，则会创建该队列，如果有则不会创建)
        channel.queueDeclare("work_queues", true, false, false, null);
        /**
         * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称
         * props 配置信息
         * body：发送消息数据
         */
        //发10条消息
        for (int i=0;i<10;i++) {
            String body = i+"你好";
            //发送消息
            channel.basicPublish("", "work_queues", null, body.getBytes());
        }
        channel.close();
        conn.close();
    }
}

2.消费者1

 public class ConsumerWorkQueues {



    /**
     * 工作队列模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 是否删除，当没有consumer时，自动删除
         *
         */
        //创建队列(如果没有一个名字叫hello-world的队列，则会创建该队列，如果有则不会创建)
        channel.queueDeclare("work_queues",true,false,false,null);


        //接收消息
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法
            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对象
         */
        channel.basicConsume("work_queues",true,consumer);
    }
}

3.消费者2

public class ConsumerWorkQueuesNext {



    /**
     * 工作队列模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();
        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 是否删除，当没有consumer时，自动删除
         *
         */
        //创建队列(如果没有一个名字叫hello-world的队列，则会创建该队列，如果有则不会创建)
        channel.queueDeclare("work_queues",true,false,false,null);


        //接收消息
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法
            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对象
         */
        channel.basicConsume("work_queues",true,consumer);
    }

}

执行结果
消费者1
在这里插入图片描述
消费者2
在这里插入图片描述

  • Pub/Sub订阅模式
    1.模式说明

在这里插入图片描述
P 生产者：也就是发送消息的程序，但是不是再发送到队列中，而是发送到交换机中（X）
C 消费者：消息的接受者，会一直等待消息的到来。
Queue 队列：消息队列，接受消息，缓存消息。
Exchange 交换机（X）：一方面，接受生产者发送的消息。另一方面，知道如何处理消息，列如传递消息到特定的队列、传递给所有队列、或者将消息丢弃。如何操作具体取决于交换机的类型，交换机的常用类型如下所示：
Fanout:广播模式，将消息交给所有绑定到交换的队列。
Direct：定向，把消息交给符合指定的routing key的队列
Topic：通配符，把消息交给符合routing pattern （路由模式） 的队列
交换机只负责转发消息，不具备存储消息的能力，如果没有任何队列与交换机进行绑定或者没有符合规则的路由键，者消息会丢失！

1.生产者示例

public class ProducerPubSub {


    /**
     * 简单模式生产
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection connection = factory.newConnection();
        //获得信道
        Channel channel = connection.createChannel();
        /*
         exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments) throws IOException {
          exchange :交换机名称
         BuiltinExchangeType:交换机类型
          DIRECT("direct"), 定向
    FANOUT("fanout"),扇形 （广播） 发送消息到每一个与之绑定队列
    TOPIC("topic"), 通配符的方式
    HEADERS("headers"); 参数匹配

         durable:是否持久化
         autoDelete： 自动删除
         internal 内部使用 一般false
         arguments参数
         */
        String exachangeName="test_fanout";
        //创建交换机
        channel.exchangeDeclare(exachangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        /**
         * String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 参数
         *
         */

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

        /*
        queueBind(String queue, String exchange, String routingKey) throws IOException {
     queue ：队列名称
     exchange：交换机名称
     routingKey：路由键 ，绑定规则
               如果交换机类型为 FANOUT ，routingKey设置为“”
         */
        //绑定队列和交换机
        channel.queueBind(queue1Name,exachangeName,"");
        channel.queueBind(queue2Name,exachangeName,"");


        /**
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称
         * props 配置信息
         * body：发送消息数据
         */
        String body="日志信息:天气晴朗";
        //发送消息
          channel.basicPublish(exachangeName,"",null,body.getBytes());
        //释放资源
          channel.close();  //关闭信道
        connection.close();//关闭连接

    }
}

2.消费者1

public class ProducerPubSub {


    /**
     * 简单模式生产
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection connection = factory.newConnection();
        //获得信道
        Channel channel = connection.createChannel();
        /*
         exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments) throws IOException {
          exchange :交换机名称
         BuiltinExchangeType:交换机类型
          DIRECT("direct"), 定向
    FANOUT("fanout"),扇形 （广播） 发送消息到每一个与之绑定队列
    TOPIC("topic"), 通配符的方式
    HEADERS("headers"); 参数匹配

         durable:是否持久化
         autoDelete： 自动删除
         internal 内部使用 一般false
         arguments参数
         */
        String exachangeName="test_fanout";
        //创建交换机
        channel.exchangeDeclare(exachangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        /**
         * String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 参数
         *
         */

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

        /*
        queueBind(String queue, String exchange, String routingKey) throws IOException {
     queue ：队列名称
     exchange：交换机名称
     routingKey：路由键 ，绑定规则
               如果交换机类型为 FANOUT ，routingKey设置为“”
         */
        //绑定队列和交换机
        channel.queueBind(queue1Name,exachangeName,"");
        channel.queueBind(queue2Name,exachangeName,"");


        /**
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称
         * props 配置信息
         * body：发送消息数据
         */
        String body="日志信息:天气晴朗";
        //发送消息
          channel.basicPublish(exachangeName,"",null,body.getBytes());
        //释放资源
          channel.close();  //关闭信道
        connection.close();//关闭连接

    }
}

在可视化rabbitMq中可以看到我们创建的交换机和绑定的两个队列
在这里插入图片描述
在这里插入图片描述
2.消费者1

public class ConsumerPubSub {

    /**
     * 简单模式的消费
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue1Name="test_fanout_queue1";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者1：将日志打印到控制台。。。。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue1Name,true,consumer);
    }
}

消费者1控制台
在这里插入图片描述
3.消费者2

public class ConsumerPubSubNext {

    /**
     * 简单模式的消费
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue2Name="test_fanout_queue2";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者2：将数据保存到数据库中。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue2Name,true,consumer);
    }
}

消费者2控制台
在这里插入图片描述

  • Routing 路由模式
    1.队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey(路由key)
    2.消息的发送方在指定交换机的时候也必须绑定路由键
    3.交换机不能将消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的RoutingKey与消息的RoutingKey完全一致，才会接收到消息
    在这里插入图片描述

注：上图的两个地方的RoutingKey一致的时候才能存放到队列中

1.生产者代码

public class ProducerRoutingKey {


    /**
     * 路由模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection connection = factory.newConnection();
        //获得信道
        Channel channel = connection.createChannel();
        /*
         exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments) throws IOException {
          exchange :交换机名称
         BuiltinExchangeType:交换机类型
          DIRECT("direct"), 定向
    FANOUT("fanout"),扇形 （广播） 发送消息到每一个与之绑定队列
    TOPIC("topic"), 通配符的方式
    HEADERS("headers"); 参数匹配

         durable:是否持久化
         autoDelete： 自动删除
         internal 内部使用 一般false
         arguments参数
         */
        String exachangeName="test_direct";
        //创建交换机
        channel.exchangeDeclare(exachangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
        /**
         * String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 参数
         *
         */

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

        /*
        queueBind(String queue, String exchange, String routingKey) throws IOException {
     queue ：队列名称
     exchange：交换机名称
     routingKey：路由键 ，绑定规则
               如果交换机类型为 FANOUT ，routingKey设置为“”
         */
        //绑定队列和交换机
        //队列1的绑定
        channel.queueBind(queue1Name,exachangeName,"error");
        //队列2的绑定
        channel.queueBind(queue2Name,exachangeName,"info");
        channel.queueBind(queue2Name,exachangeName,"error");
        channel.queueBind(queue2Name,exachangeName,"warning");


        /**
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称
         * props 配置信息
         * body：发送消息数据
         */
        String body="日志信息:天气晴朗";
        //发送消息
        channel.basicPublish(exachangeName,"info",null,body.getBytes());
        //释放资源
        channel.close();  //关闭信道
        connection.close();//关闭连接

    }
}

生产者执行之后可以在可视化界面上看到
在这里插入图片描述在这里插入图片描述
2.消费者1

public class ConsumerRoutingKey {

    /**
     * 路由模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue1Name="test_direct_queue1";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者1：将日志打印到控制台。。。。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue1Name,true,consumer);
    }
}

3.消费者2

public class ConsumerRoutingKeyNext {

    /**
     * 路由模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue1Name="test_direct_queue2";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者1：将日志打印到控制台。。。。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue1Name,true,consumer);
    }
}

分别执行消费者1和消费者2
只有消费者2的控制台打印了消息，说明路由器将消息通过路由转发到了消费者队列2中
在这里插入图片描述

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

在这里插入图片描述

rabbitmq--通配符模式Topics
他的匹配规则：
绑定键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日志的消息。
1.生产者

public class ProducerTopics {


    /**
     * 通配符模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection connection = factory.newConnection();
        //获得信道
        Channel channel = connection.createChannel();
        /*
         exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments) throws IOException {
          exchange :交换机名称
         BuiltinExchangeType:交换机类型
          DIRECT("direct"), 定向
    FANOUT("fanout"),扇形 （广播） 发送消息到每一个与之绑定队列
    TOPIC("topic"), 通配符的方式
    HEADERS("headers"); 参数匹配

         durable:是否持久化
         autoDelete： 自动删除
         internal 内部使用 一般false
         arguments参数
         */
        String exachangeName="test_topic";
        //创建交换机
        channel.exchangeDeclare(exachangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
        /**
         * String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments
         *
         * 1queue 队列名称
         * 2durable 是否持久化
         * 3exclusive  是否独占  ，只能有一个消费者监听这个队列
         * 当connection 关闭时，是否删除队列
         * 4autoDelete 参数
         *
         */

        //创建队列
        String queue1Name="test_topics_queue1";
        String queue2Name="test_topics_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);

        /*
        queueBind(String queue, String exchange, String routingKey) throws IOException {
     queue ：队列名称
     exchange：交换机名称
     routingKey：路由键 ，绑定规则
               如果交换机类型为 FANOUT ，routingKey设置为“”
         */
        //绑定队列和交换机
        //routing key 系统名称，日志的级别
        //需求 ：所有error级别的日志存入数据库，所有的order系统的日志存入数据库
        channel.queueBind(queue1Name,exachangeName,"#.error");
        channel.queueBind(queue1Name,exachangeName,"order.*");
        channel.queueBind(queue2Name,exachangeName,"*.*");


        /**
         * String exchange, String routingKey, BasicProperties props, byte[] body
         * exchange :交换机的名称，简单模式下交换机会使用默认的“”
         * 2routingKey 路由名称（队列名称）
         * props 配置信息
         * body：发送消息数据
         */
        String body="日志信息:天气晴朗 日志级别 info";
        //发送消息
          channel.basicPublish(exachangeName,"order.info",null,body.getBytes());
        //释放资源
          channel.close();  //关闭信道
        connection.close();//关闭连接

    }
}

可视化RabbitMq可以看到绑定的
在这里插入图片描述
在这里插入图片描述
2.消费者

public class ConsumerTopics {

    /**
     * 通配符模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue1Name="test_topics_queue1";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者1：将数据保存到数据库中。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue1Name,true,consumer);
    }

}

在这里插入图片描述
3.消费者2

public class ConsumerTopicsNext {

    /**
     * 通配符模式
     * @param args
     * @throws IOException
     * @throws TimeoutException
     */
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setPort(5672); //端口默认值5672
        //设置 RabbitMQ 地址
        factory.setHost("127.0.0.1");
        //建立到代理服务器到连接
        Connection conn = factory.newConnection();
        //获得信道
        Channel channel = conn.createChannel();


        String queue2Name="test_topics_queue2";
        Consumer consumer=new DefaultConsumer(channel){
            //回调方法 ，当收到消息后，会自动执行该方法

            /**
             *
             * @param consumerTag  标识
             * @param envelope  获取一些信息，交换机，路由。。。
             * @param properties 配置信息
             * @param body 数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body:"+new String(body));
                System.out.println("消费者2：将数据保存到数据库中。。。。。。。。。。");
            }
        };
        /**
         * basicConsume(String queue, boolean autoAck,  Consumer callback)
         * queue 队列名称
         * autoAck 是否自动确认
         * callback 回调对消
         */
        //接收消息
        channel.basicConsume(queue2Name,true,consumer);
    }

}

控制台
消费者1
在这里插入图片描述
消费者2
在这里插入图片描述
总结：
简单模式
生产者->队列->消费者（其实有一个默认的交换机）
在这里插入图片描述
工作队列模式
生产者->队列->消费者1（多个）默认一个交换机
消费的时候是轮询消费
在这里插入图片描述
订阅模式
FANOUT（广播）模式
生产者->交换机->队列->消费者
可以指定交换机（交换机类型不同）
在这里插入图片描述
不需要指定key
交换机会通过路由传递到绑定的队列中
RoutingKey(路由模式)
在这里插入图片描述
只有生参者与交换机绑定的routingKey和交换机与队列绑定的routingKey一致时才能传递到队列中
Toupic(通配符模式)
在这里插入图片描述
有两种符号
"*"表示匹配一个单词
"#"表示匹配多个单词

爱上编程2705
关注
专栏目录
RabbitMQ集群架构模式介绍
听雪楼
12-31 2387
主备模式 实现RabbitMQ的高可用集群, 一般在并发和数据量不高的情况下, 这种模型简单好用。主备模式也从称之为Warren模式 主节点如果挂了, 从节点提供服务 远程模式 远程模式可以实现双活的一种模式, 简称Shovel模式, 所谓Shovel就是我们可以把消息进行不同数据中心的复制工作, 可以跨地域的让两个MQ集群互联 Shovel模式拓扑图: Shovel集群的配...
RabbitMQ 工作模式介绍以及对比
weixin_44691279的博客
07-22 653
RabbitMQ 工作模式介绍
RabbitMQ模式介绍
qq_43783709的博客
10-27 728
文章目录前言一、了解 RabbitMQ？二、RabbitMQ模式1、RabbitMQ简单模式2、 RabbitMQ工作模式2.1 Work queues工作队列模式2.2订阅模式概述**Exchange（交换机）只负责转发消息，不具备存储消息的能力**，因此如果没有任何队列与Exchange绑 定，或者没有符合路由规则的队列，那么消息会丢失！ 前言 由于 RabbitMQ 综合能力强劲，接下来我们来学习RabbitMQ。 一、了解 RabbitMQ？ RabbitMQ官方地址：http://www.rab
RabbitMQ的工作模式介绍
qq_31445987的博客
11-30 262
MQ 基本概念 MQ 概述 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器，多用于分布式系统之间进行通信 MQ 的优势 应用解耦：提高系统容错性和可维护性 异步提速：提升用户体验和系统吞吐量 削峰填谷：提高系统稳定性 MQ 的劣势 系统可用性降低：系统引入的外部依赖越多，系统稳定性越差。一旦MQ宕机，就会对业务造成影响。 系统复杂度提高：MQ的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过MQ进行异步调用。 AMQP AMQP，即Advanc
RabbitMQ 工作模式介绍
云下的你
08-23 337
一、前言 RabbitMQ 是一个由 erlang 开发的 AMQP (Advanced Message Queuing Protocol) 的开源实现。 AMQP ：高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP 的主要特征是面向消息、队列、路由（包括点对点和发布 / 订阅）、...
RabbitMQ几种工作模式介绍
it_erge的博客
01-10 2978
1.RabbitMQ MQ：全称为message queue，即消息队列。它是由erlang语言开发，基于AMQP（Advanced Message Queue Protocol 高级消息队列协议）协议实现的队列。 2.工作原理 RabbitMQ的基本结构 组成部分说明： Producer 消息生产者，即生产方客户端，将...
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
C#开发的RabbitMQ队列模式
03-25
C#开发的RabbitMQ队列模式，分为生产者和消费者两个程序，使用vs2019开发的，可以运行使用，在根据自己的需求加工即可，另外在本人另外的资源还提供主题订阅模式的，已经实现了定时读取mysql数据库数据转为json发送...
beego - rabbitmq简单模式和工作模式
03-10
在本文中，我们将深入探讨如何使用Go语言的Web框架beego与RabbitMQ集成，特别关注其简单的发布/订阅模式（Simple Mode）以及工作模式（Work Mode）。 首先，我们来看**简单模式**。在RabbitMQ的简单模式中，也被...
rabbitmq各种模式代码及说明
06-19
本压缩包文件包含了RabbitMQ在SpringBoot框架下的各种模式的代码示例，帮助开发者更好地理解和应用RabbitMQ。 1. **基础概念** - **消息队列**：RabbitMQ的核心是消息队列，它存储待处理的消息，并在消费者准备好...
RabbitMQ的6种工作模式详解
逆天的博客
10-28 1万+
目录RabbitMQ几种工作模式1.Work queues代码实例1.生产者1.application.yml2.RabbitMqConfig3.TestSend2.消费者1.配置相同，config相同2.RabbitMqListen监听获取消息3.运行1.Publish发布订阅模式代码实例1.生产者1.RabbitMqConfig3.TestSend2.消费者1.配置相同，config相同2.RabbitMqListen监听获取消息3.运行3.Routing路由模式代码实例1.生产者1.RabbitMqC
RabbitMQ的五种工作模式超详解
金鳞踏雨
05-31 5828
一、简单模式。二、Work。三、Routing模式。四、Topics模式。五、PubSub模式 1. 创建连接工厂ConnectionFactory2. 设置工厂的参数3.创建连接 Connection4. 创建管道 Channel5. 简单模式中没有交换机exchange，所以不用创建（RabbitMQ会使用默认的交换机！）6. 创建队列queue7. 设置发送内容，使用channal.basicPublish()发送8. 释放资源
RabbitMQ工作队列模式简介，以及简单队列模式(一)
u011709128的专栏
07-28 2338
RabbitMQ简单使用、简单集成spring使用(一) 本篇文章主要讲解RabbitMQ的简单使用、以及集成srping后的简单使用： 简单引入RabbitMQ的客户端使用 简单集成spring配置文件使用 简单集成springboot使用 后续会逐步完善各种使用姿势、以及对使用的详解 1、简单引入RabbitMQ的客户端使用 首先创建maven工程，pom文件配置...
RabbitMQ入门与消息队列模式详解
飞月程序人生
04-20 1万+
RabbitMQ提供了6种模式，分别是HelloWorld，Work Queue，Publish/Subscribe，Routing，Topics，RPC Request/reply，本文详细讲述了前5种，并给出代码实现和思路。其中Publish/Subscribe，Routing，Topics三种模式可以统一归为Exchange模式，只是创建时交换机的类型不一样，分别是fanout、direct、topic。Spring提供了rabbitmq的一个实现，所以集成起来很方便，文章第4章给出了订阅者模式的一种
RabbitMQ常用的三种模式详解
qq_34683450的博客
10-31 6742
rabbit有direct路由模式，topic通配符主题订阅模式，fanout广播发布模式，下面将逐一详细的讲解三种模式的用法及应用场景。 一、direct路由模式 1.图解 该方式一个路由键对应一个消息队列，一个消息队列可以对应多个路由键，一个消息队列对应一个消费者，当一个队列下有多个消费者时，MQ采用的是轮询机制，选取一个消费者消费该队列下的消息，其他消费者则轮空。该模式给消息指明了准确的路...
一文搞懂Rabbitmq常用模式
沸羊羊_
07-13 1543
文章目录前言核心组成Rabbitmq模式Hello worldWork queuePublish/subscribe概述应用场景Routing 前言 上一篇文章介绍了消息中间件，本文主要讲解MQ的具体实现 RabbitMQ 消息中间件详解-传送门 核心组成 Rabbitmq模式 Hello world Work queue 一旦 rabbitmq 将消息传递给消费者，就会立即将其标记为删除状态。如果消费者接收任务，但并没有完成处理的情况下，就down了，此时，这种已分派给消费者的但并未完成处理的消息就
RabbitMQ六种工作模式详解
soberw的日常分享博客
06-01 3265
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com/RabbitMQ提供了6种模式：官网对应模式介绍：https://www.rabbitmq.com/getstarted.htmlAMQP 一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消
RabbitMQ的几种工作模式
热门推荐
Lovnx
04-29 3万+
maven： <dependencies> <!-- RabbitMQ的客户端 --> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>3.4.1</vers
RabbitMQ修改默认端口配置（常用）
毕邺
11-10 1万+
RabbitMQ修改默认端口配置（常用）场景说明端口介绍修改默认端口配置 场景说明 在一次需要迁移项目到新的服务器的时候，需要安装rabbitmq，因为要使用项目在原服务器所配置的端口，所以不得不修改rabbitmq自己默认的端口号，现仅就5672，15672，15674端口进行修改。 端口介绍 首先来说一下这三个端口分别表示什么意思： 5672, 5671 (AMQP 0-9-1 without and with TLS) ，AMQP 是 Advanced Message Queuing Protoc
rabbitmq模式
最新发布
09-15
RabbitMQ是一个用于消息队列的开源软件。它实现了高度可靠的消息传递模式，可以在应用程序之间进行可靠的异步通信。 在RabbitMQ中，有几种常见的消息传递模式： 1. 简单模式（Simple mode）：一个生产者发送消息到一个队列，一个消费者接收并处理该消息。 2. 工作队列模式（Work queue mode）：一个生产者发送消息到一个队列，在多个消费者之间进行竞争，每个消费者获取并处理一个消息。 3. 发布/订阅模式（Publish-subscribe mode）：一个生产者发送消息到一个交换机（exchange），交换机将消息广播到绑定到它上面的所有队列中，每个队列都有自己的消费者来处理消息。 4. 路由模式（Routing mode）：一个生产者发送消息到一个交换机，并指定一个路由键（routing key），交换机根据路由键将消息转发到与之匹配的队列，并由消费者来处理。 5. 主题模式（Topic mode）：类似于路由模式，但是路由键可以使用通配符匹配，可以更灵活地进行消息的路由。 这些模式可以根据具体的需求和场景选择使用，以实现不同的消息传递方式和行为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱上编程2705

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值