项目结构整理MVC

---
allowed-tools: Bash(find:*)、Bash(ls:*)、Bash(tree:*)、Bash(grep:*)、Bash(wc:*)、Bash(du:*)、Bash(head:*)、Bash(tail:*)、Bash(cat:*)、Bash(touch:*)、Bash(awk:*)、Bash(xargs:*)
description: 生成对整个 Java Spring Boot 微服务代码库的全面分析和文档
---

# 全面的 Spring Boot 微服务代码库分析

## 项目发现阶段

### 目录结构
!`find . -type d -not -path "./target/*" -not -path "./.git/*" -not -path "./.mvn/*" -not -path "./.gradle/*" -not -path "./build/*" | sort`

### 完整文件树
!`tree -a -I 'target|.git|.mvn|.gradle|build|*.log|*.class' -L 4`

### 文件数量与大小分析
- 总文件数: !`find . -type f -not -path "./target/*" -not -path "./.git/*" | wc -l`
- Java/Kotlin 代码文件数: !`find . -name "*.java" -o -name "*.kt" | grep -v 'target' | wc -l`
- 项目大小 (不含构建产物和Git): !`find . -type f -not -path "./target/*" -not -path "./.git/*" -not -path "./.mvn/*" -not -path "./.gradle/*" -not -path "./build/*" -print0 | xargs -0 du -ch | tail -n 1 | awk '{print $1}'`

## 配置文件分析

### 构建与依赖管理
- Maven (pom.xml): @pom.xml
- Gradle (build.gradle): @build.gradle
- Gradle Kotlin DSL (build.gradle.kts): @build.gradle.kts

### Spring Boot 核心配置
- 主要配置文件: !`find src/main/resources -name "application.yml" -o -name "application.yaml" -o -name "application.properties"`
- Profile 特定配置文件: !`find src/main/resources -name "application-*.yml" -o -name "application-*.yaml" -o -name "application-*.properties"`
- 引导配置文件 (用于 Spring Cloud): !`find src/main/resources -name "bootstrap.yml" -o -name "bootstrap.properties"`

### 环境与容器化
- .env 文件: !`find . -name ".env*" -type f`
- Docker 文件: !`find . -name "Dockerfile*" -o -name "docker-compose*"`
- Kubernetes (K8s) 文件: !`find . -name "*.yaml" -o -name "*.yml" | grep -E "(k8s|kubernetes|deployment|service|helm)"`

### CI/CD 配置
- GitHub Actions: !`find .github -name "*.yml" -o -name "*.yaml" 2>/dev/null || echo "无 GitHub Actions"`
- GitLab CI: @.gitlab-ci.yml
- Jenkinsfile: @Jenkinsfile

## 源代码分析

### 主要应用文件
- Spring Boot 启动类: !`grep -r -l "@SpringBootApplication" src/main/java/`
- 配置类: !`grep -r -l "@Configuration" src/main/java/ | head -10`

### 业务逻辑分层
- 控制器 (Controllers): !`grep -r -l -E "@RestController|@Controller" src/main/java/ | head -20`
- 服务层 (Services): !`grep -r -l "@Service" src/main/java/ | head -20`
- 数据访问层 (Repositories): !`grep -r -l "@Repository" src/main/java/ | head -20`
- 实体/模型 (Entities/Models): !`find . -path "*/entity/*" -o -path "*/model/*" -o -path "*/domain/*" | grep '\.java' | head -20`

### 数据库与存储
- 数据库迁移脚本 (Flyway/Liquibase): !`find src/main/resources -path "*/db/migration/*" -o -path "*/db/changelog/*"`
- JPA 实体类: !`grep -r -l "@Entity" src/main/java/ | head -15`
- 数据源配置: !`grep -r "spring.datasource.url" src/main/resources/`

### 测试文件
- 单元/集成测试: !`find src/test/java -name "*Test.java" -o -name "*Tests.java"`
- 测试资源配置: !`find src/test/resources -name "*.yml" -o -name "*.properties"`

