2026-02-05

发布时间 : 2026-04-21 01:00

02月05日

02月05日

一、今日完成情况

完成K8S学习内容和工作路径的梳理，快速梳理网课。需要从宏观上理解K8S的架构和对于开发者来说的要求。同时梳理Java开发的快速上手路径。
- 我发现学到K8S是高端课程了，房子地基还是要打好，打好就是Java基础了。
预定–完成知识图谱代码原理的快速上手、可视化代替软件的寻找、实体是否可代替的尝试

二、今日感悟

核心业务数据：
- Java开始正式上手了，今天执行的事具体内容的学习。
- 之前AI工具基础已经打的差不多了，在“器”方面目前的进度来说，需要结合具体的项目来推进，Java基础学习正式开始。
今日工作总结：
- Java的项目架构，就和cmake配置文件一样，我需要上手，这个是总览全局的
明日工作计划：
- Java执行安装包的项目第一个代码上手，导出笔记。
今日学习成长：
- 无

三、备注

四、K8S需要学习要点（AI生成）

第一阶段：宏观理解与核心概念 (建立世界观)

这个阶段的目标是理解 K8S 是什么，解决了什么问题，以及它的基本工作方式。

为什么需要 K8S？
- 理解容器化（Docker）解决了“环境一致性”问题。
- 理解 K8S 作为容器编排工具，解决了“大规模容器管理”的问题，比如：服务发现、自动扩缩容、故障自愈。
K8S 核心架构（宏观理解即可）
- Master 节点 (控制平面): 集群的大脑，负责管理和决策。
- Worker 节点 (工作节点): 真正运行你的应用程序容器的地方。
- 关键组件概念: 知道 etcd 是数据库，API Server 是入口，Scheduler 负责调度，Controller Manager 负责控制。你不需要深入，但要听得懂这些名词。

第二阶段：开发者必会的核心对象 (动手实践的基础)

这是你需要重点学习和实践的部分，也是你作为开发者与 K8S 交互的主要内容。

Pod:
- 是什么: K8S 中最小的部署单元，可以把它看作是运行你的 Java 应用容器（或其他容器）的一个“豆荚”。
- 学习重点: 理解一个 Pod 可以包含一个或多个容器，以及为什么通常一个 Pod 只放一个主应用容器。
Deployment:
- 是什么: 管理 Pod 的“控制器”。这是你最常用的对象。
- 学习重点: 如何通过 Deployment 来部署你的 Java 应用、如何定义期望的副本数量（比如运行3个实例）、以及如何实现应用的滚动更新（不中断服务升级版本）。
Service:
- 是什么: 为一组 Pod 提供一个统一、稳定的访问入口。
- 学习重点: 如何通过 Service 将你的 Java 应用（比如一个 API 服务）暴露给集群内部的其他服务，或者暴露到集群外部让用户访问。理解 ClusterIP (对内) 和 NodePort (对外) 的区别。
ConfigMap & Secret:
- 是什么: 将配置和敏感信息（如数据库密码）从你的 Java 应用代码中解耦出来的工具。
- 学习重点: 如何将 application.properties 或 application.yml 文件的内容放入 ConfigMap，然后挂载到 Pod 中供你的 Spring Boot 应用读取。Secret 用法类似，但用于密码等敏感数据。

第三阶段：开发者核心工具与实践

编写 Dockerfile:
- 目标: 将你的 Java 应用（例如一个 Spring Boot 项目生成的 .jar 包）打包成一个 Docker 镜像。这是部署到 K8S 的前提。
编写 YAML 文件:
- 目标: 学会用 YAML 格式来定义上面提到的 Deployment、Service 等 K8S 对象。这是你向 K8S “下指令”的方式。
kubectl 命令行工具:
- 目标: 掌握开发者最常用的几个命令，用于部署和排错。
- 必会命令:
  - kubectl apply -f your-app.yaml: 应用（部署/更新）你的 YAML 配置。
  - kubectl get pods,svc,deployment: 查看你部署的应用的状态。
  - kubectl logs <pod-name>: 查看你的 Java 应用打出的日志，排查问题必备。
  - kubectl describe pod <pod-name>: 查看 Pod 的详细信息，用于诊断启动失败等问题。
  - kubectl exec -it <pod-name> -- /bin/sh: 进入容器内部，用于临时调试。

总结一下你的看课策略：

