RabbitMQ简单使用

最新推荐文章于 2024-04-25 23:01:38 发布
最新推荐文章于 2024-04-25 23:01:38 发布
阅读量2.2k 收藏 1
点赞数
文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38030465/article/details/108832314
版权

1.安装：
win10安装RabbitMQ
2.使用
2.0 pom

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

2.1简单模式
一个生产者 一个消费者
生产者

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel=connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue",false,false,false,null);

        //发送消息
        // 消息内容
        String mes="hello word";
        channel.basicPublish("","basic_queue",null,mes.getBytes());
        System.out.println("生产者发送"+mes);
        Thread.sleep(10);
        channel.close();
        connection.close();
    }

消费者

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue", false, false, false, null);
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue", true, defaultConsumer);
    }

2.2 work模式
一个生产者 多个消费者
生产者

    public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel=connection.createChannel();

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

        //发送消息
       // 循环发布任务
        for (int i = 1; i <= 10; i++) {
            // 消息内容
            String mes="hello word"+i;
            channel.basicPublish("","basic_queue",null,mes.getBytes());
            System.out.println("生产者发送"+mes);
            Thread.sleep(10);
        }
        channel.close();
        connection.close();
    }

消费者1

public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue", false, false, false, null);
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue", true, defaultConsumer);
    }

消费者2

public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue", false, false, false, null);
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者2接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue", true, defaultConsumer);
    }

2.3 订阅模式
​ 一个生产者发送的消息会被多个消费者获取。

生产者：可以将消息发送到队列或者是交换机。

消费者：只能从队列中获取消息。

如果消息发送到没有队列绑定的交换机上，那么消息将丢失。

每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。 fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。 fanout 类型转发消息是最快的 。

生产者

    public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel=connection.createChannel();
        //声明exchange(广播模式)
        channel.exchangeDeclare("fanout_exchange", BuiltinExchangeType.FANOUT);
        /*//声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);*/

        //发送消息
        // 消息内容
        String mes="hello word";
        channel.basicPublish("fanout_exchange","",null,mes.getBytes());
        System.out.println("生产者发送"+mes);
        Thread.sleep(10);
      
        channel.close();
        connection.close();
    }

消费者1

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("bas_queue1", false, false, false, null);
        //声明交换机
        channel.exchangeDeclare("fanout_exchange",BuiltinExchangeType.FANOUT);
        //队列与交换机绑定
        channel.queueBind("bas_queue1","fanout_exchange","");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("bas_queue1", true, defaultConsumer);
    }

消费者2

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("bas_queue2", false, false, false, null);
        //声明交换机
        channel.exchangeDeclare("fanout_exchange",BuiltinExchangeType.FANOUT);
        //队列与交换机绑定
        channel.queueBind("bas_queue2","fanout_exchange","");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("bas_queue2", true, defaultConsumer);
    }

2.4 路由模式
1、 发送消息到交换机并且要指定路由key

2、 消费者将队列绑定到交换机时需要指定路由key

是一种完全匹配，只有匹配到的消费者才能消费消息

消息中的路由键（ routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为“ zc”，则只转发 routing key 标记为“ zc”的消息,它是完全匹配、单播的模式。

生产者

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel=connection.createChannel();
        //声明交换机direct(路由模式)
        channel.exchangeDeclare("direct_exchange",BuiltinExchangeType.DIRECT);
      
        //发送消息
        // 消息内容
        String mes="hello word";
        channel.basicPublish("direct_exchange","zc",null,mes.getBytes());
        System.out.println("生产者发送"+mes);
        Thread.sleep(10);
        
        channel.close();
        connection.close();
    }

消费者1

    public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue1", false, false, false, null);
        //绑定对列到交换机上，并制定路由件未zc
        channel.queueBind("basic_queue1","direct_exchange","zc");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue1", true, defaultConsumer);
    }

消费者2

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue2", false, false, false, null);
        //绑定对列到交换机上，并制定路由件未sb
        channel.queueBind(QUEUE_NAME,"direct_exchange","sb");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者2接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue2", true, defaultConsumer);
    }