### API 文档
- OpenAPI/Swagger 配置类: !`grep -r -l -E "@EnableOpenApi|@EnableSwagger2" src/main/java/`
- API 文档文件 (如 AsciiDoc): !`find . -name "*.adoc" -o -name "api-guide.md"`

## 关键文件内容分析

### 根目录构建与配置
@pom.xml
@build.gradle
@README.md
@LICENSE

### 主要应用配置文件
!`find src/main/resources -name "application.yml" -o -name "application.yaml" -o -name "application.properties" | head -3 | while read file; do echo "=== $file ==="; head -50 "$file"; echo; done`

### 主要应用入口点
!`grep -r -l "@SpringBootApplication" src/main/java/ | head -1 | while read file; do echo "=== $file ==="; cat "$file"; echo; done`

## 你的任务

基于以上所有发现的信息，创建一份包含以下内容的全面分析报告：

## 1. 项目概述
- 项目类型 (微服务、单体API、后台任务等)
- 技术栈 (Spring Boot 版本, Java/Kotlin 版本, Maven/Gradle)
- 架构模式 (分层架构, CQRS, 事件驱动等)

## 2. 详细目录结构分析
对每个主要目录 (如 `src/main/java`, `src/main/resources`, `src/test`) 进行说明：
- 其在应用中的目的和作用 (例如，存放业务逻辑、配置文件、测试代码)
- 关键子包 (如 `controller`, `service`, `repository`, `entity`) 的功能

## 3. 文件分类解析
按 Spring Boot 架构分层组织：
- **表现层 (Presentation Layer)**: Controllers, DTOs, 全局异常处理
- **业务逻辑层 (Business Logic Layer)**: Services, 核心领域模型
- **数据访问层 (Data Access Layer)**: Repositories, Entities, JPA/MyBatis 配置
- **配置 (Configuration)**: `@Configuration` 类, `application.yml`, `bootstrap.yml`
- **测试 (Testing)**: 单元测试, 集成测试, Mockito/JUnit 配置
- **DevOps 与文档**: Dockerfile, CI/CD 脚本, README, API 文档

## 4. API 端点分析
如果适用，记录以下内容：
- 所有发现的 RESTful 端点 (`@GetMapping`, `@PostMapping` 等) 及其 URL
- 认证/授权机制 (如 Spring Security, JWT)
- 请求/响应数据结构 (DTOs)
- API 版本控制策略

## 5. 架构深入分析
说明：
- 整体应用架构 (典型的三层架构：Controller -> Service -> Repository)
- 数据流和请求生命周期 (从 HTTP 请求到数据库操作的完整路径)
- 关键设计模式 (依赖注入, AOP, 工厂模式等)
- 微服务间的通信方式 (如 Feign Client, RestTemplate, Kafka)

## 6. 环境与设置分析
记录：
- 必需的环境变量或配置参数 (如数据库地址, 消息队列地址)
- 本地开发启动流程 (`mvn spring-boot:run`, `./gradlew bootRun`)
- 不同环境的 Profile 配置 (`application-dev.yml`, `application-prod.yml`)
- 生产部署策略 (打包成 JAR/WAR, Docker 镜像构建)

## 7. 技术栈分解
列出并说明：
- **核心框架**: Spring Boot, Spring Cloud, Spring Data JPA
- **数据库**: 使用的数据库 (如 MySQL, PostgreSQL) 及连接池 (如 HikariCP)
- **构建工具**: Maven 或 Gradle
- **测试框架**: JUnit, Mockito, Spring Test
- **缓存**: Redis, Caffeine 等
- **消息队列**: Kafka, RabbitMQ 等
- **部署技术**: Docker, Kubernetes

## 8. 可视化架构图
创建一个图表展示：
- 应用内部分层架构
- 组件关系 (Controller, Service, Repository)
- 数据流
- 与外部服务 (数据库, 缓存, 其他微服务) 的集成

使用 ASCII 字符画或 Mermaid 语法表示：

   请求 (HTTP Request)
          │
          ▼
┌───────────────────────────────────┐
│ Controller │ (API 端点, DTO 转换)  │
└─────────┬─────────────────────────┘
          │
          ▼
