RabbitMQ 工作模式学习总结

已于 2022-09-19 17:06:13 修改
阅读量588 收藏 2
点赞数
文章标签： java-rabbitmq rabbitmq 学习
于 2022-09-03 18:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45161367/article/details/126663194
版权

MQ 的基本概念

MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。用于应用解耦、异步、流量削锋、数据分发、错峰流控、日志收集等等。当前市面上mq的产品很多，比如RabbitMQ、Kafka、ActiveMQ、RocketMQ。甚至连redis这种NoSQL都支持MQ的功能。
请添加图片描述

MQ 的优势
1、 应用解耦
2、系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？

RabbitMq

RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在不同的应用之间共享数据(跨平台跨语言)。RabbitMQ是使用Erlang语言编写，并且基于AMQP协议实现。
在这里插入图片描述

RabbitMq中的概念

Broker： 也就是MQ的服务器，用于接收和分发消息，RabbitMQ Server就是 Message Broker

Virtual host：安全组件，当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等操作。

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

Channel：Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。

Queue：存放消息，等待consumer 取走

Binding：exchange 和 queue 之间的连接关系，Binding 信息会被保存到 exchange 中的查询表中，用于 message 的分发依据。

RabbitMQ 6 种工作模式

simple简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式

simple 简单模式:

请添加图片描述
应用场景
普通的异步任务
工作流程：
1、一个生产者P，一个队列，一个消费者C。

2、消息产生消息放入队列，消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)

代码示例
引入jar包：
<dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
连接工具类：
public class RabbitUtils {
    private static ConnectionFactory connectionFactory = new ConnectionFactory();
    static {
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//5672是RabbitMQ的默认端口号
        connectionFactory.setUsername("zhangsan");
        connectionFactory.setPassword("123456");
        connectionFactory.setVirtualHost("/zhangsahn");
    }
    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = connectionFactory.newConnection();
            return conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
队列交换机信息类：
public class RabbitConstant {
    public static final String QUEUE_HELLOWORLD = "helloworld";
    public static final String QUEUE_SMS = "sms";
    public static final String EXCHANGE_WEATHER = "weather";
    public static final String EXCHANGE_WEATHER_ROUTING = "weather_routing";
    public static final String QUEUE_BAIDU = "baidu";
    public static final String QUEUE_SINA = "sina";
    public static final String EXCHANGE_WEATHER_TOPIC = "weather_topic";
}
生产者：
public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {


        //获取TCP长连接
        Connection conn = RabbitUtils.getConnection();
        //创建通信“通道”，相当于TCP中的虚拟连接
        Channel channel = conn.createChannel();

        //创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列
        //第一个参数：队列名称ID
        //第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
        //第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问
        //第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列
        //其他额外的参数, null
        channel.queueDeclare(RabbitConstant.QUEUE_HELLOWORLD,false, false, false, null);

        String message = "helloWorld";
        //四个参数
        //exchange 交换机，暂时用不到，在后面进行发布订阅时才会用到
        //队列名称
        //额外的设置属性
        //最后一个参数是要传递的消息字节数组
        channel.basicPublish("", RabbitConstant.QUEUE_HELLOWORLD, null,message.getBytes());
        //使用完毕关闭资源
        channel.close();
        conn.close();
        System.out.println("===发送成功===");

    }
}
消费者：
public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {


        //获取TCP长连接
         Connection conn = RabbitUtils.getConnection();
        //创建通信“通道”，相当于TCP中的虚拟连接
        Channel channel = conn.createChannel();

        //创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列
        //第一个参数：队列名称ID
        //第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
        //第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问
        //第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列
        //其他额外的参数, null
        channel.queueDeclare(RabbitConstant.QUEUE_HELLOWORLD,false, false, false, null);

        //从MQ服务器中获取数据

        //创建一个消息消费者
        //第一个参数：队列名
        //第二个参数代表是否自动确认收到消息，false代表手动编程来确认消息，这是MQ的推荐做法
        //第三个参数要传入DefaultConsumer的实现类
        channel.basicConsume(RabbitConstant.QUEUE_HELLOWORLD, false, new Reciver(channel));

		//因为消费者需要一直监听队列，所以不需要关闭连接 
    }
}


class  Reciver extends DefaultConsumer {

