消息队列-RabbitMQ：延迟队列、rabbitmq 插件方式实现延迟队列、整合SpringBoot

news2025/1/17 3:55:46

十六、延迟队列

在这里插入图片描述

1、延迟队列概念

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

延迟队列使用场景：

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

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务，如：发生订单生成事件，在十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭。那我们一直轮询数据，每秒查一次，取出需要被处理的数据，然后处理不就完事了吗？

如果数据量比较少，确实可以这样做，比如：对于 “如果账单一周内未支付则进行自动结算” 这样的需求， 如果对于时间不是严格限制，而是宽松意义上的一周，那么每天晚上跑个定时任务检查一下所有未支付的账单，确实也是一个可行的方案。

但对于数据量比较大，并且时效性较强的场景，如：“订单十分钟内未支付则关闭 “，短期内未支付的订单数据可能会有很多，活动期间甚至会达到百万甚至千万级别，对这么庞大的数据量仍旧使用轮询的方式显然是不可取的，很可能在一秒内无法完成所有订单的检查，同时会给数据库带来很大压力，无法满足业务要求而且性能低下。

在这里插入图片描述

2、整合SpringBoot

（1）创建模块项目

在这里插入图片描述

（2）添加依赖

<dependencies>
   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!--RabbitMQ 依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.47</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <!--swagger-->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>3.0.0</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>3.0.0</version>
    </dependency>
    <!--RabbitMQ 测试依赖-->
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

（3）修改配置文件

在这里插入图片描述

spring.rabbitmq.host=42.192.149.71
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456

(4)添加Swagger配置类

在这里插入图片描述

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;


@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket webApiConfig() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                .build();
    }

    private ApiInfo webApiInfo() {
        return new ApiInfoBuilder()
                .title("rabbitmq 接口文档")
                .description("本文档描述了 rabbitmq 微服务接口定义")
                .version("1.0")
                .contact(new Contact("zhiyuan", "http://oddfar.com", "test@qq.com"))
                .build();
    }

}

3、队列 TTL

代码架构图

创建两个队列 QA 和 QB，两者队列 TTL 分别设置为 10S 和 40S，然后在创建一个交换机 X 和死信交换机 Y，它们的类型都是 direct，创建一个死信队列 QD，它们的绑定关系如下：

在这里插入图片描述

在这里插入图片描述

（1）配置类

声明：普通交换机、死信交换机、普通队列X2、死信队列

绑定：XA、XB、DY

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;
@Configuration
public class TtlQueueConfig {
    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    //死信交换机
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    //死信队列
    public static final String DEAD_LETTER_QUEUE = "QD";

    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    // 声明 死信队列交换机
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
    @Bean("queueA")
    public Queue queueA() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }

    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
    @Bean("queueB")
    public Queue queueB() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
    }

    //声明死信队列 QD
    @Bean("queueD")
    public Queue queueD() {
        return new Queue(DEAD_LETTER_QUEUE);
    }

    //声明死信队列 QD 绑定关系
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }

}

（2）消息生产者

在这里插入图片描述

使用RabbitTemplate发消息

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", new Date(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: " + message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自 ttl 为 40S 的队列: " + message);
    }
    
}

(3)消息消费者

在这里插入图片描述

在这里插入图片描述

package com.kdz.rabbitmq;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Date;

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息{}", new Date().toString(), msg);
    }
}

测试效果：

访问：localhost:8080/ttl/sendMsg/LBJ

在这里插入图片描述

延迟消息发送成功

在这里插入图片描述

在这里插入图片描述

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息， 然后被消费掉，这样一个延时队列就打造完成了。

不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加 TTL 为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

4、延时队列 TTL 优化

在这里新增了一个队列 QC，绑定关系如下，该队列不设置 TTL 时间

在这里插入图片描述

（1）配置文件类

在这里插入图片描述

在这里插入图片描述

@Configuration
public class MsgTtlQueueConfig {
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String QUEUE_C = "QC";

    //声明队列 C 死信交换机
    @Bean("queueC")
    public Queue queueC() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //没有声明 TTL 属性
        return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queuecBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }
}

（2）生产者

在这里插入图片描述

查看源码，配置参数

在这里插入图片描述

/**
 * 延时队列优化
 * @param message 消息
 * @param ttlTime 延时的毫秒
 */