跳过: 过于深入的 K8S 集群安装、网络模型（如 CNI）、存储（PV/PVC 早期可跳过）等纯运维内容。
聚焦: 重点观看讲解 Pod, Deployment, Service, ConfigMap 的章节。
实操: 跟着视频，亲手为你的一个简单 Java 项目编写 Dockerfile 和 YAML 文件，并使用 kubectl 命令把它部署到本地的 K8S 环境中（例如 Docker Desktop 自带的 K8S 或 Minikube）。

按照这个路径，你就能快速抓住作为 Java 开发者最需要掌握的 K8S 技能，高效地完成今天的学习任务。

五、spring boot学习链接

https://docs.spring.io/spring-boot/docs 这是原文文档，练习看英文文档的能力是我们一定需要学习的。

https://heuqqdmbyk.feishu.cn/wiki/LYVswfK4eigRIhkW0pvcqgH9nWd 这是前后端Java web的基础课程，属于我早期需要学习的部分。

这个项目我比较感兴趣的原因是，这个教材不是按照Java的语法开始的，是直接从具体的项目开始的，解决了我“为什么要学”的疑问，从而学习可以更加直观有动力。

Java学习路径：

学习顺序就是javase、mysql、jdbc、javaweb、mybatis、springmvc、spring，这几样基本上就是学习java的骨架。

Java SE（Java Platform, Standard Edition）是 Java 平台的标准版本，它为开发桌面、服务器端和嵌入式应用程序提供了核心的 API 和工具。Java SE 包括 Java 的基本库、Java 虚拟机（JVM）、编译器等核心组件。它是 Java 开发的基础，几乎所有的 Java 应用都建立在 Java SE 的基础上。
我就理解为C++ 的STL容器了

JDBC（Java Database Connectivity）是==Java平台中用于连接和处理关系型数据库的标准化API==。它由一组Java类和接口组成（主要在java.sql包中），允许Java程序执行SQL语句、访问数据库、并处理查询结果。它是Java连接各种数据库（如MySQL, Oracle）的统一规范，不依赖特定数据库类型。
我就理解为数据库的Java标准API接口了

MyBatis 是一款优秀的基于 Java 的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码、参数手动设置和结果集检索，通过简单的 XML 或注解配置，将 POJO（普通老式 Java 对象）映射为数据库记录。
不理解，问一下AI吧。

JavaWeb 是指利用 Java 技术栈开发基于互联网（Web）的应用程序，主要用于构建服务器端的动态网站、Web 应用系统及 RESTful 服务。它通过 HTTP 协议与前端进行交互，基于 JavaEE（现 Jakarta EE）规范，包含 Servlet、JSP、Tomcat 等核心技术及 Spring 等框架，是实现高并发、高性能企业级应用的核心技术。
负责解析前端的http请求的，这个很好理解。

SpringMVC是Spring Framework中基于Java的、实现了MVC设计模式的请求驱动类型轻量级Web框架。它利用DispatcherServlet来分发前端请求，通过分离模型(Model)、视图(View)和控制器(Controller)来简化Web开发，是目前主流的Java Web层框架。
这个是让web开发更快的封装好的库，简化开发步骤的。

Redis（Remote Dictionary Server）是一个开源的、基于内存的、高性能的键值（Key-Value）非关系型数据库。它主要用于作为应用程序的缓存、高速数据库、实时分析和消息队列，能够处理数万次/秒的读写请求，将延迟降低到微秒级。

关系型数据库和非关系型数据库的定义是什么？
- 关系型数据库（RDBMS）：用“表 + 固定结构 + 表之间的关系”来存数据的数据库，例如： MySQL / PostgreSQL / Oracle / SQL Server / SQLite
- 非关系型数据库（NoSQL）：不以“表和表之间的关系”为核心，结构灵活，通常为了解决规模、性能或灵活性问题而生，例如：Redis / MongoDB
这两种的区分依据是什么？
- 数据结构是否固定
  - 关系型：每一行都必须有属性如，id / name / age，如果需要改变就要ALTER TABLE
    - ALTER TABLE是什么？
      - 修改一张已经存在的表的结构，不是改数据内容，是改 表长什么样。比如加入一个新的数据，当中有新的属性，那table就要新增一个属性，扩展表。
  - 非关系型：每条数据结构可以不一样，字段经常变如，{ “name”: “Alice”, “age”: 18 }
- 是否强调「表与表之间的关系」join
  - join是什么，关系的定义是什么？
    - JOIN = 把两张（或多张）表，按“共同的字段”拼在一起看。表 A：学生名单，表 B：成绩表，用学号把“人”和“成绩”对上。
