RabbitMQ（二）实践篇 动手理解RabbitMQ五种模式 两小时搞定Rabbit应用 摸清路由器的的路由、广播、Topic 类型 了解Comfirm Return的过程

最新推荐文章于 2024-09-16 18:14:56 发布
最新推荐文章于 2024-09-16 18:14:56 发布
阅读量1w 收藏 2
点赞数 15
分类专栏： rabbit mq 文章标签： rabbitmq 消息队列 中间件 java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39150049/article/details/120030406
版权

上一章RabbitMq (一）理论篇部分，通过画图的的方式，我觉得比较易懂的方式，介绍了一下整体，本章是用代码实现几个模式， 例程我已经上传git，其中basic的例程时本章的案例。有兴趣的回头也可以阅读高级特性部分的简单介绍。RabbitMQ (三）高级特性安装的部分，大家自行百度，傻瓜式安装。回头我也会把需要的安装包上传。下载不到的朋友直接拿也是可以。

代码git链接

文章目录

前言

这还有什么前言啊，没有，直接开干！

准备工作

安装

找到一个安装步骤，没几步，大佬们自行安装吧。
在这里插入图片描述

启动登录

安装好，启动，关闭防火墙拿到ip加上端口15672就可以访问UI界面了。

账号密码都是guest

创建虚拟机

我创建的虚拟机是antry_vm
在这里插入图片描述

创建用户

我创建的用户是antry
注意tags填administrator

这里的tags，定义权限用，具体的看链接，目前也可以不用知道。用户权限
在这里插入图片描述

配置用户给虚拟机

我在antry_vm给antry设置权限
在这里插入图片描述
准备工作完成，撸代码了。
创建一个maven工程，引入包

<dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.3.0</version>
    </dependency>

准备一个连接工具类，和常量定义

这个不能用注释了吧，参数名称这么人性化，和我前面创建的虚拟机，用户名一一对上就好了。改成大佬你自己的参数就行了。

/**
 * 连接工具
 */
public class RabbitUtils {
    private static ConnectionFactory connectionFactory = new ConnectionFactory();
    static {
        connectionFactory.setHost("192.168.200.131");
        connectionFactory.setPort(5672);//5672是RabbitMQ的默认端口号
        connectionFactory.setUsername("antry");
        connectionFactory.setPassword("antry");
        connectionFactory.setVirtualHost("antry_vm");
    }
    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 = "helloword";
    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 = "antry";
        //四个参数
        //exchange 交换机，暂时用不到，在后面进行发布订阅时才会用到
        //队列名称
        //额外的设置属性
        //最后一个参数是要传递的消息字节数组
        channel.basicPublish("", RabbitConstant.QUEUE_HELLOWORLD, null,message.getBytes());
        channel.close();
        conn.close();
        System.out.println("===发送成功===");
    }
}

可以跑起来瞧瞧了
在这里插入图片描述

显示发送成功
此时通过antry用户登录，查看队列，就可以看到创建了一个helloword的队列，不好意思，单词写错，将就吧。
这里有一条消息，未被读取。
在这里插入图片描述

消费者

同样是获取连接，创建通道（其实也可以不用创建了，因为Producer已经创建过了，存在不会再创建，所以问题不大），创建队列，创建消费者，消费者的最后一个参数是实现Customer借口的实现类，我们可以选择实现这个接口，也可以用适配器DefaultCustomer。本次案例使用的是适配器，适配器自动挡用起来爽。这里面手动编辑监听到消息要做什么。

public class Customer {
    public static void main(String[] args) throws IOException {
//获取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));
    }

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

        @Override
        public void handleDelivery(String s, Envelope envelope, AMQP.BasicProperties basicProperties, 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);
        }
    }
}

在这里插入图片描述
消费完了之后我们在ui界面上也可以看到空空如也，都被消费了。
在这里插入图片描述

WorkQueue

