新手小白开发全过程-day4

x

摆烂一个月我又回来了，其实是下午要被拷打没招了

虽然我啥都不知道，但我有勇气去现眼哈哈哈哈哈哈哈哈哈哈哈哈，无所谓反正就见一面

恢复一下丢失的记忆，起码知道我写的代码有哪些功能

首先配置Maven多模块项目的父pom文件

<modelVersion>4.0.0</modelVersion> //指定当前 Maven 项目使用的 POM 模型版本。
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.3</version>
    <relativePath/> <!-- lookup parent from repository -->
    //告诉 Maven：“不要在本地找父项目，直接去 Maven 仓库下载”
    //如果不写，Maven 会先在本地找，找不到再去仓库，加这行是最佳实践
</parent>

让 Maven 项目继承 Spring Boot 官方提供的 “父项目”

Spring Boot 官方写了一个 “万能模板父类”（spring-boot-starter-parent），只需要 “继承” 这个模板，就不用自己手写大量重复的 Maven 配置

<parent>...</parent> 整个标签

• 核心作用：声明当前项目是一个 “子项目”，继承自 Spring Boot 官方的父项目。
• 类比：就像 Java 里 class A extends B，A 会继承 B 的属性和方法；这里你的项目会继承 spring-boot-starter-parent 的依赖版本、插件配置等。

继承父项目后，只需要写核心依赖，版本会自动继承父项目的 2.7.3：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 不用写version，自动用父项目的2.7.3 -->
</dependency>

<properties> 配置是 Maven 里的依赖版本统一管理，先把各个第三方依赖的版本号定义成变量，后续在 <dependencies> 里引用这些变量即可，避免重复写版本号

<properties>
    <mybatis.spring>2.2.0</mybatis.spring> //写 DAO 层代码，操作数据库（替代 JDBC 手写 SQL）
    <lombok>1.18.38</lombok>  //实体类（User、Order）、工具类，少写几百行重复代码
    <fastjson>1.2.76</fastjson> //接口返回 JSON 数据、接收前端 JSON 参数、解析第三方接口的 JSON 响应
    <commons.lang>2.6</commons.lang>  //替代手写的判空、字符串处理逻辑，避免重复造轮子
    <druid>1.2.1</druid>  //项目中配置数据库连接时使用
    <pagehelper>1.3.0</pagehelper>  //列表查询（如用户列表、订单列表）时，实现 “分页展示” 功能
    //当时配置想模仿苍穹外卖的分页查询查询比赛目录
    //当时还没看接口文档，或者说不知道要按照接口文档返回数据
    //只看项目介绍畅想设计了
    <aliyun.sdk.oss>3.10.2</aliyun.sdk.oss>
    <knife4j>3.0.2</knife4j> //前后端对接时，前端开发者直接看文档、调接口，不用手写接口文档
    <aspectj>1.9.4</aspectj>  //比如给所有接口加 “请求日志”，给增删改加 “事务”，不用在每个方法里写重复代码
    //主要在aop上使用，但是因为我aop没学会所以也没用
    //比如传统写法在每一行后都要加loginfo，但是如果我在server包的java包的aspect包里面声明一个AUtoFillAspect类，定义了切点，前置通知，后置返回和异常通知，然后在Controller接口就会自动记录 请求开始，正常返回，异常 的日志
    <jjwt>0.9.1</jjwt>//前后端分离项目中实现 “无状态登录”（比如登录后返回 token，后续请求带 token 验证身份）
    <jaxb-api>2.3.1</jaxb-api> //解析 XML 格式的数据，或 JJWT 生成 token 时的序列化 / 反序列化
    <poi>3.16</poi> //生成 Excel 报表（比如导出订单数据）
    //项目中需要 “Excel 导入导出” 功能时使用
    //这是当时纯cv苍穹外卖的，不知道用途直接抄过来了
    
</properties>

“轮子”：就是那些通用、基础、别人已经写好并验证过的功能（比如字符串判空、数组排序）。

Maven：构建工具（辅助）

• 本质：基于 Java 开发的工具（本身也是 Java 程序），核心是 pom.xml 配置文件；

核心功能：

• 依赖管理：比如你要用到 Spring，只需在 pom.xml 写 <dependency>，Maven 自动下载 Spring 的 jar 包，不用手动下载复制；
• 项目构建：一键执行 mvn clean package，自动编译代码、打包成 jar/war 包；
• 生命周期管理：统一编译、测试、打包、部署的流程，团队协作时规范一致。

