RabbitMQ六种工作模式01

最新推荐文章于 2023-09-14 08:29:40 发布
最新推荐文章于 2023-09-14 08:29:40 发布
阅读量813 收藏
点赞数
文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60281421/article/details/130888349
版权

01: Work Queue工作队列模式

 

 

 

 

 

 

 

 

//接口所有的属性都是静态常量属性
public interface RabbitContent {

    //队列
    String QEUEU_HELLO = "hello";
    String QUEUE_WORKING ="working";
    String QUEUE_BAIDU ="baidu";
    String QUEUE_SINA ="sina";


    //交换机
    String CHANGE_WEATHER="weather";
    String CHANGE_ROUTING="weather_routing";
    String CHANGE_TOPIC="weather_topic";
}

 SMS:

public class SMS implements Serializable {
    private static final long serialVersionUID = 3185271845751784313L;
    private String name;
    private String phone;
    private String content;
//+  get/set  无参带参构造方法
}
WorkProducer：

package cpm.pb.working;


import com.google.gson.Gson;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import cpm.pb.test.utils.RabbitContent;
import cpm.pb.test.utils.RabbitUtils;

import java.io.IOException;

public class WorkProducer {

    public static void main(String[] args) throws Exception {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_WORKING, false, false, false, null);

        //在这里面我们共发送200条消息
        for(int i = 1; i <=200; i++) {
            SMS  sms = new SMS("admin"+i, "12345678976"+i, "购票成功");
            //把对象转换成字符串
            //JSONlib   fastJson   Jankson， gson
            String s = new Gson().toJson(sms);
            //System.out.println(s);
            //发送消息
            channel.basicPublish("", RabbitContent.QUEUE_WORKING, null, s.getBytes());
        }
        System.out.println("消息发送成功...");
        channel.close();
        connection.close();
    }
}

运行：

 消费者1：

SMSOrder1：

public class SMSOrder1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_WORKING, false, false, false, null);

        channel.basicQos(1);    //排队


        channel.basicConsume(RabbitContent.QUEUE_WORKING, false, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("SMSOrder1收到消息： " + new String(body));

                //签收
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });

    }
}

赋值三个  三个消费者  SMSOrder1：  SMSOrder2： SMSOrder3

分别运行：

 让每个消费者  做延迟：

 try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(), false);

每个消费者会消费不同的消息：

发布(publish)/订阅(Subscribe)模式：

 

 

 

 

 

Weather.Java：

/**
 * 气象局[供应商和应用商操作]
 */
public class Weather {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        //创建Fanout类型的交换机
        channel.exchangeDeclare(RabbitContent.CHANGE_WEATHER, BuiltinExchangeType.FANOUT,false,false,false, null);

        //发送消息我们把数据送入先关的交换机
        channel.basicPublish(RabbitContent.CHANGE_WEATHER, "",null, "北京38°晴转阴".getBytes());

        channel.close();
        connection.close();
    }
}

 Baidu.java:

public class Baidu {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_BAIDU,false,false, false, null);

        //交换机和队列进行绑定*****************
        channel.queueBind(RabbitContent.QUEUE_BAIDU, RabbitContent.CHANGE_WEATHER,"");
        channel.basicConsume(RabbitContent.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);
            }
        });
    }
}

Sina.java:

public class Sina {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_SINA,false,false, false, null);

        //交换机和队列进行绑定
        channel.queueBind(RabbitContent.QUEUE_SINA, RabbitContent.CHANGE_WEATHER, "");

        channel.basicConsume(RabbitContent.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);
            }
        });
    }
}

 路由Routing模式:

 

 

 

 手动添加一个交换机

 

 Baidu.java:

public class Baidu {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_BAIDU,false,false, false, null);

        channel.queueBind(RabbitContent.QUEUE_BAIDU, RabbitContent.CHANGE_ROUTING, "china.henan.zhengzhou.20991011");

        channel.basicConsume(RabbitContent.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);
            }
        });
    }
}

