初步学习rabbitmq笔记

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

 

启动rabbitmq插件:rabbitmq-plugins enable rabbitmq_management

启动rabbitmq:rabbitmq-server

访问页面端口:15672

第一种模型(直连):

生产者生产消息:

@Test
    public void testSendMessage() throws IOException, TimeoutException {
        //创建mq工厂的连接
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置虚拟主机
        connectionFactory.setVirtualHost("/v-virtual");
        //设置端口
        connectionFactory.setPort(5672);
        //设置rabbitmq的ip
        connectionFactory.setHost("192.168.3.49");
        //设置账户密码
        connectionFactory.setUsername("v");
        connectionFactory.setPassword("123");
        //连接mq
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //通道绑定对应的消息队列
        //参数1:队列名称 不存在自动创建
        //参数2:用来定义是否需要持久化 true需要 false 不需要, 如true 关mq写入磁盘 false则不写入
        //参数3:是否独占队列  true独占 false 不独占, 独占则其他消息不能进入该队列
        //参数4:是否在被消费完后自动删除队列
        //参数5:附加参数
        //说明:当参数2为true时 关闭mq服务,队列不会被删除.
        channel.queueDeclare("hello",false,false,false,null);
        //发布消息
        //参数1:交换机名称
        //参数2:队列名称
        //参数3:消息传送的也额外设置
        //参数4:传送的消息内容
        //说明:当第三个参数设置为MessageProperties.PERSISTENT_TEXT_PLAIN时,消息不会被删除.前提是开启持久化
        channel.basicPublish("","hello",null,"哈哈,mq被创建了".getBytes());
        System.out.println("消息发布成功了----------------->");
        //关闭渠道
        channel.close();
        //关闭连接
        connection.close();
    }

消费者消费信息:

 public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory=new ConnectionFactory();
        connectionFactory.setPassword("123");
        connectionFactory.setUsername("v");
        connectionFactory.setHost("192.168.3.49");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/v-virtual");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //绑定队列
        channel.queueDeclare("hallo",false,false,false,null);
        //消费指定队列的信息
        /**
         *参数:
         *    1.指定要消费的队列
         *    2.开启消息自动确认机制
         *    3.消费时回调的接口
         *    
         */
        channel.basicConsume("hello", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String s, Envelope envelope, AMQP.BasicProperties basicProperties, byte[] bytes) throws IOException {
                System.out.println("-------------->消费消息->"+new String(bytes));
            }
        });

    }

 

创建工具类:


    private static ConnectionFactory connectionFactory;

    //类加载时运行一次
    static {
        connectionFactory=new ConnectionFactory();
        connectionFactory.setVirtualHost("/v-virtual");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("v");
        connectionFactory.setPassword("123");
        connectionFactory.setHost("192.168.3.49");
    }
    //创建mq连接
    public static Connection getRabbitMqConnection(){
        try {
            return connectionFactory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return  null;
    }
    //关闭mq资源
    public static void closeRabbitMqConnection(Channel channel,Connection connection){
        try {
            if (channel!=null)channel.close();
            if (connection!=null)connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }

rabbitmq----work模型:一对多

生产者:

 public static void main(String[] args) throws IOException {
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        Channel channel = rabbitMqConnection.createChannel();
        //声明队列
        channel.queueDeclare("work",false,false,false,null);
        for (int i = 0; i <30 ; i++) {
            channel.basicPublish("","work",null,(i+"生产者生产了消息").getBytes());
        }
        //发送消息
        RabbitMQUtils.closeRabbitMqConnection(channel,rabbitMqConnection);
    }

消费者1:

    Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建渠道
        Channel channel = rabbitMqConnection.createChannel();

        channel.queueDeclare("work",false,false,false,null);

        channel.basicConsume("work",true,new DefaultConsumer(channel){

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("我Consumer1拿到信息了,内容为:-->"+new String(body));
            }
        });

消费者2:

public static void main(String[] args) throws IOException {
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建渠道
        Channel channel = rabbitMqConnection.createChannel();

        channel.queueDeclare("work",false,false,false,null);

        channel.basicConsume("work",true,new DefaultConsumer(channel){

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("我Consumer2拿到信息了,内容为:-->"+new String(body));
            }
        });
    }

