RabbitMQ(一)

最新推荐文章于 2024-05-11 18:44:46 发布
最新推荐文章于 2024-05-11 18:44:46 发布
阅读量388 收藏 1
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53891873/article/details/119871092
版权

TCP/IP三次握手 四次挥手
https://blog.csdn.net/weixin_42153410/article/details/80277733
6
RabbitMQ是一个开源的遵循AMQP协议的基于Erlang语言编写，支持多种客户端（语言），用于在分布式系统中存储消息，转发消息，具有高可用，高可扩性，易用性等特征

消息的分发

轮询分发（公平，无数据倾斜）

公平分发（数据倾斜，性能好的消费得多一些）

消息分发策略的机制和对比

ActiveMQRabbitMQKafkaRocketMQ
发布订阅支持支持支持支持
轮询分发支持支持支持-
公平分发-支持支持-
重发支持支持-支持
消息拉取-支持支持支持

消息队列的高可用和高可靠

什么是高可用机制？

高可用：指产品在规定的条件和规定的时间内处于可执行规定功能状态的能力

当业务量增大时，请求也过大，一台消息中间件服务器会触及硬件（CPU、内存、磁盘）的极限，一台消息服务器已经无法满足业务的需求，所以消息中间件必须支持集群部署，来达到高可用的目的

集群模式

1.master-slave主从共享 （单写多度）
2.master-slave主从同步（单写多度）
3.多主集群同步，多主多从（多写多度）
4.多主集群转发，
5.master-slave与Breoker-cluster的组合方案

要么消息共享，要么消息同步，要么元数据共享

什么是高可靠机制？

指系统可以无故障低持续运行，比如一个系统突然崩溃，报错，异常等等并不影响线上业务的正常运行，出错的几率极低，则称之为高可靠。
在高并发场景中，如不能保证系统的高可靠，那造成的隐患和损失非常严重。

如何保证中间件消息的可靠性？
1.消息的传输：通过协议来保证系统间数据解析的正确性
2.消息的存储可靠：通过持久化来保证消息的可靠性

##安装使用
安装rabbitmq
安装erlang

手动启动方法一：systemctl start rabbitmq-server
重启服务：systemctl restart rabbitmq-server
关闭服务：rabbitmqctl stop

查看rabbitmq

systemctl status rabbitmq-server

rabbitmq图形化界面默认为ip:15672
要设置5672和15672为安全端口否则访问不了
在这里插入图片描述
在这里插入图片描述

rabbitmqctl add_user user pass #新增用户
rabbitmqctl set_user_tags user 角色 #给用户赋予角色
rabbitmqctl set change_password user 新密码  #修改密码
rabbitmqctl list_users  #可查看有哪些用户

rabbitmq角色分类

  1. none
    不能访问management plugin

  2. management:查看自己相关的节点
    列出自己可以通过AMQP登入的虚拟机

    • 查看自己的虚拟机节点Virtual hosts的queues，exchanges和bingings信息
    • 查看和关闭自己的channels和connections
    • 查看有关自己的虚拟机节点virtual hosts的统计信息。包括其他用户在这个节点virtual hosts中的活动信息

  3. Policymaker

    • 包含management的所有权限
    • 查看和创建和删除自己的virtual hosts所属的policies和parameters信息

  4. Monitoring

  • 包含management的所有权限
  • 罗列出所有的virtual hosts，包括不能登录的virtual hosts
  • 查看其他用户的connections和channels信息
  • 查看节点级别的数据如clustering和memory使用情况
  • 查看所有的virtual hosts的全局统计信息
  1. Administrator
    • 最高权限
    • 可以创建和删除virtual hosts
    • 可以查看，创建和删除users
    • 查看创建permisssions

简单的生产者消费者

生产者