@GetMapping("sendExpirationMsg/{message}/{ttlTime}")
public void sendMsg(@PathVariable String message, @PathVariable String ttlTime) {
    rabbitTemplate.convertAndSend("X", "XC", message, correlationData -> {
        correlationData.getMessageProperties().setExpiration(ttlTime);
        return correlationData;
    });
    log.info("当前时间：{},发送一条时长{}毫秒 TTL 信息给队列 C:{}", new Date(), ttlTime, message);
}

测试效果：

发起请求：

http://localhost:8080/ttl/sendExpirationMsg/ 你好 1/20000

http://localhost:8080/ttl/sendExpirationMsg/ 你好 2/2000

在这里插入图片描述

在这里插入图片描述

看起来似乎没什么问题，但是在最开始的时候，就介绍过如果使用在消息属性上设置 TTL 的方式，消息可能并不会按时 “死亡 “。

因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列， 如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。这也就是为什么第二个延迟时间短，却后执行。

此外，我们还可以通过 Rabbitmq 插件实现延迟队列。

17、 Rabbitmq 插件实现延迟队列

上文中提到的问题，确实是一个问题，如果不能实现在消息粒度上的 TTL，并使其在设置的 TTL 时间 及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题

1、安装延时队列插件

在官网上下载 https://www.rabbitmq.com/community-plugins.html，下载 rabbitmq_delayed_message_exchange 插件，然后解压放置到 RabbitMQ 的插件目录。 进入 RabbitMQ 的安装目录下的 plugins 目录，执行下面命令让该插件生效，然后重启 RabbitMQ

/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins rabbitmq-plugins enable rabbitmq_delayed_message_exchange

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2、基于死信情况与基于插件的对比

在这里插入图片描述

在这里插入图片描述

3、代码架构图

在这里插入图片描述

4、代码实现

（1）配置文件

在我们自定义的交换机中，这是一种新的交换类型，该类型消息支持延迟投递机制 消息传递后并 不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才 投递到目标队列中。

①定义队列、交换机、RoutingKey

在这里插入图片描述

②声明交换机

在这里插入图片描述

查看源码

在这里插入图片描述

在这里插入图片描述

③声明延迟队列

在这里插入图片描述

④绑定交换机和队列

在这里插入图片描述

@Configuration
public class DelayedQueueConfig {
 public static final String DELAYED_QUEUE_NAME = "delayed.queue";
 public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
 public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
 @Bean
 public Queue delayedQueue() {
 return new Queue(DELAYED_QUEUE_NAME);
 }
 //自定义交换机 我们在这里定义的是一个延迟交换机
 @Bean
 public CustomExchange delayedExchange() {
 Map<String, Object> args = new HashMap<>();
 //自定义交换机的类型
 args.put("x-delayed-type", "direct");
 return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, 
args);
 }
 @Bean
 public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
 @Qualifier("delayedExchange") CustomExchange 
delayedExchange) {
 return 
BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
 }
}

（2）生产者

在这里插入图片描述

public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
@GetMapping("sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime) {
 rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message, 
correlationData ->{
 correlationData.getMessageProperties().setDelay(delayTime);
 return correlationData;
 });
 log.info(" 当 前 时 间 ： {}, 发送一条延迟 {} 毫秒的信息给队列 delayed.queue:{}", new 
Date(),delayTime, message);
}

（3） 消息消费者：

在这里插入图片描述

public static final String DELAYED_QUEUE_NAME = "delayed.queue";
@RabbitListener(queues = DELAYED_QUEUE_NAME)
public void receiveDelayedQueue(Message message){
 String msg = new String(message.getBody());
 log.info("当前时间：{},收到延时队列的消息：{}", new Date().toString(), msg);
}

测试效果：

发起请求：

http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000

http://localhost:8080/ttl/sendDelayMsg/come on baby2/2000

在这里插入图片描述

第二个消息被先消费掉了，符合预期

5、延迟队列总结

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失。

当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些方式各有特点，看需要适用的场景。

消息队列-RabbitMQ：延迟队列、rabbitmq 插件方式实现延迟队列、整合SpringBoot 到此完结，笔者归纳、创作不易，大佬们给个3连再起飞吧

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

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

相关文章

20240113----重返学习-`nginx/conf/nginx.conf`的https证书配置说明

20240113----重返学习-`nginx/conf/nginx.conf`的https证书配置说明