    private Channel channel;
    //重写构造函数,Channel通道对象需要从外层传入，在handleDelivery中要用到
    public Reciver(Channel channel) {
        super(channel);
        this.channel = channel;
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

         String message = new String(body);
         System.out.println("消费者接收到的消息："+message);

         System.out.println("消息的TagId："+envelope.getDeliveryTag());
        //false只确认签收当前的消息，设置为true的时候则代表签收该消费者所有未签收的消息
        channel.basicAck(envelope.getDeliveryTag(), false);
    }
}
work queues 工作模式:

请添加图片描述
应用场景：
红包、项目中存在大量消息生产时(任务分配系统不需知道哪一个任务执行系统在空闲,直接将任务扔到消息队列中,空闲的系统自动争抢)。
工作流程：
1、一个生产者P，一个队列，多个消费者C。但多个消费者中只会有一个会成功地消费消息

2、消息产生者将消息放入队列消费者可以有多个,消费者1,消费者2,同时监听同一个队列,消息被消费?C1 C2共同争抢当前的消息队列内容,谁先拿到谁负责消费消息(隐患,高并发情况下,默认会产生某一个消息被多个消费者共同使用。

代码示例
封装消息实体：
public class SMS {

    private String name;
    private String mobile;
    private String content;

    public SMS(String name, String mobile, String content) {
        this.name = name;
        this.mobile = mobile;
        this.content = content;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}
生产者：
public class OrderSystem {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        for(int i = 1 ; i <= 100 ; i++) {
            SMS sms = new SMS("乘客" + i, "13900000" + i, "您的车票已预订成功");
            String jsonSMS = new Gson().toJson(sms);
            channel.basicPublish("" , RabbitConstant.QUEUE_SMS , null , jsonSMS.getBytes());
        }
        System.out.println("发送数据成功");
        channel.close();
        connection.close();
    }
}
消费者1、2、3:
//消费者1
public class SMSSender1 {

    public static void main(String[] args) throws IOException {


        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);
        
		//设置限流机制
		//channel.basicQos(0, 5, false);
        //param1: prefetchSize，消息本身的大小 如果设置为0  那么表示对消息本身的大小不限制
        //param2: prefetchCount，告诉rabbitmq不要一次性给消费者推送大于N个消息
        //param3：global，是否将上面的设置应用于整个通道，false表示只应用于当前消费者
        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_SMS , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String jsonSMS = new String(body);
                System.out.println("SMSSender1-短信发送成功:" + jsonSMS);

                try {
                	//模拟每台服务器执行效率不同
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者2
public class SMSSender2 {

    public static void main(String[] args) throws IOException {


        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_SMS , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String jsonSMS = new String(body);
                System.out.println("SMSSender2-短信发送成功:" + jsonSMS);

                try {
                    //模拟每台服务器执行效率不同
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者3
public class SMSSender3 {


    public static void main(String[] args) throws IOException {


        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个

        channel.basicConsume(RabbitConstant.QUEUE_SMS , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String jsonSMS = new String(body);
                System.out.println("SMSSender3-短信发送成功:" + jsonSMS);

                try {
                	//模拟每台服务器执行效率不同
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}
Pub/Sub 发布与订阅模式:

请添加图片描述
应用场景：
用户通知，消息推送，短信，邮件群发，群聊、天气预报推送等
工作流程:
1、一个生产者P，一个交换机X，多个队列，多个消息消费者C。每个消费队列中消息是一致的，且每个消息消费者都从自己的消息队列的第一个消息开始消费。

2、交换机为rabbitMQ中内部组件。消息生产者将消息发送给rabbitMQ后，rabbitMQ会根据订阅的消费者个数，生成对应数目的消息队列，这样每个消费者都能获取生产者发送的全部消息。

3、一旦消费者断开与rabbitMQ的连接，队列就会消失。如果消费者数目很多，对于rabbitMQ而言，也是个重大负担，订阅模式是个长连接，占用并发数，且每个消费者一个队列会占用大量空间

Exchange 交换机：
Exchange只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失。一方面，接收生产者发送的消息。另一方面，处理消息时会递交给某个特别队列或者递交给所有队列或是将消息丢弃，到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
Fanout：广播，将消息交给所有绑定到交换机的队列
Direct：定向，把消息交给符合指定routing key 的队列
Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

代码示例
生产者：
public class WeatherBureau {

    public static void main(String[] args) throws Exception {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //输入
        String input = new Scanner(System.in).next();
        //获取虚拟连接
        Channel channel = connection.createChannel();
        //第一个参数交换机名字   其他参数和之前的一样
        channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER,"" , null , input.getBytes());

        channel.close();
        connection.close();
    }
}
消费者：
//消费者1
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key（暂时用不到)
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER, "");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者2
public class BiaDu {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);

        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key（暂时用不到)
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER, "");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}
发布订阅模式 与 工作模式的异同：

不同点：
1、work queues不用定义交换机，而publish/subscribe需要定义交换机。

2、publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认交换机)。

3、publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机。

相同点：
所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。

Routing 路由模式:

请添加图片描述
应用场景：
比如一个记录日志的功能，针对error型的日志记录数据库，日常info和warning进行写日志文件，那这样我们就可以使用路由模式，创建exchange【交换机】，类型为direct：这个类型表示需要明确指定路由key，为每个对应的日志类型创建队列。绑定交换机，再创建2个消费者，1个绑定error队列，1个绑定info，warning队列。进行业务处理
工作流程：
1、每个消费者监听自己的队列，并设置routingkey。

2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定队列

代码示例
生产者：
public class WeatherBureau {

    public static void main(String[] args) throws Exception {
		//数据准备
        Map area = new LinkedHashMap<String, String>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201127天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");
        
        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");

        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry<String, String> me = itr.next();
            //第一个参数交换机名字   第二个参数作为 消息的routing key
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_ROUTING,me.getKey() , null , me.getValue().getBytes());
        }

        channel.close();
        connection.close();
    }
}
消费者：
//消费者1
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //指定队列与交换机以及routing key之间的关系
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "us.cal.lsj.20201127");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hubei.wuhan.20201127");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "us.cal.lsj.20201128");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.henan.zhengzhou.20201012");

        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者2
