Java Web 笔记

浏览器 / 前端页面 / Postman
        ↓ 发送 HTTP 请求
Tomcat / Spring Boot 内置服务器
        ↓ 找到对应的接口
Controller
        ↓ 调用业务逻辑
Service
        ↓ 操作数据库
Mapper / DAO
        ↓ 返回数据
浏览器 / 前端页面 / Postman

fetch("/user?name=张三&age=18")
    .then(response => response.json())
    .then(data => console.log(data));

axios.get("/user", {
    params: {
        name: "张三",
        age: 18
    }
});

axios.post("/user", {
    name: "张三",
    age: 18
});

@GetMapping("/user/{id}")
public User getUser(@PathVariable Integer id) {
    return userService.getUserById(id);
}

@PostMapping("/user")
public String addUser(@RequestBody User user) {
    userService.addUser(user);
    return "success";
}

传统 Java Web：
Java Web 项目 → 打成 war 包 → 部署到外部 Tomcat → 启动 Tomcat

Spring Boot：
运行 main 方法 → 自动启动内置 Tomcat → 接收 HTTP 请求

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        String name = request.getParameter("name");
        response.getWriter().write("hello " + name);
    }
}

@GetMapping("/hello")
public String hello(String name) {
    return "hello " + name;
}

HTTP 请求
   ↓
Tomcat 接收请求
   ↓
Servlet 体系处理请求
   ↓
Spring MVC 分发请求
   ↓
Controller 方法执行
   ↓
返回 JSON / 字符串 / 页面

Controller：接收请求、校验参数、返回结果
Service：处理业务逻辑
Mapper / DAO：操作数据库
Entity / POJO：封装数据对象

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Integer id) {
        return userService.getUserById(id);
    }
}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Integer id) {
        return userMapper.selectById(id);
    }
}

@GetMapping("/user")
public String getUser(String name, Integer age) {
    return name + ":" + age;
}

GET http://localhost:8080/user?name=张三&age=18

{
  "name": "张三",
  "age": 18
}

http://localhost:8080

http://localhost:8080/user?name=张三&age=18

前端 Vue / Axios
        ↓ HTTP 请求
Controller：接收请求、参数校验、返回结果
        ↓
Service：业务逻辑、事务、规则判断
        ↓
Mapper / DAO：数据库操作
        ↓
MySQL / Redis / ES

前端 Axios 请求
→ Tomcat 接收 HTTP 请求
→ 封装 HttpServletRequest / HttpServletResponse
→ Filter 过滤器链
→ DispatcherServlet
→ HandlerMapping 查找 Controller 方法
→ 得到 HandlerExecutionChain
→ Interceptor.preHandle
→ HandlerAdapter 调用 Controller
→ 参数绑定 / 类型转换 / JSON 转对象 / 参数校验
→ Controller 调用 Service
→ Service 调用 Mapper / Redis / 其他组件
→ Controller 返回 Result<T>
→ HttpMessageConverter 把 Java 对象转 JSON
→ Interceptor.postHandle / afterCompletion
→ Tomcat 返回 HTTP 响应
→ 前端拿到 JSON 更新页面

@RestController
@RequestMapping("/users")
public class UserController {
}

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public Result<UserVO> getById(@PathVariable Long id) {
        return Result.success(userService.getById(id));
    }
}

GET /users/{id}

GET /users?page=1&size=10&keyword=tom

@GetMapping("/users")
public Result<List<UserVO>> list(@RequestParam(defaultValue = "1") Integer page,
                                 @RequestParam(defaultValue = "10") Integer size,
                                 @RequestParam(required = false) String keyword) {
    return Result.success(userService.list(page, size, keyword));
}

GET /users/1001

@GetMapping("/users/{id}")
public Result<UserVO> getById(@PathVariable Long id) {
    return Result.success(userService.getById(id));
}

{
  "username": "admin",
  "password": "123456"
}

@PostMapping("/login")
public Result<LoginVO> login(@RequestBody LoginDTO dto) {
    return Result.success(userService.login(dto));
}

HTTP 请求体 JSON
→ HttpMessageConverter
→ Jackson ObjectMapper
→ Java DTO 对象

@GetMapping("/profile")
public Result<UserVO> profile(@RequestHeader("Authorization") String token) {
    return Result.success(userService.profile(token));
}

@GetMapping("/test")
public Result test(@CookieValue("JSESSIONID") String sessionId) {
    return Result.success(sessionId);
}

@GetMapping("/users/{id}")
public Result<UserVO> getById(@PathVariable Long id) {
    UserVO user = userService.getById(id);
    return Result.success(user);
}

public class Result<T> {
    private Integer code;
    private String message;
    private T data;
}

{
  "code": 200,
  "message": "success",
  "data": {
    "id": 1,
    "username": "tom"
  }
}

public class LoginDTO {

    @NotBlank(message = "用户名不能为空")
    private String username;

    @NotBlank(message = "密码不能为空")
    private String password;
}

@PostMapping("/login")
public Result<LoginVO> login(@Valid @RequestBody LoginDTO dto) {
    return Result.success(userService.login(dto));
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public Result<Void> handleRuntimeException(RuntimeException e) {
        return Result.fail(e.getMessage());
    }
}

if (user == null) {
    throw new RuntimeException("用户不存在");
}

请求
→ Interceptor.preHandle
→ Controller
→ Interceptor.postHandle
→ Interceptor.afterCompletion
→ 响应

@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) {
        String token = request.getHeader("Authorization");

        if (token == null || token.isEmpty()) {
            throw new RuntimeException("未登录");
        }

        return true;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/users/login", "/users/register");
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Integer id) {
        return userService.getUserById(id);
    }
}

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public User getUser(@PathVariable Integer id) {
        return userService.getUserById(id);
    }

    @GetMapping
    public List<User> listUsers(@RequestParam(required = false) String name) {
        return userService.listUsers(name);
    }

    @PostMapping
    public String addUser(@RequestBody User user) {
        userService.addUser(user);
        return "success";
    }
}

@RestController
public class UserController {

    @Autowired
    private UserService userService;
}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
}

@Mapper
public interface UserMapper {

    User selectById(Integer id);
}

@Component
@Service
@RestController
@Controller
@Repository

@GetMapping("/users")
public List<User> list(@RequestParam String name) {
    return userService.listByName(name);
}

@GetMapping("/users/{id}")
public User get(@PathVariable Integer id) {
    return userService.getUserById(id);
}

@PostMapping("/users")
public String add(@RequestBody User user) {
    userService.addUser(user);
    return "success";
}

@Service
public class UserService {
}

@GetMapping("/users/{id}")
public User getUser(@PathVariable Integer id) {
    return userService.getUserById(id);
}

客户端：浏览器 / 前端页面 / Postman
        ↓ 发送 HTTP Request
服务器：Spring Boot / Tomcat
        ↓ 处理请求
客户端：接收 HTTP Response

GET /user?id=1 HTTP/1.1
Host: localhost:8080
User-Agent: Chrome
Accept: application/json

POST /user HTTP/1.1
Host: localhost:8080
Content-Type: application/json

{
  "name": "张三",
  "age": 18
}

@GetMapping("/users/{id}")
public User getUser(@PathVariable Integer id) {
    return userService.getUserById(id);
}

@PostMapping("/users")
public String addUser(@RequestBody User user) {
    userService.addUser(user);
    return "success";
}

GET /users?name=张三&age=18

GET /users/1001

{
  "name": "张三",
  "age": 18
}

Content-Type: application/json

Content-Type: application/x-www-form-urlencoded

HTTP/1.1 200 OK
Content-Type: application/json

{
  "code": 200,
  "message": "success",
  "data": {
    "id": 1,
    "name": "张三"
  }
}

GET /users?name=张三&age=18

POST /users
Content-Type: application/json

{
  "name": "张三",
  "age": 18
}

{
  "id": 1,
  "name": "张三",
  "age": 18
}

@PostMapping("/users")
public User addUser(@RequestBody User user) {
    return user;
}

这章建议保留，但不用再扩展到太深，比如 TCP/IP、HTTPS 握手、HTTP/2 这些现在先不用放。你现在做 Java Web 入门笔记，重点掌握：**请求方法、参数位置、请求头、请求体、响应、状态码、JSON** 就够了。

@GetMapping("/user")
public String getUser(HttpServletRequest request) {
    String name = request.getParameter("name");
    String age = request.getParameter("age");
    return name + ":" + age;
}


这种方式能帮助理解底层原理，但实际开发中比较繁琐：所有参数都要手动取，类型也要自己转换，比如 `age` 获取到的是字符串，还要手动转成 `Integer`。Spring Boot 项目中一般不常用，更多是了解机制时使用。

@GetMapping("/user")
public String getUser(String name, Integer age) {
    return name + ":" + age;
}