这个模式是多个消费者一起消费同一个队列中的任务。因此我假设有一个要发100条信息的任务，有三个消费者都能发信息。

信息类


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;
    }
}

生产者

因为这里发送对象，需要json转换，所以引入了一个包

   <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>

生产者向MQ发送100条任务

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();
    }
}

消费者

可以创建多个消费者，代码都一样，为了区分，我建了三个，分别为SMSSender1、SMSSender2、SMSSender3

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);

        //如果不写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("SMSSender1-短信发送成功:" + jsonSMS);

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

先启动三个消费者，然后启动生产者。
在这里插入图片描述

发布订阅

生产者

注意这里发送消息的时候，选择了交换机，而不是像前面两种模式直接选择队列。前面两个模式并不是没有选择交换机，只是使用了默认的交换机。

public class WeatherBurean {
    public static void main(String[] args) throws IOException, TimeoutException {
        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();
    }
}

既然这里用到了交换机，因此就需要在新增要给交换机。
选择自己的交换机，填上交换机名称，选择fanout（广播）模式
在这里插入图片描述

新浪消费者

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);
            }
        });
    }
}

百度消费者

public class BaiDu {
    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);
            }
        });
    }
}

这两个消费者，和前面的模式不同之处在于，这里申明完队列之后，将队列和交换机进行绑定，也就是绑定到天气的交换机去获取天气信息

先运行新浪和百度的消费者，然后运行生产者，输入信息123123

可以分别在xinna和baidu看到获取到的信息
在这里插入图片描述

路由模式

生产者

这次发送，不仅有交换机，第二个参数作为routingkey，为什么这里的第二个参数被认为是routingkey呢？

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", "中国湖南株洲20201128天气数据");
        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();

    }
}

因为我们在创建这个交换机的失火，我们选择的是direct定向的类型，就会把这个参数当作routingkey
在这里插入图片描述

百度消费者

这里给百度绑定了两个routingkey，分别是china.hunan.changsha.20201127和china.hebei.shijiazhuang.20201128

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_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);
            }
        });
    }
}

新浪消费者

这里给新浪绑定了四个routingkey

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);
            }
        });
    }
}

运行之后，可以看到新浪和百度都收到了符合各自routingkey的消息
在这里插入图片描述
在这里插入图片描述

在UI中也可以看到交换机通过routingkey绑定了对应的queue，这里我们也可以看到，key没有绑定的信息，发送给交换机直接就丢失了。也证明了交换机没有存储的功能。
在这里插入图片描述

Topic

生产者

可以看出生产者没有什么变化

public class WeaherBureau {
    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();

        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();
    }
}

只是在新建交换机的时候要选择topic类型
在这里插入图片描述

百度消费者

可以看到消费者的变化，只是roukingkey绑定时，用了通配符。

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.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);
            }
        });
    }
}

新浪消费者

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);
            }
        });
    }
}

运行之后可以看到各自都拿到对应匹配的信息
在这里插入图片描述
在这里插入图片描述

Comfirm和Return

生产者

因为我们前面都跑过了消费者，这个地方可以不需要新建消费者。因为Comfirm和Return时发生在Producer和Broker之间的

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();*/
    }
}

先运行一下
在这里插入图片描述
从结果可以看到，这三个被return就是我们前面发现发送出，而丢失不见的三条消息。8条消息都被Broker接收到了，只是有三条找不到对应的队列进行投递，因此进行Return了，可以再创建几个队列来绑定这个几个routingkey，随后就会发现，所有的消息都被接收了。