public class BiaDu {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);
        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hunan.changsha.20201127");
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hebei.shijiazhuang.20201128");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}
Topics 主题模式:

请添加图片描述
应用场景：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种通知类型都接收的则两种通知都有效。
工作流程：
每个消费者监听自己的队列，并且设置带统配符的routingKey
生产者将消息发给broker，由交换机根据routingkey来转发消息到指定队列
通配符：
#是一个可以匹配一个或者多个单词
*是只匹配一个单词

代码示例
生产者：
public class WeatherBureau {

    public static void main(String[] args) throws Exception {

        Map area = new LinkedHashMap<String, String>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201127天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");
        
        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");

        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry<String, String> me = itr.next();
            //第一个参数交换机名字   第二个参数作为 消息的routing key
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_TOPIC,me.getKey() , null , me.getValue().getBytes());

        }

        channel.close();
        connection.close();
    }
}
消费者：
//消费者1
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //指定队列与交换机以及routing key之间的关系
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "us.#");

        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者2
public class BiaDu {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);
        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "*.*.*.20201127");
  
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}
RPC 远程调用模式:

RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：

1、客户端即是生产者就是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列;
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果;
3、服务端将RPC方法 的结果发送到RPC响应队列;
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

总结：

  • 简单模式，用的默认交换机，1个生产者，1个消费者，一个消息只能被一个消费者消息

  • 工作模式，多个消费者监听同一个队列，如果任务较多，可以多几个消费者，加快消费的速度。

  • 发布订阅模式，引入了交换机的类型fanout广播模式 ，每个消费者单独监听自己的对列都可以取消费自己队列的消息。

  • 路由模式，是direct的的交换机类型，指定路由

  • 主题模式，是topic的交换机类型，比路由模式多了通配符

RabbitMQ 消息确认机制

RabbitMQ提供了监听器(Listener)来接收消息投递的状态。消息确认涉及两种状态:

Confirm & Return：

Confirm代表生产者将消息送到MQ时产生的状态，后续会出现两种情况:

  • ack代表Broker已经将数据接收。
  • nack代表Broker拒收消息。原因有多种，队列已满，限流，IO异常…等

Return代表消息被MQ正常接收(ack)后，但MQ没有对应的队列进行投递时产生的状态，消息会退回给生产者。
注意:上面两种状态只代表生产者与MQ之间消息投递的情况。与消费者是否接收/确认消息无关