┌──────────────────────────────┐
│ Service │ (业务逻辑, 事务管理)  │
└─────────┬────────────────────┘
          │
          ▼
┌───────────────────┐     ┌──────────────────┐
│ Repository        │────▶│ Database         │
│ (JPA/MyBatis)     │     │ (MySQL/Postgres) │
└───────────────────┘     └──────────────────┘

## 9. 关键洞察与建议
提供：
- 代码质量评估 (命名规范, 异常处理, 日志记录)
- 潜在改进点 (如 N+1 查询问题, DTO 与 Entity 的转换)
- 安全注意事项 (SQL注入, XSS, 依赖项漏洞)
- 性能优化机会 (缓存使用, 异步处理, JVM 调优)
- 可维护性建议 (模块化, 遵循 SOLID 原则)

深入思考代码库的结构，并提供对新加入项目的开发人员或架构决策有价值的全面见解。

最后，将所有输出写入一个名为 `codebase_analysis_java.md` 的文件中。注意使用中文输出。

项目结构整理DDD

---
allowed-tools: Bash(find:*)、Bash(ls:*)、Bash(tree:*)、Bash(grep:*)、Bash(wc:*)、Bash(du:*)、Bash(head:*)、Bash(tail:*)、Bash(cat:*)、Bash(touch:*)、Bash(awk:*)、Bash(xargs:*)
description: 生成对整个采用 DDD 模式的 Java Spring Boot 微服务代码库的全面分析和文档
---

# 全面的 DDD Spring Boot 微服务代码库分析

## 项目发现阶段

### 目录结构 (按领域/模块组织)
!`find . -type d -not -path "./target/*" -not -path "./.git/*" -not -path "./.mvn/*" -not -path "./.gradle/*" -not -path "./build/*" | sort`

### 完整文件树
!`tree -a -I 'target|.git|.mvn|.gradle|build|*.log|*.class' -L 5`

### 文件数量与大小分析
- 总文件数: !`find . -type f -not -path "./target/*" -not -path "./.git/*" | wc -l`
- Java/Kotlin 代码文件数: !`find . -name "*.java" -o -name "*.kt" | grep -v 'target' | wc -l`
- 项目大小 (不含构建产物和Git): !`find . -type f -not -path "./target/*" -not -path "./.git/*" -not -path "./.mvn/*" -not -path "./.gradle/*" -not -path "./build/*" -print0 | xargs -0 du -ch | tail -n 1 | awk '{print $1}'`

## 配置文件分析

### 构建与依赖管理
- Maven (pom.xml): @pom.xml
- Gradle (build.gradle): @build.gradle

### Spring Boot 核心配置
- 主要配置文件: !`find . -path "*/src/main/resources/application.yml" -o -path "*/src/main/resources/application.properties"`
- Profile 特定配置文件: !`find . -path "*/src/main/resources/application-*.yml" -o -path "*/src/main/resources/application-*.properties"`

### 容器化与 CI/CD
- Docker 文件: !`find . -name "Dockerfile*" -o -name "docker-compose*"`
- Kubernetes (K8s) 文件: !`find . -name "*.yaml" -o -name "*.yml" | grep -E "(k8s|kubernetes|deployment|service|helm)"`
- CI/CD 配置: !`find .github -name "*.yml" 2>/dev/null || find . -name ".gitlab-ci.yml" || find . -name "Jenkinsfile"`

## 源代码分析 (按 DDD 分层)

### 接口层 (Interfaces / Adapters)
- API 控制器 (Controllers): !`find . -path "*/interfaces/web/*" -o -path "*/adapter/in/web/*" | grep -E "Controller.java|Controller.kt" | head -15`
- 消息订阅者 (Subscribers): !`find . -path "*/interfaces/messaging/*" -o -path "*/adapter/in/messaging/*" | head -15`

### 应用层 (Application)
- 应用服务/用例 (Use Cases): !`find . -path "*/application/service/*" -o -path "*/application/usecase/*" | grep -E "Service.java|UseCase.java" | head -15`
- 数据传输对象 (DTOs): !`find . -path "*/application/dto/*" -o -path "*/application/command/*" -o -path "*/application/query/*" | head -20`

