rabbitmq五种模式详解（含实现详情代码）

最新推荐文章于 2023-10-12 08:00:00 发布
最新推荐文章于 2023-10-12 08:00:00 发布
阅读量479 收藏 1
点赞数 1
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42550986/article/details/116028422
版权

rabbitMQ的结构以及每个组件的作用

在这里插入图片描述

简介：

Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker

Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等

Connection：publisher／consumer 和 broker 之间的 TCP 连接

Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)

Queue：消息最终被送到这里等待 consumer 取走

Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据

rabbitMQ的模式

下面介绍常用的五大模式：

首先建工程引入相关的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.aaa</groupId>
    <artifactId>rabbit-parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <!--子模块-->
    <modules>
        <module>consumer</module>
        <module>product</module>
    </modules>
    <dependencies>
        <!--引入rabbitMQ的依赖-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.9.0</version>
        </dependency>
    </dependencies>

</project>

工程图浏览：

consumer和product都是子项目。

在这里插入图片描述

1.简单模式

在这里插入图片描述

从上图可以看到一共三个角色
p（product）:代表的是生产者，用来生产消息的。
红色的中间部分(queue)：代表的是一个队列，是用来存储消息和发送消息的。
c(consumer):代表的是消费者，用来消费消息的。
应用场景：    
    手机短信,邮件单发

生产者的代码：

package com.aaa.myf;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Product {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         *//*"qy129_shuaifei",true,false,false,null*/

            channel.queueDeclare("qy129_shuaifei",true,false,false,null);
            String msg="毛云飞不是最帅的么！！！！！！！";
         /**
             * String exchange,交换机的名称，如果没有则使用"",它会自动采用默认
             * String routingKey，路由key,如果没有交换机的绑定，使用队列的名称
             * BasicProperties props,消息的一些额外配置，目前先不加null
             * byte[] body 消息的内容
             */
            channel.basicPublish("","qy129_shuaifei",null,msg.getBytes());
    }
}

消费者代码

package com.aaa.myf;
import com.rabbitmq.client.*;

import java.io.IOException;
public class Consumer {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                //body接受的消息
                System.out.println("消息的内容："+new String(body));

            }
        };
       channel.basicConsume("qy129_shuaifei",true,defaultConsumer);
    }
}

2.工作者模式

在这里插入图片描述

特点：
一个生产者
一个中间队列
多个消费者
是一对多的关系
消费者之间的关系是竞争关系
用处及应用场景：
   比如批量处理上，rabbitmq里面挤压了大量的信息
   抢红包
   资源分配系统

生产者：

package com.aaa.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 工作者模式：
 * 特点：一个生产者
 * 多个消费者
 * 统一一个队列
 * 这些消费者之间存在竞争关系
 */
public class Product {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         *//*"qy129_shuaifei",true,false,false,null*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        channel.queueDeclare("qy129_work",true,false,false,null);
        for (int i = 0; i < 10; i++) {

            String msg="今天天气不错，加油！！！！！！！";
            /**
             * String exchange,交换机的名称，如果没有则使用"",它会自动采用默认
             * String routingKey，路由key,如果没有交换机的绑定，使用队列的名称
             * BasicProperties props,消息的一些额外配置，目前先不加null
             * byte[] body 消息的内容
             */
            channel.basicPublish("","qy129_work",null,msg.getBytes());
        }
        //生产者这里可以管理资源，消费者不能关闭资源，他一直处于一个监听的状态
        channel.close();
        connection.close();

    }
}

消费者1号：

package com.aaa.work;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                try {
                    //加上休眠时间是为了区分两个消费者的区别
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //body接受的消息
                System.out.println("消息者01："+new String(body));

            }
        };
       channel.basicConsume("qy129_work",true,defaultConsumer);
    }
}

消费者2号

package com.aaa.work;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                //body接受的消息
                System.out.println("消息者02："+new String(body));

            }
        };
       channel.basicConsume("qy129_work",true,defaultConsumer);
    }
}

3.发布订阅模式

在这里插入图片描述

特点：
一个生产者
交换机转发消息
多个个队列
多个消费者
应用场景：
	消息推送，广告

生产者：

package com.aaa.fanout;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 订阅者模式：
 * 一个生产者
 * 多个消费者
 * 多个订阅
 * 交换机转发消息
 */