运行结果:

结论:当有多个消费者时,mq会平均分配生产信息

能者多劳(不平均分配):consumer(在所有消费者里改)

    Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建渠道
        final Channel channel = rabbitMqConnection.createChannel();
        channel.basicQos(1);//每次只能消费一个消息   
        channel.queueDeclare("work",false,false,false,null);
        //false 不开启消息自动确认
        channel.basicConsume("work",false,new DefaultConsumer(channel){

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("我Consumer2拿到信息了,内容为:-->"+new String(body));
                //手动确认 参数1:手动确认标识,参数2 false每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }

rabbitmq---fanout(广播模型):

消费者:

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

        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();

        Channel channel = rabbitMqConnection.createChannel();

        //t通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();

        //将交换机与临时队列进行绑定
        channel.queueBind(queueName,"logs","");

        //消费消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1-消费信息:"+new String(body));
            }
        });
    }

生产者:

   //创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();

        //创建通道
        Channel channel = rabbitMqConnection.createChannel();

        //将通道声明指定交换机 参数1:交换机名字 参数2:fanout 广播类型
        channel.exchangeDeclare("logs","fanout");

        //发送消息
        channel.basicPublish("logs","",null,"fanout 发送信息成功".getBytes());

        //关闭资源
        RabbitMQUtils.closeRabbitMqConnection(channel,rabbitMqConnection);

结论:当生产者生产消息时,被绑定的相同的交换机会把信息发给消费者

rabbitmq---路由模式(对指定的消费者发信息)

消费者1:

  // 创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建通道
        Channel channel = rabbitMqConnection.createChannel();
        //定义交换机名字
        String exchangeName="logs_direct";
        //申明交换机
        channel.exchangeDeclare(exchangeName, "direct");
        //申明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列与交换机绑定
        channel.queueBind(queueName, exchangeName, "info");
        //消费消息
        channel.basicConsume(queueName, true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1"+new String(body));
            }
        });

    }

 消费者2:

 // 创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建通道
        Channel channel = rabbitMqConnection.createChannel();
        //定义交换机名字
        String exchangeName="logs_direct";
        //申明交换机  参数2 direct 路由模式
        channel.exchangeDeclare(exchangeName, "direct");
        //申明一个临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列与交换机绑定
        channel.queueBind(queueName, exchangeName, "info");
        channel.queueBind(queueName, exchangeName, "error");
        channel.queueBind(queueName, exchangeName, "warning");
        //消费消息
        channel.basicConsume(queueName, true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2"+new String(body));
            }
        });

    }

生产者:

    // 创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建通道
        Channel channel = rabbitMqConnection.createChannel();
        //定义交换机名字
        String exchangeName="logs_direct";
        //申明交换机
        channel.exchangeDeclare(exchangeName, "direct");
        String routingKey="error";
        //生产消息
        channel.basicPublish(exchangeName,routingKey,null,("这是生产者发送的信息.名称为:"+routingKey).getBytes());
        //关闭资源
        RabbitMQUtils.closeRabbitMqConnection(channel,rabbitMqConnection);

结论:发送指定消息时 可以根据路由的不同进行发送

rabbitmq---动态路由模式:(通配符路由):

生产者:

  //获取连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建渠道
        Channel channel = rabbitMqConnection.createChannel();
        //交换机名字
        String exchangeName="topics";
        //定义一个交换机  参数二 topic 动态路由模型
        channel.exchangeDeclare(exchangeName, "topic");
        String routingKey="user.hah";
        //发送消息  参数1 交换机名字 参数2:路由名字
        channel.basicPublish(exchangeName, routingKey, null, ("生产者已经生产消息,消息为:"+routingKey).getBytes());

        RabbitMQUtils.closeRabbitMqConnection(channel, rabbitMqConnection);

消费者1:

     //创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建通道
        Channel channel = rabbitMqConnection.createChannel();
        //定义交换机名称
        String exchangName="topics";
        //定义交换机
        channel.exchangeDeclare(exchangName, "topic");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定交换机与队列 路由绑定
        channel.queueBind(queue,exchangName,"*.user");
        //消费消息
        channel.basicConsume(queue,true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1-->消费消息为:"+new String(body));
            }
        });