T_Antry
关注
专栏目录
面试题—开发篇
sanmi8276的博客
03-07 1317
一、Java 基础 1.JDK 和 JRE 有什么区别？ JRE：Java Runtime Environment，是Java运行环境，如果你不需要开发只需要运行Java程序，那么你可以安装JRE。例如程序员开发出的程序最终卖给了用户，用户不用开发，只需要运行程序，所以用户在电脑上安装JRE即可。 JDK：Java Development Kit，它是Java开发运行环境，在程序员的电脑上当然要安装JDK；JDK包含了JRE。 2.== 和 equals 的区别是什么？ ==：比较的对象引用，也就是
springboot整合rabbitMq实践操作（包括简单模式、工厂队列模式、发布订阅模式、路由模式、topic模式的使用）
07-27
springboot整合rabbit实践操作（包括简单模式、工厂队列模式、发布订阅模式、路由模式、topic模式的使用）
PHP操作Rabbitmq
weixin_30724853的博客
09-18 359
1.先安装php rabbitmq的组件 2. （1）基本模型 服务端代码如下 客户端代码如下 服务端代码运行如下： 客户端代码如下： 发布订阅模型（fanout) 在广播模式下，消息发送流程是这样的： 1） 可以有多个消费者 2） 每个消费者...
RabbitMQ广播模式（动态生成queue）
404 Not Found
12-20 4023
RabbitMQ的广播机制和ActiveMQ有所不同。 先来梳理下RabbitMQ中消息从产生到消费的流程吧： 而exchange 存在多种类型，这里就只说广播模式（fanout）了。在广播模式中，一个exchange对应多个queue的话，会向每个queue都发送信息，然后不同的queue再由其对应的消费者消费信息，即完成了广播。 因为广播模式中不关注routingkey和queue，只需要q...
（RabbitMQ 六）SpringBoot+RabbitMQ实现广播模式
myQNUMNINE的博客
09-04 3766
SpringBoot+RabbitMQ实现广播模式 在广播模式下，所有绑定了该交换机的的消息队列都可以接收到该消息。 与之前的实现用接收多个主题不同（有符合要求的队列则会向其发送，所以有的会打印发送两次）。在广播模式下消息只需要发送一次。 文章目录SpringBoot+RabbitMQ实现广播模式一、配置fanout二、编写发送者类三、编写接收者类四、编写测试总结 一、配置fanout 配置广播模式的消息队列：创建一个名为RabbitmqConfigFanout的配置类，类上使用注解@Configurat
RabbitMq初识（一）
黄裳博客
05-07 394
  Java消息服务（Java Message Service,JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间或分布式系统中发送消息，并进行异步通信，Java 消息服务是一个与具体平台无关的API，绝大多数MON提供商都对JMS提供了支持。   Java 消息服务的规范包括两种消息模式，点对点和发布者/订阅者，许多提供商都支持这一通用框架，因此 ，程序员可以在他们的分布式软件中实现面向消息的操作，这些操作将具有不同面向消息中间件产品的可移植性。   Ja
