高性能JAVA笔试系统源码解密：基于SpringCloud微服务架构的在线考试平台设计与MySQL+Redis技术实践详解

本文详细阐述了基于 Spring Cloud 微服务架构的高性能在线考试平台的设计与核心实现。通过将系统拆分为多个自治的微服务，并结合MySQL的数据可靠性与Redis的高性能，我们成功地构建了一个弹性、可扩展且响应迅速的平台。关键实践点总结：微服务划分明确了边界，便于团队协作和独立部署。利用Redis缓存考题、存储会话和临时答案，极大提升了并发处理能力。通过网关统一鉴权，保证了API的安全访问。

xm123m

427人浏览 · 2025-10-20 08:32:43

xm123m · 2025-10-20 08:32:43 发布

好的，请看这篇文章。

高性能在线考试平台架构解密：SpringCloud + MySQL + Redis 技术实战

1. 引言：在线考试系统的挑战与微服务架构的优势

随着在线教育的普及，在线考试系统已成为教育机构和企业的核心基础设施。构建一个高性能、高可用、可扩展的考试平台面临着诸多挑战：高并发下的系统稳定性、考试数据的强一致性、快速自动评卷、以及防止作弊等安全风险。

传统的单体架构（Monolithic Architecture）在应对这些挑战时往往力不从心。此时，基于 Spring Cloud 的微服务架构应运而生，它通过将系统拆分为一组小型、自治的服务，从而提供了卓越的弹性、可扩展性和技术多样性。本文将深入剖析一个基于 Spring Cloud 微服务架构的高性能在线考试平台，结合 MySQL 作为可靠存储、Redis 作为高性能缓存的实战方案，并通过大量代码实例展示核心实现细节。

2. 系统总体架构设计

我们设计的平台采用典型的微服务划分模式，每个服务职责单一，通过轻量级通信机制进行协作。

架构组件图：

- 客户端： Web前端（Vue/React）、移动端APP。
- 网关层： Spring Cloud Gateway：负责路由转发、API聚合、权限验证、限流熔断。
- 服务注册与发现中心： Nacos（或Eureka）：管理所有微服务的注册与发现。
- 配置中心： Nacos Config：统一管理所有微服务的配置，实现动态刷新。
- 业务微服务集群：
- user-service：用户服务（登录、注册、权限管理）。
- exam-service：考试核心服务（考试创建、题目管理）。
- answer-service：答题服务（提交答案、临时保存）。
- judge-service：评卷服务（自动判题、成绩计算）。
- score-service：成绩服务（成绩查询、统计分析）。

数据层：

MySQL：核心业务数据持久化，如用户信息、考试信息、题目库、最终成绩等。

Redis：用作缓存（提升读性能）和高速读写存储（存储临时答案、考试会话、限流计数器）。

服务调用流程：

用户请求 -> Spring Cloud Gateway -> 认证鉴权 -> 路由到具体微服务 -> 服务间通过OpenFeign调用 -> 访问MySQL/Redis -> 返回结果。

3. 核心微服务模块详解与代码实现

3.1 服务注册与发现（Nacos）

所有服务启动时都会注册到Nacos中心。

1. 依赖引入（Maven）:

xml


 <dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
 <version>2022.0.0.0</version>
 </dependency>

2. 应用配置（application.yml）:

yaml


 spring:
 application:
 name: exam-service 服务名
 cloud:
 nacos:
 discovery:
 server-addr: localhost:8848 Nacos服务器地址
 namespace: public 命名空间，用于环境隔离

3. 启动类注解：

java


 @SpringBootApplication
 @EnableDiscoveryClient // 启用服务发现客户端
 public class ExamServiceApplication {
 public static void main(String[] args) {
 SpringApplication.run(ExamServiceApplication.class, args);
 }
 }

3.2 API网关（Spring Cloud Gateway）

网关是所有流量的入口，负责关键的非业务功能。

关键配置：路由、鉴权过滤器

yaml


 spring:
 cloud:
 gateway:
 routes:
 - id: user-service-route
 uri: lb://user-service lb:// 表示从Nacos进行负载均衡
 predicates:
 - Path=/api/user/
 filters:
 - StripPrefix=1 去掉路径中的第一个前缀（/api）
 - name: AuthFilter 自定义鉴权过滤器
 args:
 excludePaths: /api/user/login,/api/user/register
 - id: exam-service-route
 uri: lb://exam-service
 predicates:
 - Path=/api/exam/
 filters:
 - StripPrefix=1

