4. 死信队列

news2024/9/23 11:15:01

二八佳人体似酥，腰间仗剑斩愚夫。虽然不见人头落，暗里教君骨髓枯。

死信

概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理
解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息 进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有 后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ的死信队列机制，当消息
消费发生异常时，将消息投入死信队列中.

还有比如说: 用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

死信来源

  1. 消息 TTL 过期

  2. 队列达到最大长度(队列满了，无法再添加数据到mq中)

  3. 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

image.png

消息 TTL 过期

生产者 设置 ttl

public class DeadMessageProducer1 {
    private static String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        Channel channel = connection.createChannel();
        // 创建交换机， 交换机 名称是  logs
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT,
                true, false, null);

        // 设置消息的 TTL 过期时间  10s
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();


        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            // routingKey 为 空
            String inputMessage = scanner.nextLine();

            // 设置过期时间
            channel.basicPublish(EXCHANGE_NAME, "zhangsan",
                    properties, inputMessage.getBytes("UTF-8"));
        }
        channel.close();
        connection.close();
    }
}

正常交换机 绑定到死信交换机

public class DeadMessageConsumer1 {
    private static String EXCHANGE_NAME = "normal_exchange";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";


    private static String QUEUE_NAME = "normal_queue";
    private static String DEAD_QUEUE_NAME = "dead_queue";

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

        //1. 创建死亡队列和绑定关系
        channel.exchangeDeclare(DEAD_EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        channel.queueDeclare(DEAD_QUEUE_NAME, true, false, false, null);
        channel.queueBind(DEAD_QUEUE_NAME, DEAD_EXCHANGE_NAME, "lisi");


        //2. 创建活着的队列和绑定
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);

        Map<String, Object> params = new HashMap();

        // 死信交换机 exchange
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        // 死信交换机的 routing-key
        params.put("x-dead-letter-routing-key", "lisi");

        // 创建队列时， 绑定 死信队列的信息。
        channel.queueDeclare(QUEUE_NAME, true, false, false, params);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "zhangsan");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };

        TimeUnit.SECONDS.sleep(8);
        channel.basicConsume(
                QUEUE_NAME, true, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

死信队列获取消息

public class DeadMessageConsumer1_1 {
    private static String EXCHANGE_NAME = "dead_exchange";
    private static String QUEUE_NAME = "dead_queue";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        final Channel channel = connection.createChannel();
        //1. 创建交换器
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        //2.  创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        //3. 绑定队列与 交换机。  其中 routingKey 为 debug,info,warn,error  ,可以绑定多个。

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "lisi");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };
        channel.basicConsume(
                QUEUE_NAME, true, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

验证

先不启动 死信队列的消费者。

先启动生产者，DeadMessageProducer1 再启动 绑定的死信交换机， DeadMessageConsumer1 启动好之后， 立即关闭 (创建绑定)。

未发送消息之前:

image.png

再从生产者上发送3条消息 （此时 DeadMesageConsumer1 已经关闭）

image.png

等 10s 之后

image.png

启动死信队列消息

image.png

消息被消费

image.png

队列达到最大长度

此时需要把原先队列删除 因为参数改变了

生产者

生产者代码去掉 TTL 属性,

发送 10 条消息

public class DeadMessageProducer2 {
    private static String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        Channel channel = connection.createChannel();
        // 创建交换机， 交换机 名称是  logs
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT,
                true, false, null);

        for (int i = 0; i < 10; i++) {
            // 设置过期时间
            String message = "发送消息" + i;
            channel.basicPublish(EXCHANGE_NAME, "zhangsan",
                    null, message.getBytes("UTF-8"));
        }
        System.in.read();
        channel.close();
        connection.close();
    }
}

交换机绑定到死信交换机， 设置长度

只能获取6个

public class DeadMessageConsumer2 {
    private static String EXCHANGE_NAME = "normal_exchange";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";


    private static String QUEUE_NAME = "normal_queue";
    private static String DEAD_QUEUE_NAME = "dead_queue";

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