20240113----重返学习-nginx/conf/nginx.conf的https证书配置说明 文件说明 不同域名的多虚拟主机配置 server {listen 443 ssl;#在443端口上监听SSL/TLS流量;server_name localhost;#指定服务器名称&#xff0c;应该与域名匹配;ssl_certificate fangchaoduan.com.pem;#指定SS…
阅读更多...
数据安全之路：深入了解MySQL的行锁与表锁机制

数据安全之路：深入了解MySQL的行锁与表锁机制

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 数据安全之路&#xff1a;深入了解MySQL的行锁与表锁机制 前言基础innodb中锁与索引的关系如何避免表锁 前言 在当今数据密集的应用中&#xff0c;数据库锁成为了确保数据一致性和并发操作的关键工具…
阅读更多...
Java 拦截器深入了解学习

Java 拦截器深入了解学习

Java 拦截器深入了解学习 命运总是不如愿。 但往往是在无数的痛苦中&#xff0c;在重重的矛盾和艰难中&#xff0c;才使人成熟起来&#xff0c;坚强起来;虽然这些东西在实际感受中给人带来的并不都是欢乐。 ————路遥《平凡的世界》 什么是拦截器&#xff08;Interceptor&am…
阅读更多...
【C++】C++对C语言的关系，拓展及命名空间的使用

【C++】C++对C语言的关系，拓展及命名空间的使用

文章目录 &#x1f4dd;C简述C融合了3种不同的编程方式&#xff1a;C和C语言关系是啥呢&#xff1f;C标准 &#x1f320;C应用&#x1f320;C语言优点第一个C程序 &#x1f320;命名空间&#x1f320;命名空间的使用命名空间的定义 &#x1f320;怎么使用命名空间中的内容呢&am…
阅读更多...
强化学习入门到不想放弃-3

强化学习入门到不想放弃-3

第三节我们主要讲一下SARSA模型 上节课的链接：强化学习入门到不想放弃-2 (qq.com) 有模型的概念：简单理解，上节课我讲的就是有模型，就是可以开上帝视角，知道全局地图 无模型的概念: 打CS，但是看不到地图的情况，全凭自己探索 今天的讲解环境还是和上节课一样，如下…
阅读更多...
Movelt使用笔记-Movelt Setup Assistant

Movelt使用笔记-Movelt Setup Assistant

目录 Setup Assistant配置1 Start 加载urdf模型3 Virtual joints 虚拟关节5 Robot Poses 机器人位姿7 Passive Joints 被动关节8 Controllers 控制器9 Simulation 仿真10 3D Perception 3D感知11 Author Information 作者信息12 Configuration Files 配置文件启动MoveIt！Setup…
阅读更多...
【Python笔记-设计模式】前端控制器模式

【Python笔记-设计模式】前端控制器模式

一、说明 常作为MVC&#xff08;Model-View-Controller&#xff09;模式的一部分&#xff0c;用来处理用户请求并将其分发给相应的处理程序&#xff08;即路由匹配&#xff09;。 (一) 解决问题 将请求的处理流程集中管理&#xff0c;统一处理所有的请求 (二) 使用场景 需…
阅读更多...
学习或从事鸿蒙开发工作，有学历要求吗？

学习或从事鸿蒙开发工作，有学历要求吗？

目前安卓有2,000万的开发者。本科及以上学历占比为35%&#xff1b;iOS有2,400万开发者&#xff0c;本科及以上学历占比为40% 绝大多数的前端开发者都是大专及以下学历&#xff0c;在2023年华为开发者大会上余承东透露华为的开发者目前有200万&#xff0c;但鸿蒙开发者统计的数据…
阅读更多...
3.WEB渗透测试-前置基础知识-快速搭建渗透环境（上）

3.WEB渗透测试-前置基础知识-快速搭建渗透环境（上）

上一个内容&#xff1a;2.WEB渗透测试-前置基础知识-web基础知识和操作系统-CSDN博客 1.安装虚拟机系统 linux Kali官网下载地址&#xff1a; https://www.kali.org/get-kali/#kali-bare-metal Centos官网下载地址&#xff1a; https://www.centos.org/download/ Deepin官网下…
阅读更多...
每个学计算机同学都应该有个创业梦

每个学计算机同学都应该有个创业梦

推荐计算机专业必看的两部电影 经典记录片电影《社交网络》推荐理由豆瓣评分电影简介 德国犯罪喜剧《如何在网上卖迷幻药》推荐理由剧情简介 两部电影主角对比 经典记录片电影《社交网络》 纪录扎克伯格&#xff0c;7年时间&#xff0c;从一名大学生摇身变成亿万富翁的故事 推荐…
阅读更多...
解读OpenAI Sora文生视频技术原理

解读OpenAI Sora文生视频技术原理

OpenAI Sora文生视频&#xff08;图像看作单帧视频&#xff09;一放出就炸翻整个AI 圈&#xff0c;也是ChatGPT掀起GenAI热潮时隔一年后&#xff0c;OpenAI再次史诗级的更新。OpenAI 随后公布的技术综述[文献1]&#xff0c;难掩其勃勃雄心&#xff1a;视频生成模型作为世界模拟…
阅读更多...
Matlab自学笔记二十七：详解格式化文本sprintf各参数设置方法

Matlab自学笔记二十七：详解格式化文本sprintf各参数设置方法

1.一个程序引例 上篇文章已经介绍了格式化文本的初步应用&#xff0c;程序示例如下&#xff1a; sprintf(|%f\n|%.2f\n|%8.2f,pi*ones(1,3)) 2.格式化操作符各字段的含义解析 格式化操作符可以有六个字段&#xff0c;只有主字符%和转换格式是必需的&#xff0c;其他都是可选…
阅读更多...
CSS3中盒子居中

CSS3中盒子居中

&#xff08;1&#xff09;利用定位&#xff08;子绝父相&#xff09;、margin-left、和margin-top实现 &#xff08;2&#xff09;利用定位&#xff08;子绝父相&#xff09;、transfrom属性实现 &#xff08;3&#xff09;利用flex布局实现盒子居中
阅读更多...
中科大计网学习记录笔记（十五）：可靠数据传输的原理

中科大计网学习记录笔记（十五）：可靠数据传输的原理

前前言&#xff1a;看过本节的朋友应该都知道本节长度长的吓人&#xff0c;但其实内容含量和之前的差不多&#xff0c;老师在本节课举的例子和解释比较多&#xff0c;所以大家坚持看完是一定可以理解透彻的。本节课大部分是在提出问题和解决问题&#xff0c;先明确出现的问题是…
阅读更多...
Ubuntu22.04和Windows10双系统安装

Ubuntu22.04和Windows10双系统安装

概要 本篇演示Ubuntu22.04和Windows10双系统的安装。先安装Ubuntu22.04&#xff0c;再安装Windows10。 一、说明 1、电脑 笔者的电脑品牌是acer(宏碁/宏基) 电脑开机按F2进入BIOS 电脑开机按F12进入Boot Manager 2、U盘启动盘 需要用到两个U盘启动盘 &#xff08;1&a…
阅读更多...
IO进程线程day7作业

IO进程线程day7作业

使用消息队列完成两个进程间相互通信 代码&#xff1a; msgsnd.c #include<myhead.h>//定义消息类型 struct msgbuf {long mtype;char mtext[1024]; };//宏表示消息正文大小 #define MSGSIZE sizeof(struct msgbuf)-sizeof(long)int main(int argc, const char *argv[…
阅读更多...
【Java程序员面试专栏 数据结构】四 高频面试算法题：哈希表

【Java程序员面试专栏 数据结构】四 高频面试算法题：哈希表

一轮的算法训练完成后，对相关的题目有了一个初步理解了，接下来进行专题训练，以下这些题目就是汇总的高频题目，一个O（1）查找的利器哈希表，所以放到一篇Blog中集中练习 题目关键字解题思路时间空间两数之和辅助哈希使用map存储出现过的值，key为值大小，value为下标位置，…
阅读更多...
C++-带你走进多态（1）

C++-带你走进多态（1）

1. 多态的概念 1.1 概念 多态的概念&#xff1a;通俗来说&#xff0c;就是多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出不同的状态。 举个栗子&#xff1a;比如买票这个行为&#xff0c;当普通人买票时&#xff0c;是全价买票&am…
阅读更多...
Android Gradle 开发与应用 (一) : Gradle基础

Android Gradle 开发与应用 (一) : Gradle基础

1. Gradle是什么 Gradle是一个通用的构建工具&#xff0c;支持诸多主要的 IDE&#xff0c;包括 Android Studio、IntelliJ IDEA、Visual Studio 等 Gradle 的底层实现(核心引擎和框架)其实是用 Java 编写的开发者通常使用 Groovy 或 Kotlin 来编写构建脚本 1.1 那么为什么Gra…
阅读更多...
OSCP靶机--AuthBy

OSCP靶机--AuthBy

OSCP靶机–AuthBy 1.考点 (1. ftp匿名登陆&#xff0c;搜集信息 2.ftp弱密码 3.hash破解【hashcat与john】4.Windows_Server_2008_R2_Enterprise 土豆提权(32bit)) 1.nmap ┌──(root㉿kali)-[~/Desktop] └─# nmap 192.168.225.46 -sV -sC -p- --min-rate 5000 Startin…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023