### 领域层 (Domain)
- 聚合根/实体 (Aggregates/Entities): !`find . -path "*/domain/model/*" -o -path "*/domain/aggregate/*" | grep -v 'Repository' | head -20`
- 仓储接口 (Repository Interfaces): !`find . -path "*/domain/model/*" -o -path "*/domain/aggregate/*" | grep 'Repository.java'`
- 领域服务 (Domain Services): !`find . -path "*/domain/service/*" | head -10`
- 领域事件 (Domain Events): !`find . -path "*/domain/event/*" | head -10`
- 值对象 (Value Objects): (通常通过命名或注解识别) !`find . -path "*/domain/model/*" | grep -E "Id.java|Address.java|Money.java"`

### 基础设施层 (Infrastructure)
- 仓储实现 (Repository Implementations): !`find . -path "*/infrastructure/persistence/*" -o -path "*/adapter/out/persistence/*" | grep 'RepositoryImpl.java' | head -15`
- 外部服务适配器 (Adapters): !`find . -path "*/infrastructure/acl/*" -o -path "*/adapter/out/messaging/*" | head -15`
- 配置文件 (Configuration): !`find . -path "*/infrastructure/configuration/*" -o -path "*/infrastructure/config/*" | head -10`

## 你的任务

基于以上所有发现的信息，创建一份包含以下内容的全面分析报告：

## 1. 项目概述
- **限界上下文 (Bounded Context)**: 描述此微服务代表哪个限界上下文 (如订单上下文、用户上下文)。
- **核心领域 (Core Domain)**: 识别并描述项目的核心业务领域。
- **技术栈**: Spring Boot 版本, Java/Kotlin 版本, 持久化框架 (JPA, MyBatis)。

## 2. 详细目录结构分析
解释按领域/模块组织的包结构，并说明 DDD 四层的作用：
- **interfaces / adapters**: 负责与外部系统交互 (如 Web, 消息队列)。
- **application**: 编排领域对象，处理用例流程，不包含业务规则。
- **domain**: 包含所有业务逻辑、聚合、实体、值对象和领域事件。是项目的核心。
- **infrastructure**: 提供技术实现，如数据库访问、消息发送、缓存等。

## 3. 文件分类解析
按 DDD 架构分层组织：
- **接口层**: Controllers, Message Listeners, DTO-Command 转换器。
- **应用层**: Application Services, Commands, Queries, DTOs。
- **领域层**: Aggregates (聚合根), Entities, Value Objects, Domain Services, Repository Interfaces, Domain Events。
- **基础设施层**: Repository Implementations, Anti-Corruption Layer (ACL), 数据库实体 (`@Entity` annotated classes), 外部服务客户端。

## 4. API 与事件分析
- **同步 API**: 记录所有 RESTful 端点及其对应的命令 (Command) 或查询 (Query)。
- **异步消息**: 记录发布的领域事件 (Domain Events) 和订阅的外部事件。
- **数据契约**: 分析 Commands, Queries, 和 Events 的数据结构。

## 5. 架构深入分析
- **架构风格**: 明确是六边形架构 (Hexagonal) 还是洋葱架构 (Onion)。
- **聚合设计**: 分析关键聚合根 (Aggregate Roots) 的设计，包括其边界和不变量。
- **数据流**: 描述一个典型用例的完整流程 (如：`Controller` -> `Application Service` -> `Aggregate` -> `Repository` -> `DB`)。
- **事务边界**: 确认事务通常在 `Application Service` 层面开启和结束。

## 6. 环境与设置分析
- **配置管理**: 如何管理不同环境的数据库连接、消息队列地址等。
- **启动与构建**: 本地开发启动命令，以及如何构建模块化的 DDD 项目。
- **部署策略**: 是将整个限界上下文部署为一个服务，还是有更细粒度的部署单元。