自定义全局鉴权过滤器（Global Filter）示例：

```java

@Component

public class AuthFilter implements GlobalFilter, Ordered {

@Autowiredprivate JwtUtil jwtUtil;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    String path = request.getPath().value();
    // 1. 检查是否为无需认证的路径
    if (path.startsWith("/api/user/login") || path.startsWith("/api/user/register")) {
        return chain.filter(exchange);
    }
    // 2. 从请求头获取Token
    String token = request.getHeaders().getFirst("Authorization");
    if (StringUtils.isEmpty(token) || !token.startsWith("Bearer ")) {
        return unauthorizedResponse(exchange, "Missing or invalid token");
    }
    token = token.substring(7);
    // 3. 验证Token
    try {
        Claims claims = jwtUtil.parseToken(token);
        String userId = claims.getSubject();
        String username = (String) claims.get("username");
        // 4. 将用户信息添加到请求头，传递给下游服务
        ServerHttpRequest mutatedRequest = request.mutate()
                .header("X-User-Id", userId)
                .header("X-Username", username)
                .build();
        return chain.filter(exchange.mutate().request(mutatedRequest).build());
    } catch (Exception e) {
        return unauthorizedResponse(exchange, "Token verification failed");
    }
}
private Mono<Void> unauthorizedResponse(ServerWebExchange exchange, String msg) {
    ServerHttpResponse response = exchange.getResponse();
    response.setStatusCode(HttpStatus.UNAUTHORIZED);
    response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
    String body = "{\"code\": 401, \"message\": \"" + msg + "\"}";
    DataBuffer buffer = response.bufferFactory().wrap(body.getBytes(StandardCharsets.UTF_8));
    return response.writeWith(Mono.just(buffer));
}
@Override
public int getOrder() {
    return 0;
}

}

```

3.3 考试服务（Exam-Service）与MySQL交互

考试服务负责考试和题目的管理。

1. 核心实体类（JPA）：

```java

@Entity

@Table(name = "examination")

@Data

public class Examination {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String title;

private String description;

@Column(name = "start_time")private LocalDateTime startTime;
@Column(name = "end_time")
private LocalDateTime endTime;
private Integer duration; // 考试时长，分钟
private Integer status; // 状态：0-未开始，1-进行中，2-已结束

}

@Entity

@Table(name = "question")

@Data

public class Question {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

@Column(name = "exam_id")private Long examId;
private String content; // 题目内容（JSON或文本）
private String type; // 题型：SINGLE_CHOICE, MULTI_CHOICE, TRUE_FALSE, ESSAY
private String options; // 选择题选项（JSON数组）
private String answer; // 标准答案
private Integer score; // 题目分值

}

```

2. 服务层与数据持久层：

```java

public interface ExamRepository extends JpaRepository {

// 查找正在进行中的考试

List findByStatus(Integer status);

// 使用@Query进行复杂查询@Query("SELECT e FROM Examination e WHERE e.endTime < :now AND e.status = 1")
List<Examination> findOngoingExamsPastEndTime(@Param("now") LocalDateTime now);

}

@Service

@Transactional

public class ExamService {

@Autowiredprivate ExamRepository examRepository;
public Examination createExam(Examination exam) {
    // 业务逻辑校验...
    return examRepository.save(exam);
}
public Examination getExamById(Long examId) {
    return examRepository.findById(examId)
            .orElseThrow(() -> new RuntimeException("Exam not found"));
}
// 定时任务：更新考试状态
@Scheduled(cron = "0 /1    ?") // 每分钟执行一次
public void updateExamStatus() {
    LocalDateTime now = LocalDateTime.now();
    // 更新“未开始”->“进行中”
    examRepository.findByStatus(0).stream()
            .filter(exam -> !exam.getStartTime().isAfter(now))
            .forEach(exam -> {
                exam.setStatus(1);
                examRepository.save(exam);
            });
    // 更新“进行中”->“已结束”
    List<Examination> toEnd = examRepository.findOngoingExamsPastEndTime(now);
    toEnd.forEach(exam -> exam.setStatus(2));
    examRepository.saveAll(toEnd);
}

}

```

3.4 答题服务（Answer-Service）与Redis实战

答题是高并发场景的核心。用户开始考试时，考试会话和临时答案都应存入Redis，以保证极快的读写速度，减轻MySQL压力。

1. Redis配置：