RabbitMQ从基础到进阶
suweijie的博客
07-19 121
MQ的基本使用、高级使用：消息可靠性、实现延迟队列、消息堆积、高可用MQ集群
【面试题001】最强java八股文
热门推荐
檀越的博客
11-20 2万+
一、基础篇 网络基础 TCP三次握手 1、OSI与TCP/IP 模型 2、常见网络服务分层 3、TCP与UDP区别及场景 4、TCP滑动窗口，拥塞控制 5、TCP粘包原因和解决方法 6、TCP、UDP报文格式 HTTP协议 1、HTTP协议1.0_1.1_2.0 2、HTTP与HTTPS之间的区别 3、Get和Post请求区别 4、HTTP常见响应状态码 5、重定向和转发区别 6、Cookie和Session区别。 浏览器输入URL过程 操作系统基础 进程和线程的区别 1、进程间..
JAVA面试必备
hmq58540的博客
08-21 3113
一、基础篇 网络基础 TCP三次握手 1、OSI与TCP/IP 模型 2、常见网络服务分层 3、TCP与UDP区别及场景 4、TCP滑动窗口，拥塞控制 5、TCP粘包原因和解决方法 6、TCP、UDP报文格式 HTTP协议 1、HTTP协议1.0_1.1_2.0 2、HTTP与HTTPS之间的区别 3、Get和Post请求区别 4、HTTP常见响应状态码 5、重定向和转发区别 6、Cookie和Session区别。 浏览器输入URL过程 操作系统基础 进程和线程的区别 1、进程间通.
面经-hangzhou
m0_46338222的博客
07-08 6597
加油
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
Spring boot整合消息队列RabbitMQ实现四种消息模式（适合新手或者开发人员了解学习RabbitMQ机制）
06-27
在业务逻辑的异步处理，系统解耦，分布式通信以及控制高并发的场景下，消息队列有着...并比较了两种模式：生产者-消费者模式和发布-订阅模式的区别。AMQP作为比JMS更加高级的消息协议，支持更多的消息路由和消息模式。
RabbitMQ
kalvin_y_liu的博客
09-11 716
MQ(Message Queue) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件。可以把消息传递的过程想象成 当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上， RabbitMQ 就好比由邮局、邮箱和邮递员组成的一个系统。
使用 RabbitMQ 实现秒杀订单系统的异步消息处理
cxkjntm123的博客
09-10 1409
秒杀订单的主交换机和队列：用于处理异步下单请求。成功和失败的订单队列：分别处理订单处理成功和失败的消息。死信队列（Dead Letter Queue）：处理超时或者其他异常导致的消息失败。我们使用了来根据路由键将消息发送到不同的队列。每个订单请求在被处理时，首先会进入秒杀队列，然后根据处理结果被转发到成功或失败的队列。处理成功的订单如果超时未支付，会被转发到死信队列，进行进一步处理（例如取消订单、回滚库存等）。在 RabbitMQ 中，交换机是负责将消息路由到相应队列的组件。
【RabbitMQ 项目】服务端：数据管理模块之消息队列管理
weixin_74113106的博客
09-15 395
服务端数据管理模块之消息队列管理
RabbitMQ SDK 支持发布、消费，连接恢复，死信队列，多种使用场景
panshiqu的专栏
09-13 756
基于Example封装便于使用的SDK，支持发布、消费，连接恢复，死信队列，以及官方入门中的多种使用场景 使用手动消息确认，队列和消息标记为持久，并不使用临时独占队列 消费者可合理调大Qos.prefetchCount来提高吞吐率 业务逻辑如下返回错误，重新投递仍失败后将进入死信队列，保证消息不丢失，还可反复消费来排查问题 生产者正常退出若是等待发布接口返回消息将不丢失 消费者正常退出是会等待业务逻辑处理且发送确认完成的 建议业务逻辑对消息的消费支持幂等
SpringBoot 消息队列RabbitMQ 交换机模式 Fanout广播 Direct定向 Topic话题
最新发布
生产队的驴
09-16 410
作用是接收生产者发送的消息，并根据某种规则将这些消息路由到一个或多个队列。交换机根据绑定规则和路由键来决定如何将消息分发到队列。简而言之，交换机是消息路由的核心组件，它负责将消息从生产者引导到适当的队列，以便消费者能够处理这些消息。
RabbitMQ消费者确认和重复机制
sdg_advance的博客
09-13 510
极端情况就是消费者一直无法执行成功，那么消息requeue就会无限循环，导致mq的消息处理飙升，带来不必要的压力，为了应对上述情况Spring又提供了消费者失败重试机制：在消费者出现异常时利用本地重试，而不是无限制的requeue到mq队列。如果消费者再次执行依然出错，消息会再次requeue到队列，再次投递，直到消息处理成功为止。即：当消费者处理消息结束后，应该向RabbitMQ发送一个回执，告知RabbitMQ自己消息处理状态。测试可以发现：当消息处理发生异常时，消息依然被RabbitMQ删除了。
RabbitMQ消息队列入门与五种应用模式详解
ExchangeType：交换机类型决定了路由消息行为，RabbitMQ中有三种类型Exchange，分别是fanout、direct、topic； MessageQueue：消息队列，用于存储还未被消费者消费的消息； Message：由Header和body组成，Header是由...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值