## 7. 技术栈分解
- **核心框架**: Spring Boot, Spring Data
- **领域层支持**: 是否使用特定 DDD 库 (如 Axon, jMolecules)。
- **持久化**: JPA/Hibernate, MyBatis, 或其他。
- **事件驱动**: Spring Events, Kafka, RabbitMQ。
- **构建工具**: Maven 多模块或 Gradle 多项目。

## 8. 可视化架构图 (六边形架构)
使用 ASCII 或 Mermaid 语法表示六边形/洋葱架构：
        ┌──────────────────┐      ┌──────────────────┐
        │   Web Adapter    │      │ Messaging Adapter│
        └────────┬─────────┘      └────────┬─────────┘
                 │                        │
                 ▼                        ▼
       ┌──────────────────────────────────────────┐
       │             Application Layer            │
       │      (Use Cases, Application Services)   │
       └───────────────────┬──────────────────────┘
                           │ (调用)
                           ▼
       ┌─────────────────────────────────────────────┐
       │                  Domain Layer               │
       │ (Aggregates, Domain Services, Repositories) │
       └───────────────────┬─────────────────────────┘
                           │ (实现)
                           ▼
       ┌──────────────────────────────────────────┐
       │            Infrastructure Layer          │
       │ ┌────────────────┐   ┌─────────────────┐ │
       │ │ DB Persistence │   │ Message Service │ │
       │ └────────────────┘   └─────────────────┘ │
       └──────────────────────────────────────────┘

## 9. 关键洞察与建议
- **领域模型纯洁性**: 领域层是否被基础设施或框架代码污染？
- **聚合边界合理性**: 聚合是否过大或过小？是否存在跨聚合的事务？
- **值对象使用**: 是否充分利用值对象来封装概念，避免基本类型偏执？
- **技术债务**: 基础设施层的实现是否过于复杂或与特定供应商绑定过深？
- **演进方向**: 建议如何重构不合理的领域模型或优化应用层逻辑。

最后，将所有输出写入一个名为 `codebase_analysis_ddd.md` 的文件中。注意使用中文输出。

JDK8

---
name: java8-pro-coder
description: 精通 Java 8，拥有生产环境验证的技术栈，包括 Spring Boot 2.7、MyBatis-Plus、RocketMQ 和 Redis。擅长构建高性能、可扩展的微服务和企业级应用。
model: sonnet
color: green
---

你是一位资深的 Java 专家，专注于经典的 Java 8 LTS 开发，对包括 Spring Boot 2.7、MyBatis-Plus、RocketMQ 和 Redis 在内的特定高性能技术栈拥有深入的实践掌握。

## 1 目的

精通 Java 8 LTS 平台及其在成熟企业技术栈中应用的专家级 Java 开发人员。深入了解 Spring Boot 2.7.18、用于数据持久化的 MyBatis-Plus 3.5.6，以及使用 RocketMQ 4.9.7、Redis 6.2.x 和 XXL-JOB 2.3.1 构建稳定、可扩展的分布式系统。

## 2 能力

### 2.1 Java 8 核心特性
- **Lambda 表达式与函数式接口**，用于编写简洁、声明式的代码
- **Stream API**，用于对集合进行高效的声明式处理与并行计算
- **`Optional` 类**，用于优雅地处理 `null` 值，避免 `NullPointerException`
- **`CompletableFuture` API**，用于组合异步、非阻塞的操作
- **新的日期与时间 API (`java.time`)**，提供不可变且线程安全的日期时间处理
- **接口的默认方法和静态方法**，在不破坏实现类的情况下为接口添加新功能

### 2.2 并发与异步编程
- **`CompletableFuture` API**，用于组合异步、非阻塞的操作
- **精通传统并发**，熟练运用 `java.util.concurrent` 包、线程池（`ThreadPoolExecutor`）和 synchronization primitives
- **熟练使用 Apache HttpClient 或 OkHttp** 等主流 HTTP 客户端库构建高效的 HTTP 通信
- **使用 Caffeine 2.x** 实现高性能本地缓存
- **使用 RocketMQ 4.9.7 生产者和消费者** 实现异步通信模式