public class Product {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         *//*"qy129_shuaifei",true,false,false,null*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        channel.queueDeclare("qy129_fanout01",true,false,false,null);
        channel.queueDeclare("qy129_fanout02",true,false,false,null);
        /**
         * 创建交换机
         * String exchange,交换机的名称
         * BuiltinExchangeType type,交换机的类型
         * boolean durable是否持久化
         */
        channel.exchangeDeclare("qy129_angermao", BuiltinExchangeType.FANOUT,true);
        /**
         * String queue,队列名
         * String exchange,交换机的名称
         * String routingKey；路由key,如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("qy129_fanout01","qy129_angermao","");
        channel.queueBind("qy129_fanout02","qy129_angermao","");
        for (int i = 0; i < 10; i++) {
            String msg="今天天气不错，加油！！！！！！！"+i;
            /**
             * String exchange,交换机的名称，如果没有则使用"",它会自动采用默认
             * String routingKey，路由key,如果没有交换机的绑定，使用队列的名称
             * BasicProperties props,消息的一些额外配置，目前先不加null
             * byte[] body 消息的内容
             */
            channel.basicPublish("qy129_angermao","",null,msg.getBytes());
        }
        //生产者这里可以管理资源，消费者不能关闭资源，他一直处于一个监听的状态
        channel.close();
        connection.close();

    }
}

消费者01:

package com.aaa.fanout;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                try {
                    //加上休眠时间是为了区分两个消费者的区别
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //body接受的消息
                System.out.println("消息者01："+new String(body));

            }
        };
       channel.basicConsume("qy129_fanout01",true,defaultConsumer);
    }
}

消费者02:

package com.aaa.fanout;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                //body接受的消息
                System.out.println("消息者02："+new String(body));

            }
        };
       channel.basicConsume("qy129_fanout02",true,defaultConsumer);
    }
}

4.路由模式

在这里插入图片描述

特点：
一个生产者
交换机 转发消息
有多个队列
routekey:路由key routekey匹配的消息可以达到对应的序列
应用场景：
   短信，聊天工具，邮箱。。
   手机号/邮箱地址，都可以是路由key

生产者：

package com.aaa.direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 路由模式：
 * 一个生产者
 * 多个消费者
 * 多个队列
 * 交换机转发消息
 * routekey:路由key只要routekey匹配的消息可以
 */
public class Product {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         *//*"qy129_shuaifei",true,false,false,null*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        channel.queueDeclare("qy129_direct01",true,false,false,null);
        channel.queueDeclare("qy129_direct02",true,false,false,null);
        /**
         * 创建交换机
         * String exchange,交换机的名称
         * BuiltinExchangeType type,交换机的类型
         * boolean durable是否持久化
         */
        channel.exchangeDeclare("qy129_direct", BuiltinExchangeType.FANOUT,true);
        /**
         * String queue,队列名
         * String exchange,交换机的名称
         * String routingKey；路由key,如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("qy129_direct01","qy129_direct","error");

        channel.queueBind("qy129_direct02","qy129_direct","info");
        channel.queueBind("qy129_direct02","qy129_direct","error");
        channel.queueBind("qy129_direct02","qy129_direct","warning");
        for (int i = 0; i < 10; i++) {
            String msg="今天天气不错，加油！！！！！！！"+i;
            /**
             * String exchange,交换机的名称，如果没有则使用"",它会自动采用默认
             * String routingKey，路由key,如果没有交换机的绑定，使用队列的名称
             * BasicProperties props,消息的一些额外配置，目前先不加null
             * byte[] body 消息的内容
             */
            channel.basicPublish("qy129_direct","error",null,msg.getBytes());
        }
        //生产者这里可以管理资源，消费者不能关闭资源，他一直处于一个监听的状态
        channel.close();
        connection.close();

    }
}

消费者01：

package com.aaa.direct;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                try {
                    //加上休眠时间是为了区分两个消费者的区别
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //body接受的消息
                System.out.println("消息者01："+new String(body));

            }
        };
       channel.basicConsume("qy129_direct01",true,defaultConsumer);
    }
}

消费者02:

package com.aaa.direct;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                //body接受的消息
                System.out.println("消息者02："+new String(body));

            }
        };
       channel.basicConsume("qy129_direct02",true,defaultConsumer);
    }
}

5.topic主体模式

在这里插入图片描述

绑定按照统配符的模式:
 *:匹配一个单词
 #：统配n个字符
应用场景：
	做物流分拣的多级传递.

生产者：

package com.aaa.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * topic主体模式：
 * 一个生产者
 * 多个消费者
 * 绑定按照通配符的模式
 * *:统配一个单词
 * #:统配n个单词
 */