public class Producer {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("ip");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();
            //4.通过通道创建交换机，声明队列，绑定关系，路由key,发送消息，和接收消息
            String queueName = "queue3";
            /**
             * @Param1 队列的名称
             * @Param2 是否要持久化，durable=false,所谓持久化消息是否存盘，如果false 非持久化 true 持久化 非持久化会存盘吗？会存盘，会随着服务器重启而丢失，持久化队列重启不会丢失
             *  @Param3 排他性，是否是一个独占队列
             *  @Param4 是否自动删除，随着最后一个消费者消息完毕消息以后是否把队列自动删除,false,不删除，true自动删除
             *  @Param5 携带附属参数
             */
            channel.queueDeclare(queueName,false,false,true,null);
            //channel.queueDeclare(queueName,false,false,false,null);
            //5.准备消息内容
            String message = "HElLO RABBITMQ";
            //6.发送消息给队列
            channel.basicPublish("",queueName, null,message.getBytes());
            System.out.println("消息发送成功咯");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
             //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

消费者

public class Consumer {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("ip");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            /**
             * @Param1 要接收的队列名
             */
            channel.basicConsume("queue3", true, new DeliverCallback() {
                public void handle(String consumerTag, Delivery message) throws IOException {
                    System.out.println("消费者收到的信息是：" + new String(message.getBody(), "UTF-8"));
                }
            }, new CancelCallback() {
                public void handle(String s) throws IOException {
                    System.out.println("消费者接收消息失败了。。。。");
                }
            });
            System.out.println("开始接收消息");
            //程序不向下执行
            System.in.read();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

在这里插入图片描述
queue1没有设置自动删除，也没有持久化
queue2设置了持久化features==》 D==>durable:true 持久化队列重启后还在
queue3自动删除配置的true ,就有一个features==》 AD==>auto-delete:true

若原本消息设置的auo-delete是false直接改为true,会报错

java.io.IOException
	at com.rabbitmq.client.impl.AMQChannel.wrap(AMQChannel.java:129)
	at com.rabbitmq.client.impl.AMQChannel.wrap(AMQChannel.java:125)
	at com.rabbitmq.client.impl.AMQChannel.exnWrappingRpc(AMQChannel.java:147)
	at com.rabbitmq.client.impl.ChannelN.queueDeclare(ChannelN.java:968)
	at com.rabbitmq.client.impl.recovery.AutorecoveringChannel.queueDeclare(AutorecoveringChannel.java:342)
	at com.doudou.simple.Producer.main(Producer.java:44)
Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'auto_delete' for queue 'queue1' in vhost '/': received 'true' but current is 'false', class-id=50, method-id=10)
	at com.rabbitmq.utility.ValueOrException.getValue(ValueOrException.java:66)
	at com.rabbitmq.utility.BlockingValueOrException.uninterruptibleGetValue(BlockingValueOrException.java:36)
	at com.rabbitmq.client.impl.AMQChannel$BlockingRpcContinuation.getReply(AMQChannel.java:502)
	at com.rabbitmq.client.impl.AMQChannel.privateRpc(AMQChannel.java:293)
	at com.rabbitmq.client.impl.AMQChannel.exnWrappingRpc(AMQChannel.java:141)
	... 3 more
Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'auto_delete' for queue 'queue1' in vhost '/': received 'true' but current is 'false', class-id=50, method-id=10)
	at com.rabbitmq.client.impl.ChannelN.asyncShutdown(ChannelN.java:517)
	at com.rabbitmq.client.impl.ChannelN.processAsync(ChannelN.java:341)
	at com.rabbitmq.client.impl.AMQChannel.handleCompleteInboundCommand(AMQChannel.java:182)
	at com.rabbitmq.client.impl.AMQChannel.handleFrame(AMQChannel.java:114)
	at com.rabbitmq.client.impl.AMQConnection.readFrame(AMQConnection.java:739)
	at com.rabbitmq.client.impl.AMQConnection.access$300(AMQConnection.java:47)
	at com.rabbitmq.client.impl.AMQConnection$MainLoop.run(AMQConnection.java:666)
	at java.lang.Thread.run(Thread.java:748)

rabbitmq为什么是基于通道去处理而不是链接呢？