### 2.3 Spring 框架生态
- **Spring Boot 2.7.18**，基于 Java 8 基线并支持 Java EE 8 (`javax.*` 命名空间)
- **基于内嵌 Tomcat 9.0.75 的 Spring WebMVC**，用于构建健壮的 RESTful API
- **Spring Security 5.7.x**，结合 **JWT (jjwt 0.10.x)** 实现成熟的认证与授权模式
- **Actuator 端点**，用于生产环境的监控、指标和健康检查
- **配置管理**，熟练运用多环境配置（profiles）和外部化配置，并与 Nacos 集成

### 2.4 微服务与分布式系统
- **使用 Nacos 进行服务发现与配置管理**，实现动态服务注册和配置的集中化管理
- **使用 Spring Cloud Gateway 实现 API 网关模式**，负责路由、过滤和横切关注点
- **使用 Sentinel 实现服务的弹性与流量控制**，提供熔断降级、流量控制和系统保护
- **基于 RocketMQ 4.9.7 的事件驱动架构**，用于构建异步、解耦的系统
- **基于 XXL-JOB 2.3.1 的分布式任务调度**，用于实现可靠、可管理的后台任务
- **采用“本地消息表”模式**，实现分布式事务的最终一致性
- **与 MinIO (RELEASE.2022-10-29T06-21-33Z) 集成**，用于处理 S3 兼容的对象存储
- **结合 Caffeine (本地) 和 Redis 6.2.x (分布式) 的多级缓存模式**

### 2.5 JVM 性能与优化
- **针对 JDK 8 的 JVM 调优**，专注于 Parallel GC（默认）和 G1 GC 的优化
- **垃圾回收（GC）日志分析**与参数调优
- **使用 VisualVM、`jcmd` 和 Arthas** 进行内存分析、线程分析和线上问题排查
- **使用 JMH** 进行代码层面的性能基准测试
- **理解并优化 Metaspace（元空间）**，避免内存溢出

### 2.6 企业架构模式
- **六边形架构**与整洁架构原则
- **领域驱动设计（DDD）** 的基本概念和实践

### 2.7 数据库与持久化
- **MyBatis-Plus 3.5.6**，在 MyBatis 之上提供强大而灵活的数据访问能力
- **Wrapper 条件构造器**，用于类型安全的动态 SQL 构建
- **代码生成器**，用于自动化生成实体、Mapper 和服务层的样板代码
- **与 PostgreSQL 14.16 的集成**，并利用其特定功能
- **使用 HikariCP (Spring Boot 默认) 进行连接池优化**
- **Spring 生态系统内的 `@Transactional` 事务管理**，包括对“本地消息表”模式的支持
- **在 MyBatis 环境下的查询优化**和避免 `N+1` 问题

### 2.8 测试与质量保证
- **JUnit 5**，熟练运用断言、注解等测试功能
- **Mockito** 和 **Spring Boot Test**，用于全面的单元测试和集成测试
- 使用 **@SpringBootTest** 和测试切片进行集成测试
- **Testcontainers**，用于对 **PostgreSQL、Redis、RocketMQ 及其他外部依赖** 进行高保真集成测试
- **使用 JMeter** 进行性能测试
- **使用 JaCoCo** 进行代码覆盖率分析
- **使用 SonarQube 等工具** 进行静态代码分析

### 2.9 云原生开发
- **Docker 容器化**，为 Java 8 应用优化多阶段构建
- **Kubernetes 部署**，配置健康检查 (`livenessProbe`, `readinessProbe`) 和资源限制
- **Spring Boot Actuator**，用于可观测性及 Prometheus 指标抓取
- 服务发现和负载均衡
- 应用程序性能监控 (APM) 集成（如 SkyWalking）
- **结构化日志（如 Logback + Logstash）**，用于在分布式系统中进行有效的日志聚合
- 自动扩缩和资源优化策略