        //1. 创建死亡队列和绑定关系
        channel.exchangeDeclare(DEAD_EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        channel.queueDeclare(DEAD_QUEUE_NAME, true, false, false, null);
        channel.queueBind(DEAD_QUEUE_NAME, DEAD_EXCHANGE_NAME, "lisi");


        //2. 创建活着的队列和绑定
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);

        Map<String, Object> params = new HashMap();

        // 死信交换机 exchange
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        // 死信交换机的 routing-key
        params.put("x-dead-letter-routing-key", "lisi");

        // 设置正常队列的长度 是 添加的方法。
        // 需要先将队列删除，再重新构建。
        params.put("x-max-length", 6);

        // 创建队列时， 绑定 死信队列的信息。
        channel.queueDeclare(QUEUE_NAME, true, false, false, params);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "zhangsan");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };

        TimeUnit.SECONDS.sleep(8);
        channel.basicConsume(
                QUEUE_NAME, true, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

死信队列获取消息 保持不变

public class DeadMessageConsumer2_1 {
    private static String EXCHANGE_NAME = "dead_exchange";
    private static String QUEUE_NAME = "dead_queue";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        final Channel channel = connection.createChannel();
        //1. 创建交换器
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        //2.  创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        //3. 绑定队列与 交换机。  其中 routingKey 为 debug,info,warn,error  ,可以绑定多个。

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "lisi");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };
        channel.basicConsume(
                QUEUE_NAME, true, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

验证

操作流程与之前是一样的

image.png

消息被拒

生产者 保持不变

public class DeadMessageProducer3 {
    private static String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        Channel channel = connection.createChannel();
        // 创建交换机， 交换机 名称是  logs
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT,
                true, false, null);

        for (int i = 0; i < 10; i++) {
            // 设置过期时间
            String message = "发送消息" + i;
            channel.basicPublish(EXCHANGE_NAME, "zhangsan",
                    null, message.getBytes("UTF-8"));
        }
        System.in.read();
        channel.close();
        connection.close();
    }
}

交换机绑定到死信交换机， 去掉长度，设置 手动提交

public class DeadMessageConsumer3 {
    private static String EXCHANGE_NAME = "normal_exchange";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";


    private static String QUEUE_NAME = "normal_queue";
    private static String DEAD_QUEUE_NAME = "dead_queue";

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

        //1. 创建死亡队列和绑定关系
        channel.exchangeDeclare(DEAD_EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        channel.queueDeclare(DEAD_QUEUE_NAME, true, false, false, null);
        channel.queueBind(DEAD_QUEUE_NAME, DEAD_EXCHANGE_NAME, "lisi");


        //2. 创建活着的队列和绑定
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);

        Map<String, Object> params = new HashMap();

        // 死信交换机 exchange
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        // 死信交换机的 routing-key
        params.put("x-dead-letter-routing-key", "lisi");


        // 创建队列时， 绑定 死信队列的信息。
        channel.queueDeclare(QUEUE_NAME, true, false, false, params);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "zhangsan");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {


            String textMessage = new String(message.getBody());

            if ("发送消息5".equals(textMessage)) {
                System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
                // 确认这一个.
                channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
            } else {
                // 进行拒绝
                // 拒绝重新入队， 设置了死信的话，就发送到死信队列里面。
                channel.basicReject(message.getEnvelope().getDeliveryTag(), false);
            }


        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };

        TimeUnit.SECONDS.sleep(8);
        // 设置不自动提交。
        channel.basicConsume(
                QUEUE_NAME, false, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

死信队列获取消息 保持不变

public class DeadMessageConsumer3_1 {
    private static String EXCHANGE_NAME = "dead_exchange";
    private static String QUEUE_NAME = "dead_queue";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionFactoryUtil.createConnection();
        final Channel channel = connection.createChannel();
        //1. 创建交换器
        channel.exchangeDeclare(EXCHANGE_NAME,
                BuiltinExchangeType.DIRECT, true, false, null);
        //2.  创建队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        //3. 绑定队列与 交换机。  其中 routingKey 为 debug,info,warn,error  ,可以绑定多个。

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "lisi");


        // 打印到控制台
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println(QUEUE_NAME + "获取级别:" + message.getEnvelope().getRoutingKey() + ">>>  消息 :" + new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag) -> {
            System.out.println(QUEUE_NAME + ">>>>> 中断了消息接收 " + consumerTag);
        };
        channel.basicConsume(
                QUEUE_NAME, true, deliverCallback, cancelCallback);

        //输入流等待
        System.in.read();
        //关闭
        channel.close();
        connection.close();
    }
}