Sina.java:

public class Sina {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_SINA,false,false, false, null);

        channel.queueBind(RabbitContent.QUEUE_SINA, RabbitContent.CHANGE_ROUTING, "us.cal.la.20991012");

        channel.basicConsume(RabbitContent.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);
            }
        });
    }
}

 

 主题Topic模式(常用):

 

 

 TopicProducer.java:

public class TopicProducer {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Map<String, String> area = new LinkedHashMap<String, String>();
        area.put("china.hebei.shijiazhuang.20991011", "中国河北石家庄20991011天气数据");
        area.put("china.shandong.qingdao.20991011", "中国山东青岛20991011天气数据");
        area.put("china.henan.zhengzhou.20991011", "中国河南郑州20991011天气数据");
        area.put("us.cal.la.20991011", "美国加州洛杉矶20991011天气数据");

        area.put("china.hebei.shijiazhuang.20991012", "中国河北石家庄20991012天气数据");
        area.put("china.shandong.qingdao.20991012", "中国山东青岛20991012天气数据");
        area.put("china.henan.zhengzhou.20991012", "中国河南郑州20991012天气数据");
        area.put("us.cal.la.20991012", "美国加州洛杉矶20991012天气数据");


        //发送数据
        Iterator<Map.Entry<String, String>> iterator = area.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            //发送数据
            channel.basicPublish(RabbitContent.CHANGE_TOPIC, next.getKey(), true, null, next.getValue().getBytes());
        }

        System.out.println("消息发送成功");


        //channel.close();
        //connection.close();

    }

}

Baidu.java:

public class Baidu {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_BAIDU,false,false, false, null);

        channel.queueBind(RabbitContent.QUEUE_BAIDU, RabbitContent.CHANGE_TOPIC, "china.#");

        channel.basicConsume(RabbitContent.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);
            }
        });
    }
}

Sina.java:

public class Sina {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(RabbitContent.QUEUE_SINA,false,false, false, null);

        channel.queueBind(RabbitContent.QUEUE_SINA, RabbitContent.CHANGE_TOPIC, "us.*.*.*");

        channel.basicConsume(RabbitContent.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);
            }
        });

    }
}

 MQ的消息确认机制 Confirm&return 与消费者没有关系

 

 

 

 TopicProducer.java:

public class TopicProducer {
    public static void main(String[] args) throws Exception {
        //这里我们不创建队列
        //只创建交换机
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Map<String, String> area = new LinkedHashMap<String, String>();
        area.put("china.hebei.shijiazhuang.20991011", "中国河北石家庄20991011天气数据");
        area.put("china.shandong.qingdao.20991011", "中国山东青岛20991011天气数据");
        area.put("china.henan.zhengzhou.20991011", "中国河南郑州20991011天气数据");
        area.put("us.cal.la.20991011", "美国加州洛杉矶20991011天气数据");

        area.put("china.hebei.shijiazhuang.20991012", "中国河北石家庄20991012天气数据");
        area.put("china.shandong.qingdao.20991012", "中国山东青岛20991012天气数据");
        area.put("china.henan.zhengzhou.20991012", "中国河南郑州20991012天气数据");
        area.put("us.cal.la.20991012", "美国加州洛杉矶20991012天气数据");

        channel.confirmSelect();  //开启监听事件

        channel.addConfirmListener(new ConfirmListener() {

            //消息被mq接受，状态
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息被mq接受：" + deliveryTag + "-----" + multiple);
            }

            //消息被mq举手的状态
            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("消息被mq拒收：" + deliveryTag + "-----" + multiple);
            }
        });


        //消息返回操作
        channel.addReturnListener(new ReturnCallback() {
            @Override
            public void handle(Return msg) {
                System.out.println("返回消息的状态吗" + msg.getReplyCode());
                System.out.println("返回消息的文本信息" + msg.getReplyText());
                System.out.println("返回消息的交换机" + msg.getExchange());
                System.out.println("返回消息的路由" + msg.getRoutingKey());
                System.out.println("返回消息为" + new String(msg.getBody()));
            }
        });

        //发送数据
        Iterator<Map.Entry<String, String>> iterator = area.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<String, String> next = iterator.next();
            //发送数据
            channel.basicPublish(RabbitContent.CHANGE_TOPIC, next.getKey(), true, null, next.getValue().getBytes());
        }

        System.out.println("消息发送成功");


        //channel.close();
        //connection.close();

    }
}