2.5 通配符模式
发送给主题转发器的消息不能是任意设置的选择键，必须是用小数点隔开的一系列的标识符。
这些标识符可以是随意，但是通常跟消息的某些特性相关联。

主题转发器的逻辑类似于direct类型的转发器。消息通过一个特定的路由键发送到所有与绑定键匹配的队列中，关于绑定键有两种特殊的情况：
1.* 号只能匹配一个字符
2.#能匹配一个或多个字符

生产者

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel=connection.createChannel();
        //声明交换机topic(通配符模式)
        channel.exchangeDeclare("topic_exchange",BuiltinExchangeType.TOPIC);
     
        //发送消息
        // 消息内容
        String mes="hello word";
        channel.basicPublish("topic_exchange","zc.nb.ss.kkkk",null,mes.getBytes());
        System.out.println("生产者发送"+mes);
        Thread.sleep(10);
      
        channel.close();
        connection.close();
    }

消费者1

 public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue1", false, false, false, null);
        //绑定对列到交换机上
        channel.queueBind("basic_queue1","topic_exchange","zc.#");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者1接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue1", true, defaultConsumer);
    }

消费者2

    public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue2", false, false, false, null);
     
        //绑定对列到交换机上
        channel.queueBind("basic_queue2","topic_exchange","*.nb");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者2接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue2", true, defaultConsumer);
    }