```java

@Configuration

public class RedisConfig {

@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 使用Jackson2JsonRedisSerializer来序列化和反序列化对象
    Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    mapper.activateDefaultTyping(LazyCollectionStepThroughHandler.INSTANCE, ObjectMapper.DefaultTyping.NON_FINAL);
    serializer.setObjectMapper(mapper);
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(serializer);
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(serializer);
    template.afterPropertiesSet();
    return template;
}

}

```

2. 核心业务：开始考试 & 保存答案

```java

@Service

public class AnswerSessionService {

@Autowiredprivate RedisTemplate<String, Object> redisTemplate;
private static final String EXAM_SESSION_KEY_PREFIX = "exam:session:";
private static final String USER_ANSWER_KEY_PREFIX = "exam:answer:";
/
  初始化考试会话
  @param userId 用户ID
  @param examId 考试ID
  @return 会话ID（可用于后续操作）
 /
public String startExamSession(Long userId, Long examId) {
    String sessionId = UUID.randomUUID().toString();
    String key = EXAM_SESSION_KEY_PREFIX + sessionId;
    Map<String, Object> sessionData = new HashMap<>();
    sessionData.put("userId", userId);
    sessionData.put("examId", examId);
    sessionData.put("startTime", System.currentTimeMillis());
    sessionData.put("remainingTime", 3600); // 剩余时间，秒
    // 将考试会话存入Redis，并设置过期时间（略大于考试时长）
    redisTemplate.opsForHash().putAll(key, sessionData);
    redisTemplate.expire(key, Duration.ofMinutes(65)); // 设置65分钟后过期
    // 同时初始化一个Hash结构来存储该用户的答案
    String answerKey = USER_ANSWER_KEY_PREFIX + userId + ":" + examId;
    redisTemplate.opsForValue().set(answerKey, "{}", Duration.ofMinutes(65));
    return sessionId;
}
/
  保存或更新一道题的答案（自动保存功能）
  @param userId 用户ID
  @param examId 考试ID
  @param questionId 题目ID
  @param answer 用户答案
 /
public void saveAnswer(Long userId, Long examId, Long questionId, String answer) {
    String answerKey = USER_ANSWER_KEY_PREFIX + userId + ":" + examId;
    // 使用Redis的Hash结构来存储题目答案：field=questionId, value=answer
    redisTemplate.opsForHash().put(answerKey, questionId.toString(), answer);
    // 同时更新最后操作时间，用于判断是否作弊（长时间无操作等）
    String sessionKey = ...; // 需要通过其他方式获取sessionId，这里简化
    redisTemplate.opsForHash().put(EXAM_SESSION_KEY_PREFIX + sessionKey, "lastActiveTime", System.currentTimeMillis());
}
/
  提交试卷：从Redis中获取所有答案，持久化到MySQL，并清理Redis
  @param sessionId 会话ID
 /
@Transactional
public void submitExam(String sessionId) {
    String sessionKey = EXAM_SESSION_KEY_PREFIX + sessionId;
    Map<Object, Object> sessionData = redisTemplate.opsForHash().entries(sessionKey);
    if (sessionData.isEmpty()) {
        throw new RuntimeException("Exam session expired or not found");
    }
    Long userId = Long.valueOf((Integer) sessionData.get("userId"));
    Long examId = Long.valueOf((Integer) sessionData.get("examId"));
    String answerKey = USER_ANSWER_KEY_PREFIX + userId + ":" + examId;
    // 1. 从Redis中获取所有答案
    Map<Object, Object> allAnswers = redisTemplate.opsForHash().entries(answerKey);
    // 2. 将答案批量保存到MySQL（这里省略AnswerRecord实体和Repository代码）
    List<AnswerRecord> records = new ArrayList<>();
    allAnswers.forEach((qId, answer) -> {
        AnswerRecord record = new AnswerRecord();
        record.setUserId(userId);
        record.setExamId(examId);
        record.setQuestionId(Long.valueOf((String) qId));
        record.setUserAnswer((String) answer);
        record.setSubmitTime(LocalDateTime.now());
        records.add(record);
    });
    // answerRecordRepository.saveAll(records);
    // 3. 异步触发评卷服务
    // judgeService.judgeExam(userId, examId);
    // 4. 提交成功后，清理Redis中的会话和答案数据
    redisTemplate.delete(sessionKey);
    redisTemplate.delete(answerKey);
}

}

```

4. 高并发与性能优化实践

4.1 Redis缓存应用

1. 缓存考题信息： 考试开始时，将考题信息加载到Redis，避免考试期间频繁查询MySQL。