潇洒（sa）一点
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA操作RabbitMQ-work工作队列模式
程序猿的博客
10-03 245
工作队列模式：一个生产者，多个消费者，多个消费者共同监听一个队列，一个消息只能被一个消费者获取。工作队列模式又分为两种，轮询模式分发和公平分发。 轮询模式分发：一条消息一个消费者，按均分配。 公平分发：根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；按劳分配。 P：消息的生产者 C1，C2：消息的消费者 红色：队列 生产者将消息发送到队列（通过默认交换机），消费者从队列中获取消息。 1. pom.xml引入rabbitmq依赖 <...
RabbitMq中的工作队列模式
weixin_44569326的博客
09-11 401
原生JAVA操作RabbitMQ发送持久化消息时，添加的参数为：MessageProperties.PERSISTENT_TEXT_PLAIN。与简单模式相比，工作队列模式(Work Queue)多了一些消费者，该。模式也使用direct交换机，应用于处理消息较多的情况。3 消息队列默认采用轮询的方式将消息平均发送给消费者。工作队列模式应用于处理消息较多的情况。2 一条消息只会被一个消费者消费。一条消息只会被一个消费者消费。1 一个队列对应多个消费者。
RabbitMQ:工作队列模式
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-03 3948
任务队列）背后的主要思想是避免立即执行资源密集型任务并等待其完成。相反，我们将任务安排在以后完成。我们将_任务_封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当您运行多个工作线程时，任务将在它们之间共享。这个概念在 Web 应用程序中特别有用，因为在 Web 应用程序中，不可能在较短的 HTTP 请求窗口中处理复杂的任务。
RabbitMQ-工作队列模式
海的那边，还是海吗
09-14 181
在分布式应用程序中，任务分发是一个常见的挑战。RabbitMQ是一个强大的消息队列系统，可以用于实现各种消息传递模式，包括工作队列模式。本博客将介绍RabbitMQ工作队列模式的基本概念，以及如何使用Java编写示例代码来实现高效的任务分发。工作队列模式，也称为任务队列模式，是一种消息传递模式，用于在分布式系统中实现任务分发。在这种模式下，一个生产者（producer）将任务发布到队列中，多个消费者（consumer）从队列中获取任务并执行。
【RabbitMQ三】——RabbitMQ工作队列模式（Work Queues）
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
01-18 863
学习一门知识需要亲自动手去验证去证明这种方式是可行了，这样对于这个知识点才算是理解的更深。按照这样做一定行，而不是应该可以，大概可以吧。
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
基于RabbitMQ几种Exchange 模式详解
08-28
基于RabbitMQ几种Exchange模式详解 本文将详细介绍RabbitMQ中四种Exchange模式：fanout、direct、topic、header。在实际应用中，header模式使用较少，本文将对前三种模式进行比较。 一、Fanout Exchange Fanout ...
消息队列RabbitMQ入门与5种模式详解
02-24
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统；AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端...
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
Java课程实验 RabbitMQ 常用的工作模式
07-07
RabbitMQ是一个强大的消息中间件，提供了不同的工作模式以满足不同的消息传递需求。以下是RabbitMQ中常用的工作模式： 1. 简单模式（Simple Mode）： - 简单模式是最基本的消息传递模式，也是最简单的模式。生产者...
rabbitmq的5种模式详解
gymaisyl的博客
02-01 2674
Hello World （直连模式） # producer.py import pika # 1. 创建连接 credentials = pika.PlainCredentials('root', 'root123') # 需要连接对象的用户名和密码 parameters = pika.ConnectionParameters(host='192.168.100.37', port=5672, virtual_host='/ok', ..
04. RabbitMQ的几种工作模式
程序员阿红的博客
03-20 1754
04. RabbitMQ的几种工作模式 🍎姓名:程序员阿红🍎 🍊喜欢:Java编程🍊 🍉重要的事情说三遍!!!🍉 🍓欢迎大家关注哦,互相学习🍓 🍋欢迎大家访问哦,互相学习🍋 🍑欢迎大家收藏哦,互相学习🍑 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🍟🍟🍟RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此我们只学习前5种 🍗🍗🍗在线手册：https://www.rabbitmq.com/getstarted.htm 5种消息模型，大体分为两类： 1和2属于点对点 3、4
RabbitMQ五大模式轻松理解
风影浪子
06-13 7296
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
Python操作rabbitmq 实践笔记
weixin_30765577的博客
10-17 369
发布/订阅系统 1.基本用法 生产者 1 import pika 2 import sys 3 4 username = 'wt' #指定远程rabbitmq的用户名密码 5 pwd = '111111' 6 user_pwd = pika.PlainCredentials(username, pwd) 7 s_conn = pika.Blocking...
RabbitMQ学习笔记
daineng的专栏
11-22 1万+
参考链接： http://www.rabbitmq.com/getstarted.html RabbitMQ的官方入门教材，参考3也基于它http://blog.csdn.net/linvo/article/details/5750987 RabbitMQ和Python的入门经典：《兔子和兔子窝》，原文地址已失效http://www.01happy.com/python-pika-r
RabbitMQ学习笔记：获取消息（Ack Mode）
OceanSky的专栏
10-26 9455
在服务器端的客户端页面从队列中获取消息是一个危险的动作，生产环境一定要了解业务之后再做操作 Act Mode Nack message requeue true 获取消息，但是不做ack应答确认，消息重新入队 Ack message requeue false 获取消息，应答确认，消息不重新入队，将会从队列中删除 reject requeue true 拒绝获取消息，消息...
rabbitmq五种模式详解（含实现代码）
浅时光|初如梦
08-07 3285
1.简单模式 当生产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费. 1.1 结构 生产者:生成消息,发送到交换机 交换机:根据消息属性,将消息发送给队列 消费者:监听这个队列,发现消息后,获取消息执行消费逻辑 1.2应用场景 常见的应用场景就是一发,一接的结构 例如: 手机短信,邮件单发 2.争抢模式 强调的也是后端队列与消费者绑定的结构 2.1结构 生产者:.
RabbitMQ的第2种消息模型：work模式
user2025的博客
05-17 1457
work消息模型【能者多劳】 不同消费者可能消费消息的速度不一样，work模型通过手动确认机制实现能者多劳 多个消费者通过自动确认机制 工具类 public class RabbitMQUtil { private static ConnectionFactory connectionFactory; static { //创建连接工厂 connectionFactory = new ConnectionFactory(); //设置Rabb
RabbitMQ系列之三 RabbitMQ几种典型模式
热门推荐
程序猿的博客
11-15 2万+
本文详细介绍简单模式Simple、工作模式Work、发布订阅模式Publish/Subscribe、路由模式Routing、通配符模式Topics、远程调用模式RPC(区别于普通的消息队列的范畴了，所以这里暂不对该队列模式进行详解) 模式1：简单模式（Simple / HelloWorld 单生产单消费） 简单的发送与接收，没有特别的处理。 RabbitMQ连接（公共的连接方法，其他模式共用此方...
RabbitMQ五种工作模式
最新发布
06-02
以下是RabbitMQ的五种工作模式： 1. 简单模式(Simple Mode)：生产者发送消息到队列，消费者从队列中获取消息并处理。 2. 工作队列模式(Work Queue Mode)：多个消费者共享同一个队列，竞争消费队列中的消息。 3. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值