消费者3

    public static void main(String[] args)throws Exception {
        //与mq建立连接
        //定义连接工厂
        ConnectionFactory connectionFactory=new ConnectionFactory();
        //设置服务地址
        connectionFactory.setHost("127.0.0.1");
        //端口
        connectionFactory.setPort(5672);
        //账号密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = connectionFactory.newConnection();
        //建立通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare("basic_queue3", false, false, false, null);
        //绑定对列到交换机上
        channel.queueBind("basic_queue3","topic_exchange","#.kkkk");
        DefaultConsumer defaultConsumer=new DefaultConsumer(channel){
            //获取消息，并且处理
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                // body 即消息体
                String msg = new String(body);
                System.out.println("消费者3接收到消息：" + msg);
                try {
                    Thread.sleep(50);//模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //消费消息
        channel.basicConsume("basic_queue3", true, defaultConsumer);
    }

消费者1和消费者3能接收到消息，消费者2不能接收到消息。

小手cool
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot之RabbitMQ的使用方法
08-26
SpringBoot之RabbitMQ的使用方法 RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件，消息中间件的工作过程可以用生产者消费者模型来表示。即，生产者不断的向消息队列发送信息...
RabbitMq整合使用
02-07
**RabbitMQ整合使用详解** RabbitMQ是一个开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中，用于处理异步任务、解耦组件以及实现流量控制。在Spring Boot框架中...
简单了解一下RabbitMQ
weixin_45984552的博客
04-20 2837
一、什么是消息队列 MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 消息中间件负责数据传递、存储和消息分发三个部分，数据的存储和分发过程中肯定要遵循某种规范，在tcp/ip 之上建立一种新的协议AMQP 二、AMQP和JMS的区别 MQ是消息通信
RabbitMQ 消息队列学习 (二)
IT_Holmes的博客
05-17 743
1. 工作队列(Work Queues) 消息应答 1.1 什么是 消息应答机制？ 1.2 自动应答 和 手动应答 1.3 消息 自动重新入队 过程原理 1.4 消息 手动应答 代码测验 2. RabbitMQ 持久化 2.1 队列持久化 2.2 消息持久化 3. 不公平分发 策略 4. 预去值 策略 5. 发布确认 5.1 发布确认 过程原理 5.2 开启 发布确认 5.3 单个确认发布 5.4 批量确认发布 5.5 异步确认发布 6. 如何处理异步发布确认的 未确认消息 7. 三种确认发布 对比
RabbitMQ最全使用教程-小白也能看懂
最新发布
2401_84557521的博客
04-25 2625
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。
RabbitMqUtil异步确认模式
y632481222的博客
02-27 261
（一）异步确认模式\n 异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说， 他是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功。\n下面就让我们来详细讲解异步确认是怎么实现的。\n\n public static void publishMessageAsync() throws Exception {\n Channel channel = RabbitMqUtils.getChannel();\n cha
Kafka消费不及时
weixin_42852525的博客
02-12 678
kafka消费不及时
mq的一个utils
戴林峰的博客
04-02 185
package com.xiaoyuan.handle.msgNotify.utils; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import org.springframework.beans....
RabbitMQ基本概念和使用
01-30
RabbitMQ是一个消息代理，核心原理：发送消息，接收消息...首先通过一个非常简单的”helloworld“例子介绍如何使用RabbitMQ，然后再介绍其涉及的基本概念并对交换机和队列多做点介绍。本例非常简单——发送一个消息”h
java使用rabbitMq服务
04-24
在学校简单了解过，从未在生产环境使用过。这一个月任务都是消息队列相关。于是私下里在自己腾讯云轻量级服务器安装了单机兔子先生。现在MQ的基本学习告一段落。感觉这文档还是挺有用的哈，，“应付”我们的日常开发...
SpringBoot+RabbitMq具体使用的几种姿势
08-26
从简单的点对点通信到复杂的发布/订阅模式，RabbitMQ都能提供稳定、高效的服务。在选择消息中间件时，可以根据业务场景的特性，如吞吐量、社区支持和消息可靠性，来确定最适合的解决方案。在中小型公司中，RabbitMQ...
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
Util通用工具类（轮子类）
08-15
避免重复造轮子，开发中常用封装的工具类，包括：类型转换器，时间格式转换器，文件传输，非Controller中获取当前session的工具类，唯一id生成器，MD5加密类（封装jdk自带的md5加密方法），数字格式化的类，得到中文首字母，渲染工具类，资源文件相关的操作类，对比两个对象的变化的工具类，Spring的ApplicationContext的持有者,可以用静态方法的方式获取spring容器中的bean，sql语句工具类，高频方法集合类
RabbitMq使用手册
12-07
RabbitMq 使用手册 本文档为 RabbitMq 使用手册，介绍了 RabbitMq 的应用场景和开发指导。RabbitMq 是一个由 Erlang 开发的 AMQP（Advanced Message Queue）流行的开源消息队列系统。RabbitMq 的结构图如下： ...
C++/QT 使用RabbitMQ
11-18
这个简单的应用展示了如何在QT+C++环境中使用RabbitMQ的基本功能。然而，实际项目中可能需要处理更复杂的需求，如错误处理、消息确认机制、多线程处理等。在深入学习RabbitMQ时，建议阅读官方文档，了解更高级的概念...
rabbitmq的常用使用
10-07
RabbitMQ 的常用使用 RabbitMQ 是一个流行的开源消息队列系统，常用于异步通信、解耦、消息队列、流媒体处理等场景。下面将详细介绍 RabbitMQ 的常用使用。 二、消费消息 在 RabbitMQ 中，消费消息是指从队列中...
Java TCP Socket断线重连问题（服务端不发送也不接收心跳信息）
m0_37817986的博客
09-13 1873
客户端设置 读取超时，若服务断开，则再次读取时会报错，从而判断服务端断开，后续进行重连操作
RocketMQ 消息重试机制
这个需求，做不了
09-25 2409
RocketMQ 消息重试分为发送重试（生产者）和消费重试（消费者）
Java socket程序中客户端无法向服务器发送数据的bug
Darren的博客
06-26 1121
项目场景： Java网络编程的Echo项目，该项目框架如下。 问题描述： 当在客户端使用PrintWriter进行Socket写入时，发现服务器端无法接收到数据。 在客户端使用Scanner接收命令行输入字符串，然后发送到服务器时，服务器无法读到数据 原因分析： 字节流（Writer及其子类）写入数据（包括父类的write方法和打印流的print方法），写入的时候都是写到缓存里，需要手动情况缓存（flush）之后才是真正的写入到socket。因此如果没有手动清空缓存，实际上是并没有成功发送消息的。
rabbitmq的简单使用
08-30
下面是 RabbitMQ 的简单使用步骤： 1. 安装 RabbitMQ：你可以从 RabbitMQ 官方网站下载适合你操作系统的安装包，并按照安装指南进行安装。 2. 创建连接：在你的应用程序中，首先需要与 RabbitMQ 建立一个连接。你...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值