关键区别：Maven 不参与业务逻辑编写，只负责 “项目的构建和依赖管理”，没有 Maven 也能开发 Java 项目（手动下载 jar 包、手动编译），但效率极低。

# 执行 mvn clean package 命令时，Maven 做的事：
1. 清理：删除 target 目录（旧的编译/打包文件）；
2. 解析 pom.xml：读取依赖（如 spring-boot-starter-web）、插件配置；
3. 下载依赖：检查本地仓库是否有对应 jar 包，没有就从中央仓库下载；
4. 编译：把 src/main/java 下的 Java 代码编译成 class 文件，存入 target/classes；
5. 测试：编译并运行 src/test/java 下的测试代码；
6. 打包：把编译后的 class 文件+依赖打包成 jar/war 包，存入 target 目录。

Spring：开发框架（提升效率）

• 本质：基于 Java 语言编写的一套类库（jar 包），核心是 IOC（控制反转）和 AOP（面向切面编程）；
• 核心功能
  • 简化对象管理：IOC 容器帮你创建、管理对象（Bean），不用手动 new；
  • 简化通用功能：AOP 实现日志 / 事务 / 权限的统一处理，声明式事务 @Transactional 一行搞定；
  • 生态丰富：Spring Boot（快速开发）、Spring Cloud（微服务）、Spring MVC（接口开发）等，覆盖企业开发全场景。

手动 new 对象 vs Spring 管理 Bean

手动 new 对象（无 Spring）	Spring 管理 Bean（IOC 容器）
开发者手动创建对象：UserService userService = new UserService();	开发者告诉 Spring “要管理这个类”，由 Spring 容器创建对象；
开发者手动管理对象的生命周期（创建、销毁）	Spring 容器自动管理 Bean 的生命周期（初始化、销毁）；
开发者手动注入依赖：userService.setUserDao(new UserDao());	Spring 容器自动注入依赖（@Autowired）；

标记为 Bean 的类，若依赖其他 Bean，只需在变量上添加 @Autowired

@Service/@Repository/@Controller 本质是 @Component 的 “别名”

配置application.yml是springboot的默认配置文件，属于误打误撞了，现在才知道，之前觉得yml格式规整就没用.properties格式

正常顺序是在main包下面创建java和resources包，re包下面配置yml，xml，static和templates文件

static是静态文件目录，templates是模板文件目录

源码目录结构是：

src/main/java
└── com
    └── itranswarp
        └── learnjava
            ├── Application.java
            ├── entity
            │   └── User.java
            ├── service
            │   └── UserService.java
            └── web
                └── UserController.java

阶段1：设置值（Java内部）
competition.setCreateTime(LocalDateTime.now())  
    ↓
competition对象中 createTime = LocalDateTime对象(2026-03-08T09:40:08)
    ↓
【此时数据还在Java内存中，是LocalDateTime类型，不是字符串】

阶段2：返回给前端（序列化）
controller返回 competition对象
    ↓
Spring调用消息转换器
    ↓
JacksonObjectMapper工作
    ↓
LocalDateTime → "2026-03-08 09:40:08"  ← 格式化在这里发生
    ↓
JSON字符串返回给前端

先获取时间存到java内存里，发送json时再用webmvc捕获然后转换

service层为什么长这样，为什么不直接再service实现业务代码

这种结构，是 面向接口编程（Interface-Oriented Programming） 的典型实践

1. 解耦（核心价值）

• 接口（如 PlayerService）：只定义 “能做什么”（方法签名），不关心 “怎么做”。
• 实现类（如 PlayerServiceImpl）：负责具体的业务逻辑实现。
• 这样一来，Controller 层只依赖 PlayerService 接口，而不依赖具体的 PlayerServiceImpl。如果以后需要替换实现（比如从 MySQL 换成 MongoDB，或者重构业务逻辑），只需要新增一个实现类，Controller 层代码完全不用改。

2. 便于扩展和多实现

同一个接口可以有多个实现类，应对不同场景：

• 例如：ManageTeamService 可以有 ManageTeamServiceImpl（正式环境实现）和 ManageTeamServiceMockImpl（测试环境模拟实现）。
• 这在微服务、插件化开发中尤为重要。

3. 便于单元测试

• 依赖接口后，可以使用 Mock 框架（如 Mockito）轻松模拟一个 PlayerService 的实现，而不需要启动整个 Spring 容器或连接真实数据库，就能对 Controller 进行单元测试。

4. 符合 “开闭原则”

• 对扩展开放，对修改关闭。新增业务逻辑时，优先新增实现类或扩展接口，而不是修改原有代码，降低了引入 Bug 的风险。