```java

@Service

public class QuestionService {

@Autowiredprivate QuestionRepository questionRepository;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
private static final String EXAM_QUESTIONS_KEY_PREFIX = "exam:questions:";
public List<Question> getQuestionsByExamId(Long examId) {
    String key = EXAM_QUESTIONS_KEY_PREFIX + examId;
    // 先查缓存
    List<Question> questions = (List<Question>) redisTemplate.opsForValue().get(key);
    if (questions != null) {
        return questions;
    }
    // 缓存未命中，查询数据库
    questions = questionRepository.findByExamId(examId);
    if (!questions.isEmpty()) {
        // 写入缓存，设置过期时间（如考试结束后过期）
        redisTemplate.opsForValue().set(key, questions, Duration.ofHours(2));
    }
    return questions;
}
// 当题目有更新时，清除缓存
public void evictQuestionsCache(Long examId) {
    String key = EXAM_QUESTIONS_KEY_PREFIX + examId;
    redisTemplate.delete(key);
}

}

```

2. 分布式锁控制并发提交： 防止用户连续点击提交按钮导致重复提交。

```java

@Service

public class ExamSubmitService {

@Autowiredprivate RedisTemplate<String, Object> redisTemplate;
public boolean trySubmitExam(Long userId, Long examId) {
    String lockKey = "submit:lock:" + userId + ":" + examId;
    String requestId = UUID.randomUUID().toString(); // 保证解锁的是当前请求
    // 尝试获取锁，设置过期时间防止死锁
    Boolean acquired = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, Duration.ofSeconds(10));
    if (Boolean.TRUE.equals(acquired)) {
        try {
            // 获取锁成功，执行提交逻辑
            submitExam(userId, examId);
            return true;
        } finally {
            // 释放锁，使用Lua脚本保证原子性
            String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            redisTemplate.execute(new DefaultRedisScript<>(luaScript, Long.class), 
                                 Collections.singletonList(lockKey), requestId);
        }
    } else {
        // 获取锁失败，说明正在提交中
        throw new RuntimeException("Submission in progress, please do not repeat");
    }
}

}

```

5. 总结与展望

本文详细阐述了基于 Spring Cloud 微服务架构的高性能在线考试平台的设计与核心实现。通过将系统拆分为多个自治的微服务，并结合 MySQL 的数据可靠性与 Redis 的高性能，我们成功地构建了一个弹性、可扩展且响应迅速的平台。

关键实践点总结：

- 架构清晰： 微服务划分明确了边界，便于团队协作和独立部署。
- 性能优先： 利用Redis缓存考题、存储会话和临时答案，极大提升了并发处理能力。
- 数据安全： 通过网关统一鉴权，保证了API的安全访问。
- 并发控制： 使用Redis分布式锁解决了高并发下的重复提交等难题。

未来展望：

未来可以考虑引入 Elasticsearch 实现考题和成绩的复杂搜索与统计分析；使用 RabbitMQ 或 Kafka 进行更彻底的异步化解耦，例如将评卷过程完全异步化；利用 Seata 处理分布式事务，确保在更复杂业务场景下的数据一致性。通过持续迭代，该平台将能更好地应对未来更大的业务挑战。

注意： 以上代码为示例，实际生产环境需要更完善的异常处理、日志记录、事务管理和安全措施。请根据具体需求进行调整和优化。

Java Integer.valueOf()缓存池与自动装箱陷阱详解

本文深度剖析Java自动装箱拆箱机制，揭示Integer.valueOf()缓存池的底层原理及实际开发中的常见陷阱

一、自动装箱与拆箱的基本概念

在Java 5中引入的自动装箱（Autoboxing）和拆箱（Unboxing）机制，使基本数据类型与其对应的包装类之间的转换能够自动完成。这一特性虽然提高了代码的简洁性，但也带来了不少潜在问题。

自动装箱是指将基本数据类型自动转换为对应的包装类对象：

java


 Integer i = 100; // 编译器自动转换为 Integer.valueOf(100)

自动拆箱是指将包装类对象自动转换为基本数据类型：

java


 int num = i; // 编译器自动转换为 i.intValue()

二、Integer.valueOf()的缓存池机制

2.1 缓存池的实现原理

Integer.valueOf()方法是实现自动装箱的核心，其最显著的特点就是整数缓存池。让我们查看其源码实现：

java


 public static Integer valueOf(int i) {
 if (i >= IntegerCache.low && i <= IntegerCache.high)
 return IntegerCache.cache[i + (-IntegerCache.low)];
 return new Integer(i);
 }