验证

image.png

启动1，再启动2

image.png

只将5 拒收 ， 死信队列 只获取到消息 5

image.png

image.png

延时队列

概念

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，
延时队列中的元素是希望在指定时间到了以后或之前取出和处理，
简单来说，延时队列就是用来存放需要在指定时间被处理的 元素的队列。

延时队列使用场景

1.订单在十分钟之内未支付则自动取消
2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
3.用户注册成功后，如果三天内没有登陆则进行短信提醒。
4.用户发起退款，如果三天内没有得到处理则通知相关运营人员。
5.预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务，
如：发生订单生成事件，在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭；
看起来似乎 使用定时任务，一直轮询数据，每秒查一次，取出需要被处理的数据，然后处理不就完事了吗？
如果 数据量比较少，确实可以这样做，比如：对于“如果账单一周内未支付则进行自动结算”这样的需求，
如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支 付的账单，
确实也是一个可行的方案。但对于数据量比较大，并且时效性较强的场景，如：“订单十 分钟内未支付则关闭“，
短期内未支付的订单数据可能会有很多，活动期间甚至会达到百万甚至千万 级别，
对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单 的检查，
同时会给数据库带来很大压力，无法满足业务要求而且性能低下

image.png

TTL

TTL 是什么呢？TTL 是 RabbitMQ中一个消息或者队列的属性，表明一条消息或者该队列中的所有
消息的最大存活时间, 单位是毫秒。换句话说，如果一条消息设置了 TTL 属性或者进入了设置 TTL 属性的队列，那么这条消息如果在 TTL 设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的 TTL 和消息的 TTL，那么较小的那个值将会被使用，有两种方式设置 TTL

队列设置 TTL

在创建队列的时候设置队列的“x-message-ttl”属性

image.png

消息设置 TTL

另一种方式便是针对每条消息设置 TTL

image.png

区别

如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队
列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者 之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需 要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以 直接投递该消息到消费者，否则该消息将会被丢弃。

前一小节我们介绍了死信队列，刚刚又介绍了 TTL，至此利用 RabbitMQ实现延时队列的两大要素已
经集齐，接下来只需要将它们进行融合，再加入一点点调味料，延时队列就可以新鲜出炉了。想想看，延 时队列，不就是想要消息延迟多久被处理吗，TTL 则刚好能让消息在延迟多久之后成为死信，另一方面， 成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为 里面的消息都是希望被立即处理的消息。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/59579.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

「Redis」05 Jedis操作Redis

「Redis」05 Jedis操作Redis

笔记整理自【尚硅谷】Redis 6 入门到精通 超详细 教程 Redis——Jedis操作Redis 即通过 Java 操作 Redis。 1. Jedis基本操作 Ⅰ. 测试连接 连接Redis注意事项 禁用Linux的防火墙&#xff1a;Linux&#xff08;CentOS7&#xff09;里执行命令&#xff1a;systemctl stop/disab…
阅读更多...
我的周刊（第068期）

我的周刊（第068期）

我的信息周刊&#xff0c;记录这周我看到的有价值的信息&#xff0c;主要针对计算机领域&#xff0c;内容主题极大程度被我个人喜好主导。这个项目核心目的在于记录让自己有印象的信息做一个留存以及共享。&#x1f3af; 项目osquery[1]像操作 SQL 一样操作你的电脑&#xff0c…
阅读更多...
康复训练的未来：VR和元宇宙如何帮助患者康复

康复训练的未来：VR和元宇宙如何帮助患者康复

欢迎来到Hubbleverse &#x1f30d; 关注我们 关注宇宙新鲜事 &#x1f4cc; 预计阅读时长&#xff1a;7分钟 本文仅代表作者个人观点&#xff0c;不代表平台意见&#xff0c;不构成投资建议。 一位有平衡问题的患者站在波速球上&#xff0c;同时在两只潇洒的企鹅之间击打着…
阅读更多...
第十六章 品质保证：发布覆盖率测试报告