非关系型数据库可以如何区分？
- Key-Value（键值型），KV存储，非常热门：
  - Redis，Memcached都是，用于缓存。
- 文档型（Document）
  - 以MongoDB为例子，存储灵活，以JSON字段格式为主，表的结构不稳定。举例：{ “user”: “Alice”,”orders”: [ … ]}
- 列族型（Column-Family）不做展开
- 搜索 / 索引型不做展开

存储相关的学习必要性如下，现在主流的关系型数据库还是PostgreSQL为主，MySQL算是祖师爷，所以我还是打算PostgreSQL切入。

优先级	数据库类型	代表软件	建议学习深度
P0 (必修)	关系型数据库	MySQL 或 PostgreSQL	精通。包括建表、复杂联表查询、索引原理、事务隔离级别。
P1 (必修)	缓存数据库	Redis	熟练。掌握常用数据类型、分布式锁、缓存穿透/雪崩解决方案。
P2 (选修)	文档数据库	MongoDB	会用。了解其 CRUD 语法，知道什么场景下该选它而不是 MySQL。
P3 (进阶)	搜索引擎	Elasticsearch	了解。如果你要做复杂的全文搜索（类似百度、电商搜索），这个是标配。

六、Java学习顺序

好的，根据你今天的笔记 [[2026-02-05]]，我为你梳理出了一条清晰的 Java 开发学习路径，明确了学习顺序和每个阶段的重点。

这条路径完全基于你笔记中提到的技术栈，并结合了现代企业开发的普遍要求，可以帮你系统地构建知识体系。

Java 开发学习路径梳理

第一阶段：打好地基 —— 掌握核心语言

Java SE (Java Platform, Standard Edition)
- 定位： 这是所有 Java 技术的核心与基石，就像你理解的 “C++ 的STL容器” 一样，是基础中的基础。
- 学习重点：
  - 核心语法： 变量、流程控制、数组等。
  - 面向对象： 深刻理解封装、继承、多态。
  - 核心API： 熟练使用集合框架 (List, Set, Map)、IO流、多线程、网络编程。
  - JVM基础： 了解内存模型、垃圾回收机制。
- 学习目标：
  - 重点： 集合框架（ArrayList, HashMap，重中之重）、面向对象（接口、多态）、异常处理、IO流（读写文件）。
- 跳过： Swing/AWT（桌面画图，完全没用，千万别学）、多线程高阶（前期了解Thread即可，JUC并发包后面再补）。

第二阶段：掌握数据存储 —— 数据库技术

在学习如何用 Java 操作数据库之前，你需要先学会数据库本身。根据你笔记中的优先级表格，顺序如下：

关系型数据库 (P0 必修)
- 代表： MySQL 或 PostgreSQL。
- 学习重点：
  - 精通 SQL 语言，特别是复杂的联表查询 (JOIN)。
  - 理解索引的原理和优化方法。
  - 掌握事务（ACID）和不同的隔离级别。
- 学习目标：
  - 内容： SQL基础（CRUD） -> JDBC（只需了解原理，写一个Demo就扔掉） -> MyBatis（重点）。
- 项目结合： 试着把你的 TrendRadar 的新闻标题存入数据库，而不是只打印在屏幕上。
缓存数据库 (P1 必修)
- 代表： Redis。
- 学习重点：
  - 熟练掌握 Redis 的五种基本数据类型 (String, List, Set, Hash, ZSet)。
  - 理解其作为缓存的核心作用，用于提升应用性能。
  - 学习分布式锁、缓存穿透/雪崩等常见问题的解决方案。

第三阶段：连接程序与数据 —— 持久层技术

现在，你需要学习如何用 Java 代码去操作第二阶段学习的数据库。

JDBC (Java Database Connectivity)
- 定位： Java 连接数据库的“官方标准API接口”，是理解所有数据库框架的基础。
- 学习重点：
  - 理解其工作原理。
  - 能够使用原生 JDBC 代码完成对数据库的增删改查操作。
  - 了解 PreparedStatement 的作用，防止 SQL 注入。
MyBatis（重点）
- 定位： 一个优秀的持久层框架，让你告别繁琐的 JDBC 代码。
- 学习重点：
  - 学习如何通过简单的 XML 或注解来配置 SQL 语句。
  - 掌握动态 SQL 的用法，实现灵活的查询。
  - 将数据库表记录与 Java 对象（POJO）进行映射。

第四阶段：走向互联网 —— Web 开发