从源码可以看出，当数值在特定范围内时，不会创建新的Integer对象，而是返回缓存池中已存在的对象。

2.2 缓存范围的变化

Integer缓存池的默认范围是-128到127，但这个范围在不同Java版本中有所变化：

- Java 5引入缓存机制：固定范围为-128到127
- Java 6及以后：最大值127可以通过JVM参数调整
- Java 7/8：缓存范围可以通过-XX:AutoBoxCacheMax=参数扩展
- Java 9及以后：缓存上限最大可扩展到Integer.MAX_VALUE - 128

2.3 缓存池的配置方式

通过JVM参数调整缓存范围：

```bash

将缓存上限设置为500

-XX:AutoBoxCacheMax=500

```

三、自动装箱的陷阱与解决方案

3.1 对象相等性比较陷阱

最常见的问题出现在使用==比较Integer对象时：

```java

Integer a = 100;

Integer b = 100;

System.out.println(a == b); // true：在缓存范围内，是同一对象

Integer c = 200;

Integer d = 200;

System.out.println(c == d); // false：超出缓存范围，是不同的对象

```

解决方案：始终使用equals()方法比较包装类对象

java


 System.out.println(a.equals(b)); // true
 System.out.println(c.equals(d)); // true

3.2 性能陷阱

自动装箱在循环或大量计算中会导致严重的性能问题：

```java

// 低效写法：每次循环都进行自动装箱

Long sum = 0L;

for (long i = 0; i < Integer.MAX_VALUE; i++) {

sum += i; // 每次都会进行 Long.valueOf(sum.longValue() + i)

}

// 高效写法：使用基本数据类型

long sum = 0L;

for (long i = 0; i < Integer.MAX_VALUE; i++) {

sum += i;

}

```

3.3 空指针异常陷阱

自动拆箱可能抛出NullPointerException：

java


 Integer value = null;
 int num = value; // 抛出 NullPointerException

防御性编程：

java


 Integer value = possiblyNullMethod();
 int num = (value != null) ? value : 0; // 安全处理

四、其他包装类的缓存机制

除了Integer类，其他包装类也有类似的缓存机制：

4.1 Byte、Short、Long缓存

- 缓存范围：-128到127
- 实现原理与Integer类似

4.2 Character缓存

- 缓存范围：0到127（ASCII字符集）

4.3 Boolean缓存

- 只有两个静态实例：TRUE和FALSE

java


 Boolean bool1 = true; // 返回 Boolean.TRUE
 Boolean bool2 = true; // 返回 Boolean.TRUE
 System.out.println(bool1 == bool2); // true

五、实际应用场景与最佳实践

5.1 集合框架中的使用

java


 List<Integer> list = new ArrayList<>();
 for (int i = 0; i < 1000; i++) {
 list.add(i); // 自动装箱，注意性能影响
 }

5.2 数据库映射中的注意事项

在ORM框架（如Hibernate、MyBatis）中，实体类使用包装类可以更好地表示数据库中的NULL值：

java


 @Entity
 public class User {
 private Integer age; // 允许为null，对应数据库中的NULL
 private int status; // 不允许为null，默认值为0
 }

5.3 最佳实践总结

- 比较操作：包装类比较始终使用equals()方法
- 循环体内：尽量避免自动装箱，使用基本数据类型
- 性能敏感场景：明确使用valueOf()而非构造函数
- 空值处理：注意自动拆箱可能导致的NPE
- 缓存利用：在缓存范围内可安全使用==比较（但不推荐）

六、最新Java版本的改进

从Java 9开始，Integer等包装类的构造方法已被标记为@Deprecated，推荐直接使用valueOf()方法：

```java

// Java 9+ 不推荐

Integer i = new Integer(100);

// 推荐方式

Integer i = Integer.valueOf(100);

Integer i = 100; // 自动装箱

```

总结

Integer.valueOf()的缓存机制是Java为了优化内存和性能而设计的重要特性。理解其工作原理对于编写正确、高效的Java代码至关重要。在实际开发中，开发者应该：

- 深刻理解自动装箱拆箱的底层机制
- 避免在性能敏感场景中滥用自动装箱
- 使用正确的方式比较包装类对象
- 注意空指针异常的预防

通过遵循这些最佳实践，可以充分利用Java自动装箱的特性，同时避免常见的陷阱，编写出更加健壮和高效的代码。

本文基于Java 17最新特性编写，具体实现细节可能因Java版本而异，建议在实际开发中参考对应版本的官方文档。

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

腾讯云开发者社区

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git