第十六章 品质保证：发布覆盖率测试报告

代码覆盖率才是评价一个项目品质的标准。在挑选一个项目的时候&#xff0c;有经验的使用者都会根据代码覆盖率来确定代码的可靠性。 虽然自动化测试工具可以自动验证代码的正确性&#xff0c;但是如果只有部分代码经过了测试&#xff0c;或者只是简单地跑通了代码&#xff0c;…
阅读更多...
BlockingQueue二

BlockingQueue二

接着上篇BlockingQueue没讲完的 LinkedTransferQueue LinkedTransferQueue是一个由链表结构组成的无界阻塞队列&#xff0c;相对于其它阻塞队列&#xff0c;LinkedBlockingQueue可以算是LinkedBlockingQueue与SynhronoousQueue结合&#xff0c;LinkedtransferQueue是一种无界…
阅读更多...
Unity学习笔记--详细介绍CacheServer、部署方法、以及在Unity中的位置

Unity学习笔记--详细介绍CacheServer、部署方法、以及在Unity中的位置

目录前言CacheServer是什么&#xff1f;解决了什么问题&#xff1f;其他知识点在哪里找到Cache Server&#xff1f;怎么部署CacheServer&#xff1f;Unity什么时候需要生成内部文件&#xff1f;CacheServer缓存的是什么&#xff1f;随着越来越多的资源被导入和存储&#xff0c;…
阅读更多...
实战-COVID-19-KSH（html+ python +django +爬虫 +pyecharts 实时疫情动态）内附MySQL详细安装配置教程

实战-COVID-19-KSH（html+ python +django +爬虫 +pyecharts 实时疫情动态）内附MySQL详细安装配置教程

GitHub代码 Windows10 python3.7 一、MySQL配置 1.官网下载地址 2.配置初始化文件my.ini 解压后在根目录下创建my.ini文件&#xff08;建立.txt-修改扩展名为.int即可&#xff09; 打开my.ini文件&#xff0c;输入以下内容&#xff08;注意需要改动2处&#xff09;&#x…
阅读更多...
求一个网页设计作业——个人博客(HTML+CSS)

求一个网页设计作业——个人博客(HTML+CSS)

&#x1f389;精彩专栏推荐 &#x1f4ad;文末获取联系 ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业&#xff1a; 【&#x1f4da;毕设项目精品实战案例 (10…
阅读更多...
9.Springboot整合Security很全

9.Springboot整合Security很全

1.什么是Security SpringSecurity是基于Spring AOP和Servlet过滤器的安全框架。 它提供全面的安全性解决方案&#xff0c;同时在Web 请求级和方法调用级处理身份确认和授权。 2.Spring Security核心功能&#xff1f; &#xff08;1&#xff09;认证&#xff08;你是谁&…
阅读更多...
薪资25k，从华为外包测试“跳”入字节，说说我转行做测试的这5年...

薪资25k，从华为外包测试“跳”入字节，说说我转行做测试的这5年...

转行测试5年了 当时因为家里催促就业&#xff0c;在其中一个室友的内推下进入了一家英语教培机构&#xff0c;前期上班和工资都还算满意&#xff0c;甚至觉得自己找到了一份很稳定的工作了&#xff0c;可是好景不长&#xff0c;“双减政策”的到来&#xff0c;让公司的经济遭受…
阅读更多...
Linux进程间通讯技术

Linux进程间通讯技术

Linux进程间通讯 文章目录Linux进程间通讯1.进程通讯基本认知1.1 进程通讯的概念1.2 进程通讯的目的1.3 进程通讯的本质1.4 进程通讯的分类2.管道技术基本认知2.1 管道的概念2.2 为什么需要管道2.3 管道的四个特点2.4 管道的四种情况2.5 管道的大小获取2.6 命名管道与匿名管道的…
阅读更多...
MyBatis-Plus条件构造器[常用的模糊查询、排序查询、逻辑查询和指定字段查询案例]

MyBatis-Plus条件构造器[常用的模糊查询、排序查询、逻辑查询和指定字段查询案例]