public class Product {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        /**
         * String queue, 队列的名称
         * boolean durable, 是否该队列持久化 rabbitMQ服务重启后该存放是否存在。
         * boolean exclusive, 是否独占 false
         * boolean autoDelete, 是否自动删除  如果长时间没有发生消息 则自动删除
         * Map<String, Object> arguments 额外参数  先给null
         *//*"qy129_shuaifei",true,false,false,null*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        /*channel.queueDeclare("qy129_shuaifei",true,false,false,null);*/
        channel.queueDeclare("qy129_topic01",true,false,false,null);
        channel.queueDeclare("qy129_topic02",true,false,false,null);
        /**
         * 创建交换机
         * String exchange,交换机的名称
         * BuiltinExchangeType type,交换机的类型
         * boolean durable是否持久化
         */
        channel.exchangeDeclare("qy129_exchange_topic", BuiltinExchangeType.TOPIC,true);
        /**
         * String queue,队列名
         * String exchange,交换机的名称
         * String routingKey；路由key,如果交换机为fanout模式则不需要路由key
         */
        channel.queueBind("qy129_topic01","qy129_exchange_topic","*.orange.*");

        channel.queueBind("qy129_topic02","qy129_exchange_topic","*.*.rabbit");
        channel.queueBind("qy129_topic02","qy129_exchange_topic","lazy.#");


        for (int i = 0; i < 10; i++) {
            String msg="今天很生气，啥也不想说，明天加油，依旧光芒万丈！！！！！！！"+i;
            /**
             * String exchange,交换机的名称，如果没有则使用"",它会自动采用默认
             * String routingKey，路由key,如果没有交换机的绑定，使用队列的名称
             * BasicProperties props,消息的一些额外配置，目前先不加null
             * byte[] body 消息的内容
             */
            channel.basicPublish("qy129_exchange_topic","lazy.orange.rabbit",null,msg.getBytes());
        }
        //生产者这里可以管理资源，消费者不能关闭资源，他一直处于一个监听的状态
        channel.close();
        connection.close();

    }
}

消费者01：

package com.aaa.topic;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer01 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                try {
                    //加上休眠时间是为了区分两个消费者的区别
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //body接受的消息
                System.out.println("消息者01："+new String(body));

            }
        };
       channel.basicConsume("qy129_topic01",true,defaultConsumer);
    }
}

消费者02：