大家都知道，在使用rabbitmq时不管是消费还是生产都需要创建信道（channel） 和connection（连接），如下图producer示例。我们完全可以直接使用Connection就能完成信道的工作，为什么还要引入信道呢，试想这样一个场景，一个应用有多个线程需要从rabbitmq中消费，或是生产消息，那么必然会建立很多个connection ,也就是多个tcp连接，对操作系统而言，建立和销毁tcp连接是很昂贵的开销，如果遇到使用高峰，性能瓶颈也随之显现，rabbitmq采用类似nio的做法，连接tcp连接复用，不仅可以减少性能开销，同时也便于管理。

每个线程都把持一个信道，所以信道复用了TCP连接。同时rabbitmq可以确保每个线程的私密性，就像拥有独立的连接一样。当每个信道的流量不是很大时，复用单一的connection可以再产生性能瓶颈的情况下有效地节省tcp连接资源，但是当信道本身的流量很大时，这时候多个信道复用一个connection就会产生性能瓶颈，进而是整体的流量被限制了。此时就需要开辟多个connection，将这些信道均摊到这些connection中，至于这些相关调优策略需要根据业务自身的实际情况进行调节。
在这里插入图片描述

可以存在没有交换机的队列吗？

不可能，虽然没有指定交换机，但一定会存在一个默认的交换机

RabbitMQ的核心组成部分

在这里插入图片描述

交换机（Exchange）一定是要有的，如果没写的话，则是会使用默认的交换机

核心概念
Server: 又被称为Broker,接受客户端的连接，实现AMQP服务。就是我们自己安装的rabbitmq-server
Connection: 连接，应用程序与Broker的网络连接（使用的是TCP/IP连接）
Channel: 网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道，每个通道Channel代表一个会话任务。
Message：消息，服务于应用程序之间传递的数据，由Properties和body组成，Properties可以对消息进行修饰，比如消息的优先级，延迟等高级特征，Body则是消息体的内容。
Virtual Host 虚拟地址，用于逻辑层隔离，最上层的消息路由，一个虚拟机理由可以有若干的Exchange和Queueu，同一个虚拟机里面不能有相同名字的Exchange。
Exchange: 交换机，接收消息，根据路由键发送消息到绑定的队列（不具备储存消息的能力）
Bindings： Exchange和Queue之间的虚拟连接，Binding中可以保护多个routing key.
Routing key: 是一个路由规则，虚拟机可以用它来确定如何路由一个特定消息。
Queue:队列，也是MessageQueue队列，保存消息转发给消费者

RabbitMQ的整体架构

在这里插入图片描述

RabbitMQ的操作流程
第一：获取Conection
第二：获取Channel
第三：定义Exchange，Queue
第四：使用一个RoutingKey将Queue Binding到一个Exchange上
第五：通过指定一个Exchange和一个RoutingKey来将消息发送到对应的Queue上，
第六：Consumer在接收时也是获取connection，接着获取channel，然后指定一个Queue，到Queue上取消息，它对Exchange，RoutingKey及如何Binding都不关心，到对应的Queue上去取消息就行了。

注意：一个PublisherClient发送消息，哪些ConsumerClient可以收到消息，在于Exchange，RoutingKey，Queue的关系上

RabbitMQ的运行流程

在这里插入图片描述

交换机的四种类型
在这里插入图片描述

  1. fanout
    找出绑定的队列，不再判断routing key

  2. direct
    先获取绑定的队列，然后还会再判断routing key;且routingkey需是完全匹配模式

  3. topic
    匹配bindKey和routingKey，但routing key的规则是模糊匹配模式

  4. headers
    不 匹配bindingKey和routingKey，而是在绑定队列与交换器的时候指定一个键值对；当交换器在分发消息的时候会先解开消息体里的headers数据，然后判断里面是否有所设置的键值对，如果发现匹配成功，才将消息分发到队列中；这种交换器类型在性能上相对来说较差，在实际工作中很少会用到。