请求示例：
```text
GET /user?name=张三&age=18

@GetMapping("/user")
public String getUser(@RequestParam("name") String username) {
    return username;
}

@GetMapping("/user")
public String getUser(@RequestParam(value = "name", required = false) String username) {
    return username;
}

public class User {
    private String name;
    private Integer age;

    // getter / setter
}

@GetMapping("/user")
public String getUser(User user) {
    return user.getName() + ":" + user.getAge();
}

GET /user?name=张三&age=18

GET /user?hobby=唱歌&hobby=跳舞&hobby=篮球

@GetMapping("/user")
public String getUser(String[] hobby) {
    return Arrays.toString(hobby);
}

@GetMapping("/user")
public String getUser(@RequestParam List<String> hobby) {
    return hobby.toString();
}

@GetMapping("/date")
public String getDate(@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date) {
    return date.toString();
}

GET /date?date=2026-06-07

@GetMapping("/time")
public String getTime(
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime time
) {
    return time.toString();
}

GET /time?time=2026-06-07 18:30:00

@PostMapping("/user")
public String addUser(@RequestBody User user) {
    return user.getName() + ":" + user.getAge();
}

{
  "name": "张三",
  "age": 18
}

@GetMapping("/user/{id}")
public String getUser(@PathVariable Integer id) {
    return "id = " + id;
}

GET /user/1001

@GetMapping("/user/{id}")
public String getUser(@PathVariable("id") Integer userId) {
    return "id = " + userId;
}

@GetMapping("/order/{date}")
public String getOrder(
    @PathVariable
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    LocalDate date
) {
    return date.toString();
}

前端 / 浏览器 / Postman
        ↓
Controller：接收请求、响应数据
        ↓
Service：处理业务逻辑
        ↓
DAO / Mapper：访问数据库
        ↓
数据库

@RestController
@RequestMapping("/users")
@GetMapping
@PostMapping
@PathVariable
@RequestParam
@RequestBody

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Integer id) {
        return userService.getUserById(id);
    }
}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User getUserById(Integer id) {
        return userMapper.selectById(id);
    }
}

@Mapper
public interface UserMapper {

    User selectById(Integer id);

}

private UserService userService = new UserService();

@Component
public class EmpServiceA implements EmpService {
}

@Autowired
private EmpService empService;

@Component：把类交给 Spring 管理，实例化后注册为 Bean（放进容器）
@Autowired：从 Spring 容器中取出需要的 Bean，注入到当前类的成员变量中

Controller 依赖 Service
Service 依赖 DAO
所有依赖关系由 Spring 自动装配，不用手动 new 和组装

// 自己创建对象，自己管理生命周期
UserService userService = new UserService();

@Autowired
private UserService userService;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

}

private UserService userService;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;
}

public UserController(UserService userService) {
    this.userService = userService;
}

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;
}

@RestController
@RequestMapping("/users")
public class UserController {

    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

@PostMapping("/users")
public String addUser(@RequestBody User user) {
    userService.addUser(user);
    return "success";
}

请求参数 → Controller 接收 → Service 处理 → Mapper 操作数据库 → 返回结果

前端 / Postman
        ↓
Controller：接收请求
        ↓
Service：业务逻辑
        ↓
Mapper / DAO：执行 SQL
        ↓
MySQL：保存和查询数据

create table 表名(
   字段1 字段类型 [约束] [comment 字段1注释],
   ......
   字段n 字段类型 [约束] [comment 字段n注释]
)[comment 表注释];


CREATE TABLE emp (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20) NOT NULL,
    age INT,
    gender CHAR(1),
    entry_date DATE,
    dept_id INT
);

普通整数用 INT；
大 ID 用 BIGINT；
状态值用 TINYINT；
普通字符串用 VARCHAR；
固定长度字符串用 CHAR；
长文本用 TEXT；
日期用 DATE；
日期时间用 DATETIME；
金额用 DECIMAL，不推荐 DOUBLE。

id BIGINT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50) NOT NULL,
phone CHAR(11),
status TINYINT DEFAULT 1,
price DECIMAL(10,2),
create_time DATETIME,
update_time DATETIME

-- 危险：修改所有员工年龄
UPDATE emp SET age = 18;

-- 危险：删除整张表所有数据
DELETE FROM emp;

SELECT ...
FROM ...
WHERE ...
GROUP BY ...
HAVING ...
ORDER BY ...
LIMIT ...

FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT

SELECT
    name,
    age,
    IF(age >= 18, '成年人', '未成年人') AS age_type
FROM emp;

SELECT
    name,
    gender,
    CASE gender
        WHEN '男' THEN '男性'
        WHEN '女' THEN '女性'
        ELSE '未知'
    END AS gender_name
FROM emp;

SELECT
    name,
    age,
    CASE
        WHEN age < 18 THEN '未成年'
        WHEN age BETWEEN 18 AND 60 THEN '成年人'
        ELSE '老年人'
    END AS age_type
FROM emp;

 创建表时指定
  create table 表名(
      字段名 数据类型,
      ...
      [constraint 外键名称] foreign key (外键字段名) references 主表(字段名)
  );
  建完表后，添加外键
alter table 表名 add constraint 外键名称 foreign key (外键字段名) references 主表(字段名);`

SELECT e.id, e.name, d.name AS dept_name
FROM emp e
LEFT JOIN dept d ON e.dept_id = d.id;

START TRANSACTION;

UPDATE account SET money = money - 100 WHERE id = 1;
UPDATE account SET money = money + 100 WHERE id = 2;

COMMIT;

ROLLBACK;

-- 创建索引
create [unique] index 索引名 on 表名 (字段名, ...);

-- 查看索引
show index from 表名;

-- 删除索引
drop index 索引名 on 表名;

CREATE TABLE user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(100) NOT NULL,
    nickname VARCHAR(50),
    phone VARCHAR(20),
    status TINYINT DEFAULT 1,
    create_time DATETIME,
    update_time DATETIME
);

Controller 层：接收请求，返回响应
Service 层：处理业务逻辑
Mapper 层：操作数据库

src/main/java/com/jinbai/demo
├── controller
│   └── EmpController.java
├── mapper
│   └── EmpMapper.java
├── pojo
│   └── Emp.java
└── DemoApplication.java

controller：接收前端请求，返回数据
mapper：操作数据库，编写 SQL
pojo：实体类，用来封装数据库表数据
DemoApplication：Spring Boot 启动类

1. 注册数据库驱动
2. 获取数据库连接
3. 编写 SQL
4. 创建 PreparedStatement
5. 设置 SQL 参数
6. 执行 SQL
7. 处理 ResultSet 结果集
8. 释放数据库资源

JDBC：自己写完整数据库操作流程
MyBatis：自己写 SQL，框架帮你执行 SQL 和封装结果

// 1. 定义 SQL，? 是参数占位符，后面再给它赋值
String sql = "select * from emp where id = ?";

// 2. 获取数据库连接：需要数据库地址、用户名、密码
Connection conn = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/db01", "root", "123456");

// 3. 创建 PreparedStatement，用来执行带参数的 SQL
PreparedStatement ps = conn.prepareStatement(sql);

// 4. 给第 1 个 ? 占位符设置参数值，这里 id = 1
ps.setInt(1, 1);

// 5. 执行查询 SQL，返回 ResultSet 结果集
ResultSet rs = ps.executeQuery();

// 6. 遍历查询结果，把数据库中的一行数据封装成 Java 对象
while (rs.next()) {
    Emp emp = new Emp();
    emp.setId(rs.getInt("id"));              // 获取 id 字段
    emp.setUsername(rs.getString("username"));// 获取 username 字段
    emp.setName(rs.getString("name"));      // 获取 name 字段
    emp.setGender(rs.getShort("gender"));   // 获取 gender 字段
}

// 7. 关闭资源，避免连接一直被占用
rs.close();
ps.close();
conn.close();

@Mapper // 告诉 Spring / MyBatis：这是一个 Mapper 接口，需要生成代理对象
public interface EmpMapper {

    // 调用 getById 方法时，MyBatis 会执行这条 SQL
    // #{id} 表示获取方法参数 id 的值，并作为 SQL 参数传入
    @Select("select * from emp where id = #{id}")
    Emp getById(Integer id); // 根据 id 查询一条员工数据，返回 Emp 对象
}

// empMapper 实际上是 MyBatis 生成的代理对象
// 调用 getById(1)，底层会执行：select * from emp where id = 1
Emp emp = empMapper.getById(1);

empMapper.getById(1) → Mapper 代理对象 → 找到 SQL → JDBC 执行 SQL → ResultSet 结果映射 → 返回 Emp 对象

JDBC：连接数据库 + 设置参数 + 执行 SQL + 处理 ResultSet + 关闭资源都要自己写
MyBatis：开发者写 Mapper 和 SQL，框架负责执行 SQL、传参、封装结果和管理资源

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver # MySQL 8 常用驱动类
    url: jdbc:mysql://localhost:3306/db01       # 数据库连接地址，db01 是数据库名
    username: root                              # 数据库用户名
    password: 123456                            # 数据库密码

JDBC 是底层数据库操作标准，MyBatis 是对 JDBC 的封装。

JDBC 负责“Java 怎么操作数据库”
MyBatis 负责“把 Mapper 方法调用转换成 JDBC SQL 执行，并把结果封装成 Java 对象”

// 业务接口
public interface UserService {
    void save();
}