package com.aaa.topic;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer02 {
    public static void main(String[] args) throws Exception{
        //创建连接对象-配置连接信息
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.49.197");
        //创建连接对象Connection
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();

        //接受信息
        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                //body接受的消息
                System.out.println("消息者02："+new String(body));

            }
        };
       channel.basicConsume("qy129_topic02",true,defaultConsumer);
    }
}
文艺.小清新
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
消息队列RabbitMQ入门与5种模式详解
02-24
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统；AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端...
Rabbitmq的六种模式
zxyhj的博客
01-06 2282
Rabbitmq的六种模式
RabbitMq基础篇-04-结合代码介绍5大消费模式
Alan0517
11-14 1516
(star) can substitute for exactly one word . 匹配不多不少恰好一个词#(hash) can substitute for zero or more words . 匹配 0 或更多个词item.* 能匹配item.save 但是不能匹配item或者item.save.save,有且仅有一个item.# 能匹配item/item.save/item.save.save 说白了只要是item开头都可以。
RabbitMQ之五种消息模型
热门推荐
qq_43243541的博客
10-28 3万+
首先什么是MQ MQ全称是Message Queue,即消息对列！消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 RabbitMQ 基于AMQP协议，erlang语言开发，稳定性好！基于AMQP的一款消息管理系统 官网： http:...
RocketMQ（七） RocketMQ的两种消费模式
m0_67402970的博客
06-12 1370
目录一、概述二、集群消费三、广播消费RocketMQ主要提供了两种消费模式：集群消费以及广播消费。我们只需要在定义消费者的时候通过**setMessageModel(MessageModel.XXX)**方法就可以指定是集群还是广播式消费，默认是集群消费模式，即每个Consumer Group中的Consumer均摊所有的消息。下面我们通过简单的示例演示一下。一个 Consumer Group 中的 Consumer 实例平均分摊消费消息。使用方法：setMessageModel(MessageModel.
细谈RocketMQ的消费模式
凡是过往，皆为序章
10-17 2万+
目录 集群消费 广播消费 使用集群消费模拟广播消费 首先明确一点，RocketMQ 是基于发布订阅模型的消息中间件。所谓的发布订阅就是说，consumer 订阅了 broker 上的某个 topic，当 producer 发布消息到 broker 上的该 topic 时，consumer 就能收到该条消息。 之前我们讲过 consumer group 的概念，即消费同一类消息的多个 co...
RabbitMQ消息中间件示例详解
08-26
RabbitMQ 消息中间件示例详解 RabbitMQ 消息中间件是使用 Erlang 语言开发的高级消息队列协议（Advanced Message Queuing Protocol，AMQP），具有高可靠性和一致性。它可以胜任订单处理、秒杀等一致性要求较高的...
JAVA获取rabbitmq消息总数过程详解
08-25
在Java中，获取RabbitMQ消息总数的过程涉及与RabbitMQ服务器建立连接、创建通道、声明队列以及查询队列状态。以下是一个详细的步骤解析： 1. **建立连接**: 首先，需要通过`ConnectionFactory`类来创建一个连接工厂...
RabbitMQ 最常用的三大模式实例解析
08-25
RabbitMQ 三大模式实例解析详解 RabbitMQ 是一个基于 AMQP 协议的开源消息队列系统，它提供了多种模式来实现消息的发送和接收。今天，我们将详细介绍 RabbitMQ 中的三大模式实例解析：Direct 模式、Fanout 模式和 ...
基于RabbitMQ的简单应用(详解)
08-28
RabbitMQ是一种开源的消息代理和队列服务器，它实现了Advanced Message Queuing Protocol（AMQP）标准，广泛应用于分布式系统中，用于解耦生产者和消费者，处理异步任务，以及在高并发场景下保证数据的可靠传输。...
RocketMQ原理（3）——水平扩展及负载均衡详解
guolong1983811的专栏
12-16 4430
https://zhuanlan.zhihu.com/p/25140744 RocketMQ是一个分布式具有高度可扩展性的消息中间件。本文旨在探索在broker端，生产端，以及消费端是如何做到横向扩展以及负载均衡的。 Broker端水平扩展 Broker负载均衡 Broker是以group为单位提供服务。一个group里面分master和slave,master和sla
RabbitMQ的五种常见消费模型
最新发布
唯有努力，方可自信！
10-12 1万+
在RabbitMQ中，消息的生产和消费是通过一系列的消费模型来管理的。本文将深入介绍RabbitMQ的五种常见消费模型，包括简单队列模型、工作队列模型、发布/订阅模型、路由模型和主题模型，在这种模型中，交换机会将消息路由到与它所绑定的队列匹配的路由键的队列中。如果有消息时，所有的消费者都会在接收到该消息后进行同样的处理，无法根据具体情况进行消息的划分，而且消息被平均分配，不能根据消息的重要性和紧急性进行处理。需要根据消息内容的模式将消息路由到不同队列的应用程序，例如按标签或关键字分发和处理不同的任务。
学习笔记之MQ的几种模式
weixin_30878501的博客
08-16 682
MQ的几种模式： Producer消息产生者，红色队列，Customer消息消费者，蓝色交换机exchange 简单模式：消息产生者产生消息，消息的消费者进行消费 工作模式：消息消...
Spring RabbitMQ Channel理解
Sam_Deep_Thinking
12-06 9395
有了TCP连接后,为何还需要channel,是基于什么场景呢？channel的性能又如何呢？
RabbitMQ 笔记（一）Connection Factory
qingtianla的博客
08-28 3043
有三个连接工厂可供选择： PooledChannelConnectionFactory ThreadChannelConnectionFactory CachingConnectionFactory 对于大多数用例，应该使用PooledChannelConnectionFactory。如果您希望确保严格的消息顺序而不需要使用作用域操作，则可以使用ThreadChannelConnectionFactory。如果您希望使用相关的发布者确认，或者希望通过其CacheMode打开多个连接，则应该使用Cach
Spring boot + RabbitMQ 整合(模块化)
weixin_44521511的博客
10-29 1133
项目名称 rabbitmq-order,分为模块化创建了多个模块 entity : rabbitmq-order-entity mapper: rabbitmq-order-mapper service: rabbitmq-order-service consumer:rabbitmq-order-consumer 根: pom.xml 配置 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://..
RabbitMQ的六种模式
qq_32379229的博客
04-23 5349
一、RabbitMQ从信息接收者角度可以看做三种模式,一对一,一对多(此一对多并不是发布订阅，而是每条信息只有一个接收者)和发布订阅。其中一对一是简单队列模式，一对多是Worker模式，而发布订阅包括发布订阅模式，路由模式和通配符模式，为什么说发布订阅模式包含三种模式呢，其实发布订阅，路由，通配符三种模式都是使用只是交换机(Exchange)类型不一致 1：一对一 需要建立两个项目（NuGet引入RabbitMQ.Client），一个Send，一个Receive。代码如下 Send: public
RabbitMq工作模式
@王某人
11-10 2440
rabbitMq工作模式 Work queues工作队列模式 模式说明 Work Queues 与入门程序的 简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 订阅模式概述 订阅模式示例图： 前面2个案例中，只有3个角色： P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。 queue：消息队列，图中红色部分 而在订阅模型中，多了一个exchange角色，而且过程略有变化
PHP代码简单实现RabbitMQ
做一个乐于分享的程序员
08-08 1335
window amqp扩展安装，php实现rabbitmq的消息推送和消息接收
RabbitMQ从入门到进阶
01-30
RabbitMQ从入门到进阶的详细讲解，其中包含各种用例、代码等

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值