从消息分发的性能上来比较：fanout > direct > topic > headers
topic的匹配规则只是用于消费者而不是生产者

通配符

路由键以.为分隔符，每一个分隔符的代表一个单词
通配符*匹配一个单词、通配符#可以匹配多个单词
*可以在routingKey和bindKey上使用，#只能用于RoutingKey中

RabbitMQ支持消息的模式

参考官网：https://www.rabbitmq.com/getstarted.html
默认交换机的模式是direct模式
在这里插入图片描述

  1. 简单模式 Simple
    .
    在这里插入图片描述

  2. 工作模式 Work
    在这里插入图片描述
    当有多个消费者接入时，消息如何分配

    • 轮询模式：一个消费者一条按均分配;不会根据你的处理速度等有所倾斜
    • 公平分发：根据消费者的能力进行公平分发；处理快的处理的多；处理慢的处理得少；按劳分配；

  3. 发布订阅模式
    在这里插入图片描述
    创建交换机的模式为fanout
    在这里插入图片描述
    即是队列订阅到同一个交换机，生产者发送一条消息，订阅者均可收到

  4. 路由模式
    Receiving messages selectively
    在这里插入图片描述
    相比于订阅模式制订了路由key,即是什么条件下发到什么队列
    创建交换机的模式为direct,如果用fanout全部都会收到
    在这里插入图片描述
    在这里插入图片描述
    指定发送的路由key
    在这里插入图片描述

  5. 主题Topic模式
    Receiving messages based on a pattern (topics)
    在这里插入图片描述
    即是路由模式的升级；支持模糊匹配的路由；
    创建交换机类型选择topic
    在这里插入图片描述
    #代表0级或1级或多级
    *代表有且只有一级
    发送指定路由key为order只有queue3可以收到
    发送指定路由key为course只有queue2不能收到
    发送指定路由key为.course.queue2可以收到
    com.course.order=>queue1,queue2,queue3均可收到
    com.course.order.xxx.xx=>queue1,queue3可收到;queue2收不到

  6. 参数模式
    在这里插入图片描述

根据参数为多少去匹配：
创建交换机模式选择为headers
在这里插入图片描述

RabbitMQ使用场景

解耦、削峰、异步

用代码去操作绑定等

例子为direct模式
生产者

public class Producer {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("ip");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            //5.准备消息内容
            String message = "HElLO RABBITMQ routing code direct模式";
            //准备交换机
            String exchangeName = "cdxx-direct-exchange-code";
            //路由key-模糊匹配路由
            String routeKey = "course";
            //指定交换机类型
            String type = "direct";
            //6.代码声明交换机
            /**
             * @Param1:交换机的名字
             * @Param2：交换机的类型
             * @Param3: 是否持久化，true持久化，持久化后rabbitmq重启不会消失
             */
            channel.exchangeDeclare(exchangeName,type,true);