代码示例
配置文件：
publisher-confirms: true #ture表示使用生产者确认模式
生产者：
public class WeatherBureau {
    public static void main(String[] args) throws IOException, TimeoutException {
        Map area = new LinkedHashMap<String, String>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201127天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");

        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");

        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        //开启confirm监听模式
        channel.confirmSelect();
        channel.addConfirmListener(new ConfirmListener() {
            public void handleAck(long l, boolean b) throws IOException {
                //第二个参数代表接收的数据是否为批量接收，一般我们用不到。
                System.out.println("消息已被Broker接收,Tag:" + l );
            }

            public void handleNack(long l, boolean b) throws IOException {
                System.out.println("消息已被Broker拒收,Tag:" + l);
            }
        });
       channel.addReturnListener(new ReturnCallback() {
            public void handle(Return r) {
                System.err.println("===========================");
                System.err.println("Return编码：" + r.getReplyCode() + "-Return描述:" + r.getReplyText());
                System.err.println("交换机:" + r.getExchange() + "-路由key:" + r.getRoutingKey() );
                System.err.println("Return主题：" + new String(r.getBody()));
                System.err.println("===========================");
            }
        });
        Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry<String, String> me = itr.next();
            //Routing key 第二个参数相当于数据筛选的条件
            //第三个参数为：mandatory true代表如果消息无法正常投递则return回生产者，如果false，则直接将消息放弃。
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_TOPIC,me.getKey() ,true, null , me.getValue().getBytes());
        }
        //如果关闭则无法进行监听，因此此处不需要关闭
        //channel.close();
        //connection.close();
    }
}
消费者：
//消费者1
public class Sina {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "us.#");

        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

//消费者2
public class Baidu {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);
        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "*.*.*.20201127");
  
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }
}

RabbitMQ的优缺点

优点：
  • 持久化：RabbitMQ可以保证所在的服务器宕机后，消息不会丢失。
  • 高可用：部分机器宕机了还可以继续使用。
  • 高级功能：如消息重试、死信队列等
缺点：
  • 吞吐量较低，大概在每秒几万，这样像对于大型电商促销秒杀就不能胜任。
  • 集群线性扩展比较麻烦
  • 开发语言是erlang，懂得人不是很多，无法对其改造。