// 真实对象：只负责核心业务
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        System.out.println("保存用户");
    }
}

// 代理对象：负责增强功能，并调用真实对象
public class UserServiceProxy implements UserService {
    private UserService target = new UserServiceImpl();

    @Override
    public void save() {
        System.out.println("方法执行前：记录日志");
        target.save(); // 调用真实对象的方法
        System.out.println("方法执行后：记录日志");
    }
}

public class Test {
    public static void main(String[] args) {
        // 接口引用指向代理对象，本质上利用了多态
        UserService userService = new UserServiceProxy();

        // 调用的是代理对象的 save() 方法
        userService.save();
    }
}

调用 userService.save()
        ↓
进入代理对象 save()
        ↓
执行前置增强逻辑
        ↓
调用真实对象 save()
        ↓
执行后置增强逻辑

代理 = 多态 + 包装真实对象 + 方法增强 + 调用转发

静态代理：自己手写代理类，容易理解，但每个业务类都要写对应代理类，代码量大。
动态代理：程序运行时自动生成代理对象，不需要手写代理类，Spring、MyBatis 常用。

@Mapper
public interface EmpMapper {
    @Select("select * from emp")
    List<Emp> list();
}

EmpMapper empMapper = new EmpMapper(); // 错误，接口不能 new

public class EmpMapperImpl implements EmpMapper {
    @Override
    public List<Emp> list() {
        // 手写 JDBC 代码，连接数据库、执行 SQL、封装结果
    }
}

接口名：EmpMapper
方法名：list
SQL：select * from emp
返回类型：List<Emp>

EmpMapper.list()  --->  select * from emp

EmpMapper empMapper = MyBatis 生成的代理对象;

public class EmpMapperProxy implements EmpMapper {
    @Override
    public List<Emp> list() {
        // 1. 根据接口名 + 方法名，找到 list() 对应的 SQL
        // 2. 通过 JDBC 执行 SQL：select * from emp
        // 3. 获取数据库查询结果
        // 4. 把每一行数据封装成 Emp 对象
        // 5. 把多个 Emp 对象放入 List 集合并返回
    }
}

empMapper.list();

调用 empMapper.list()
        ↓
empMapper 实际是 MyBatis 生成的代理对象
        ↓
代理对象拦截 list() 方法调用
        ↓
根据 EmpMapper.list 找到对应 SQL
        ↓
通过 JDBC 执行 select * from emp
        ↓
将查询结果封装成 Emp 对象
        ↓
返回 List<Emp>

@Transactional
public void save() {
    // 操作数据库
}

调用代理对象 save()
        ↓
开启事务
        ↓
调用真实对象 save()
        ↓
方法正常结束：提交事务
        ↓
方法出现异常：回滚事务

真实对象：负责核心业务
代理对象：负责增强功能 + 调用真实对象
调用者：通常只看到接口，不关心底层是真实对象还是代理对象

// 查询 tb_emp 表中的所有员工
@Select("select * from tb_emp")
List<Emp> list();

// 根据 id 查询员工信息
@Select("select * from tb_emp where id = #{id}")
Emp getById(Integer id);

// 根据 id 删除员工
@Delete("delete from tb_emp where id = #{id}")
void delete(Integer id);

// 新增员工数据
@Insert("insert into tb_emp(name, age) values(#{name}, #{age})")
void insert(Emp emp);

@Insert("insert into emp(username, name, gender) values(#{username}, #{name}, #{gender})")
void insert(Emp emp);

@Options(useGeneratedKeys = true, keyProperty = "id")
@Insert("insert into emp(username, name, gender) values(#{username}, #{name}, #{gender})")
void insert(Emp emp);

Emp emp = new Emp();
emp.setUsername("tom");
emp.setName("Tom");

empMapper.insert(emp);

System.out.println(emp.getId()); // 可以拿到新增后的自增主键

// 根据 id 修改员工信息
@Update("update tb_emp set name = #{name}, age = #{age} where id = #{id}")
void update(Emp emp);

#{id}：从方法参数或对象属性中取值
#{name}：从 Emp 对象的 name 属性中取值
#{age}：从 Emp 对象的 age 属性中取值

@Select("select * from emp where id = #{id}")
Emp getById(Integer id);

Emp emp = empMapper.getById(1);

select * from emp where id = ?

@Insert("insert into emp(username, name, gender) values(#{username}, #{name}, #{gender})")
void insert(Emp emp);

@Select("select * from emp where username = #{username} and gender = #{gender}")
List<Emp> listByCondition(@Param("username") String username,
                          @Param("gender") Integer gender);

@Select("select * from emp where id = #{id}")
Emp getById(Integer id);

@Select("select * from emp order by ${field}")
List<Emp> listOrderBy(@Param("field") String field);

#{}：安全，占位符传参，常用
${}：字符串拼接，有 SQL 注入风险，慎用

@Select("select id, username, name, gender from emp")
List<Emp> list();

数据库字段：id       username       name       gender
Java 属性：id       username       name       gender

@Select("select create_time createTime, update_time updateTime from emp")
List<Emp> list();

mybatis:
  configuration:
    map-underscore-to-camel-case: true

create_time  →  createTime
update_time  →  updateTime

<!-- 抽取公共字段列表 -->
<sql id="commonSelect">
    id, name, age, gender, entrydate
</sql>

<!-- 使用 include 引入公共 SQL 片段 -->
<select id="list" resultType="com.jinbai.demo.pojo.Emp">
    select
        <include refid="commonSelect"/>
    from tb_emp
</select>

sql：定义公共 SQL 片段
include：引入公共 SQL 片段
refid：引用 sql 片段的 id

@Mapper
public interface EmpMapper {
    List<Emp> list(String name, Integer gender);
}