            //7.声明队列
            /**
             * @Param1 队列的名称
             * @Param2 是否要持久化，durable=false,所谓持久化消息是否存盘，如果false 非持久化 true 持久化 非持久化会存盘吗？会存盘，会随着服务器重启而丢失，持久化队列重启不会丢失
             *  @Param3 排他性，是否是一个独占队列
             *  @Param4 是否自动删除，随着最后一个消费者消息完毕消息以后是否把队列自动删除,false,不删除，true自动删除
             *  @Param5 携带附属参数,headers模式下匹配参数
             */
            channel.queueDeclare("codequeue5",true,false,false,null);
            channel.queueDeclare("codequeue6",true,false,false,null);
            channel.queueDeclare("codequeue7",true,false,false,null);
            //8.绑定队列和交换机关系
            /**
             * @Param1 队列的名称
             * @Param2 交换机的名称
             * @Param3 routing key
             */
            channel.queueBind("codequeue5",exchangeName,"order");
            channel.queueBind("codequeue6",exchangeName,"order");
            channel.queueBind("codequeue7",exchangeName,"course");
            //6.发送消息给队列
            /**
             * @Param1:交换机 可以存在没有交换机的队列吗？不可能，虽然没有指定交换机，但一定会存在一个默认的交换机
             * @Param2：路由key
             * @Param3: 消息的状态控制
             * @Param4：消息主题
             */
            channel.basicPublish(exchangeName,routeKey, null,message.getBytes());
            System.out.println("消息发送成功咯");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
             //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

消费者

public class Consumer {
    public static Runnable runnable = new  Runnable(){
        public void run() {
            //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
            //ip port
            //1.创建连接工程
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("ip");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("user");
            connectionFactory.setPassword("mima");
            connectionFactory.setVirtualHost("/");
            final String queueName = Thread.currentThread().getName();
            Connection connection = null;
            Channel channel = null;
            try {
                //2.创建连接connection
                connection = connectionFactory.newConnection("生产者");
                //3.通过连接获取通道channel
                channel = connection.createChannel();

                /**
                 * @Param1 要接收的队列名
                 * @Param2 是否自动应答
                 */
                Channel finalChannel = channel;
                channel.basicConsume(queueName, true, new DeliverCallback() {
                    public void handle(String consumerTag, Delivery message) throws IOException {
                        System.out.println("消费者 "+queueName+" 收到的信息是：" + new String(message.getBody(), "UTF-8"));
                    }
                }, new CancelCallback() {
                    public void handle(String s) throws IOException {
                        System.out.println("消费者接收消息失败了。。。。");
                    }
                });
                System.out.println("开始接收消息");
                //程序不向下执行
                System.in.read();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //7.关闭通道
                if (channel != null && channel.isOpen()){
                    try {
                        channel.close();//关闭通道
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }
                //8.关闭连接
                if (connection != null && connection.isOpen()){
                    try {
                        connection.close(); //关闭连接
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            }
        }

    };
    public static void main(String[] args) {
       new Thread(runnable,"codequeue5").start();
       new Thread(runnable,"codequeue6").start();
       new Thread(runnable,"codequeue7").start();

    }
}

轮询分发代码

public class Producer {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
      connectionFactory.setHost("ip");
       connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            for (int i = 0; i < 20; i++) {
                //5.准备消息内容
                String message = "HElLO RABBITMQ work模式"+i;

                //6.发送消息给队列
                /**
                 * @Param1:交换机 可以存在没有交换机的队列吗？不可能，虽然没有指定交换机，但一定会存在一个默认的交换机
                 * @Param2：路由key
                 * @Param3: 消息的状态控制
                 * @Param4：消息主题
                 */
                channel.basicPublish("","workqueue1", null,message.getBytes());
                //Thread.sleep(1000);
            }

            System.out.println("消息发送成功咯");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
             //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

public class Consumer1 {

    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
       connectionFactory.setHost("ip");
       connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            /**
             * @Param1 要接收的队列名
             * @Param2 是否自动应答
             */
            channel.basicConsume("workqueue1", true, new DeliverCallback() {
                public void handle(String consumerTag, Delivery message) throws IOException {
                    try {
                        System.out.println("消费者 Consumer1 收到的信息是：" + new String(message.getBody(), "UTF-8"));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                public void handle(String s) throws IOException {
                    System.out.println("消费者接收消息失败了。。。。");
                }
            });

            System.out.println("Consumer1开始接收消息");
            //程序不向下执行
            System.in.read();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

package com.doudou.work.circle;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @ClassName Consumer 轮询分发：每个人接收一条数据
 * @Description
 * @Author lihongling
 * @Date 2021/8/26 19:18
 **/
public class Consumer2 {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
      connectionFactory.setHost("ip");
       connectionFactory.setPort(5672);
        connectionFactory.setUsername("user");
        connectionFactory.setPassword("mima");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            /**
             * @Param1 要接收的队列名
             * @Param2 是否自动应答
             */
            channel.basicConsume("workqueue1", true, new DeliverCallback() {
                public void handle(String consumerTag, Delivery message) throws IOException {
                    try {
                        System.out.println("消费者 Consumer2 收到的信息是：" + new String(message.getBody(), "UTF-8"));
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                public void handle(String s) throws IOException {
                    System.out.println("消费者接收消息失败了。。。。");
                }
            });

            System.out.println("Consumer2开始接收消息");
            //程序不向下执行
            System.in.read();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

公平分发代码
生产者和轮询一样
区别主要在这
在这里插入图片描述

package com.doudou.work.fair;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @ClassName Consumer 已用图形化界面绑定了
 * @Description
 * @Author lihongling
 * @Date 2021/8/26 19:18
 **/
public class Consumer1 {

    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.20.197");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("cdxx");
        connectionFactory.setPassword("cdxx");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            /**
             * @Param1 要接收的队列名
             * @Param2 是否自动应答,false手动应答,公平分发需用false
             */
            final Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("workqueue1", false, new DeliverCallback() {
                public void handle(String consumerTag, Delivery delivery) throws IOException {
                    try {
                        System.out.println("消费者 Consumer1 收到的信息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(100);
                        /**
                         * @Param1
                         * @Param2 false，单条消费
                         */
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    }catch (Exception e){
                        e.printStackTrace();
                    }

                }
            }, new CancelCallback() {
                public void handle(String s) throws IOException {
                    System.out.println("消费者接收消息失败了。。。。");
                }
            });

            System.out.println("Consumer1开始接收消息");
            //程序不向下执行
            System.in.read();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}


public class Consumer2 {
    public static void main(String[] args) {
        //所有的中间件技术都是基于tcp/ip协议基础上构建新型协议规范，只不过rabbitmq遵循的是qmqp协议
        //ip port
        //1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.20.197");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("cdxx");
        connectionFactory.setPassword("cdxx");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            //2.创建连接connection
            connection = connectionFactory.newConnection("生产者");
            //3.通过连接获取通道channel
            channel = connection.createChannel();

            /**
             * @Param1 要接收的队列名
             * @Param2 是否自动应答 false手动应答 公平分发需用false  true就和轮循分发一样了
             */
            final Channel finalChannel = channel;
            finalChannel.basicQos(1);
            finalChannel.basicConsume("workqueue1", false, new DeliverCallback() {
                public void handle(String consumerTag, Delivery delivery) throws IOException {
                    try {
                        System.out.println("消费者 Consumer2 收到的信息是：" + new String(delivery.getBody(), "UTF-8"));
                        Thread.sleep(1000);
                        /**
                         * @Param1
                         * @Param2 false，单条消费
                         */
                        finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }, new CancelCallback() {
                public void handle(String s) throws IOException {
                    System.out.println("消费者接收消息失败了。。。。");
                }
            });

            System.out.println("Consumer2开始接收消息");
            //程序不向下执行
            System.in.read();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //7.关闭通道
            if (channel != null && channel.isOpen()){
                try {
                    channel.close();//关闭通道
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            //8.关闭连接
            if (connection != null && connection.isOpen()){
                try {
                    connection.close(); //关闭连接
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

界面的一些操作：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
绑定交换机：
1.在队列绑定交换机
在这里插入图片描述

2.在交换机绑定队列
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

一些报错

发送消息的交换机，不存在

Exception in thread "main" com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'cdxx-direct-exchange-code' in vhost '/', class-id=60, method-id=40)
	at com.rabbitmq.utility.ValueOrException.getValue(ValueOrException.java:66)
	at com.rabbitmq.utility.BlockingValueOrException.uninterruptibleGetValue(BlockingValueOrException.java:36)
	at com.rabbitmq.client.impl.AMQChannel$BlockingRpcContinuation.getReply(AMQChannel.java:502)
	at com.rabbitmq.client.impl.ChannelN.close(ChannelN.java:617)
	at com.rabbitmq.client.impl.ChannelN.close(ChannelN.java:542)
	at com.rabbitmq.client.impl.ChannelN.close(ChannelN.java:535)
	at com.rabbitmq.client.impl.recovery.AutorecoveringChannel.lambda$close$0(AutorecoveringChannel.java:73)
	at com.rabbitmq.client.impl.recovery.AutorecoveringChannel.executeAndClean(AutorecoveringChannel.java:101)
	at com.rabbitmq.client.impl.recovery.AutorecoveringChannel.close(AutorecoveringChannel.java:73)
	at com.doudou.all.Producer.main(Producer.java:58)
Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no exchange 'cdxx-direct-exchange-code' in vhost '/', class-id=60, method-id=40)
	at com.rabbitmq.client.impl.ChannelN.asyncShutdown(ChannelN.java:517)
	at com.rabbitmq.client.impl.ChannelN.processAsync(ChannelN.java:341)
	at com.rabbitmq.client.impl.AMQChannel.handleCompleteInboundCommand(AMQChannel.java:182)
	at com.rabbitmq.client.impl.AMQChannel.handleFrame(AMQChannel.java:114)
	at com.rabbitmq.client.impl.AMQConnection.readFrame(AMQConnection.java:739)
	at com.rabbitmq.client.impl.AMQConnection.access$300(AMQConnection.java:47)
	at com.rabbitmq.client.impl.AMQConnection$MainLoop.run(AMQConnection.java:666)
	at java.lang.Thread.run(Thread.java:748)
小小菜鸟呀
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ(三)
哀&RT
03-19 123
　这节我们主要讲RabbitMQ的分发，由生产者发布一个任务，多个接受者去获取任务来进行加工处理。下面介绍任务分发　　　　一个队列的优点就是很容易处理并行化的工作能力，但是如果我们积累了大量的工作，我们就需要更多的工作者来处理，这里就要采用分布机制了。　　我们创建一个新的生产者NewTaskpackage com.mq; import java.io.IOException; import ja...
Rabbitmq（一）
qq_37150393的博客
11-14 158
官网www.rabbimq.com 常见的性能极高的消息列队 消息类对的产品 1. JMS java的消息队列（性能不高） 2. AMQP(advanced message queue protocal),高级消息队列规则，实现了这个吗前排的消息队列就可以做到高性能； 3. Rabbitmq:支持分布式，支持高可用的消息队列软件 4. ...
RabbitMq基础篇-03-客户端页面介绍
Alan0517
11-14 1626
文章目录1. 管理界面1.1 总览1.2 连接1.3 通道1.4 交换机1.5 队列2. 简单理解AMQP协议 1. 管理界面 1.1 总览 1.2 连接 1.3 通道 1.4 交换机 1.5 队列 2. 简单理解AMQP协议
RabbitMQ 使用java连接时出现异常com.rabbitmq.client.impl.AMQChannel.wrap和ConnectException
小熊的博客
03-20 3345
RabbitMQ 使用java连接时出现异常 异常一： java.io.IOException at com.rabbitmq.client.impl.AMQChannel.wrap(AMQChannel.java:129) at com.rabbitmq.client.impl.AMQChannel.wrap(AMQChannel.java:125) at com.rabbitmq.client.impl.AMQConnection.start(AMQConnection.java:396) at
【RabbitMQ】RabbitMQ管理界面介绍
最新发布
低调做人，低调编码，神码都是浮云
05-11 1663
RabbitMQ管理界面介绍
rabbitmq消费者获取RequestContextHolder.getRequestAttributes()为null
hecr_mingong的博客
06-18 2897
1.问题描述 rabbitmq发送了一个消息之后,在消费者端获取RequestContextHolder.getRequestAttributes()为null,导致在消费者端发送feign时,配置的拦截器获取RequestContextHolder.getRequestAttributes()也为null,从而设置不了header. 2.解决方案 rabbitmq的生产者发送消息时添加请求头: MessagePostProcessor messagePostProcessor = mes
RabbitMQ 连接异常导致容器中的SpringBoot 项目退出问题分析
gaojing2240的博客
11-20 3169
1、首先描述一下问题： 今日在开发环境提测时，发现了部署在容器中的后台服务一直在重新启动，导致无法提供服务。 2、项目背景 采用了Springboot+nacos，消息中心使用mq 先贴一下报错信息 2020-11-19 20:23:12 | INFO | grpc-default-executor-7 | org.springframework.amqp.rabbit.connection.CachingConnectionFactory | Attempting to...
rabbitmq java代码_RabbitMQ入门：Hello RabbitMQ 代码实例
weixin_33994823的博客
02-19 161
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".SLF4J: Defaulting to no-operation (NOP) logger implementationSLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further d...
RabbitMQ Server3.13.0
04-02
RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一，提供了一流的消息中间件服务...
RabbitMQ一个简单可靠的方案（.NET Core实现）
08-31
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛应用于分布式系统中，用于处理异步任务、消息传递以及解耦组件。在.NET Core开发环境中，RabbitMQ提供了...
spring-boot-mq-rabbitmq 一套打通rabbitmq 打开可用 有注释
04-08
RabbitMQ作为一款广泛应用的消息中间件，以其稳定性和灵活性深受开发者喜爱。Spring Boot作为Java开发中的轻量级框架，简化了配置和集成各种技术，包括RabbitMQ。本套教程将详细介绍如何在Spring Boot项目中整合...
RabbitMQ一个第三方队列组件
09-15
RabbitMQ是一个开源的消息代理和队列服务器，它实现了高级消息队列协议（AMQP），广泛应用于分布式系统中的异步任务处理、数据交换以及实时通信。这个第三方组件因其高效、可靠和灵活的特点，在IT行业中备受青睐，...
RabbitMQ基本概念和使用
01-30
例如一个日志系统，很容易使用RabbitMQ简化工作量，一个Consumer进行消息的正常处理，另一个Consumer复制对消息进行日志记录，只要在程序中指定两个Consumer所监听的queue以相同的方式绑定到同一个exchange即可，...
【Pulsar】RabbitMQ客户端发送消息失败问题
随便写写
11-16 2857
程序版本 Pulsar：2.8.0 amqp：2.8.0.1 问题描述 Pulsar支持通过RabbitMQ的客户端发送消息，但是实际使用过程中出现如下异常： channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=Unknown exchange:ex02, class-id=0, method-id=0) 详细日志如下 Exception in thread "main" java.i
rabbitmq Features
fei321321的博客
06-16 2848
rabbitmq Features auto-delete 消费者都断开连接了，不论有没有剩余消息，队列自动删除。（得有消费者启动后再断开，而非不连接）；为true时，持久化默认为true durable 队列持久化
rabbitMQ的详细介绍
热门推荐
wang20010104的博客
04-07 7万+
rabbitMQ的详细介绍
RabbitMQ管理界面说明
多学"亿"点的博客
11-11 2094
1、 RabbitMQ管理界面说明 connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况 channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。 Exchanges：交换机，用来实现消息的路由 Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。 2、Admin用户和虚拟主机管理 上面的Tags选项，其实是指定用户的角色，可选的有以下几个： 超级管理员(adm
Docker 安装RabbitMQ以及使用客户端图形化界面
qq_65142821的博客
04-07 551
15672表示 用户操作界面的端口。默认账号密码都为：guest。
RabbitMq-2.2 (RabbitMq的客户端界面认识)
乐百寿
09-26 313
一，界面总览： 二，新建用户： 三，创建v-host 四，创建队列 五，mq的架构图： 六，RibbitMq支持的模式：
rabbitmq一次接收多条消息
10-31
RabbitMQ支持一次接收多条消息的功能，这个功能可以通过设置basic.qos参数来实现。在消费者端，我们可以使用basic.qos方法和prefetch_count参数来控制RabbitMQ一次性发送给消费者的消息数量。例如，如果我们将prefetch_count设置为10，则RabbitMQ将一次性发送10条消息给消费者，直到消费者处理完这些消息并发送确认消息后，RabbitMQ才会继续发送下一批消息。这个功能可以提高消费者的处理效率，减少网络传输的开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值