只要平凡丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ的5种消息模型
qq_43640120的博客
08-22 668
MQ官方教程地址：http://www.rabbitmq.com/getstarted.html 什么是MQ `MQ`(Message Quene) : 翻译为 `消息队列`,通过典型的 `生产者`和`消费者`模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 `消息中间件` 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。基于AMQP协
RabbitMQ学习总结
03-22
RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）的开源消息代理...在实际应用中，可以根据不同的业务需求选择合适的消息模式，如简单队列、发布/订阅、工作队列、路由、主题等，以实现更灵活的系统设计。
RabbitMQ消息中间件专题课程(附讲义源码)
12-12
在分布式系统中，我们会广泛使用各种消息中间件来进行系统间的数据交换，以便于各系统之间实现异步解耦。目前市场上开源的消息中间件有很多：如Kafka、RabbitMQ、RocketMQ等等。其中RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。 本课程针对RabbitMQ进行详细讲解，帮助学员掌握并熟悉微消息中间件的应用场景，快速上手并能够实战开发，胜任企业项目开发和企业面试需要。 以下为课程目录:   
消息队列-RabbitMQ应用场景和消息确认机制
weixin_42506047的博客
10-23 350
.1 RabbitMQ 消息队列 1.1 使用场景
RabbitMQ二、RabbitMQ的六种模式
最新发布
学习笔记
06-01 1311
主要了解rabbitmq的六种模式
RabbitMQ学习心得
weixin_41761445的博客
10-12 201
什么是RabbitMQ 前言 对于一门新技术的掌握，个人感觉还是得从由来开始，我们需要知道他为什么而产生的。这样更利于学习。 1.RabbitMQ的由来 Message Queue的需求由来已久，80年代最早在金融交易中，高盛等公司采用Teknekron公司的产品，当时的Message queuing软件叫做：the information bus（TIB）。 TIB被电信和通讯公司采用，...
RabbitMQ六种工作模式详解
soberw的日常分享博客
06-01 3054
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com/RabbitMQ提供了6种模式：官网对应模式介绍：https://www.rabbitmq.com/getstarted.htmlAMQP 一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消
Springboot整合RabbitMq学习
01-05
SpringBoot整合RabbitMQ的学习是一个重要的主题，尤其对于那些希望在Java环境中构建高效、可扩展的消息传递系统的开发者来说。RabbitMQ是一个开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing ...
RabbitMq学习笔记1
08-03
**RabbitMQ工作模式与交换器类型** RabbitMQ支持多种工作模式和交换器类型，包括简单模式、工作模式（资源竞争）、发布/订阅模式、路由模式、主题模式以及RPC模式。下面是一些主要的交换器类型： 1. **Fanout交换...
rabbitmq学习资料
01-30
【RabbitMQ 学习资料】这篇文档是针对初学者准备的，主要涵盖了RabbitMQ的基本概念、消息队列的工作原理、AMQP和JMS的区别、常见消息中间件的对比，以及RabbitMQ的安装与配置，还有其提供的Web管理界面和基本功能。...
Java相关技术总结，包括redis，MySQL，RabbitMq，面试题总结，源码解读
05-02
理解RabbitMQ的工作模式，如Direct、Fanout、Topic和Header交换器，以及队列绑定等概念，对于正确使用RabbitMQ至关重要。 面试题总结部分，Java开发者应该掌握的基本概念包括：多线程（线程安全、同步机制）、集合...
RabbitMQ安装与原理详解
一名小码农的博客
01-12 515
文章目录一、概述二、安装1. 安装Erlang2. 安装RabbitMQ三、RabbitMQ1. 启动和关闭2. 插件管理 一、概述 消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。 消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 ...
RabbitMQ六种工作模式
qq_45743985的博客
09-06 630
RabbitMq的工作模式其实大致都是基于四种类型的交换机来划分的，simple简单模式、work模式、Routing路由模式是基于Direct类型的交换机来实现(simple简单模式、work模式是基于default AMQP默认交换机也就是Direct类型的)；publish/Subscribe发布订阅模式是基于fanout类型的交换机来实现的。Routing路由模式是基于；Topic主题模式是基于Topic类型的交换机来实现的。
图文并茂的RabbitMQ工作模式
王华春_Jason
09-15 781
一、简单模式 1、简单模式 一对一模式，一个生产者、一个消费者，生产者发送消息，消费者消费消息。 生产者：也就是要发送消息的程序 消费者：消息的接收者，会一直等待消息到来 消息队列：类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息 2、实例代码： //生产者 public class Producer { public static void main(String[] args) throws IOException, TimeoutException
RabbitMQ最佳实践
Java知音
07-15 316
点击上方“Java知音”，选择“置顶公众号”技术文章第一时间送达！作者：无知者云https://www.cnblogs.com/davenkin推荐阅读(点击即可跳转阅读...
RabbitMQ五种工作模式
热门推荐
weixin_41882200的博客
05-21 1万+
RabbitMQ五种工作模式 1、简单队列 一个生产者对应一个消费者！！ 2、work 模式 一个生产者对应多个消费者，但是一条消息只能有一个消费者获得消息！！！ 轮询分发就是将消息队列中的消息，依次发送给所有消费者。一个消息只能被一个消费者获取。 3、发布/订阅模式 一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听该队列的消费者所接收并消费。 ps:X表示交换器，在RabbitMQ中，交换器主要有四种类型:direct、fanout、topic、headers，这里的交换器是 fa
RabbitMQ之工作模式
Uncle
09-12 3614
六大工作模式 RabbitMQ有以下几种工作模式 ： 1、Work queues 2、Publish/Subscribe 3、Routing 4、Topics 5、Header 6、RPC 一、 Work queues 工作队列模式，采用默认的交换机，路由名称为队列名称，有多个终端消费同一个队列的时候，交换机采用轮询发送消息，通俗点说就是给第一个发一条，另外一个发下一条 应用场景： 对于 任务过...
RabbitMQ 的五种工作模式
每日一记，每周一结。
07-13 1113
Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
二、RabbitMQ的五种工作模式
qq_49723651的博客
11-05 2818
1.简单（Simple）模式P：生产者，也就是要发送消息的程序。C：消费者：消息的接收者，会一直等待消息到来。queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。简单模式就是单发单收，消息的消费者监听消息队列，如果队列中有消息，就消费掉，消息被拿走后，自动从队列中删除。2.工作队列（Work Queue）模式公平分发：每个消费者接收消息的概率是相等的，消息队列会循环依次给每个消费者发送消息，这种是默认的策略。
RabbitMQ学习笔记：Java操作与Spring整合
"这是一份关于RabbitMQ的学习资料，涵盖了从基础的Java操作到Spring的整合使用，同时还包括了一些有价值的博客链接。" RabbitMQ是企业级的消息中间件，常用于实现分布式系统中的异步处理、应用解耦、流量削锋以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值