JavaWeb
- 定位： 让你的 Java 程序能够通过浏览器被访问，处理前端发来的 HTTP 请求。
- 学习重点：
  - 理解 HTTP 协议。
  - 掌握 Servlet、Filter、Listener 等核心组件。
  - 了解 Tomcat 等 Web 服务器的工作原理。

第五阶段：提升开发效率 —— 主流框架

这是现代 Java 开发的核心，也是企业招聘的重点。

Spring Framework
- 定位： Java 企业级开发的“事实标准”，是一个生态系统。
- 学习重点：
  - IoC (控制反转): 核心思想，用于解耦代码。
  - AOP (面向切面编程): 用于处理日志、事务等通用功能。
SpringMVC
- 定位： Spring 框架中用于 Web 开发的部分，是 JavaWeb 技术的封装和简化。
- 学习重点：
  - 学习如何使用注解 (@Controller, @RequestMapping, @ResponseBody 等) 来处理 Web 请求。
  - 掌握 MVC 设计模式，实现模型、视图、控制器的分离。
Spring Boot (强烈建议加入)
- 定位： Spring 的“脚手架”，极大地简化了 Spring 应用的开发和部署。
- 学习重点：
  - 约定优于配置： 理解其核心理念。
  - 自动配置： 学习其原理。
  - 起步依赖 (Starters): 快速集成各种第三方库。
  - 能够独立、快速地构建一个微服务。