<mapper namespace="com.example.mapper.EmpMapper">

    <select id="list" resultType="com.example.pojo.Emp">
        select *
        from emp
        where name like concat('%', #{name}, '%')
          and gender = #{gender}
    </select>

</mapper>

namespace：对应 Mapper 接口的全类名
id：对应 Mapper 接口中的方法名

com.example.mapper.EmpMapper.list()
        ↓
XML 中 namespace + id 对应的 SQL

<if>       条件判断
<where>    自动生成 where，并处理多余的 and / or
<set>      用于 update，自动处理多余逗号
<foreach>  遍历集合，常用于批量删除、批量插入

<select id="list" resultType="com.example.pojo.Emp">  
select *  
from emp  
<where>  
<if test="name != null and name != ''">  
name like concat('%', #{name}, '%')  
</if>  
<if test="gender != null">  
and gender = #{gender}  
</if>  
</where>  
</select>


<select id="list" resultType="com.example.pojo.Emp">
    select *
    from emp
    <where>
        <if test="name != null and name != ''">
            name like concat('%', #{name}, '%')
        </if>
        <if test="gender != null">
            and gender = #{gender}
        </if>
    </where>
</select>

<update id="update">
    update emp
    <set>
        <if test="username != null">username = #{username},</if>
        <if test="name != null">name = #{name},</if>
        <if test="gender != null">gender = #{gender},</if>
    </set>
    where id = #{id}
</update>

<delete id="deleteByIds">
    delete from emp
    where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

delete from emp where id in (1, 2, 3)

@Mapper
public interface EmpMapper {
    @Select("select * from emp")
    List<Emp> list();
}

调用 empMapper.list()
        ↓
进入 MyBatis 生成的 Mapper 代理对象
        ↓
根据 EmpMapper.list 找到对应 SQL
        ↓
执行 select * from emp
        ↓
把查询结果封装成 List<Emp>
        ↓
返回给 Service 层

src/main/resources/mapper/EmpMapper.xml

package com.jinbai.demo.mapper;

import com.jinbai.demo.pojo.Emp;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

// Mapper 接口，只定义方法，不直接写复杂 SQL
@Mapper
public interface EmpMapper {

    // 查询所有员工，SQL 写在 XML 映射文件中
    List<Emp> list();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace 必须对应 Mapper 接口的全限定类名 -->
<mapper namespace="com.jinbai.demo.mapper.EmpMapper">

    <!-- id 必须对应 Mapper 接口中的方法名 -->
    <!-- resultType 表示查询结果封装成 Emp 对象 -->
    <select id="list" resultType="com.jinbai.demo.pojo.Emp">
        select * from tb_emp
    </select>

</mapper>

# 配置 MyBatis XML 映射文件位置
mybatis.mapper-locations=classpath:mapper/*.xml

namespace：绑定 Mapper 接口
id：绑定 Mapper 方法名
resultType：指定返回结果封装类型
mapper-locations：告诉 MyBatis 去哪里找 XML 文件

@RestController
@RequestMapping("/emps")
public class EmpController {

    @GetMapping
    public Result list() {
        return Result.success();
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        return Result.success();
    }

    @PostMapping
    public Result save(@RequestBody Emp emp) {
        return Result.success();
    }

    @PutMapping
    public Result update(@RequestBody Emp emp) {
        return Result.success();
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        return Result.success();
    }
}

{
  "code": 1,
  "msg": "success",
  "data": {}
}

浏览器 / 前端页面
        ↓
      Nginx
        ↓
Spring Boot / Java 后端服务
        ↓
      数据库

前端请求
  ↓
Controller 接收请求参数
  ↓
Service 处理业务逻辑
  ↓
Mapper 执行 SQL
  ↓
数据库返回结果
  ↓
Service 封装业务结果
  ↓
Controller 包装 Result 返回前端

EmpService        接口
EmpServiceImpl    实现类

public interface EmpService {
    PageBean page(Integer page, Integer pageSize);
}

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;

    @Override
    public PageBean page(Integer page, Integer pageSize) {
        Long total = empMapper.count();
        Integer start = (page - 1) * pageSize;
        List<Emp> rows = empMapper.list(start, pageSize);
        return new PageBean(total, rows);
    }
}

@Mapper
public interface EmpMapper {
    @Select("select count(*) from emp")
    Long count();

    @Select("select * from emp limit #{start}, #{pageSize}")
    List<Emp> list(Integer start, Integer pageSize);
}

@RestController
public class EmpController {
    @Autowired
    private EmpService empService;

    @GetMapping("/emps")
    public Result page(Integer page, Integer pageSize) {
        PageBean pageBean = empService.page(page, pageSize);
        return Result.success(pageBean);
    }
}

public interface EmpService {
    PageBean page(Integer page, Integer pageSize);
}

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;

    @Override
    public PageBean page(Integer page, Integer pageSize) {
        Long total = empMapper.count();
        Integer start = (page - 1) * pageSize;
        List<Emp> rows = empMapper.list(start, pageSize);
        return new PageBean(total, rows);
    }
}

@Mapper
public interface EmpMapper {
    @Select("select count(*) from emp")
    Long count();

    @Select("select * from emp limit #{start}, #{pageSize}")
    List<Emp> list(Integer start, Integer pageSize);
}

<form action="/upload" method="post" enctype="multipart/form-data">
    姓名: <input type="text" name="username"><br>
    年龄: <input type="text" name="age"><br>
    头像: <input type="file" name="image"><br>
    <input type="submit" value="提交">
</form>

@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username,
                         Integer age,
                         @RequestParam("image") MultipartFile file) throws IOException {
        System.out.println(username);
        System.out.println(age);
        System.out.println(file.getOriginalFilename());
        return Result.success();
    }
}

前端选择文件
  ↓
后端接收 MultipartFile
  ↓
后端把文件上传到 OSS
  ↓
OSS 返回文件访问 URL
  ↓
后端把 URL 返回给前端 / 保存到数据库

aliyun:
  oss:
    endpoint: https://oss-cn-hangzhou.aliyuncs.com
    access-key-id: yourAccessKeyId
    access-key-secret: yourAccessKeySecret
    bucket-name: yourBucketName

@Component
public class AliOSSUtils {

    @Value("${aliyun.oss.endpoint}")
    private String endpoint;

    @Value("${aliyun.oss.access-key-id}")
    private String accessKeyId;

    @Value("${aliyun.oss.access-key-secret}")
    private String accessKeySecret;

    @Value("${aliyun.oss.bucket-name}")
    private String bucketName;
}

@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

Header.Payload.Signature

Map<String, Object> claims = new HashMap<>();
claims.put("id", 1);
claims.put("username", "Tom");

String jwt = Jwts.builder()
        .signWith(SignatureAlgorithm.HS256, "itheima") // 签名秘钥
        .setClaims(claims)                             // 自定义内容
        .setExpiration(new Date(System.currentTimeMillis() + 12 * 3600 * 1000))
        .compact();

Claims claims = Jwts.parser()
        .setSigningKey("itheima")
        .parseClaimsJws(jwt)
        .getBody();

token: eyJhbGciOiJIUzI1NiJ9.xxx.xxx

Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.xxx.xxx

浏览器请求
  ↓
Filter 放行前逻辑
  ↓
Controller / 其他资源
  ↓
Filter 放行后逻辑
  ↓
浏览器收到响应

@WebFilter(urlPatterns = "/*")
public class DemoFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) {
        System.out.println("init 初始化，只执行一次");
    }

    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        System.out.println("放行前逻辑");

        chain.doFilter(request, response); // 放行，请求继续往后走

        System.out.println("放行后逻辑");
    }

    @Override
    public void destroy() {
        System.out.println("destroy 销毁，只执行一次");
    }
}

@ServletComponentScan
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

1. 获取请求 URL
2. 判断是否是登录接口 /login
   - 是：直接放行
   - 否：继续校验
3. 从请求头获取 token
4. 判断 token 是否为空
   - 为空：返回未登录
   - 不为空：继续校验
5. 解析 JWT
   - 成功：放行
   - 失败：返回未登录

@WebFilter(urlPatterns = "/*")
public class LoginCheckFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        String url = request.getRequestURL().toString();
        if (url.contains("login")) {
            chain.doFilter(request, response);
            return;
        }

        String jwt = request.getHeader("token");
        if (jwt == null || jwt.isEmpty()) {
            response.getWriter().write("NOT_LOGIN");
            return;
        }

        try {
            Jwts.parser().setSigningKey("itheima").parseClaimsJws(jwt);
        } catch (Exception e) {
            response.getWriter().write("NOT_LOGIN");
            return;
        }

        chain.doFilter(request, response);
    }
}

@Component
public class LoginCheckInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        // Controller 方法执行前执行
        // return true 表示放行，return false 表示拦截
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {
        // Controller 方法执行后、视图渲染前执行；前后端分离项目中用得较少
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                Exception ex) throws Exception {
        // 整个请求完成后执行，适合清理资源、记录日志
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

浏览器
  ↓
Filter
  ↓
DispatcherServlet
  ↓
Interceptor preHandle
  ↓
Controller
  ↓
Interceptor postHandle / afterCompletion
  ↓
Filter 放行后逻辑
  ↓
响应浏览器

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public Result ex(Exception e) {
        e.printStackTrace();
        return Result.error("对不起，操作失败，请联系管理员");
    }
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;
    @Autowired
    private EmpMapper empMapper;

    @Transactional
    public void delete(Integer id) {
        deptMapper.deleteById(id);
        empMapper.deleteByDeptId(id);
    }
}

@Transactional(rollbackFor = Exception.class)
public void delete(Integer id) throws Exception {
    deptMapper.deleteById(id);
    if (true) {
        throw new Exception("出错了");
    }
    empMapper.deleteByDeptId(id);
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveLog() {
    // 即使外层业务回滚，这里也可以独立提交
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Component
@Aspect
public class TimeAspect {

    @Around("execution(* com.example.service.impl.*.*(..))")//拦截 `com.example.service.impl` 包下 **所有类的所有方法**
    //切面方法，当拦截到匹配的方法时会执行
    //- `ProceedingJoinPoint`：封装了被拦截方法的全部信息（类名、方法名、参数等）
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();
		//- **执行原始目标方法**（被拦截的那个业务方法）
        Object result = joinPoint.proceed(); // 调用原始目标方法

        long end = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature() + "耗时：" + (end - begin) + "ms");
        return result;
    }
}

@Component
@Aspect
public class TimeAspect {

    @Pointcut("execution(* com.example.service.impl.*.*(..))")
    public void pt() {}

    @Around("pt()")// ← 引用上面定义的切点，不用再写长表达式了
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - begin));
        return result;
    }
}

execution(访问修饰符? 返回值 包名.类名.方法名(方法参数) throws 异常?)

// 匹配 DeptServiceImpl 的 delete(Integer) 方法
@Around("execution(public void com.example.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

// 匹配 service 包及子包下所有类的所有方法
@Around("execution(* com.example.service..*.*(..))")

// 匹配所有 Service 结尾类的所有方法
@Around("execution(* com.example..*Service.*(..))")

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

@Around("@annotation(com.example.anno.Log)")
public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
    return joinPoint.proceed();
}

@Log
@PostMapping("/depts")
public Result save(@RequestBody Dept dept) {
    deptService.save(dept);
    return Result.success();
}

Signature signature = joinPoint.getSignature(); // 方法签名
Object[] args = joinPoint.getArgs();            // 方法参数
Object target = joinPoint.getTarget();          // 目标对象

Object result = joinPoint.proceed();            // 执行目标方法并拿返回值

@Order(1)
@Aspect
@Component
public class Aspect1 {}

@Order(2)
@Aspect
@Component
public class Aspect2 {}

application.properties
application.yml
application.yaml

server.port=8081

server:
  port: 8081

application.yaml
  < application.yml
  < application.properties
  < Java 系统属性（-Dxxx=xxx）
  < 命令行参数（--xxx=xxx）

java -Dserver.port=9000 -jar app.jar --server.port=10010

-Dserver.port=9000

--server.port=10010

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

@Autowired
private ApplicationContext applicationContext;

@Test
public void testGetBean() {
    DeptController bean1 = (DeptController) applicationContext.getBean("deptController");
    DeptController bean2 = applicationContext.getBean(DeptController.class);
    DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
}

@Autowired
private EmpService empService;

@Scope("prototype")
@RestController
public class DeptController {
}

@Configuration
public class CommonConfig {

    @Bean
    public SAXReader saxReader() {
        return new SAXReader();
    }
}

@Bean("reader")
public SAXReader saxReader() {
    return new SAXReader();
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring-boot-starter-web
├── spring-web
├── spring-webmvc
├── spring-boot-starter-json
│   └── Jackson
├── spring-boot-starter-tomcat
│   └── 内嵌 Tomcat
└── spring-boot-starter
    └── 默认日志体系

Starter：准备原材料，也就是 jar 包
自动配置：根据原材料创建默认 Bean
IOC 容器：保存并管理这些 Bean

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.x.x</version>
    <relativePath/>
</parent>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependencyManagement>
    <dependencies>
        ...
    </dependencies>
</dependencyManagement>

<!-- 
  这是 Maven 项目的根配置，声明这是一个 XML 文件。
  xmlns 是命名空间，可以暂时理解为“这个文件的格式说明书地址”。
-->
<project>
    <!-- 
        modelVersion：Maven 模型版本。
        对于 Maven 2.x 和 3.x，这个值固定是 4.0.0。
        就像说“我遵循的是 2020 年发布的说明书版本”。
    -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 
        groupId：这个 BOM 项目所属的组织或公司的唯一标识。
        通常用公司域名的倒序，比如 com.example。
        它定义了“谁发布了这份版本清单”。
    -->
    <groupId>com.example</groupId>

    <!-- 
        artifactId：这个 BOM 项目的唯一 ID。
        它定义了“这份版本清单叫什么名字”。
        这里叫 my-bom，意味着其他项目可以通过这个名字来引用它。
    -->
    <artifactId>my-bom</artifactId>

    <!-- 
        version：这个 BOM 项目自身的版本号。
        代表“这份版本清单的第 1.0.0 版”。
        当其他项目引用它时，也需要指定这个版本号。
    -->
    <version>1.0.0</version>

    <!-- 
        packaging：打包方式。
        pom：表示这是一个“纯配置”项目，它不包含任何 Java 代码，
        不会生成 jar 或 war 包，只生成一个供其他项目引用的 pom 文件。
        这是所有 BOM 和父工程的标配。
    -->
    <packaging>pom</packaging>

    <!-- 
        dependencyManagement：依赖版本管理中心。
        这是 BOM 最核心的部分！它的作用是“声明版本”，而不是“引入依赖”。
        它像一本“官方价目表”，告诉其他项目：“如果你用到下面这些依赖，
        请参考我指定的版本，以保证兼容性。”
    -->
    <dependencyManagement>
        <dependencies>
            <!-- 
                这里声明了一个依赖：Spring 的 Web 模块。
                注意：这里只有 groupId、artifactId 和 version。
                当其他项目通过 <scope>import</scope> 导入这个 BOM 后，
                再引入 spring-web 时就可以省略 version 标签了，
                Maven 会自动从这份 BOM 里找到版本号 6.1.6 并填入。
            -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>6.1.6</version>
            </dependency>

            <!-- 
                这里声明了 Jackson 的核心数据绑定库。
                同样，其他项目导入此 BOM 后，引入 jackson-databind 时，
                就不需要再写 <version>2.17.0</version> 了。
                这能确保一个组织内所有项目使用相同的 Jackson 版本，
                避免因版本不一致导致的各种奇怪问题。
            -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.17.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

以后谁导入了我这个 BOM，
谁再使用 spring-web，就默认用 6.1.6；
谁再使用 jackson-databind，就默认用 2.17.0。

<packaging>pom</packaging>

<dependencyManagement>
    <dependencies>
        ...
    </dependencies>
</dependencyManagement>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<type>pom</type>
<scope>import</scope>

type=pom：我要导入的不是 jar，而是一个 pom 文件
scope=import：把这个 pom 里的 dependencyManagement 版本管理规则导入进来

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>xxx</groupId>
            <artifactId>xxx-bom</artifactId>
            <version>xxx</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.5</version>
</parent>

<parent>
    ...
</parent>

spring-boot-starter-parent
        ↓
内部使用 spring-boot-dependencies
        ↓
spring-boot-dependencies 就是 Spring Boot 官方 BOM
        ↓
所以你的 starter 可以不写 version

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

启动类 main 方法
        ↓
SpringApplication.run(...)
        ↓
判断应用类型，准备环境配置
        ↓
创建 ApplicationContext，也就是 IoC 容器
        ↓
加载启动类、组件类、自动配置类，注册 BeanDefinition
        ↓
执行 refresh()，创建非懒加载单例 Bean，完成依赖注入和初始化
        ↓
如果是 Web 项目，启动内嵌 Tomcat
        ↓
应用启动完成，可以接收请求

@SpringBootApplication
public class NetworkDiskApplication {
    public static void main(String[] args) {
        SpringApplication.run(NetworkDiskApplication.class, args);
    }
}

普通非 Web 应用
Servlet Web 应用
Reactive Web 应用

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

application.properties
application.yml
application-{profile}.yml
环境变量
JVM 系统属性
命令行参数
配置中心
其他 PropertySource

server:
  port: 8081

spring:
  application:
    name: networkdisk-gateway

java -jar app.jar --server.port=9090

@Value
@ConfigurationProperties
@ConditionalOnProperty
自动配置类
日志配置
Web 服务器端口配置

普通应用：AnnotationConfigApplicationContext
Servlet Web 应用：ServletWebServerApplicationContext
Reactive Web 应用：ReactiveWebServerApplicationContext

ServletWebServerApplicationContext

BeanDefinition

Bean 的 class 类型
Bean 的名称
作用域 singleton / prototype
是否懒加载
构造方法参数
依赖关系
初始化方法
销毁方法

@ComponentScan 扫描到的 @Controller、@Service、@Repository、@Component
@Configuration 配置类中的 @Bean 方法
@Import 导入的配置类
@EnableAutoConfiguration 加载的自动配置类
XML 配置
程序化注册的 BeanDefinition

@Service
public class UserServiceImpl implements UserService {
}

准备 BeanFactory
        ↓
执行 BeanFactoryPostProcessor
        ↓
注册 BeanPostProcessor
        ↓
初始化消息源、事件广播器
        ↓
创建非懒加载单例 Bean
        ↓
完成依赖注入
        ↓
执行初始化回调
        ↓
发布容器启动完成事件

读取 BeanDefinition
        ↓
选择构造方法并实例化对象
        ↓
填充属性，完成依赖注入
        ↓
执行 Aware 回调
        ↓
执行 BeanPostProcessor 前置处理
        ↓
执行 @PostConstruct、InitializingBean、initMethod
        ↓
执行 BeanPostProcessor 后置处理
        ↓
Bean 创建完成，可以被业务代码使用

@Autowired
private UserService userService;

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Spring MVC
内嵌 Tomcat
Jackson
日志
参数校验等 Web 相关依赖

读取 server.port
        ↓
创建 TomcatServletWebServerFactory
        ↓
创建 TomcatWebServer
        ↓
启动 Tomcat
        ↓
注册 DispatcherServlet
        ↓
开始接收 HTTP 请求

读取配置元数据
注册 BeanDefinition
执行 BeanFactoryPostProcessor
执行 BeanPostProcessor
实例化非懒加载单例 Bean
完成依赖注入
执行初始化方法
启动 Web 服务器

application.properties
application.yml
application-{profile}.yml
环境变量
JVM 系统属性
命令行参数
配置中心或其他 PropertySource

server:
  port: 8081

spring:
  application:
    name: networkdisk-gateway

java -jar app.jar --server.port=9090

Bean 对应的类
Bean 的名称
作用域 singleton 或 prototype
是否懒加载
构造参数
依赖关系
初始化方法
销毁方法

@ComponentScan 扫描到的组件
@Configuration 中的 @Bean 方法
@Import 导入的配置
自动配置类提供的 Bean
XML 配置中声明的 Bean
程序化注册的 Bean

读取 BeanDefinition
        ↓
选择构造方法并实例化
        ↓
填充属性和注入依赖
        ↓
执行 Aware 回调
        ↓
执行 BeanPostProcessor 前置处理
        ↓
执行 @PostConstruct、InitializingBean、initMethod
        ↓
执行 BeanPostProcessor 后置处理
        ↓
Bean 可以被业务代码使用

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {
}

@SpringBootApplication
public class Application {

    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper();
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

com.disk.NetworkDiskApplication

com.disk
com.disk.controller
com.disk.service
com.disk.mapper
com.disk.infrastructure
以及 com.disk 下的其他子包

com.disk
├── NetworkDiskApplication.java
├── controller
├── service
├── mapper
├── domain
└── infrastructure

@SpringBootApplication(scanBasePackages = {
        "com.disk",
        "org.example"
})
public class Application {
}

@ComponentScan({
        "com.disk",
        "org.example"
})

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/network_disk
    username: root
    password: 123456

DataSource
JdbcTemplate
事务管理器
数据库初始化相关组件

类路径存在 JDBC 和 DataSource
配置文件存在数据库连接信息
容器中没有用户自己定义的 DataSource
当前环境符合该自动配置的要求

META-INF/spring/
org.springframework.boot.autoconfigure.AutoConfiguration.imports

org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration

扫描所有 jar 包 → 找到全部配置类

读取自动配置候选清单
        ↓
导入候选自动配置类
        ↓
检查每个配置类的条件
        ↓
只让满足条件的配置生效

@Configuration
@ConditionalOnProperty(
        name = "com.disk.ai.pgvector.enabled",
        havingValue = "true"
)
public class PgVectorConfiguration {
}

com:
  disk:
    ai:
      pgvector:
        enabled: true

@ConditionalOnProperty(
        name = "com.disk.ai.pgvector.enabled",
        havingValue = "true",
        matchIfMissing = true
)

@Bean
@ConditionalOnMissingBean
public ObjectMapper objectMapper() {
    return new ObjectMapper();
}

容器里没有 ObjectMapper
    → 创建默认 ObjectMapper

容器里已经有用户定义的 ObjectMapper
    → 自动配置退让，不再创建

ServletWebServerFactory
TomcatServletWebServerFactory
DispatcherServlet
DispatcherServletRegistrationBean
HandlerMapping
HandlerAdapter
HttpMessageConverter
Jackson JSON 转换器
异常处理相关组件
静态资源处理器

Spring Boot 运行在一个事先启动的 Tomcat 中

main 方法启动 Spring Boot
        ↓
Spring Boot 创建 IOC 容器
        ↓
IOC 容器创建 TomcatServletWebServerFactory
        ↓
Spring Boot 在当前 JVM 中启动 Tomcat
        ↓
Tomcat 开始监听端口

浏览器或前端发送 HTTP 请求
        ↓
Tomcat 接收网络连接
        ↓
请求进入 DispatcherServlet
        ↓
HandlerMapping 查找 Controller 方法
        ↓
HandlerAdapter 调用 Controller
        ↓
Controller 调用 Service
        ↓
Service 调用 Mapper 或其他服务
        ↓
返回 Java 对象
        ↓
HttpMessageConverter 使用 Jackson 转成 JSON
        ↓
Tomcat 返回 HTTP 响应

// 推荐结构
com.example.Application
com.example.controller.EmpController
com.example.service.EmpService
com.example.mapper.EmpMapper

// 如果确实要扫描多个包，可以显式指定
@SpringBootApplication
@ComponentScan({"com.example", "com.other"})
public class Application {}

@ComponentScan：自动扫描当前包及子包里的组件
@Import：手动指定我要把哪些类交给 Spring 管理

public class SmsService {

    public void send() {
        System.out.println("发送短信");
    }
}

@Component
@Service
@Configuration

@Configuration
@Import(SmsService.class)
public class AppConfig {
}

@RestController
public class TestController {

    private final SmsService smsService;

    public TestController(SmsService smsService) {
        this.smsService = smsService;
    }

    @GetMapping("/test")
    public String test() {
        smsService.send();
        return "ok";
    }
}

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        return template;
    }
}

@Configuration
@Import(RedisConfig.class)
public class AppConfig {
}

除了 AppConfig 这个配置类，
RedisConfig 这个配置类也要一起解析。
RedisConfig 里面的 @Bean 方法也要生效。

@Import(MyBatisConfig.class)
@Import(RedisConfig.class)
@Import(SecurityConfig.class)

1. 导入普通类
2. 导入配置类
3. 导入 ImportSelector / ImportBeanDefinitionRegistrar

public class MyImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[] {
                "com.example.service.SmsService",
                "com.example.service.EmailService"
        };
    }
}

@Configuration
@Import(MyImportSelector.class)
public class AppConfig {
}

@Import(MyImportSelector.class)
        ↓
执行 selectImports()
        ↓
返回 SmsService、EmailService 的全限定类名
        ↓
Spring 把这些类导入容器

public class MyRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata,
            BeanDefinitionRegistry registry) {

        RootBeanDefinition beanDefinition =
                new RootBeanDefinition(SmsService.class);

        registry.registerBeanDefinition("smsService", beanDefinition);
    }
}

@Configuration
@Import(MyRegistrar.class)
public class AppConfig {
}

ImportSelector：返回类名，让 Spring 自己注册
ImportBeanDefinitionRegistrar：我自己手动注册 BeanDefinition

@MapperScan
@EnableFeignClients
@EnableDubbo
@EnableScheduling

@Configuration
public class AppConfig {

    @Bean
    public SmsService smsService() {
        return new SmsService();
    }
}

@Configuration
@Import(SmsService.class)
public class AppConfig {
}

@Bean：我自己 new 一个对象，交给 Spring
@Import：我告诉 Spring，你去把这个类处理成 Bean 或配置类

@Bean
public SmsService smsService() {
    return new SmsService("aliyun", "accessKey");
}

@Import(SmsConfig.class)

@ComponentScan：自动扫描当前包及子包里的组件
@Import：手动指定我要把哪些类交给 Spring 管理

加载源配置类
加载并处理所有配置类
自动配置

@EnableAutoConfiguration

@SpringBootApplication
        ↓
@EnableAutoConfiguration
        ↓
@Import(...)
        ↓
导入 Spring Boot 自动配置类
        ↓
根据条件创建默认 Bean

DispatcherServlet
RequestMappingHandlerMapping
RequestMappingHandlerAdapter
TomcatServletWebServerFactory
Jackson 的 ObjectMapper
错误处理相关 Bean

@Service
public class UserService {
}

@Configuration
public class JsonConfiguration {

    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper();
    }
}

第三方类不能添加 @Component
对象创建过程需要传入复杂参数
需要根据配置动态构造对象
需要对第三方对象进行统一初始化

@Bean
public DataSource dataSource() {
    HikariDataSource dataSource = new HikariDataSource();
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    return dataSource;
}

@Configuration
@Import({
        RedisConfiguration.class,
        SecurityConfiguration.class
})
public class ApplicationConfiguration {
}

普通类
@Configuration 配置类
ImportSelector
DeferredImportSelector
ImportBeanDefinitionRegistrar

aliyun-oss-spring-boot-starter
└── pom.xml                // 只负责依赖聚合，依赖 autoconfigure 和 OSS SDK

aliyun-oss-spring-boot-autoconfigure
├── AliOssProperties.java  // 读取 aliyun.oss.* 配置
├── AliOssAutoConfiguration.java // 自动创建 AliOSSUtils Bean
└── META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@Data
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOssProperties {
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
}

@AutoConfiguration
@EnableConfigurationProperties(AliOssProperties.class)
@ConditionalOnClass(AliOSSUtils.class)
@ConditionalOnProperty(
        prefix = "aliyun.oss",
        name = "enabled",
        havingValue = "true",
        matchIfMissing = true
)
public class AliOssAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public AliOSSUtils aliOSSUtils(AliOssProperties properties) {
        AliOSSUtils utils = new AliOSSUtils();

        utils.setEndpoint(properties.getEndpoint());
        utils.setAccessKeyId(properties.getAccessKeyId());
        utils.setAccessKeySecret(properties.getAccessKeySecret());
        utils.setBucketName(properties.getBucketName());

        return utils;
    }
}

@AutoConfiguration
    声明这是一个自动配置类

@EnableConfigurationProperties
    注册并绑定 AliOssProperties

@ConditionalOnClass
    类路径中存在 AliOSSUtils 才配置

@ConditionalOnProperty
    配置开关满足要求才启用

@ConditionalOnMissingBean
    用户没有自定义时才创建默认 Bean

src/main/resources/META-INF/spring/
org.springframework.boot.autoconfigure.AutoConfiguration.imports

com.example.oss.autoconfigure.AliOssAutoConfiguration

META-INF/spring.factories

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
        <version>${project.version}</version>
    </dependency>

    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
    </dependency>
</dependencies>

<dependency>
    <groupId>com.example</groupId>
    <artifactId>aliyun-oss-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

aliyun:
  oss:
    endpoint: oss-cn-hangzhou.aliyuncs.com
    access-key-id: xxx
    access-key-secret: xxx
    bucket-name: xxx

@RestController
public class UploadController {
    @Autowired
    private AliOSSUtils aliOSSUtils;

    @PostMapping("/upload")
    public Result upload(MultipartFile image) throws IOException {
        String url = aliOSSUtils.upload(image);
        return Result.success(url);
    }
}

@RestController
@RequestMapping("/emps")
public class EmpController {

    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize) {
        return Result.success();
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        return Result.success();
    }

    @PostMapping
    public Result save(@RequestBody Emp emp) {
        return Result.success();
    }
}

pom.xml
   ↓
Maven 读取项目配置
   ↓
下载依赖
编译源码
运行测试
打包 jar
安装到本地仓库
发布到远程仓库

这个项目叫什么
属于哪个组织
当前版本是什么
需要哪些依赖
使用哪个 Java 版本
如何编译和打包
有哪些子模块
父工程是谁

project                     # 项目根目录
|-- src                     # 源代码目录
|   |-- main                # 主目录
|   |   |-- java            # Java源代码目录
|   |   |-- resources       # 资源文件目录，配置文件、Mapper XML、静态资源
|   |   |-- webapp          # Web应用目录
|   |-- test                # 测试目录
|       |-- java            # 测试源代码目录
|       |-- resources       # 测试资源文件目录
|-- target                  #  Maven 编译和打包后生成的目录
|-- pom.xml                 # Maven 项目配置文件

<?xml version="1.0" encoding="UTF-8"?>

<!-- Maven 项目的根标签 -->
<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/xsd/maven-4.0.0.xsd">

  <!-- 模型版本 -->
  <modelVersion>4.0.0</modelVersion>
  <!-- 公司或者组织的唯一标志，并且配置时生成的路径也是由此生成，
        如：com.companyname.project-group，
        maven会将该项目打成的jar包放本地路径：
        /com/companyname/project-group -->
  <groupId>com.companyname.project-group</groupId>

  <!-- 项目的唯一ID，一个groupId下面可能多个项目，就是靠artifactId来区分的 -->
  <artifactId>project</artifactId>

  <!-- 版本号 -->
  <version>1.0</version>

  <!-- 属性变量 -->
  properties：定义一些可在整个POM文件中重复使用的变量。
        这里定义了Java编译的源代码版本和目标字节码版本都是 1.8。
        在其他地方可以通过 ${maven.compiler.source} 来引用这个值，方便统一修改。
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <!-- 依赖 -->
    dependencies：这是项目最常用的部分，用来声明项目所依赖的第三方库。
        在这个区域里列出的每个 dependency，Maven 都会去仓库（本地或中央）中下载并引入到你的项目中。
        一个依赖通常由 groupId, artifactId, version 三个坐标唯一定位。
        这里声明依赖了 Spring Framework 的核心模块 spring-core，版本是 5.3.9
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.9</version>
    </dependency>
  </dependencies>

  <!-- 依赖管理 -->
  dependencyManagement：这是一个“依赖版本管理”区域，看起来和 dependencies 很像。
        但是，这里的声明只会影响版本号，并不会真正地引入依赖。
        它的作用是：在子模块的 pom.xml 中声明依赖时，可以不指定 version，从而统一所有子模块的依赖版本。
        可以理解为“爸爸定好规矩，孩子们都按这个规矩来”。
  <dependencyManagement>
    <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>5.3.9</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <!-- 仓库管理 -->
    repositories：配置 Maven 去哪些远程仓库下载依赖。
        这里配置了 Maven 中央仓库（Central Repository），这是默认的公共仓库。
        如果你的项目需要用到公司内部的私有仓库，也需要在这里添加配置。
  <repositories>
    <repository>
        <id>central</id>
        <url>https://repo.maven.apache.org/maven2</url>
    </repository>
  </repositories>

  <!-- 构建 -->
  build：配置项目构建相关的所有内容。
        包括最终打包的文件名、使用的插件等。
  <build>
    <!-- 插件管理 -->
    plugins：配置构建过程中使用的 Maven 插件。
            插件可以扩展 Maven 的功能，比如编译代码、打包、运行测试等。
            这里配置了 maven-compiler-plugin，它负责编译 Java 代码。
            通过 <configuration> 标签，我们告诉它使用 1.8 版本的编译器。
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

项目声明依赖
   ↓
先检查本地仓库
   ↓
本地没有则检查公司私服
   ↓
私服没有则访问中央仓库
   ↓
下载后保存到本地仓库

validate => compile => test => package => verify => install => deploy

# 生成站点文档
mvn site
# 部署站点文档
mvn site:deploy

validate
→ compile
→ test
→ package

validate
→ compile
→ test
→ package
→ verify
→ install

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

JUnit
Mockito
Spring Boot Test

<type>pom</type>
<scope>import</scope>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>6.1.11</version>
    <exclusions>
        <exclusion>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </exclusion>
    </exclusions>
</dependency>

项目
├── A
│   └── jackson 2.15
└── B
    └── jackson 2.17

路径更近的依赖优先
同一层级时，先声明的依赖优先
dependencyManagement 指定的版本优先

项目 → A → Jackson 2.15
项目 → B → C → Jackson 2.17

mvn dependency:tree

mvn dependency:tree -Dincludes=com.fasterxml.jackson.core

user-service
+- spring-boot-starter-web
|  \- jackson-databind:2.17.1
\- other-library
   \- jackson-databind:2.15.4

Java 版本
Spring Boot 版本
Spring Cloud 版本
第三方依赖版本
Maven 插件版本
子模块列表
公共构建配置

<packaging>pom</packaging>

<?xml version="1.0" encoding="UTF-8"?>

<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
         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mall</groupId>
    <artifactId>mall-parent</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <!-- 父工程主要保存配置，不生成业务 jar -->
    <packaging>pom</packaging>

    <!-- 统一定义属性 -->
    <properties>
        <java.version>17</java.version>
        <spring-boot.version>3.3.1</spring-boot.version>
        <spring-cloud.version>2023.0.3</spring-cloud.version>
        <mysql.version>8.4.0</mysql.version>
        <mybatis-plus.version>3.5.7</mybatis-plus.version>
        <lombok.version>1.18.32</lombok.version>

        <!-- 统一项目编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.release>${java.version}</maven.compiler.release>
    </properties>

    <!-- 统一管理依赖版本，不主动引入依赖 -->
    <dependencyManagement>
        <dependencies>

            <!-- Spring Boot 的 BOM -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Spring Cloud 的 BOM -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>${mysql.version}</version>
            </dependency>

            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>

            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!-- 管理项目内部模块版本 -->
            <dependency>
                <groupId>com.mall</groupId>
                <artifactId>mall-common</artifactId>
                <version>${project.version}</version>
            </dependency>

            <dependency>
                <groupId>com.mall</groupId>
                <artifactId>mall-api</artifactId>
                <version>${project.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <!-- 声明本次聚合构建包含哪些模块 -->
    <modules>
        <module>mall-common</module>
        <module>mall-api</module>
        <module>user-service</module>
        <module>product-service</module>
        <module>order-service</module>
        <module>gateway-service</module>
    </modules>

</project>

properties
    定义公共变量，例如 Java 版本和依赖版本

dependencyManagement
    统一规定各依赖应使用什么版本

modules
    声明执行构建时需要一起构建哪些模块

<?xml version="1.0" encoding="UTF-8"?>

<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
         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!-- 当前模块继承 mall-parent -->
    <parent>
        <groupId>com.mall</groupId>
        <artifactId>mall-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>

        <!-- 父 POM 位于当前模块的上一级目录 -->
        <relativePath>../pom.xml</relativePath>
    </parent>

    <!-- groupId 和 version 可以继承父工程，因此通常只写 artifactId -->
    <artifactId>user-service</artifactId>

</project>

groupId
version
properties
dependencyManagement
pluginManagement
部分 build 配置
普通 dependencies 中声明的依赖

<properties>
    <java.version>17</java.version>
</properties>

${java.version}

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
</dependency>

多个模块如何复用同一套 Maven 配置

<modules>
    <module>mall-common</module>
    <module>mall-api</module>
    <module>user-service</module>
    <module>product-service</module>
    <module>order-service</module>
</modules>

mvn clean package

mall-common
      ↑
mall-api
      ↑
user-service
      ↑
order-service

1. mall-common
2. mall-api
3. user-service
4. product-service
5. order-service

tlias-parent              // 父工程，主要管理版本和模块，packaging=pom
├── tlias-pojo            // 实体类模块
├── tlias-utils           // 工具类模块
└── tlias-web-management  // Web 管理模块，依赖 pojo 和 utils

<!-- 父工程 pom.xml -->

<!-- 
  项目的唯一标识（坐标），在 Maven 仓库中定位这个项目：
  - groupId: 组织/公司域名倒写，通常是 com.公司名
  - artifactId: 项目名称，这里叫 tlias-parent
  - version: 版本号
-->
<groupId>com.example</groupId>
<artifactId>tlias-parent</artifactId>
<version>1.0-SNAPSHOT</version>

<!-- 
  packaging: 打包方式
  - pom: 表示这是一个"父工程"（聚合工程），本身不写代码、不打 jar/war 包
  - 它的作用只有两个：① 管理依赖版本 ② 聚合子模块
-->
<packaging>pom</packaging>

<!-- 
  properties: 自定义属性标签，类似 Java 的变量定义
  作用：把版本号抽出来统一管理，避免在下面多处重复写版本号
  使用时通过 ${变量名} 引用，比如 ${lombok.version}
-->
<properties>
    <!-- Lombok 版本：编译时自动生成 getter/setter/构造器等 -->
    <lombok.version>1.18.24</lombok.version>
    <!-- JJWT 版本：用于生成和解析 JWT 令牌（常用于登录认证） -->
    <jjwt.version>0.9.1</jjwt.version>
</properties>

<!-- 
  dependencyManagement: 依赖版本管理（注意 Management 这个词）
  作用：声明"这个项目可能会用到的依赖及其版本"，但注意 ——
  ❌ 不会真正引入依赖（子模块不会自动继承）
  ✅ 只是定了一个"版本参考表"，子模块引用时可以不写 version
-->
<dependencyManagement>
    <dependencies>
        <!-- Lombok 依赖声明 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <!-- 用 ${} 引用上面 properties 里定义的版本号 -->
            <version>${lombok.version}</version>
        </dependency>

        <!-- JJWT 依赖声明 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jjwt.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 子工程 pom.xml -->

<!-- 
  parent: 声明当前模块的"父工程"是谁
  作用：继承父工程的配置（依赖版本管理、插件管理、公共属性等）
-->
<parent>
    <!-- 父工程的坐标，必须和父工程 pom.xml 中的 groupId/artifactId/version 完全一致 -->
    <groupId>com.example</groupId>
    <artifactId>tlias-parent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 
      relativePath: 父工程 pom.xml 的相对路径
      作用：告诉 Maven 去哪里找父工程的 pom 文件
      - 默认值是 ../pom.xml（父工程在上一级目录）
      - 这里写成 ../tlias-parent/pom.xml，说明父工程在"上一级目录的 tlias-parent 文件夹下"
      - 如果父工程在上一级目录，可以省略不写，Maven 会自动去 ../pom.xml 找
    -->
    <relativePath>../tlias-parent/pom.xml</relativePath>
</parent>

<!-- 
  dependencies: 当前子模块真正的依赖
  注意：这里引用了 jjwt，但 没有写 version！
  因为版本号由父工程的 <dependencyManagement> 统一管理
-->
<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <!-- version 省略，从父工程继承，实际使用 ${jjwt.version}=0.9.1 -->
    </dependency>
</dependencies>

<modules>
    <module>../tlias-pojo</module>
    <module>../tlias-utils</module>
    <module>../tlias-web-management</module>
</modules>

本地开发调试：mvn install
团队共享组件：mvn deploy
稳定版本：RELEASE / 1.0.0
开发版本：SNAPSHOT / 1.0-SNAPSHOT

日志门面或抽象：SLF4J、Commons Logging
日志实现：Logback、Log4j2、JUL

@Slf4j
@Service
public class FileService {

    public void upload(String userId, String fileName) {
        log.info(
                "开始上传文件, userId={}, fileName={}",
                userId,
                fileName
        );
    }
}```

`@Slf4j` 是 Lombok 提供的注解，编译后相当于生成：
```java
private static final Logger log =
        LoggerFactory.getLogger(FileService.class);

TRACE < DEBUG < INFO < WARN < ERROR

TRACE 不输出
DEBUG 不输出
INFO 输出
WARN 输出
ERROR 输出

log.info(
        "用户登录成功, userId={}, clientIp={}",
        userId,
        clientIp
);

// 不推荐
log.debug("查询用户信息: " + user);

try {
    fileService.upload(file);
} catch (IOException e) {
    log.error(
            "文件上传失败, fileName={}",
            file.getOriginalFilename(),
            e
    );
}

log.error("文件上传失败: {}", e.getMessage());

请求或任务的关键标识
用户 ID、订单 ID、文件 ID
业务执行的关键节点
耗时信息
第三方调用结果
异常堆栈
重要配置加载结果
状态变化

用户密码
AccessKeySecret
Token 完整内容
银行卡号
身份证号
敏感个人信息
超大的请求体或文件内容

@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {

    private final UserMapper userMapper;

    public UserDTO findById(Long userId) {
        long start = System.currentTimeMillis();

        log.debug("开始查询用户, userId={}", userId);

        User user = userMapper.selectById(userId);

        if (user == null) {
            log.warn("用户不存在, userId={}", userId);
            throw new UserNotFoundException(userId);
        }

        log.info(
                "查询用户完成, userId={}, cost={}ms",
                userId,
                System.currentTimeMillis() - start
        );

        return convert(user);
    }
}

logging:
  level:
    root: info
    com.disk: debug
    org.springframework.web: info
    org.springframework.jdbc.core: debug

整个项目默认 INFO
自己项目 com.disk 包输出 DEBUG
Spring MVC 输出 INFO
JdbcTemplate 输出 DEBUG

# application-dev.yml
logging:
  level:
    com.disk: debug

# application-prod.yml
logging:
  level:
    com.disk: info

logging:
  file:
    name: logs/network-disk.log

控制台输出
按日期滚动
按文件大小切分
保留天数
不同级别写入不同文件
异步日志
自定义格式

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <include resource=
        "org/springframework/boot/logging/logback/defaults.xml"/>

    <property name="LOG_PATH" value="logs"/>

    <appender name="CONSOLE"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                %d{yyyy-MM-dd HH:mm:ss.SSS}
                [%thread] %-5level
                %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <appender name="FILE"
              class="ch.qos.logback.core.rolling.RollingFileAppender">

        <file>${LOG_PATH}/application.log</file>

        <rollingPolicy class=
            "ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">

            <fileNamePattern>
                ${LOG_PATH}/application-%d{yyyy-MM-dd}.%i.log.gz
            </fileNamePattern>

            <maxFileSize>100MB</maxFileSize>
            <maxHistory>30</maxHistory>
        </rollingPolicy>

        <encoder>
            <pattern>
                %d{yyyy-MM-dd HH:mm:ss.SSS}
                [%thread] %-5level
                %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>

</configuration>

String traceId = UUID.randomUUID().toString()
        .replace("-", "");

MDC.put("traceId", traceId);

try {
    filterChain.doFilter(request, response);
} finally {
    MDC.remove("traceId");
}

%X{traceId}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

src/test/java

单元测试
测试切片
集成测试

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserMapper userMapper;

    public UserDTO findById(Long userId) {
        User user = userMapper.selectById(userId);

        if (user == null) {
            throw new UserNotFoundException(userId);
        }

        return new UserDTO(
                user.getId(),
                user.getUsername()
        );
    }
}

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserMapper userMapper;

    @InjectMocks
    private UserService userService;

    @Test
    void shouldReturnUserWhenUserExists() {
        // Arrange：准备测试数据
        User user = new User();
        user.setId(1L);
        user.setUsername("jinbai");

        when(userMapper.selectById(1L))
                .thenReturn(user);

        // Act：执行待测试方法
        UserDTO result = userService.findById(1L);

        // Assert：验证结果
        assertThat(result.id()).isEqualTo(1L);
        assertThat(result.username()).isEqualTo("jinbai");

        // 验证依赖是否按预期调用
        verify(userMapper).selectById(1L);
    }

    @Test
    void shouldThrowExceptionWhenUserNotFound() {
        when(userMapper.selectById(99L))
                .thenReturn(null);

        assertThatThrownBy(
                () -> userService.findById(99L)
        )
                .isInstanceOf(UserNotFoundException.class);

        verify(userMapper).selectById(99L);
    }
}

@Mock
    创建假的 UserMapper

@InjectMocks
    创建 UserService，并注入假的 UserMapper

when(...).thenReturn(...)
    定义模拟对象被调用时返回什么

verify(...)
    验证某个方法是否被调用

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockitoBean
    private UserService userService;

    @Test
    void shouldReturnUser() throws Exception {
        UserDTO user = new UserDTO(1L, "jinbai");

        when(userService.findById(1L))
                .thenReturn(user);

        mockMvc.perform(
                get("/api/users/{id}", 1L)
        )
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.data.id").value(1))
                .andExpect(
                        jsonPath("$.data.username")
                                .value("jinbai")
                );
    }
}

Controller
Spring MVC 基础组件
参数绑定
JSON 转换
校验
ControllerAdvice
MockMvc

URL 是否正确
HTTP 方法是否正确
参数绑定是否正确
参数校验是否生效
返回状态码是否正确
JSON 结构是否符合预期
全局异常处理是否正确

@DataJpaTest
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    void shouldFindUserByUsername() {
        User user = new User();
        user.setUsername("jinbai");
        userRepository.save(user);

        Optional<User> result =
                userRepository.findByUsername("jinbai");

        assertThat(result).isPresent();
    }
}

@SpringBootTest
class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Test
    void shouldLoadUserFromDatabase() {
        UserDTO user = userService.findById(1L);

        assertThat(user).isNotNull();
    }
}

Bean 能否正常创建
自动配置是否生效
依赖注入是否正确
事务是否生效
多个业务组件能否协作
数据库、Redis 等基础设施能否正常交互

@SpringBootTest
@AutoConfigureMockMvc
class UserApiTest {

    @Autowired
    private MockMvc mockMvc;
}

@SpringBootTest(
        webEnvironment =
                SpringBootTest.WebEnvironment.RANDOM_PORT
)
class UserApiRealServerTest {

    @LocalServerPort
    private int port;

    @Test
    void shouldStartServer() {
        assertThat(port).isPositive();
    }
}

@SpringBootTest
@Transactional
class UserServiceIntegrationTest {
}

@Testcontainers
@SpringBootTest
class UserRepositoryIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres =
            new PostgreSQLContainer<>(
                    "postgres:16"
            );

    @Autowired
    private UserRepository userRepository;

    @Test
    void shouldSaveUser() {
        User user = new User();
        user.setUsername("jinbai");

        User saved = userRepository.save(user);

        assertThat(saved.getId()).isNotNull();
    }
}

能用普通 JUnit 测试，就不启动 Spring
能用测试切片，就不加载整个项目
只有跨组件协作时，才使用 @SpringBootTest