系列文章目录 Mybatis-Plus知识点[MyBatisMyBatis-Plus的基础运用]_心态还需努力呀的博客-CSDN博客 Mybatis-PlusSpringBoot结合运用_心态还需努力呀的博客-CSDN博客MyBaits-Plus中TableField和TableId用法_心态还需努力呀的博客-CSDN博客 MyBatis-Plus中的更新操作&#x…
阅读更多...
2.2 反相放大器、高输入电阻反相放大器、反相高压放大器

2.2 反相放大器、高输入电阻反相放大器、反相高压放大器

笔者电子信息专业硕士毕业&#xff0c;获得过多次电子设计大赛、大学生智能车、数学建模国奖&#xff0c;现就职于南京某半导体芯片公司&#xff0c;从事硬件研发&#xff0c;电路设计研究。对于学电子的小伙伴&#xff0c;深知入门的不易&#xff0c;特开次博客交流分享经验&a…
阅读更多...
【cocos源码学习】解决cocos2d-x-4.0 Android Demo构建遇到的问题

【cocos源码学习】解决cocos2d-x-4.0 Android Demo构建遇到的问题

环境 硬件&#xff1a;macbook pro 四核Intel Core i7系统&#xff1a;macOS Big Sur 11.4.2、 xcode Version 13.1 、cmake 3.20.5软件&#xff1a;iterm2 Build 3.4.8、zsh 5.8、Android Studio Dolphin | 2021.3.1cocos2d-x v4 &#xff1a; 官方下载压缩包 http://cocos2d…
阅读更多...
目标检测算法——YOLOv5/YOLOv7改进之结合特征提取网络RFBNet（涨点明显）

目标检测算法——YOLOv5/YOLOv7改进之结合特征提取网络RFBNet（涨点明显）

>>>深度学习Tricks，第一时间送达<<< 🚀🚀🚀NEW！！！魔改YOLOv5/v7目标检测算法来啦 ~ 计算机视觉——致力于目标检测领域科研Tricks改进与推荐 | 主要包括Backbone、Neck、Head、普通注意力机制、自注意力机制Transformer、Swin Transformer v2，各…
阅读更多...
Java中Set集合的使用和底层原理

Java中Set集合的使用和底层原理

文章目录Set系列集合介绍Set集合概述HashSet无序原理Set集合对象去重LinkedHashSetTreeSet排序规则Set系列集合介绍 Set集合概述 Set系列集合特点: 无序&#xff1a;存取数据的顺序是不一定的, 当数据存入后, 集合的顺序就固定下来了 不重复&#xff1a;可以去除重复 无索引&…
阅读更多...
HTML期末学生大作业：中华传统文化【苏绣手工艺】带psd设计图（15页）

HTML期末学生大作业：中华传统文化【苏绣手工艺】带psd设计图（15页）

&#x1f389;精彩专栏推荐 &#x1f4ad;文末获取联系 ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业&#xff1a; 【&#x1f4da;毕设项目精品实战案例 (10…
阅读更多...
线程的基本操作以及线程的状态

线程的基本操作以及线程的状态

目录 &#x1f433;今日良言:得之坦然&#xff0c;失之淡然&#xff0c;争取必然&#xff0c;顺其自然。 &#x1f42f;一、线程的基本操作 &#x1f42d;1.线程的创建 &#x1f42d;2.线程的中断 &#x1f42d;3.线程的等待 &#x1f42d;4.获取线程实例 &#x1f42d;…
阅读更多...
[附源码]计算机毕业设计学分制环境下本科生学业预警帮扶系统Springboot程序

[附源码]计算机毕业设计学分制环境下本科生学业预警帮扶系统Springboot程序

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
【POJ No. 3264】区间最值差 Balanced Lineup

【POJ No. 3264】区间最值差 Balanced Lineup

【POJ No. 3264】区间最值差 Balanced Lineup 北大OJ 题目地址 其实这道题 之前也做过一次了 http://t.csdn.cn/0YZgC 不过上次是用ST 做的。这次换做 分块来实现。 【题意】 每天挤奶时&#xff0c;约翰的N 头奶牛&#xff08;1≤N≤50,000&#xff09;都以相同的顺序排队…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023