修正观念： 不要单独花大量时间学 Spring 然后再学 SpringMVC。
直接学 Spring Boot： 它把 Spring、SpringMVC、Tomcat 全部打包好了。
- 学习如何写 Controller（接收请求）。
- 学习 Service（业务逻辑）。
- 学习 Dependency Injection (IOC，依赖注入，Spring的灵魂）。

总结

你的学习顺序规划得非常合理：Java SE -> 数据库 -> JDBC/MyBatis -> JavaWeb -> Spring/SpringMVC。

重点在于打好 Java SE 和 数据库 的基础，这决定了你的上限。
关键在于掌握 Spring Boot，这是目前企业开发的主流，能让你快速上手实际项目。

按照这个路径稳步前进，你的 Java 开发技能体系会非常扎实。

七、学习重点-考核标准

任务完成的过程当中，我们需要给自己设置一个可量化的完成标准，用来检验自己是否掌握，最好可视化。

我们为 Java SE 阶段 设定清晰、可检验的“成功节点”。

Java SE 阶段：成功节点与量化考核标准

总目标： 能够独立、规范地使用 Java 核心语法和 API，完成一个具备完整功能、代码结构良好的命令行应用程序。

我们将目标分解为三个层次：概念理解 -> 编码实现 -> 综合运用。

节点一：核心语法与面向对象基础 (约1-2周)

成功标志： 能用面向对象的思想，将现实问题抽象为类与对象。
量化考核标准：
1. 概念描述： 能口头或书面清晰解释以下概念，并举例说明：
  - 类与对象的区别。
  - 封装、继承、多态各自的目的和实现方式（用 private、extends、@Override 等关键词）。
  - 接口和抽象类的区别及使用场景。
2. 编码实现： 完成以下编程任务：
  - 任务1（封装与基础）： 定义一个 Student 类，包含 id、name、score 等私有属性，提供公有的 getter/setter 方法，并重写 toString() 方法。
  - 任务2（继承与多态）： 定义一个父类 Animal（有 name 属性和 makeSound() 方法），创建两个子类 Dog 和 Cat，重写 makeSound() 方法。编写一个测试类，使用父类引用指向子类对象，调用其方法，体验多态。
  - 任务3（接口）： 定义一个 Swimmable 接口，内含 swim() 方法。让 Dog 类实现此接口。

节点二：核心API熟练运用 (约2-3周)

成功标志： 能在程序中熟练、正确地选择并使用集合、处理异常、进行文件操作。
量化考核标准：
1. 集合框架（重中之重）：
  - 编码任务： 编写一个“学生管理系统”的核心数据层（仅内存操作，无需数据库）。
    - 使用 HashMap<Integer, Student> 来存储学生，键为学号，值为 Student 对象。
    - 实现增、删、改、查功能。
    - 能根据分数，使用 ArrayList<Student> 配合 Collections.sort() 进行排序。
    - 必须能解释： ArrayList 和 LinkedList 在增删改查上的性能区别；HashMap 的 put/get 操作大致原理（哈希、链表/红黑树）。
2. 异常处理：
  - 在上述学生管理系统中，对所有用户输入（如学号格式、成绩范围）进行校验，遇到非法输入时，使用 try-catch 捕获并抛出自定义的业务异常（如 InvalidScoreException），并在最外层进行统一处理，给出友好提示。
3. IO流：
  - 编码任务： 为上述学生管理系统增加“数据持久化”功能。
    - 程序启动时，从 students.data 文本文件中加载所有学生信息到 HashMap。
    - 程序退出前，将 HashMap 中的所有学生信息保存回 students.data 文件。
    - （进阶）使用序列化/反序列化（ObjectInputStream/ObjectOutputStream）来读写对象。

节点三：综合实战项目 (约1周)

成功标志： 整合前两个节点的所有知识，完成一个结构清晰、运行稳定、可扩展的小型项目。
量化考核项目：控制台版“新闻热点追踪系统(TrendRadar CLI)”
- 项目需求：
  1. 新闻条目用 News 类表示，属性：id, title, content, source, publishTime, hotScore（热度分）。
  2. 数据存储： 使用 HashMap<Integer, News> 在内存中存储新闻。启动时从文件加载，退出时保存。
  3. 核心功能：
    - 新增新闻：输入新闻信息，计算初始热度分。
    - 浏览新闻：按热度分(hotScore)降序输出所有新闻标题和分数。
    - 查看详情：根据ID查看某条新闻的完整内容。
    - 模拟热度更新：提供一个“过一天”功能，随机增加或减少某些新闻的热度分。
    - 删除旧闻：删除热度分低于某个阈值的新闻。
  4. 代码规范：
    - 合理分包（如 com.趋势雷达.model, com.趋势雷达.service, com.趋势雷达.util）。
    - 使用面向接口编程，例如定义 NewsService 接口和其实现类 NewsServiceImpl。
    - 所有用户输入处均有异常处理，程序不会因输入错误而崩溃。
    - 使用 Log4j 或 SLF4J 记录关键操作日志（如“新闻已添加”、“热度已更新”），而不是只使用 System.out.println。
- 验收标准（你的检查清单）：
  - 项目能成功编译和运行。
  - 增、删、查、排序、持久化五大功能全部实现且工作正常。
  - 代码结构分为 model, service, main 等包，职责清晰。
  - 使用了接口和实现类进行解耦。
  - 自定义了至少一种业务异常（如 NewsNotFoundException）。
  - 程序日志被正确记录到文件或控制台。
  - 你能够向别人（或未来的自己）清晰地讲解这个项目的核心类设计和主要执行流程。

八、Java环境配置

1、紧凑包结构的“误会”

问题显示：

新建的Java文件架构如下，可是Main报错信息如下：

这是一个可爱的报错，是路径问题，这个架构需要解析一下，pom.xml是配置Java包的依赖的，算是一个总览全局的配置文件。

Main.java 代码中，你写了 package org.example;。但在你的项目目录结构（左侧边栏）中，你的 Main.java 是直接放在 java 文件夹下的，而不是放在 org/example 文件夹里。

Java 的规则： 如果声明包名是 org.example，那么物理路径必须是 src/main/java/org/example/Main.java。

可是为什么看上去是一个’.’ ，而不是org/example 的文件结构呢？

在 Java 的物理磁盘结构中，.（点）就代表了路径的分隔符 /。

代码中： package org.example;
磁盘上： src/main/java/org/example/（即 java 文件夹里有一个 org 文件夹，org 里面有一个 example 文件夹）。

IDEA 发现你的 org 文件夹里只有 example 这一个子文件夹，为了节省左侧栏的横向空间，它会把这两个文件夹“合并”显示为 org.example。

绝对路径下：
“Users/kipley/Documents/code/Java/JavaSE01_01/src/main/java/org/example/Main.java”

彻底解决办法：关闭“紧凑包结构”：

为了让你像在 Finder 中一样直观地管理目录，请务必执行以下操作：

在左侧 Project 面板的右上角，点击 三个点 ⋮（或者 齿轮图标 ⚙️）。
找到 Tree Appearance（树外观）选项。
取消勾选 “Compact Middle Packages” (紧凑中间包)。

操作后的变化： 你会发现 org 和 example 变成了上下级的嵌套关系。现在，如果你想在 org 下面创建一个并行的包（比如 org.util），你只需要在 org 这个文件夹上右键点击 New -> Package 即可。

可以看到，已经修改过来了。

### 2、目录结构梳理

A、标准 Maven 目录结构：

src/main/java: 放置所有生产环境的 Java 源代码。
src/main/resources: 放置配置文件（如 .properties, .yaml）、SQL 脚本等非 Java 文件。
src/test/java: 放置测试代码（JUnit 等）。永远不要把测试代码写在 main 目录下。

B、变量命名规范：

Java 极度依赖命名来区分不同的组件。

包名 (Packages): 全部小写。通常采用反向域名，如 com.caprina.project。
类名 (Classes): 大驼峰命名法 (PascalCase)。每个单词首字母大写，如 SystemMonitor 或 DataAnalyzer。
方法名与变量名: 小驼峰命名法 (camelCase)。首字母小写，后续单词首字母大写，如 getCpuUsage() 或 maxRetryCount。
常量: 全部大写，单词间用下划线分隔，如 MAX_THREADS。

C++ 迁移小贴士： Java 社区几乎不使用 snake_case（下划线命名），除非是静态常量。

C、pom.xml包管理文件

默认配置

默认我的项目的文件内容：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>org.example</groupId>  
  <artifactId>JavaSE01_01</artifactId>  
  <version>1.0-SNAPSHOT</version>  
  <name>Archetype - JavaSE01_01</name>  
  <url>http://maven.apache.org</url>  
</project>

参数解释：

标签	含义	规范建议
`<modelVersion>`	POM 模型版本	必须为 `4.0.0`，这是 Maven 2 和 3 的标准。
`<name>`	项目显示名称	给开发人员看的“友好名称”，可以包含空格和特殊字符。
`<url>`	项目主页	通常指向 GitHub 仓库或官方文档地址。
`<properties>`	属性配置	规范必修：用于统一定义 Java 版本、源码编码（UTF-8）等。
`<dependencies>`	依赖管理	用于声明项目引用的第三方库（如 Lombok, Spring Boot）。

Maven 的核心逻辑：自动化的仓库管理。 当你把一段 XML 代码（依赖坐标）贴进 pom.xml 时，Maven 会执行以下动作：

自动下载：去互联网上的“中央仓库”寻找对应的 .jar 文件。
自动管理：把它下载到你 Mac 本地的 .m2 隐藏文件夹里。
自动关联：把这个库加入到 IDEA 的 Classpath（类路径）中，这样你在写代码时就能 import 它们了。

安装包配置来源

全世界的 Java 开发者都去同一个地方找：
mvnrepository.com

操作流程：

在搜索框输入你想要的库名（如 MySQL 或 Fastjson）。
选择使用人数最多的那个版本。
点击 Maven 选项卡，直接点击代码框，它会自动复制那段 XML。
回到 IDEA，贴进你的 pom.xml。

依赖配置方法

系统性记忆法则：XML 的“套娃”规范：

Root (根节点) -> Container (复数容器) -> Element (单数元素)

管理依赖：<dependencies> 里面套 <dependency>。
管理插件：<plugins> 里面套 <plugin>。
管理版本变量：<properties> 里面套具体的变量名（如 <java.version>21</java.version>）。

举例dependency嵌套：

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.30</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

架构示例

<project>
    <groupId>...</groupId>
    <artifactId>...</artifactId>

    <dependencies>
        <dependency>...</dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>...</plugin>
        </plugins>
    </build>
</project>

可以看到 dependencies 和 build 的架构是并行的，plugins插件是放在build里面的，这个架构需要记住。

标签介绍（groupId，artifactId）：

Dependencies (依赖) —— “食材”：

位置：直接放在 <project> 下的 <dependencies> 容器里。
作用：这些是你写代码时要用到的库。
例子：如果你要处理 JSON，你把 Jackson 库放进这里。你的代码里会写 import com.fasterxml.jackson...。
结局：它们会被打包进你的程序里，跟着你的代码一起运行。

Plugins (插件) —— “厨具/加工工具”

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration> <source>21</source> <target>21</target></configuration>
</plugin>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>21</source> <target>21</target>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>org.example.Main</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

标签	官方解释	大白话类比 (以手机为例)	规范建议
`<groupId>`	项目组/组织 ID	品牌名/厂商名 (如：Apple)	通常是公司的反向域名。例如你的 `org.example`，或者 `com.google`。
`<artifactId>`	项目 ID	型号/产品名 (如：iPhone16)	具体的项目名称。建议用小写字母和中划线，如 `server-monitor`。

D、git文件：

.git文件是用来github上传的，里面存放的是：

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 kipleyarch@gmail.com