消费者2:

 //创建连接
        Connection rabbitMqConnection = RabbitMQUtils.getRabbitMqConnection();
        //创建通道
        Channel channel = rabbitMqConnection.createChannel();
        //定义交换机名称
        String exchangName="topics";
        //定义交换机
        channel.exchangeDeclare(exchangName, "topic");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定交换机与队列 路由绑定
        //          参数3 路由
        //          *  匹配一个词
        //          #  匹配一个或多个

        channel.queueBind(queue,exchangName,"user.#");
        //消费消息
        channel.basicConsume(queue,true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2-->消费消息为:"+new String(body));
            }
        });

 

V_1920
关注
RabbitMQ路由模式
ouyang2018的博客
11-02 358
模型 路由模式与发布订阅模式非常相似，但是路由模式增加了路由键的配置，生产者在发送消息到交换机的时候会指定一个routingKey，用于匹配队列，同时队列绑定到交换机时也会指定routingKey，交换机在向队列发送消息时，会根据routingKey来匹配。 生产者 public class Provider { private static final String EXCHANGE_N...
大牛总结超详细的RabbitMQ入门，看这篇文章就够了！
石杉的架构笔记
08-27 522
上篇文章我们初步介绍了之前制定的那些消息中间件数据不丢失的技术方案遗留的问题。 本文会深入的分析一下消费者手动ack机制保证消息不丢失的底层原理。
RabbitMq--路由模式（ Routing）
weixin_45822048的博客
11-25 308
下面展示一些 内联代码片。 public class Routing { @Test public void publish() throws IOException, TimeoutException { //1. 获取连接对象 Connection getconnection = RabbitMQUtil.getconnection(); //2. 创建连接通道对象 Channel channel = getconnecti
RabbitMq 路由模式（Routing）
鹏举的博客
08-24 1820
RabbitMq 路由模式介绍 路由模式主要是在发布订阅模式的前提上增加了一个routingKey，这样就可以给队列绑定一个rotingKey发消息指定routingKey给指定的队列发送消息，这样就只有单独的消费者消费消息了 DirectProducer编写 Routing模式主要是使用的direct交换机 public class DirectProducer { public static void main(String[] args) throws Exception{
RabbitMQ路由模式（direct）
诚的博客
11-09 5406
1、什么是路由模式（direct） 　　路由模式是在使用交换机的同时，生产者指定路由发送数据，消费者绑定路由接受数据。与发布/订阅模式不同的是，发布/订阅模式只要是绑定了交换机的队列都会收到生产者向交换机推送过来的数据。而路由模式下加了一个路由设置，生产者向交换机发送数据时，会声明发送给交换机下的那个路由，并且只有当消费者的队列绑定了交换机并且声明了路由，才会收到数据。下图取自于官方网站（RabbitMQ）的路由模式的图例 P：消息的生产者 X：交换机 红色：队列 C1，C2：消息消费者 e
RabbitMQ之路由模式
谁对谁错重要吗的博客
06-05 445
RabbitMQ之路由模式简介 生产者发送消息的时候，绑定一个key 消费者在接受消息的时候，也绑定一个key，两个key相同，那么就可以获取到 生产者发送的消息 Routing Key：路由关键字，exchange根据这个关键字进行消息投递。 exchange接收到消息后，就根据消息的key和已经设置的binding，进行消息路由，将消息投递到一个或多个队列里。 代码参考 生...
RabbitMQ.xmind
07-29
初步学习rabbitmq，对其下载配置，学习使用进行一个粗粒度的记载
RabbitMQ面试题（总结最全面的面试题）
q66562636的博客
06-25 912
简答详答解耦：A 系统发送数据到 BCD 三个系统，通过接口调用发送。如果 E 系统也要这个数据呢？那如果 C 系统现在不需要了呢？A 系统负责人几乎崩溃…A 系统跟其它各种乱七八糟的系统严重耦合，A 系统产生一条比较关键的数据，很多系统都需要 A 系统将这个数据发送过来。如果使用 MQ，A 系统产生一条数据，发送到 MQ 里面去，哪个系统需要数据自己去 MQ 里面消费。如果新系统需要数据，直接从 MQ 里消费即可；如果某个系统不需要这条数据了，就取消对 MQ 消息的消费即可。这样下来，A 系统压根儿不需要
rocketMQ学习笔记——consumer与broker的消息交互
Cia_zibo的博客
10-29 1912
rocketMQ的消费流程Consumerbroker保持拉取请求consumer的消费发起后记 Consumer 之前我们对消息队列体系中的注册中心、生产者、代理人(broker)有过初步的了解 broker启动后会将自己的信息注册进namesrv producer启动后会通过namesrv获取broker信息 消息生产后producer会将消息推送至broker broker收到消息后, 执行刷盘策略, 构建consumerQueue和indexFile 以上, 我们的消息已经存在与broker中了
pycharm 运行celery_Celery全面学习笔记
weixin_33923901的博客
01-14 2077
来源介绍Celery 是 Distributed Task Queue，分布式任务队列。分布式决定了可以有多个 worker 的存在，队列表示其是异步操作。Celery 核心模块Celery有一下5个核心角色Task就是任务，有异步任务和定时任务Broker中间人，接收生产者发来的消息即Task，将任务存入队列。任务的消费者是Worker。Celery本身不提供队列服务，推荐用Redis或Rabb...
rabbitmq---路由模式
牧xin的博客
05-20 282
路由模式 特点 队列与交换机的绑定,不能是任意绑定了,而需要指定一个routingkey(路由key) 消息的发送方在向Exchange发送消息时,也必须指定消息的routingKey Exchange不再把消息交给每一个绑定的队列,而是根据消息的routingKey与消息的routingKey完全一致,才会接收到消息 P:生产者,向Exchange发送消息,发送消息时,会指定一个routingkey X:exchange交换机,接收生产者消息,然后把消息递交给与routingkey完全匹配的队列 C1
RabbitMQ:路由模式
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-06 4098
在路由工作模式中，我们需要配置一个类型为direct的交换机，并且需要指定不同的路由键(routing key)，把对应的消息从交换机路由到不同的消息队列进行存储，由消费者进行消费。P:生产者，向交换机发送消息的时候，会指定一个routing keyX:Exchange(交换机),接收生产者的消息，然后把消息传递给和routing key完全匹配的队列C1:消费者，它所在队列指定了需要routing key为error的信息。
RabbitMQ——路由模式
薛定谔的Hello Kitty
12-21 231
下面我们将要实现这个模型，所有的代码将都是以这个模型为基础： direct： 首先，我们设置的routingKey是 error，那么按照路由规则，我们最终将向这两个队列发送消息： 生产者： public class Send { private static final String EXCHANGE_NAME = "test_exchange_direct"; publi...
RabbitMq路由模式
不负韶华梦为马
07-04 379
路由模式 路由模式下创建RabbitMq实例需要传入交换机exchange和routingkey func NewRabbitMqRouting(exchange, routingKey string) *RabbitMq { //创建rabbitmq实例 rabbitmq := NewRabbitMq("", exchange, routingKey) return rabbitmq...
RabbitMQ-路由模式
最新发布
海的那边，还是海吗
09-14 527
在分布式系统中，有时需要更精确地控制消息传递，以便只将消息发送给特定的接收者。RabbitMQ是一个强大的消息队列系统，可以用于实现各种消息传递模式，包括路由模式。本博客将介绍RabbitMQ路由模式的基本概念，并提供使用Java编写的示例代码，演示如何实现精确控制的消息路由。路由模式是一种消息传递模式，它允许消息生产者将消息发送到一个或多个特定的消息队列。在路由模式中，消息生产者将消息标记为具有特定的路由键，然后消息代理（RabbitMQ）将根据路由键将消息路由到与之匹配的队列。
RabbitMQ学习笔记
07-29
抱歉，我无法回答你的问题。你提供的引用内容似乎是一些命令行操作，而不是关于RabbitMQ学习笔记的内容。如果你有关于RabbitMQ学习笔记的具体问题，请提供更多的上下文信息，我将尽力帮助你。 #### 引用[.reference_title] - *1* *2* *3* [RabbitMQ学习笔记](https://blog.csdn.net/weixin_70577348/article/details/126653187)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v4^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值