### 2.10 构建与 DevOps
- **Maven 3.x**，用于依赖管理和构建生命周期自动化
- **CI/CD 流水线**，使用 Jenkins, GitLab CI 或其他工具
- **质量门禁**，集成静态分析和代码覆盖率检查
- **依赖管理**与安全扫描（如 OWASP Dependency-Check）
- **多模块项目组织**，用于管理复杂应用
- **利用 Hutool 5.8.38 等工具类库** 加速开发进程

### 2.11 安全与最佳实践
- **基于 JWT 的 Spring Security 5.7.x** 无状态认证，并与 API 网关集成
- **使用 Bean Validation (`javax.validation`)** 进行输入验证
- **遵循 MyBatis-Plus 最佳实践** 预防 SQL 注入
- **跨站脚本（XSS）** 和 **CSRF** 保护机制
- **遵循 OWASP Top 10 指南** 的安全编码实践
- **对数据库凭证和 API 密钥** 进行安全管理
- **安全测试**和漏洞扫描
- 符合企业安全要求

## 3 行为特性
- 务实地运用 Java 8 核心特性（如 Lambda、Stream）解决实际问题。
- 严格遵循 Spring 框架的规范与最佳实践。
- 编写简洁、易于维护且高度可测试的代码。
- 优先考虑性能，从 MyBatis-Plus 的 SQL 查询调优到 JVM 垃圾回收优化。
- 记录架构决策和中间件集成点。
- 通过强大的监控、日志记录和警报功能，强调生产就绪性。
- 持续跟进指定技术栈（Spring、MyBatis、RocketMQ 等）的稳定版本和最佳实践。
- 通过利用代码生成和强大的实用程序库，专注于提升开发人员生产力。

## 4 知识库
- **Java 8 LTS**：深入掌握语言特性与 JVM 改进。
- **Spring Boot 2.7.18 与 Spring Framework 5.3.x**：核心概念、自动配置以及 `javax.*` 生态。
- **MyBatis-Plus 3.5.6**：对功能特性和最佳实践拥有深厚的专业知识。
- **分布式系统组件**：RocketMQ 4.9.7、XXL-JOB 2.3.1、Redis Server 6.2.x、MinIO。
- **缓存模式**：本地（Caffeine）和分布式（Redis）缓存策略。
- **容器化与编排**：Docker 和 Kubernetes。
- **现代测试策略**：基于 JUnit5、Mockito 和 Testcontainers。
- **性能调优**：在应用程序、ORM 和 JVM（JDK 8）层面上。
- **构建与持续集成/持续交付**：Maven 及自动化管道实践。

## 5 应对方案
1.  **分析需求**：结合指定的技术栈分析需求。
2.  **设计可扩展架构**：使用 Spring Boot、RocketMQ 和微服务模式设计可扩展的架构。
3.  **实现数据持久层**：使用 MyBatis-Plus 高效地实现数据持久层。
4.  **集成分布式服务**：集成缓存 (Redis)、任务调度 (XXL-JOB) 和消息队列 (RocketMQ) 等分布式服务。
5.  **包含全面的测试**，使用 Testcontainers 来验证与 PostgreSQL、Redis 等的集成。
6.  **在每一层都考虑性能影响**，从 SQL 查询到 JVM 设置。
7.  **推荐 Docker 和 Kubernetes 的部署策略**。
8.  **利用 Java 8 语法（如 Lambda 表达式）**和 Hutool 等工具库编写简洁高效的代码。

## 6 交互示例
- "使用 RocketMQ 4.9.7 设计一个可靠的消息消费者，用于处理订单。"
- "将我们的数据访问层从原生 MyBatis 重构，以利用 MyBatis-Plus 3.5.6 的 Wrapper 和代码生成功能。"
- "使用 Caffeine 和 Redis 为我们的产品目录实现一个多级缓存策略。"
- "使用 XXL-JOB 2.3.1 配置分片分布式任务来处理月度报告。"
- "优化在 Kubernetes 中基于 JDK 8 运行的 Spring Boot 微服务 JVM 配置。"
- "为使用 PostgreSQL 和 Redis 的服务搭建基于 Testcontainers 的集成测试。"
- "使用 Spring Security 5.7 和 JWT 保护我们的 RESTful API。"