JavaWeb on Creat

web后端实战

Thu, 16 Apr 2026 00:00:00 +0000

本文更新于 2026-04-16

Restful

REST(REpresentational state Transfer)，表述性状态转换，它是一种软件架构风格。 ❗它并不是一种标准或协议，而是一组设计原则，旨在让网络服务更加简洁、高效且易于扩展。

具体请求url

动作	完整的 URL 示例	语义
查询全部	`GET localhost:8080/books`	查列表
查询单个	`GET localhost:8080/books/{id}`	查详情
新增	`POST localhost:8080/books`	存入新数据
更新	`PUT localhost:8080/books/{id}`	覆盖旧数据
删除	`DELETE localhost:8080/books/{id}`	移除数据

对应的注解

注解	对应的 HTTP 方法	REST 语义	典型应用场景
`@GetMapping`	GET	查	获取列表、查看详情、条件搜索。
`@PostMapping`	POST	增	提交表单、上传文件、新增部门/员工。
`@PutMapping`	PUT	改（整）	修改整个对象的信息（如修改员工的所有资料）。
`@PatchMapping`	PATCH	改（部）	修改部分信息（如只修改状态、只重置密码）。
`@DeleteMapping`	DELETE	删	删除单个或批量删除资源。

特性	POST	PUT
语义	创建 (Create)：用于创建子资源。	更新/替换 (Update/Replace)：用于更新或替换指定资源。
资源标识	资源 ID 通常由服务器生成。	资源 ID 通常由客户端指定。
对应 SQL	类似于 `INSERT`。	类似于 `UPDATE` (全量) 或 `REPLACE INTO`。
幂等性	不幂等。	幂等。

	@GetMapping("/depts") 
	//指定请求方式 
	public Result list(){ 
	 System.out.println("查询全部部门数据"); 
	 List<Dept> deptList = deptService.findAll(); 
	 return Result.success(deptList); 
	}

优点

轻量级: 相比早期的 SOAP 协议，REST 传输的数据量更小。
易于理解: 直接利用 HTTP 语义，开发者上手极快。
高兼容性: 只要支持 HTTP 协议的平台（浏览器、移动端、IoT）都能轻松调用。
利于缓存: 良好的 RESTful 设计可以充分利用 HTTP 缓存机制，提升性能。

数据封装

在 MyBatis 中，如果实体类属性名（比如 deptName）和数据库字段名（比如 name）对不上，MyBatis 找不到对应关系，封装出来的结果就会是 null

手动结果映射`@Results @Result`

@Mapper 
public interface DeptMapper{ 
 @Results({ 
 @Result(column = "create_time", property = "createTime"), 
 @Result(column = "update_time", property = "updateTime") 
 }) 
 @Select("SELECT id, name, create_time, update_time FROM dept ORDER BY update_time DESC") 
 List<Dept> findAll(); 
}

起别名

在写 SQL 语句时，利用 SQL 的 AS 关键字，手动将数据库字段名改成和实体类属性名一致。

优点： 简单直接。
缺点： 如果字段很多，SQL 语句会变得非常臃肿，且每个查询都要写一遍。

	SELECT 
	 id, name, 
	 dept_name AS deptName, -- 数据库是 dept_name，实体类是 deptName
	 create_time AS createTime 
	FROM dept;

开启驼峰命名自动转换 (最推荐)

这是目前最常用的方案。大部分开发规范中，数据库字段用下划线（dept_name），Java 属性用小驼峰（deptName）。

只需要在 Spring Boot 的配置文件 application.yml（或 properties）中开启一个开关，MyBatis 就会自动帮你转换。

配置文件设置：

 mybatis:
 configuration:
 # 开启驼峰命名自动映射：a_column -> aColumn
 map-underscore-to-camel-case: true

效果： 开启后，dept_name 会自动映射到 deptName

使用 ResultMap (最强大、最灵活)

如果命名完全不规则（比如数据库叫 d_n，实体类叫 deptName），或者需要处理复杂的关联查询，就需要手动定义映射规则。

在 Mapper 的 XML 文件中定义 <resultMap>：

	<resultMap id="DeptResultMap" type="com.example.pojo.Dept">
	 <id column="id" property="id" />
	 <result column="name" property="deptName" />
	 <result column="c_time" property="createTime" />
	</resultMap>
	
	<select id="findAll" resultMap="DeptResultMap">
	 SELECT id, name, c_time FROM dept
	</select>

维度	ResultMap (Join)	分开查询 (Service组装)
开发效率	高 (MyBatis 自动化)	中 (需要写 Java 逻辑)
SQL 复杂度	高 (涉及多表关联)	低 (全是单表操作)
传输压力	较大 (存在冗余字段)	小 (按需取数据)
缓存灵活性	差	好

<!--自定义结果集--> 
<resultMap id="empResultMap" type="asia.creat.pojo.Emp"> 
 <id column="id" property="id" /> 
 <result column="username" property="username" /> 
 <result column="name" property="name" /> 
 <result column="gender" property="gender" /> 
 <result column="phone" property="phone" /> 
 <result column="job" property="job" /> 
 <result column="salary" property="salary" /> 
 <result column="image" property="image" /> 
 <result column="entry_date" property="entryDate" /> 
 <result column="dept_id" property="deptId" /> 
 <result column="create_time" property="createTime" /> 
 <result column="update_time" property="updateTime" /> 
 <!--封装exprList--> 
 <collection property="exprList" ofType="asia.creat.pojo.EmpExpr"> 
 <id column="ee_Id" property="id"/> 
 <result column="ee_company" property="company"/> 
 <result column="ee_job" property="job"/> 
 <result column="ee_begin" property="begin"/> 
 <result column="ee_end" property="end"/> 
 <result column="ee_emp_id" property="empId"/> 
 </collection>
</resultMap>

Nginx

server{
	listen 90;
	# 省略......
	# ......
	location ^~ /api/{
		# 只要URL 是以 /api/ 开头的请求
		rewrite ^~/api/(.*)$ /$1 break;
		proxy_pass http://localhost:8080; # 代理转发
	}
}

各种注解

HttpServletRequest

	/* 
	* 基于HttpServetRequest接收前端请求参数，删除部门数据 
	* */ 
	@DeleteMapping("/depts") 
	public Result deleteById(HttpServletRequest request){ 
	 String idStr = request.getParameter("id"); 
	 int id = Integer.parseInt(idStr); 
	 System.out.println("根据ID删除部门:"+id); 
	 return Result.success(); 
	}

@RequestParam

	@DeleteMapping("/depts") 
	public Result deleteById(@RequestParam("id") Integer deptId){ 
	 System.out.println("根据ID删除部门:"+deptId); 
	 return Result.success(); 
	}

@DeleteMapping("/depts"): 指定该方法处理发送到 /depts 路径的 DELETE 类型请求。
@RequestParam("id"):
- ❗明确映射：强制要求前端必须传递一个名为 id 的参数，否则报错
  - 默认Request 为 true，设为false 则不传递不会报错
- 自动转换：Spring 会自动将前端传来的字符串（如 "1"）转换为 Java 的 Integer 类型。如果前端传了非数字字符，Spring 会直接抛出 400 Bad Request 错误，无需你手动编写 Integer.parseInt。
Integer deptId: 这里的变量名可以叫 deptId，因为在注解中明确指定了匹配前端的 id 字段

省略@RequestParam

如果请求参数名与形参变量名相同，直接定义方法形参即可接收 但是此时的形参只能为前端请求参数名

	@DeleteMapping("/depts") 
	public Result deleteById(Integer id){ 
	 System.out.println("根据ID删除部门:"+id); 
	 return Result.success(); 
	}

指定默认值

使用defaultValue设置默认值

	/* 
	* 分页查询 
	* */ 
	@GetMapping 
	public Result page(@RequestParam(defaultValue = "1") Integer page, Integer pageSize){ 
	 log.info("分页查询{},{}",page,pageSize); 
	 PageResult<Emp> pageResult = empService.page(page, pageSize); 
	 return Result.success(pageResult); 
	}

@RequestBody

当请求进入后端时，@RequestBody 会告诉 Spring：“不要去 URL 路径或查询参数里找数据，去请求体（HTTP Body）里找。把那段 JSON 字符串拿出来，转换成我定义的这个 Java 对象。”

Controller:
	@PostMapping("/depts") 
	public Result add(@RequestBody Dept dept){ //将json数据封装到对象 
	 System.out.println("新增部门"+dept); 
	 deptService.add(dept);
	 return Result.success(); 
	}
	
Service:
	@Override 
	public void add(Dept dept) { 
	 dept.setCreateTime(LocalDateTime.now()); 
	 dept.setUpdateTime(LocalDateTime.now()); 
	 deptMapper.add(dept); 
	}
	
Mapper:
	@Insert("INSERT INTO dept (name,create_time,update_time)VALUES (#{name},#{creatTime},#{updateTime})") 
	❗❗❗注意：VALUES后用的是属性名(驼峰命名)而不是字段名(下划线)❗❗❗
	
	void add(Dept dept);

使用前提

请求方式：通常用于 POST、PUT 或 PATCH。GET 请求没有请求体，所以不能使用
Content-Type：前端发送请求时，Header 中必须包含 Content-Type: application/json。否则后端会报 415 Unsupported Media Type 错误
属性匹配：JSON 中的键名（Key）必须与 Java 实体类中的属性名完全一致，且实体类必须提供 Setter 方法

@PathVariable

REST 风格提倡“URL 代表资源”。例如，你想访问 ID 为 5 的部门，URL 应该是 .../depts/5，而不是传统的 .../depts?id=5。这里的 5 就是一个路径变量要让 @PathVariable 生效，需要两个步骤的配合：

在路径中使用占位符：用 {变量名} 标注。
在参数前加注解：将占位符的值映射到 Java 变量。

@GetMapping("/depts/{id}") 
public Result getInfo(@PathVariable Integer id){ 
	❗❗❗ 如果占位符名称 {id} 和方法参数名 id 一致，可以直接映射❗❗❗
 System.out.println("根据ID查询部门："+ id); 
 return Result.success(); 
}

[!NOTE] 在URL中可以携带多个路径参数如 “/depts/1/0”

@DateTimeFormat

@DateTimeFormat 是一个非常实用的注解，主要用于 格式化请求参数（也就是从前端传到后端的日期字符串）

在实体类中使用（处理搜索条件）

@Data
public class EmpQueryDTO {
 private String name;
 
 // 接收类似 "2024-01-01" 的字符串
 @DateTimeFormat(pattern = "yyyy-MM-dd")
 private LocalDate beginDate;

 @DateTimeFormat(pattern = "yyyy-MM-dd")
 private LocalDate endDate;
}

直接在 Controller 参数中使用

@GetMapping 
	public Result pageByCondition(String name, Integer gender, 
		 @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin, 
		 @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end, 
		...
		...
		return Result.success(result); 
	}

[!NOTE] 如果是普通 GET 请求的参数，用 @DateTimeFormat；如果是 @RequestBody 接收的 JSON 数据，用 @JsonFormat

@Options

@Options 注解主要用于在使用 注解开发（即直接在 Mapper 接口方法上写 @Insert 或 @Update）时，配置一些额外的开关和属性。最常见的用法是 获取自增主键

	@Options(useGeneratedKeys = true,keyProperty = "id")
	//获取到生成的主键 
	@Insert("...插入语句...") 
	void insertEmp(Emp emp);

useGeneratedKeys = true：告诉 MyBatis 使用数据库生成的自增主键
keyProperty = "id"：告诉 MyBatis 把拿到的主键值，设置到 emp 对象的哪个属性中执行后的效果：

	empService.insertEmp(emp); 
	System.out.println(emp.getId()); // 这里就能打印出数据库生成的那个新 ID 了

除了获取主键，@Options 还可以配置以下内容：

属性	作用
`timeout`	设置这条 SQL 执行的超时时间（单位：秒）
`flushCache`	设置为 `true` 时，只要语句被调用，就会清空一级和二级缓存
`useCache`	是否将该查询结果放入二级缓存（默认为 true）
`statementType`	设置 SQL 执行方式（默认为 `PREPARED`，即预编译）

XML形式的等价写法

	<insert id="insert" useGeneratedKeys="true" keyProperty="id">
	 insert into emp(...) values(...)
	</insert>

将多个参数提取到实体类

代码整洁：方法参数由 10 个变成 1 个。
高复用性：这个实体类可以在 Controller、Service、Mapper 之间直接传递。
自动封装：Spring MVC 会自动根据请求参数的名称（Query Params）与实体类的属性名进行匹配并赋值

@Data 
public class EmpQueryParam { 
 private Integer page = 1; 
 private Integer pageSize = 10; 
 private String name; 
 private Integer gender; 
 @DateTimeFormat(pattern = "yyyy-MM-dd") 
 private String begin; 
 @DateTimeFormat(pattern = "yyyy-MM-dd") 
 private String end; 
}

注意事项

不要加 @RequestBody：@RequestBody 是用来解析 POST 请求里的 JSON 体的。对于 GET 请求的 URL 参数映射到对象，直接写参数即可。
默认值处理：在实体类中直接为 page 和 pageSize 赋初值，可以省去 Controller 里的 @RequestParam(defaultValue = "...")。
日期处理：记得给日期属性加上 @DateTimeFormat，否则当前端传 2026-05-20 时，后端会因为无法转换为 LocalDate 而报错。

路径抽取

修改前：每个方法（如查询、删除、新增）都要在注解里写 @GetMapping("/depts") 或 @DeleteMapping("/depts/{id}")
修改后：在 public class DeptController 顶部添加 @RequestMapping("/depts")。这样下方的方法注解就可以简化，例如：
- 查询全部简写为：@GetMapping
- 根据 ID 查询简写为：@GetMapping("/{id}")

@RequestMapping("/depts") //指定请求路径前缀 
@RestController
public class DeptController { 
 @Autowired 
 private DeptService deptService; 
	 
 @RequestMapping(value = "/depts",method = RequestMethod.GET) 
 @GetMapping 
 //指定请求方式 
 public Result list(){...} 
	 
 @PostMapping 
 public Result add(@RequestBody Dept dept){...} 
	 
 @DeleteMapping 
 public Result deleteById(Integer id){...} 
	 
 @GetMapping("/{id}") --> 即为 "/depts/{id}"
 public Result getInfo(@PathVariable Integer id){...} 
	 
	 
 @PutMapping 
 public Result update(@RequestBody Dept dept){...} 
}

日志Logback

JUL (java.util.logging)：Java 原生日志框架，虽然配置简单但灵活性和性能较差
Log4j：早期非常流行的第三方日志框架，配置灵活
Logback：由 Log4j 作者开发的升级版，性能更优，也是目前 Spring Boot 默认集成的日志实现
Slf4j (Simple Logging Facade for Java)：重点强调的“简单日志门面”，它不是真正的日志实现，而是一套标准接口，允许你在不修改代码的情况下切换底层的日志框架（如从 Log4j 切换到 Logback）

	//logger 来自 SLF4j包
	private static final Logger log =
	 org.slf4j.LoggerFactory.getLogger(LogTest.class);

可替换为注解：@Slf4j

日志级别

日志级别	说明	记录方式
trace	追踪，记录程序运行轨迹，使用很少	`log.trace("...")`
debug	调试，记录调试过程中的信息，实际应用中通常视为最低级别	`log.debug("...")`
info	记录一般信息，描述运行关键事件（如网络连接、IO 操作），使用较多	`log.info("...")`
warn	警告信息，记录潜在有害情况，使用较多	`log.warn("...")`
error	错误信息，使用较多	`log.error("...")`

只有大于等于设定级别的日志才会被输出。
如果将 root 级别设为 info，那么 trace 和 debug 级别的日志将不会被记录或显示

	<root level="info">
		<appender-ref ref="STDOUT" />
		<appender-ref ref="FILE" />
	</root>

PageHelper分页查询

原理

PageHelper 利用了 MyBatis 的 拦截器（Interceptor） 机制。它的工作流程如下：

拦截：当你调用 Mapper 方法前，PageHelper 会拦截到即将执行的 SQL
解析：自动检测你当前使用的数据库类型（MySQL, Oracle, MariaDB 等）
改写：根据你设置的页码（pageNum）和每页数量（pageSize），动态地在原始 SQL 后面拼接分页子句
自动 Count：它还会额外执行一条 SELECT COUNT(0) 来获取总记录数，方便前端显示总页数
❗SQL语句结尾不能加分号；(PageHelper会追加limit语句)
❗PageHelper仅仅能对紧跟在其后的第一个查询语句进行分页处理

使用

原始Service层

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

使用后

@Override 
	public PageResult<Emp> page(Integer page, Integer pageSize) { 
	 //设置分页参数PageHelper 
	 PageHelper.startPage(page, pageSize); 
	 //执行查询 
	 List<Emp> emp = empMapper.list(page, pageSize); 
	 //解析查询结果并封装数据 
	 Page<Emp> p = (Page<Emp>) emp; //多态的实现
	 return new PageResult<Emp>(p.getTotal(), p.getResult()); 
	}

Spring事务管理

Spring 事务的本质是利用 AOP（面向切面编程）。当你给一个方法加上事务注解时，Spring 会为该类创建一个代理对象。

开启：在方法执行前，代理对象关闭自动提交，开启事务。
提交：如果方法正常执行完毕，代理对象提交事务。
回滚：如果方法执行过程中抛出异常，代理对象捕获异常并回滚数据。

@Transactional

这是开发中最常用的方式，通过注解直接管理事务，代码零侵入

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

 @Transactional // 开启事务
 @Override
 public void deleteDept(Integer id) {
 // 1. 删除部门
 deptMapper.deleteById(id);
 
 // 模拟异常：一旦报错，上面的删除操作也会撤销
 // int i = 1/0; 
 
 // 2. 删除该部门下的所有员工
 empMapper.deleteByDeptId(id);
 }
}

属性	描述
`rollbackFor`	指定哪些异常触发回滚。默认只回滚 `RuntimeException`。建议设置为 `Exception.class` 以涵盖所有异常。
`propagation`	事务传播行为：定义当一个事务方法调用另一个事务方法时，事务如何传递。
`readOnly`	是否为只读事务。查询操作建议设为 `true`，可以优化数据库性能。

rollbackFor

	@Transactional//默认出现运行时异常RuntimeException才会回滚
	@Transactional(rollbackFor = {Exception.class})//指定所有异常都会回滚

propagation

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务
SUPPORTS	支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行；如果当前存在已有事务，则挂起当前事务
MANDATORY	必须有事务，否则抛异常
NEVER	必须没事务，否则抛异常

readOnly

@Transactional(readOnly = true)
public User getUserById(Long id) {
 return userRepository.findById(id);
}

作用：告诉数据库这是一个只读事务。
好处：数据库可以针对只读操作进行优化（例如在 MySQL 中不分配回滚段），提高查询效率

维度	说明
它能防止修改吗？	不一定。这取决于数据库和驱动。虽然 Hibernate 会跳过脏检查，但如果你在只读事务中强行执行原生 SQL 的 `UPDATE`，某些数据库可能仍然允许执行（虽然这会导致语义混乱）。
主从架构（Read/Write Splitting）	这是 `readOnly` 的关键应用场景。通过 AOP 拦截 `readOnly=true` 的方法，可以将请求路由到从库（Read Node），而将其他的路由到主库。
性能损耗	虽然它能优化内存，但开启事务本身也是有开销的（获取连接、上下文切换）。对于极其简单的单条查询，有时不加 `@Transactional` 反而更快。

失效场景

非 public 方法：@Transactional 只能用于 public 方法。
方法内部调用：同一个类中，A 方法调用 B 方法，即使 B 加了注解也不会生效（因为绕过了 AOP 代理）。
异常被捕获：如果你在代码里 try...catch 了异常且没有抛出，Spring 无法感知到报错，就不会回滚。
数据库不支持：比如 MySQL 的 MyISAM 引擎不支持事务，必须使用 InnoDB。

⭐Tips

加在 Service 层：不要加在 Controller 层，确保业务逻辑的完整性。
显式指定回滚范围：推荐使用 @Transactional(rollbackFor = Exception.class)。
保持方法短小：事务会占用数据库连接，尽量不要在事务方法中进行远程接口调用或耗时操作，防止连接池耗尽

[!TIP] @Transactional 可以加在方法上、类上、接口上 ※ 推荐加在方法上 ※

文件上传

MultipartFile

MultipartFile 是处理文件上传的核心接口。它代表了 HTML 表单中 multipart/form-data 类型的文件内容。

	@PostMapping("/upload") 
	public Result upload(String name, Integer age, MultipartFile file){ 
	 log.info("接收参数：{},{},{}",name,age,file); 
	 return Result.success(); 
	}

方法	说明
`getName()`	获取表单中文件参数的名称（如上面例子中的 “file”）。
`getOriginalFilename()`	获取客户端文件系统的原始文件名。
`getContentType()`	获取内容类型（如 `image/png`）。
`isEmpty()`	判断文件是否为空（没有内容或未选择文件）。
`getSize()`	返回文件大小（单位：字节）。
`getBytes()`	以字节数组形式读取文件内容。
`getInputStream()`	获取输入流，用于流式读取（适合大文件处理）。
`transferTo(File dest)`	最常用：将上传的文件直接保存到目标文件。

问题及注意事项

多文件上传：如果你需要一次上传多个文件，将参数改为数组或列表即可： public String upload(@RequestParam("files") MultipartFile[] files)
文件名冲突：直接使用 getOriginalFilename() 可能导致重名覆盖。建议使用 UUID 或 时间戳 重命名文件。
临时存储： MultipartFile 在处理时会产生临时文件（存储在操作系统的 tmp 目录）。一旦请求处理完成，这些临时文件会被自动删除。
安全性：务必校验文件后缀名和文件头（Magic Number），防止用户上传恶意的 .exe 或 .sh 脚本文件。

存储在本地

	@PostMapping("/upload") 
	public Result upload(String name, Integer age, MultipartFile file) throws IOException { 
	 log.info("接收参数：{},{},{}",name,age,file); 
	 //原始文件名 
	 String fof = file.getOriginalFilename(); 
	 //新文件名 
	 String extension = fof.substring(fof.lastIndexOf(".")); 
	 String newName = UUID.randomUUID() + extension; 
	 //保存文件 
	 file.transferTo(new File("F:/images/"+ newName)); 
	 return Result.success(); 
	}

Spring中默认上传文件最大大小为1MB，超过大小需要在配置文件中配置

# 文件上传
Spring:
	servlet: 
	 multipart: 
	 # 最大单个文件大小 
	 max-file-size: 10MB 
	 # 最大请求大小（包含所有文件和表单数据） 
	 max-request-size: 100MB

OSS

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

# 阿里云 OSS配置 
aliyun: 
 oss: 
 endpoint: https://oss-cn-beijing.aliyuncs.com 
 bucketName: creat-spring-oss 
 region: cn-beijing

批量注入值@ConfigurationProperties

@Component 
public class AliyunOSSOperator { 
 @Autowired 
 private AliyunOSSProperties aliyunOSSProperties; 
	
	
	public String upload(byte[] content, String originalFilename) throws ClientException {
	 String endpoint = aliyunOSSProperties.getEndpoint(); 
	 String bucketName = aliyunOSSProperties.getBucketName(); 
	 String region = aliyunOSSProperties.getRegion();
	 
	 ......
 }
}

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

全局异常处理器

无论程序在哪里抛出了异常，都能被这个处理器统一拦截，并返回一个优雅、格式统一的错误信息给前端或客户端

注解

@RestControllerAdvice：标记这是一个增强版的控制器，专门处理全局层面的逻辑(@ControllerAdvice + @ResponseBody)。
@ExceptionHandler：指定具体的异常类型，当这种异常发生时，执行对应的方法。

核心流程：

异常发生：Controller 或 Service 层抛出一个异常（如 UserNotFoundException）。
自动捕获：Spring 发现该异常未被内部 try-catch，于是将其向上抛给全局处理器。
匹配处理：处理器根据异常类型找到对应的处理方法。
返回结果：处理器将异常包装成一个通用的 Result 对象（包含错误码、错误消息），转换成 JSON 返回。

@RestControllerAdvice // = @ControllerAdvice + @ResponseBody
public class GlobalExceptionHandler {

 // 处理自定义业务异常
 @ExceptionHandler(BusinessException.class)
 public Result handleBusinessException(BusinessException e) {
 return Result.error(e.getCode(), e.getMessage());
 }

 // 处理参数验证异常 (如 @Valid 校验失败)
 @ExceptionHandler(MethodArgumentNotValidException.class)
 public Result handleValidationException(MethodArgumentNotValidException e) {
 String msg = e.getBindingResult().getFieldError().getDefaultMessage();
 return Result.error(400, msg);
 }

 // 兜底：处理所有未知的运行异常
 @ExceptionHandler(Exception.class)
 public Result handleException(Exception e) {
 log.error("系统崩溃了，救命！", e); 
 return Result.error(500, "服务器开小差了，请稍后再试");
 }
 ---------------------
	@ExceptionHandler 
	public Result handleException(Exception e) { 
	 log.error("发生异常: ", e); 
	 return Result.error("服务器发生异常，请稍后再试"); 
	} 
	@ExceptionHandler 
	public Result handleDuplicateKeyException(DuplicateKeyException e) { 
	 log.error("发生异常: ", e); 
	 String msg = e.getMessage(); 
	 int i = msg.indexOf("Duplicate entry"); 
	 String errMsg = msg.substring(i); 
	 String[] arr = errMsg.split(" "); 
	 
	 return Result.error("'" + arr[2] + "' 已存在，请检查数据"); 
	}
}

会话技术

工作流程

Cookie 的本质是通过 HTTP 响应头和请求头在外部交换数据：

设置阶段：服务器在响应（Response）中加入 Set-Cookie 头部字段。
存储阶段：浏览器收到响应后，将 Cookie 内容保存在本地（内存或硬盘）。
携带阶段：下次请求同一个域名时，浏览器会自动在请求（Request）头中加入 Cookie 字段。

缺点

维度	缺点	说明
存储能力	容量小	单个 Cookie 最大限制约为 4KB，不适合存大数据。
用户控制	可被禁用	用户可以在浏览器设置中完全禁止接收 Cookie，导致功能失效。
安全性	不安全	默认明文存储在客户端，极易受到 XSS 攻击窃取或中间人篡改。
访问限制	跨域限制	受到同源策略限制，Cookie 无法在不同的一级域名间直接共享。
网络性能	占用带宽	每次 HTTP 请求都会自动携带相关 Cookie，增加了请求头体积，浪费流量。
合规隐私	隐私问题	常用于行为追踪，可能触犯 GDPR 等隐私法规，令用户反感。
生命周期	时效性	默认为会话级别（关闭浏览器即消失），除非开发者手动设置 `Max-Age`。
物理限制	无法跨设备	数据绑定在特定设备的特定浏览器上，无法实现手机/电脑端同步。

典型场景与规避方案

敏感信息处理：
- 原则：绝不在 Cookie 中存储密码、身份证号等敏感数据。
- 方案：仅存储加密后的 Token，并设置 HttpOnly 属性以防止 JS 脚本读取。
移动端开发：
- 痛点：部分原生 App 内置浏览器或某些移动端环境对 Cookie 支持不佳。
- 方案：在移动端或前后端分离架构中，优先考虑使用 JWT (JSON Web Token) 并通过自定义 Header 传输。
分布式/集群环境：
- 痛点：多台服务器之间无法直接共享保存在各自内存或浏览器关联的传统 Session。
- 方案：采用 分布式会话（如 Spring Session + Redis），将状态数据统一托管在外部缓存中。

Session

工作原理

Session 的核心在于服务器与浏览器之间的一个“约定”。

创建： 当用户第一次访问服务器时，服务器会为该用户创建一个唯一的 HttpSession 对象，并生成一个唯一的 ID（通常称为 JSESSIONID）。
传递： 服务器通过 HTTP 响应头，将这个 JSESSIONID 以 Cookie 的形式发送给浏览器。
识别： 当浏览器再次请求该服务器时，会自动在请求头中携带这个 JSESSIONID。
检索： 服务器根据收到的 ID，在内存中找到对应的 Session 对象

生命周期

开始： 用户第一次调用 request.getSession() 时。
超时： 为了节省服务器内存，Session 不会永久存在。如果用户在一段时间内（默认通常是 30 分钟）没有任何操作，Session 会自动销毁。

缺点

维度	优势	劣势
开发难度	简单易用：Java 原生支持，直接调用 `getAttribute` 即可，逻辑清晰。	依赖 Cookie：如果客户端禁用了 Cookie，Session 就会失效（需额外处理 URL 重写）。
数据安全	安全性高：敏感数据留在服务器，客户端只拿一个加密 ID，不容易被篡改。	会话劫持：如果 ID 被窃取，攻击者可以完全冒充用户身份（需 HTTPS 配合）。
性能表现	读写极快：数据就在本地内存中，无需网络开销，适合单机小型应用。	内存消耗：用户多了会占满服务器内存。用户关浏览器不点退出，数据会白白占用内存直到超时。
架构扩展	无需额外中间件：单机部署时非常方便，不需要安装 Redis 等数据库。	分布式困境：多台服务器环境下，Session 不共享，会导致用户登录状态频繁丢失。
数据类型	灵活：可以存储复杂的 Java 对象，不需要像 Token 那样进行频繁的序列化转换。	存储限制：不能存太大的东西（如大列表、大图片），否则严重拖慢服务器性能。

对比Cookie

特性	Cookie	Session
存储位置	客户端（浏览器）	服务器端
安全性	较低（易被伪造或窃取）	较高（敏感数据不发送给客户端）
存储容量	较小（通常单个 4KB）	较大（取决于服务器内存）
数据类型	只能存储字符串	可以存储任意 Java 对象
性能影响	几乎不占用服务器资源	占用服务器内存，用户多时压力大

⭐Token令牌（主流）

工作原理

1. 签发： 当用户通过用户名和密码登录成功后，服务器会根据用户信息（如用户 ID）和一段只有服务器知道的“秘钥”，生成一个加密的字符串（即 Token）。

2. 传输： 服务器将这个 Token 作为响应体的一部分发送给浏览器。与 Session 不同，服务器此时不会在自己的内存或数据库中保存这个 Token。

3. 存储： 浏览器接收到 Token 后，通常将其存储在 localStorage、sessionStorage 或 Cookie 中。

4. 携带： 当浏览器后续请求受保护的资源（如获取订单列表）时，会手动将 Token 放入 HTTP 请求头中（通常放在 Authorization: Bearer <Token> 字段）。

5. 校验： 服务器接收到请求后，不再去查找数据库或内存，而是直接使用存储在服务器本地的“秘钥”对该 Token 进行解密和签名校验。

6. 提取： 如果校验通过，服务器就认为该请求是合法的，并直接从 Token 内部解密出用户信息（如该用户是“张三”），从而完成业务处理。

JWT组成

这部分用于描述 JWT 的元数据，告诉服务器如何处理这个令牌。

内容： 通常包含令牌的类型（typ: “JWT”）和所使用的加密算法（alg: 如 “HS256” 或 “RS256”）。
编码： 使用 Base64URL 算法进行编码。

	{ "alg": "HS256", "typ": "JWT" }

Payload（有效载荷）—— “货物”

这是 JWT 的核心部分，包含了实际要传递的用户信息（Claims）。

标准字段： 如签发人（iss）、过期时间（exp）、用户 ID（sub）等。
自定义字段： 你可以放入用户的角色、权限、姓名等（例如："role": "admin"）。
编码： 同样使用 Base64URL 编码。
注意： 这里的内容只是编码，并不是加密。绝对不要在此处存放密码或敏感信息，因为任何人拿到 Token 都能通过解码看到里面的内容。

	{ 
		"sub": "ZhangSan", 
		"role": "Java-Dev", 
		"exp": 1746144000 
	}

Signature（签名）—— “防伪封条”

这是保证安全的关键。它用于验证 Token 在传输过程中是否被篡改。

生成原理： 服务器将编码后的 Header 和 Payload 用点拼接起来，再加上一个只有服务器知道的密钥（Secret），按照 Header 中指定的算法进行哈希计算。
作用： 如果有人修改了 Payload 里的用户权限（比如把 user 改成 admin），由于他没有服务器的密钥，生成的签名就会和原来的不匹配。服务器校验失败，该 Token 立即失效。

	a-string-secret-at-least-256-bits-long

总结外观

一个完整的 JWT 看起来像这样： eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9. eyJzdWIiOiJaaGFuZ3NhbiIsInJvbGUiOiJKYXZhLURldiIsImV4cCI6MTc0NjE0NDAwMH0. MJSEga1Hm1wHRnaCKpjSzXcr7DpI3TlhDQoGcIWnXDA

xxxxx.yyyyy.zzzzz

红色部分 (xxxxx): 头部，声明算法。
蓝色部分 (yyyyy): 负载，存放用户信息。
绿色部分 (zzzzz): 签名，由前两部分加盐哈希而成

JWR生成/解析

private static final String SECRET = "基于base64的字符串（字节数必须大于32）"; 
private static final SecretKey KEY = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
 
@Test 
public void testGenerateJwt() { 
 Map<String, Object> dataMap = new HashMap<>(); 
 dataMap.put("userId", 1); 
 dataMap.put("username", "admin"); 
 
 String token = Jwts.builder() 
 .claims(dataMap) 
 .expiration(new Date(System.currentTimeMillis() + 3600 * 1000)) 
 .signWith(KEY) 
 .compact(); 
 
 System.out.println(token); 
} 
 
@Test 
public void testParseJwt() { 
 String token = "JWT得到的Token"; 
 Claims claims = Jwts.parser() 
 .verifyWith(KEY) 
 .build() 
 .parseSignedClaims(token) 
 .getPayload(); 
 System.out.println(claims); 
}

`Cookie,Session,Token`对比

维度	Cookie	Session	Token (JWT)
定义	存储在浏览器端的一段文本。	服务器端的一种会话记录机制。	一段经过加密/签名的凭证字符串。
核心位置	客户端	服务器（内存/数据库/Redis）	客户端（服务器不存储）
工作逻辑	浏览器自动携带。	依赖 Session ID 匹配服务器记录。	客户端手动放入 Header，服务器解密。
安全性	较低，容易被拦截或伪造。	较高，敏感信息存在服务器。	高，有签名校验，防篡改。
扩展性	无。	差，多台服务器需做数据同步。	极佳，天然支持跨服务器、跨域。
存储压力	无（存在用户本地）。	较大，用户多时会消耗大量服务器内存。	无（存在用户本地）。

优点对比

维度	Cookie (客户端存储)	Session (服务端存储)	Token (无状态令牌/JWT)
最大优势	减轻服务器压力：数据存用户本地，服务器不占内存。	数据最安全：敏感信息不发给客户端，只在服务器内部。	极易水平扩展：服务器不存任何数据，非常适合微服务/集群。
生命周期	持久性好：可以设置长达数天的有效期，甚至关机后再开也存在。	控制力强：服务器可以随时主动让某个特定用户下线。	性能均衡：不需要查数据库或缓存，服务器解析 Token 即可校验身份。
开发难度	最简单：浏览器原生支持，几乎不需要写代码逻辑。	非常简单：成熟的框架（如 Spring）自动处理 ID 传递。	跨域支持完美：不受浏览器跨域限制，App、小程序、H5 通用。
存储能力	随用随取：适合存偏好设置（如主题颜色、语言）。	类型多样：可以存复杂的 Java 对象（用户角色、权限列表）。	自包含：Token 内部可以携带用户信息，减少后端查询次数。

过滤器Filter

核心作用

过滤器主要用于处理一些通用性的横切关注点：

权限校验：检查请求头中是否携带有效的 JWT Token。
字符编码转换：统一设置 request 和 response 的编码（如 UTF-8）。
日志记录：统计接口的访问耗时、记录请求来源 IP。
敏感词过滤：对用户提交的内容进行安全扫描。

工作原理：责任链模式

过滤器并不是独立存在的，它们通常组成一个过滤器链 (FilterChain)。

执行前处理：请求进入时，过滤器先执行 doFilter 方法中 chain.doFilter() 之前的代码。
放行（传递）：调用 chain.doFilter(request, response)。如果有下一个过滤器，就传给下一个；如果没有，就传给 Servlet（或 Controller）。
执行后处理：当核心业务处理完返回响应时，代码会回到 chain.doFilter() 之后，执行后续逻辑。

执行顺序

$$Filter \rightarrow Controller \rightarrow Service \rightarrow Mapper \rightarrow DB$$
$$\uparrow \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \downarrow$$
$$Filter(回程) \leftarrow Controller \leftarrow Service \leftarrow Mapper$$

		[浏览器请求]
		 │
		 ▼
		┌────── Filter (去程：校验Token、记录时间) ──────┐
		│ │ │
		│ ▼ │
		│ ┌──── Controller (解析请求、参数校验) ────┐ │
		│ │ │ │ │
		│ │ ▼ │ │
		│ │ ┌── Service (业务逻辑处理) ────────┐ │ │
		│ │ │ │ │ │ │
		│ │ │ ▼ │ │ │
		│ │ │ ┌ Mapper (SQL执行) ──┐ │ │ │
		│ │ │ │ │ │ │ │ │
		│ │ │ │ ▼ │ │ │ │
		│ │ │ │ [ 数据库 DB ] <────┘ │ │ │
		│ │ │ │ │ (返回结果) │ │ │
		│ │ │ └────────────────────────────┘ │ │
		│ │ │ │ │ │ │
		│ │ └── Service (业务结果组装) ────────┘ │ │
		│ │ │ │ │
		│ └──── Controller (封装结果对象) ─────────┘ │
		│ │ │
		└────── Filter (回程：清理ThreadLocal、日志打印) ┘
		 │
		 ▼
		[返回响应]
//-- 这种图强调了 Filter 是最外层，它包裹着所有的内部组件：--
		( ( ( ( [ 数据库 DB ] ) ) ) )
 ▲ ▲ ▲ ▲ ▲ ▼ ▼ ▼ ▼ ▼
 │ │ │ └─────┴───┘ │ │ │ │
 │ │ └──── Mapper ─────┘ │ │ │
 │ └─────── Service ─────────┘ │ │
 └────────── Controller ───────────┘ │
 └───────────── Filter ──────────────────┘
 [请求进入] [响应返回]

去程： Client $\rightarrow$ Filter $\rightarrow$ Controller $\rightarrow$ Service $\rightarrow$ Mapper $\rightarrow$ DB

核心： 数据库执行查询/更新

回程： DB $\rightarrow$ Mapper $\rightarrow$ Service $\rightarrow$ Controller $\rightarrow$ Filter $\rightarrow$ Client

—页尾—

注意事项

@PathVariable与@RequestParam

方式	前端URL	后端请求	什么时候用？
精准定位	`/clazzs/5`	`/{id}` + `@PathVariable`	删除单个 ID
带清单操作	`/clazzs?ids=1,2,3`	`(无路径)` + `@RequestParam`	批量删除
路径串烧	`/clazzs/1,2,3`	`/{ids}` + `@PathVariable`	极少用，除非有特殊设计需求

`xml`的更新语句

字段类型	业务要求	判定表达式	避坑指南
String	必填 (非空且非空串)	`test="name != null and name != ''"`	这样可以防止前端传个空字符串 `""` 导致数据库存入无意义数据。
String	允许置空	`test="address != null"`	注意：这样如果传 `""`，它会判定为非 null，从而把空串插入数据库。
Integer / 数字	必填	`test="id != null"`	绝对不要加 `and id != ''`！如果 id 为 0，MyBatis 可能会误判它等于空串，导致 0 存不进去。
Integer / 数字	允许置空	`test="degree != null"`	同上，只判断 null 即可。

操作类型	字段类型	推荐写法	理由
SELECT (搜索)	任何类型	`!= null and != ''`	防前端传空搜索框导致的“查无数据”。
UPDATE (更新)	String	`!= null and != ''`	过滤无效空串，保证数据严谨。
UPDATE (更新)	Integer	`!= null`	最安全，防止 `0` 值无法更新。
INSERT (插入)	任何类型	`!= null`	通常只为了防止 null 值覆盖数据库默认值。

Web

Sat, 11 Apr 2026 00:00:00 +0000

本文更新于 2026-04-11

SpringBootWeb基础

/* 
* 请求处理类 
* */ 
@RestController 
public class HelloController { 
 /* 
 * 响应返回值 
 * */ @RequestMapping("/Hello") 
 public String Hello(String name){ 
 System.out.println("name:"+name); 
 return "Hello" + name + "~"; 
 } 
}

HTTP协议

概念:Hyper Text Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则

特点:
1. 基于TCP协议：面向连接，安全
2. 基于请求-响应模型的：一次请求对应一次响应
3. HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。
- 缺点:多次请求间不能共享数据。
- 优点:速度快

请求协议

请求数据格式

请求行 (Request Line)

包含三个核心信息：

请求方法：GET、POST、PUT、DELETE 等。
资源路径：例如 /api/v1/users。
协议版本：通常是 HTTP/1.1 或 HTTP/2。

示例：POST /login HTTP/1.1

请求头 (Request Headers)

用键值对（Key: Value）的形式告知服务器客户端的环境、权限以及数据格式。常见头信息：

Host: 服务器域名。
User-Agent: 客户端浏览器或系统信息。
Content-Type: 最重要的字段，告诉服务器请求体里装的是什么格式的数据（如 JSON 或表单）。
Authorization: 携带 Token 进行登录校验。

空行 (Empty Line)

必须存在的一行空行，用于分隔“报头”和“数据体”。

请求体 (Request Body)

真正传输的数据。注意：GET 请求通常没有请求体（参数放在 URL 后），而 POST、PUT 请求通常将数据放在这里。

请求数据获取

@RestController 
public class RequestController { 
 @RequestMapping("/request") 
 public String request(HttpServletRequest request) { 
 //获取请求方式 
 String method = request.getMethod(); 
 System.out.println("请求方式:" + method); 
 //获取请求url地址 
 String url = request.getRequestURL().toString();
 //http://localhost:8080/request 
 
 System.out.println("请求url地址:" + url); 
 String uri = request.getRequestURI();//request 
 System.out.println("请求uri地址:" + uri); 
 
 //获取请求协议 
 String protocol = request.getProtocol(); 
 System.out.println("请求协议:" + protocol); 
 //获取请求参数 - name 
 String name = request.getParameter("name"); 
 String age = request.getParameter("age"); 
 System.out.println("请求参数name:" + name + ",age:" + age); 
 
 //获取请求头 - Accept 
 String accept = request.getHeader("Accept"); 
 System.out.println("请求头Accept:" + accept); 
 
 return "OKK"; 
 } 
}

URL (Uniform Resource Locator)：资源的路径。它像家庭住址：http://localhost:8080/request。
URI (Uniform Resource Identifier)：资源的身份证。它只关心资源本身：/request。

面试题： 所有的 URL 都是 URI，但不是所有的 URI 都是 URL

响应协议

响应数据格式

响应行

协议版本 + 状态码 + 状态描述

例如：HTTP/1.1 200 OK 或 HTTP/1.1 404 Not Found。

响应头

服务器告知客户端的数据元信息。

Content-Type: 最关键。告知浏览器数据格式（如 application/json 或 text/html）。
Set-Cookie: 服务器给客户端种下的“小饼干”。

空行

分隔头部与内容。

响应体

真正传回给前端的数据（HTML、JSON、图片字节流等）

HTTP 状态码	含义说明
`1xx`	响应中 - 临时状态码，表示请求已经接收，告诉客户端应该继续请求或者如果它已经完成则忽略它。
`2xx`	成功 - 表示请求已经被成功接收，处理已完成。
`3xx`	重定向 - 重定向到其他地方；让客户端再发起一次请求以完成整个处理。
`4xx`	客户端错误 - 处理发生错误，责任在客户端。如：请求了不存在的资源、客户端未被授权、禁止访问等。
`5xx`	服务器错误 - 处理发生错误，责任在服务端。如：程序抛出异常等。
最常见状态码：

状态码	英文描述	解释
`200`	`OK`	请求成功，服务器正常处理并返回资源
`404`	`Not Found`	请求的资源不存在
`500`	`Internal Server Error`	服务器内部错误，无法完成请求
字段解释：

响应头字段	含义说明
`Content-Type`	表示该响应内容的类型，例如`text/html`, `application/json`。
`Content-Length`	表示该响应内容的长度（字节数）。
`Content-Encoding`	表示该响应压缩算法，例如`gzip`。
`Cache-Control`	指示客户端应如何缓存，例如`max-age=300`表示可以最多缓存 300 秒。
`Set-Cookie`	告诉浏览器为当前页面所在的域设置 cookie。

响应数据设置

@RestController 
public class ResponseController { 
 @RequestMapping("/response") 
 public void response(HttpServletResponse response) throws IOException { 
 //设置响应状态码 
 response.setStatus(401); 
 //设置响应头 
 response.setHeader("name","itcast"); 
 //设置响应体 
 response.getWriter().write("<h1>Hello Response</h1>"); 
 // 
 } 
 /* 
 * 方法二 
 * 基于ResponseEntity构建响应对象 
 * */ @RequestMapping("/response2") 
 public ResponseEntity<String> response2(){ 
 return ResponseEntity 
 .status(401) 
 .header("name","javaweb") 
 .body("<h1>Hello ResponseEntity</h1>"); 
 } 
}

案例

//UserController
/* 
 * 用户信息Controller 
 * */@RestController 
public class UserController { 
 @RequestMapping("/list") 
 public List<User> list() throws FileNotFoundException { 
 //加载并读取user.txt 
 InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt"); 
 ArrayList<String> lines = IoUtil.readLines 
 (in, StandardCharsets.UTF_8, new ArrayList<>()); 
 //解析用户信息，封装为User对象，list集合 
 List<User> userList = lines.stream().map(line -> { 
 String[] parts = line.split(","); 
 Integer id = Integer.parseInt(parts[0]); 
 String username = parts[1]; 
 String password = parts[2]; 
 String name = parts[3]; 
 Integer age = Integer.parseInt(parts[4]); 
 LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); 
 return new User(id, username, password, name, age, updateTime); 
 }).toList(); 
 
 //返回数据json 
 return userList; 
 } 
}

//User
@Data 
@NoArgsConstructor // 
@AllArgsConstructor //全参 
public class User { 
 private Integer id; 
 private String username; 
 private String password; 
 private String name; 
 private Integer age; 
 private LocalDateTime updateTime; 
 
}

1.静态资源文件存放位置

resources/static

2.@ResponseBody 注解的作用

将 controller 方法的返回值直接写入 HTTP 响应体

如果是对象或集合，会先转为 json，再响应

@RestController = @Controller + @ResponseBody

分层解耦

耦合: 衡量软件中各个层/各个模块的依赖关联程度。

内聚: 软件中各个功能模块内部的功能联系。

设计原则：高内聚低耦合

三层架构

层次名称	对应英文	核心注解	职责描述（通俗理解）
控制层	Controller	`@RestController`	门面。负责接收请求、校验参数，并把结果响应给前端。它不负责处理业务。
业务逻辑层	Service	`@Service`	大脑。负责所有的计算、逻辑判断、事务管理。它是系统最核心的部分。
数据访问层	dao(Data Access Object)	`@Repository`	搬运工。负责与数据库打交道，进行增删改查（CRUD）。

Controller

/* 
 * 用户信息Controller 
 * */@RestController 
public class UserController { 
 private UserService userService = new UserServiceImpl(); 
 *多态的实现*
 @RequestMapping("/list") 
 public List<User> list() throws FileNotFoundException { 
 
 List<User> list = userService.findAll(); 
 *多态的实现*
 
 return list; 
 } 
}

Service

//接口
public interface UserService { 
 /* 
 *查询所有用户信息 
 * */ 
 public List<User> findAll(); 
}

//实现类
//带impl就是一个实现类 
public class UserServiceImpl implements UserService { 
 private UserDao userDao = new UserDaoImpl(); 
	*多态的实现*
 @Override 
 public List<User> findAll() { 
 List<String> lines = userDao.findAll(); 
 *多态的实现*
 
 List<User> userList = lines.stream().map(line -> { 
 String[] parts = line.split(","); 
 Integer id = Integer.parseInt(parts[0]); 
 String username = parts[1]; 
 String password = parts[2]; 
 String name = parts[3]; 
 Integer age = Integer.parseInt(parts[4]); 
 LocalDateTime updateTime = LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); 
 return new User(id, username, password, name, age, updateTime); 
 }).toList(); 
 return userList; 
 } 
}

Dao

//接口
public interface UserDao { 
 /* 
 * 加载用户数据 
 * */ 
 public List<String> findAll(); 
}

//实现类
public class UserDaoImpl implements UserDao { 
 @Override 
 public List<String> findAll() { 
 
 InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt"); 
 
 ArrayList<String> lines = IoUtil.readLines 
 (in, StandardCharsets.UTF_8, new ArrayList<>()); 
 
 return lines; 
 } 
 
}

控制反转（IOC）& 依赖注入（DI）& Bean对象

对象的创建控制权由程序自身转移到外部(容器)，这种思想称为控制反转
容器为应用程序提供运行时，所依赖的资源，称之为依赖注入
IOC容器中创建、管理的对象，称之为Bean

IOC详解

如何将一个类交给 IOC 容器管理？

@Component（注意：是加在实现类上，而非接口上）

如何从 IOC 容器中找到该类型的 bean，然后完成依赖注入？

@Autowired

@Component时声明bean的基础注解其他三个是@Component的衍生注解

注解	适用层级	语义描述
`@Component`	通用组件	不属于以下三类时，用此注解（如工具类、配置类）。
`@Controller`	标注在控制层类 (Web)	负责处理 HTTP 请求，分发数据。
`@Service`	标注在业务逻辑层类	负责核心业务逻辑处理、事务管理。
`@Repository`	标注在数据访问层类 (Dao)	负责数据库的增删改查，并能将原生数据库异常转为 Spring 异常。（由于与mybatis整合，用的少）

[!warning] ❗：@RestController 注解内部已经包含 @Controller

❗：声明bean的时候，可以通过注解的value属性指定bean的名字，如果没有指定，默认为类名首字母小写

DI详解

基于@Autowired进行依赖注入的常见方式

①.属性注入

这是最常见、最简洁的方式。直接在成员变量上加上 @Autowired。

 @RestController
 public class UserController {
 	@Autowired
 	private UserService userService; // 直接注入
 }

优点：代码极其简洁，可读性好。
缺点：
- 不能使用 final 修饰变量（因为变量必须在对象实例化后通过反射注入）。
- 隐藏依赖关系：外部不通过反射很难看到这个类到底依赖了谁。
- 违背单一职责原则：因为写起来太简单，容易导致一个类注入了过多的依赖。

②.构造器注入—Spring官方推荐

通过类的构造函数来完成注入。

 @Service //将当前类给IOC容器管理 
 public class UserServiceImpl implements UserService { 
 private final UserDao userDao; //可以是final
 @Autowired //可省略！
 public UserServiceImpl(UserDao userDao) { 
 this.userDao = userDao; 
 }
 }

优点：
- 支持 final 关键字：保证了依赖在对象创建后不可变，更加安全。
- 完全初始化：确保对象在被调用前，所有依赖都已就绪。
- 易于测试：在写单元测试时，可以直接通过 new 一个对象并传入 Mock 依赖，不需要启动整个 Spring 容器。
注意：如果类中只有一个构造函数，Spring 4.3 以后可以省略 @Autowired

③.Setter方法注入

通过对应的 setXxx 方法来注入依赖。

 @RestController 
 public class UserController { 
 private UserService userService; 

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

优点：允许依赖在之后被修改（灵活性高）。
缺点：
- 不能使用 final。
- 对象在被使用时可能处于“未完全初始化”的状态（如果没调用 set 方法）

对比：

注入方式	是否推荐	支持 final	优点	缺点
属性注入	慎用	否	简单、快	依赖关系不透明，不方便单元测试
构造器注入	强烈推荐	是	安全、强制初始化、方便测试	代码略显冗长
Setter 注入	可选	否	灵活，可按需注入	无法保证对象完整性

当出现多个相同类型的Bean就会报错，如何解决？

①使用 @Primary

如果你希望在大多数情况下都使用某个特定的实现类，可以在该类上加上 @Primary 注解。

效果：当存在多个候选 Bean 时，Spring 会优先注入标注了 @Primary 的那一个

 @Primary
 @Service
 public class UserServiceImpl1 implements UserService { 
 // ... 
 }

 @Service
 public class UserServiceImpl2 implements UserService { 
 // ... 
 }

②使用@Qualifier(指定具体的名称)

如果你想在不同的地方注入不同的实现，可以配合 @Autowired 使用 @Qualifier，并指定 Bean 的名称。

注意：Bean 的默认名称是类名首字母小写（如 userServiceImpl1），你也可以在注解中手动指定名称，如 @Service("userService2")。

 @RestController
 public class UserController {
 @Autowired
 @Qualifier("userServiceImpl1") // 明确告诉 Spring：我要这一个
 private UserService userService;
 }

③使用@Resource(直接按名称查找)

@Resource 是 JDK 提供的注解（Spring 也支持）。它与 @Autowired 的最大区别在于查找顺序：

@Autowired：先按类型找，如果类型有多个，再按名称找。
@Resource：先按名称找，如果名称找不到，再按类型找。

 @RestController
 public class UserController {
 @Resource(name = "userServiceImpl2") // 直接通过名字“精准定位”
 private UserService userService;
 }

解决方案	核心原理	适用场景
`@Primary`	权重优先	存在一个“绝对主流”的实现类时。
`@Qualifier`	类型 + 名称辅助	需要在不同类中灵活切换不同实现时。
`@Resource`	名称优先	想减少对 Spring 注解的依赖，或更倾向于按名字查找时。

问题

问：“既然没有代码显式调用构造函数，Spring 是如何实现注入的？”

这是通过 IoC 容器 的生命周期管理实现的。Spring 启动时会解析 BeanDefinition（Bean 的定义信息）。如果发现是构造器注入，Spring 会通过反射查找匹配的参数 Bean，并利用 Constructor.newInstance() 方法完成实例化。这种方式将对象的创建权交给了容器，实现了真正的控制反转。

问：“如果你在代码里同时用了 @Primary 和 @Qualifier，谁会生效？”

“@Qualifier 的优先级更高。因为 @Primary 定义的是默认的首选 Bean，而 @Qualifier 是在注入点进行的‘精准指名’。这就好比食堂默认提供大米饭（Primary），但你明确跟打饭阿姨说你要面条（Qualifier），阿姨肯定会给你面条。”

附录

状态码大全

Maven

Fri, 10 Apr 2026 00:00:00 +0000

本文更新于 2026-04-10

用于管理和构建Java项目的工具
拥有本地仓库，中央仓库，远程仓库（私服）

* 生命周期

Maven 的工作是有固定逻辑顺序的 只需要执行一个命令，它会自动执行之前的所有步骤：（前提：同一生命周期）

clean：清理旧的编译文件（删掉 target 目录）
compile：编译源代码
test：运行单元测试
package：打包（生成可执行的 Jar 包）
install：把打好的包安装到本地仓库，让其他项目也能引用它

坐标

在 Maven 中，坐标（Coordinates） 是用来唯一标识一个 Jar 包（插件或项目）的地址

坐标的核心组成（GAV）

一个最基本的坐标由三个核心部分组成，简称 GAV：

groupId (团体/组织 ID)：
- 含义：定义当前项目隶属的实际项目或组织。
- 命名习惯：通常是公司域名的倒写。例如：com.google、org.apache、com.alibaba。
artifactId (项目 ID)：
- 含义：该组织下的某个具体模块或项目的名称。
- 命名习惯：通常是项目名。例如：spring-boot-starter-web、mysql-connector-java。
version (版本)：
- 含义：当前项目的版本号。
- 常见格式：1.0.0-RELEASE（正式版）或 2.1.5-SNAPSHOT（开发快照版）

在`pom.xml`中的样子

当你去 Maven 中央仓库 搜到一个依赖时，它会给你这样一段坐标代码，你只需把它复制到 dependencies 标签里：

	<dependency>
	 <groupId>org.mybatis</groupId>
	 <artifactId>mybatis</artifactId>
	 <version>3.5.13</version>
	</dependency>

坐标与目录结构的逻辑顺序

坐标不仅仅是几个字母，它直接决定了 Jar 包在本地仓库中的物理存放路径。

如果本地仓库路径是 D:\maven_repo，那么上面 MyBatis 的 Jar 包会被存放在： D:\maven_repo \ org \ mybatis \ mybatis \ 3.5.13 \ mybatis-3.5.13.jar

groupId：中的点（.）会被转换成文件夹斜杠（\）。
artifactId：是下一级文件夹。
version：是再下一级文件夹。

依赖配置

在 Maven 项目中，依赖配置（Dependency Configuration） 是通过 pom.xml 文件来声明项目运行所需的外部库

依赖传递与排除 (Exclusions)

这是 Maven 解决复用性的核心逻辑：如果引入了 A，而 A 依赖了 B，Maven 会自动把 B 也下载下来。

问题：如果 A 引入的 B 版本太旧，导致项目报错怎么办？解决：使用 <exclusions> 手动切断传递

<dependency>
 <groupId>com.example</groupId>
 <artifactId>library-a</artifactId>
 <version>1.0.0</version>
 
 <exclusions>
 <exclusion>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-log4j12</artifactId>
 </exclusion>
 </exclusions>
</dependency>

常见配置逻辑顺

确定需求：比如需要连接 MySQL。
查找坐标：在 MVNrepository 搜索 mysql-connector-java
粘贴配置：将代码放入 pom.xml
刷新 Maven：在 IDEA 中点击刷新图标
检查冲突：在 IDEA 右侧 Maven 面板查看 Dependencies 树，确认没有红色的冲突标识

[!WARNING] 警告

如果依赖配置变更了，必须要刷新/重新加载

单元测试

单元测试 (Unit Testing) 是指对软件中的最小可测试单元（在 Java 中通常是一个类或一个方法）进行检查和验证

为什么要写单元测试？

快速反馈：改完代码秒知对错，不用等启动整个项目或手动点浏览器。
防止回滚：当你重构（修改）旧代码时，单元测试能确保你没有改坏原本正常的功能。
文档作用：好的测试代码本身就是最好的“功能说明书”。

[!NOTE]

测试代码与应用程序代码分开,便于维护

可以自动生成测试报告(通过:绿色，失败:红色)

一个测试方法执行失败，不会影响其它测试方法

JUnit

测试类要求

维度	要求标准	说明
存放路径	`src/test/java`	必须与业务代码（`src/main/java`）分开存放。
包名结构	与被测类包名一致	例如被测类在 `com.demo.service`，测试类也应在此包下。
类名规范	以 `Test` 结尾	例如：`UserServiceTest.java`（Surefire 插件默认识别规则）。
依赖配置	`scope` 设为 `test`	确保测试相关的 Jar 包（如 JUnit）不会被打包到生产环境。

断言`assert`

本质：测试逻辑的“裁判”。它对比 预期值 (Expected) 与 实际值 (Actual)
逻辑流：执行业务逻辑 -> 获取结果 -> 调用断言方法 -> 判定测试通过/失败

	@Test 
	public void testGenderWithAssert(){ 
	 UserService userService = new UserService(); 
	 String gender = userService.getGenderByIdCard("100000200010011011"); 
	 Assertions.assertEquals("男", gender,"性别获取逻辑有问题");
	 //会检测与结果是否一致
	}

[!PROBLEM] 测试代码中，通常会极力避免手动写 try-catch

断言方法	说明	适用场景
`assertEquals(exp, act)`	判断两个值是否相等	验证计算结果、字符串内容、对象相等。
`assertNotEquals(exp, act)`	判断两个值是否不相等	验证更新后的值确实变了。
`assertTrue(condition)`	判断条件是否为 `true`	验证布尔逻辑（如：`canAfford` 方法）。
`assertFalse(condition)`	判断条件是否为 `false`	验证否定逻辑（如：用户是否未登录）。
`assertNull(obj)`	判断对象是否为空	验证查询不到数据时的返回。
`assertNotNull(obj)`	判断对象是否不为空	验证对象是否成功创建或查询到。
`assertArrayEquals(exp, act)`	判断两个数组是否相等	验证列表排序或批量处理后的数组。

	@Test 
	public void testGenderWithAssert2(){ 
	 UserService userService = new UserService(); 
	 String gender = userService.getGenderByIdCard("100000200010011011"); 
	 
		//当异常发生的时候 测试能否抛出正确的异常
	 Assertions.assertThrows(IllegalArgumentException.class,()-> 
	 userService.getGenderByIdCard(null)); 
	}

组合断言

当一个测试方法里有多个断言时：

普通逻辑：第一个断言挂了，后面都不跑了。
assertAll 逻辑：所有断言都会跑完，最后统一输出哪些挂了。

	// 笔记示例：
	assertAll("用户信息校验",
	 () -> assertEquals("男", gender),
	 () -> assertEquals(36, age)
	);

注解`Annotation`

生命周期钩子

注解	执行时机	强制要求	典型用途
`@BeforeAll`	所有测试开始前，只执行一次	必须是 `static` 方法	初始化数据库连接池、启动 Redis 容器。
`@BeforeEach`	每个测试方法执行前都跑一次	普通方法	重置对象状态、准备 Mock 数据。
`@AfterEach`	每个测试方法执行后都跑一次	普通方法	清理临时文件、撤销数据库更改。
`@AfterAll`	所有测试结束后，只执行一次	必须是 `static` 方法	关闭数据库连接、释放系统资源。

执行顺序逻辑： @BeforeAll $\rightarrow$ (@BeforeEach $\rightarrow$ @Test $\rightarrow$ @AfterEach) $\times$ N次 $\rightarrow$ @AfterAll

	before All
	before each
	after each
	before each
	男
	after each
	before each
	26
	after each
	before each
	after each
	after All
	
	进程已结束，退出代码为 0

核心测试与显示

@Test：最基础的标签，告诉 Maven 这是一个标准的单元测试。
@DisplayName("描述内容")：
- 作用：在 IDEA 的运行面板或测试报告中，显示中文或易读的描述，而不是枯燥的方法名。
- 复用性：让非技术人员（或一个月后的你）一眼看懂这个测试在测什么

参数化测试

@ParameterizedTest

作用：声明这个方法是一个“参数化测试”，它会多次运行，每次注入不同的值。
逻辑：它必须配合“数据源”注解使用。

@ValueSource

作用：最简单的数据源，提供一组基本类型的值（如 Strings, Ints）
身份证性别测试：

 @ParameterizedTest
 @ValueSource(strings = 
 				{"100000200010011021",
 				"100000200010011032",
 				"100000200010011051"
 			})
 @DisplayName("验证多个男性身份证的识别")
 public void testGenderWithAssert2(String idCard){//strings传入idCard
 UserService userService = new UserService(); 
 String gender = userService.getGenderByIdCard(idCard); 
 Assertions.assertEquals("男",gender); 
 }

总结

注解分类	注解名称	记忆关键词
控制流	`@Before...` / `@After...`	时机控制（前置/后置）
基础	`@Test`	入场券（标记测试）
美化	`@DisplayName`	别名（中文描述）
高级	`@ParameterizedTest`	分身术（一法多测）
数据源	`@ValueSource`	数据池（提供参数）

[!WARNING]

静态限制：记住 @BeforeAll 和 @AfterAll 必须加 static 关键字，因为它们在类实例创建之前就要运行。

依赖冲突：如果你在 pom.xml 里用的是 JUnit 4，这些注解（来自 org.junit.jupiter 包）是无法识别的。

不要混用：通常一个方法要么标 @Test，要么标 @ParameterizedTest，不要两个都标。

规范

在企业开发规范中，这种写法被称为 “测试环境准备（Test Fixture Setup）”

	private UserService userService; 
	@BeforeEach 
	public void setUp(){ 
	 userService = new UserService(); 
	}

依赖范围

范围 (Scope)	编译 (main)	测试 (test)	运行 (runtime)	打包	典型例子
`compile` (默认)	✅	✅	✅	✅	Spring 核心库、Log4j
`test`	❌	✅	❌	❌	JUnit 5、Mockito
`provided`	✅	✅	❌	❌	Servlet API、Lombok
`runtime`	❌	✅	✅	✅	JDBC 驱动实现
`system`	✅	✅	✅	✅	本地磁盘上的 Jar 包，迁移报错

详细范围

compile（编译范围）

逻辑：如果不写 <scope>，默认就是这个。
特性：全能型。你在写代码、跑测试、部署上线时都需要它。
复用性：它具有传递性（如果你依赖 A，A 依赖 B，那么你的项目也会获得 B）。

🔹 test（测试范围）

逻辑：只在 src/test/java 下的代码中有效。
为什么要用：像 JUnit 这种工具，上线运行代码时根本不需要。
规范：必须给所有测试框架加上 test 范围，防止线上包由于包含测试类而变得臃肿。

🔹 provided（已提供范围）

逻辑：编译时我需要它，但打包时请不要带上它。
典型场景：
- Servlet API：你的代码需要它来编译，但你最终要把项目部署到 Tomcat。Tomcat 已经自带了 Servlet 的 Jar 包，如果你的包里也带一个，就会产生版本冲突。
- Lombok：编译时生成 Getter/Setter，编译完后就不再需要了。

🔹 runtime（运行时范围）

逻辑：写代码（编译）时不需要，但程序跑起来（运行）时必须有。
典型场景：数据库驱动（如 MySQL Connector）。
- 我们在代码里通常使用 JDK 自带的 java.sql.Connection（接口），不需要直接调用 MySQL 的具体实现类。只有在程序运行时，Maven 才会加载驱动包来建立真实连接。

BOM

BOM 的全称是 Bill of Materials（物料清单）

简单来说，BOM 是一个特殊的 pom.xml 文件，它的核心逻辑不是为了提供代码，而是为了统一管理依赖的版本号

使用BOM

在 pom.xml 中导入 BOM

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

引入具体依赖（不写版本号）

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

维度	传统方式	使用 BOM
版本控制	每个模块各自维护，易冲突	全局统一，一处修改全线更新
配置量	每个 `<dependency>` 都要写版本	只在顶层写一次，子模块极简
复用性	差，需要反复确认版本号	极强，确保所有组件完美兼容
稳定性	容易出现 Jar 包版本不匹配	官方认证的“全家桶”组合，最稳定

Vue3 & Ajax.md

Thu, 09 Apr 2026 00:00:00 +0000

本文更新于 2026-04-09

Vue

Vue.js 是一个用于构建用户界面的 JavaScript 框架。它最核心的价值在于：不再需要手动操作 DOM。

框架：就是一套完整的项目解决方案，用于快速构建项目
优点：大大提升前端项目的开发效率
引入Vue模块

	<div id="app">{{ message }}</div>
	
	<script type="module">
	 import { createApp, ref } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
	
	 createApp({
	 setup() {
	 const message = ref('Hello Vue!')
	 return {
	 message
	 }
	 }
	 }).mount('#app')
	</script>

指令

基础显示指令

指令	作用	说明
`v-text`	更新元素的文本内容	类似 `innerText`，但通常直接用 `{{ }}` 更方便。
`v-html`	更新元素的 `innerHTML`	内容按 HTML 解析。注意：只在信任的内容上使用，防止 XSS 攻击。
`v-once`	只渲染一次	之后即使数据变了，这里也不会更新，用于性能优化。

条件渲染指令

v-if / v-else-if / v-else：真正的条件渲染。如果条件为假，元素根本不会被创建（不出现在 DOM 树中）
- 原理:基于条件判断，来控制创建或移除元素节点(条件渲染)
- 场景:要么显示，要么不显示，不频繁切换的场景
v-show：通过修改 CSS 的 display: none 来切换显隐。元素始终存在于 DOM 中
- 原理:基于CSS样式display来控制显示与隐藏
- 场景:频繁切换显示隐藏的场景

场景建议：频繁切换显示用 v-show，运行时条件不大可能改变用 v-if

列表渲染指令

v-for：基于一个数组来渲染一个列表
语法：v-for="(item, index) in list" :key="item.id"
- item：当前遍历项
- index：当前索引（从 0 开始）
- list：要循环的数组
- :key="item.id"：给列表项唯一标识，提升渲染性能

	<tbody>
 <tr v-for="(e, index) in empList" :key="e.id">
 <td>{{index+1}}</td>
 <td>{{e.name}}</td>
 <td>{{e.gender == 1?"男":"女" }}</td>
 <td>{{e.job}}</td>
 <td>{{e.entrydate}}</td>
 <td>{{e.updatetime}}</td>
 </tr>
 </tbody>
 
 
	empList: [
	 { "id": 1,
		"name": "姓名",
		"gender": 1,
		"job": "1",
		"entrydate": "2023-06-09",
		"updatetime": "2024-07-30T14:59:38"
	 }

[!NOTE]

关键点：使用 v-for 时必须绑定 :key。这能帮助 Vue 的 Diff 算法精准识别每个节点，提高更新性能

注意：遍历的数组，必须在data中定义;要想让哪个标签循环展示多次，就在哪个标签上使用 v-for 指令。

属性绑定与事件监听

v-bind (缩写 :)：动态绑定 HTML 属性。

	<img v-bind:src="imageSrc">
	<img :src="imageSrc">
	插值表达式不能在标签内使用

v-on (缩写 @)：绑定事件监听器。
- 完整写法：v-on:事件名="方法名"
- 简写形式（最常用）：@事件名="方法名"

	//HTML
	<button type="button" @click="search">查询</button>
    <button type="reset" @click="clear">清空</button>

	//JS
	methods:{
			search(){
				console.log(this.searchForm);
			},
			clear(){
				this.searchForm.name = '';
				this.searchForm.gender = '';
				this.searchForm.job = '';
			}
		}

双向绑定指令(表单)

v-model：在表单元素（input, select, textarea）上创建双向数据绑定。
原理：它是 v-bind:value 和 v-on:input 的语法糖
- 从数据到视图：当变量值改变时，输入框的内容自动变
- 从视图到数据：当用户在输入框打字时，变量的值实时更新

	<select name="gender" v-model="searchForm.gender">
		...
	</select>
	
	<select name="job" v-model="searchForm.job">
		...
	</select>
	
	searchForm:{
				name:'',
				gender:'',
				job:''
                },

Ajax

Ajax (Asynchronous JavaScript and XML) 是让网页实现“局部刷新”的核心技术。它允许网页在不重新加载整个页面的情况下，从服务器请求数据。

XML: (Extensible Markup Language)可扩展标记语言，本质是一种数据格式，可以用来存储复杂的数据结构。

作用
- 数据交换: 通过Ajax可以给服务器发送请求，并获取服务器响应的数据。
- 异步交互: 可以在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页的技术，如:搜索联想、用户名是否可用的校验等等。

同步异步

同步

浏览器页面在发送请求给服务器，在服务器处理请求的过程中，浏览器页面不能做其他的操作。只能等到服务器响应结束后才能，浏览器页面才能继续做其他的操作

异步

浏览器页面发送请求给服务器，在服务器处理请求的过程中，浏览器页面还可以做其他的操作。

async & await

可以通过async、await可以让异步变为同步操作。async就是来声明一个异步方法，await是用来等待异步任务执行


 async search() {
 //基于axios发送异步请求，请求http://127.0.0.1:5500/json/simple.json，根据条件查询员工列表
 const result = await axios.get(`http://127.0.0.1:5500/json/simple.json?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`);
 
 this.empList = result.data.data;
 },

Axios

步骤
- 引入Axios的js文件
- 使用Axios发送请求，并获取响应结果
为了方便，Axios已经为所有支持的请求方法提供了别名
格式：axios.请求方式(url [,data [, config ]])

	//GET请求
    document.querySelector('#getData').onclick = function() {
    
        //发出请求后 不会等待服务器返回（异步），而是继续执行后续代码
	axios.get('https://jsonplaceholder.typicode.com/posts/1').then((result) => {
	 console.log(result.data);
	}).catch((err) => {
		console.log(err);
	});
	
	console.log('================================');//先输出
	
	}

Vue 的生命周期

阶段	状态名 (Vue 2)	Vue 3 (组合式 API)	状态描述
创建	`beforeCreate`	`setup`	实例初始化，无数据
	`created`	`setup`	数据可用，无 DOM
挂载	`beforeMount`	`onBeforeMount`	虚拟 DOM 已准备好
	`mounted`	`onMounted`	DOM 已渲染（最常用）
更新	`beforeUpdate`	`onBeforeUpdate`	数据变了，页面没变
	`updated`	`onUpdated`	页面更新完成
销毁	`beforeDestroy`	`onBeforeUnmount`	清理现场（防内存泄漏）
	`destroyed`	`onUnmounted`	完全消失

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script type="module">
 // 导入 Vue 3 的 createApp 方法
 import { createApp } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'
 createApp({
 data() {
 return {
 // 搜索表单绑定的数据
 searchForm: {
 name: '', // 姓名
 gender: '', // 性别
 job: '' // 职位
 },
 // 员工列表，表格渲染的数据
 empList: []
 }
 },
 methods: {
 // 查询方法，点击“查询”按钮或页面加载时调用
 search() {
 // 发送 GET 请求到远程接口，带上表单参数
 axios.get(`https://web-server.itheima.net/emps/list?name=${this.searchForm.name}&gender=${this.searchForm.gender}&job=${this.searchForm.job}`)
 .then((result) => {
 // 将返回的员工数组赋值给 empList，页面自动渲染
 this.empList = result.data.data;
 })
 // 控制台输出分隔线，调试用
 console.log('================================');
 },
 /*
 result.data：是整个响应体（包含 code、msg、data 等字段）
 result.data.data：才是真正需要的员工数组
 */
 // 清空方法，点击“清空”按钮时调用
 clear() {
 // 重置表单
 this.searchForm = {
 name: '',
 gender: '',
 job: ''
 };
 // 重新查询，显示所有数据
 this.search();
 }
 },
 // 生命周期钩子，页面加载完成后自动查询一次，显示所有数据
 mounted() {
 this.search();
 }
 }).mount('#container')
</script>

HTML

Tue, 07 Apr 2026 00:00:00 +0000

本文更新于 2026-04-07

HTML

HyperText Markup Language

HTML 不是一种编程语言，而是一种标记语言（Markup Language）。它通过一系列“标签”来描述网页的结构，是构建 Web 页面的基石。

HTML 核心标签

HTML 是网页的骨架，用于定义页面内容。

标题标签 (<h1> - <h6>)：用于定义 1 到 6 级标题，数字越小级别越高，字体越大。
超链接标签 (<a>)：
- href 属性：指定资源访问的 URL 地址。
- target 属性：指定打开链接的位置。
  - _self：在当前页面打开（默认）。
  - _blank：在新的空白页面打开。

表单

表单容器 `<form>`

所有表单控件必须放在 <form> 标签内，它负责定义数据提交的方向和方式。

action: 服务器接收数据的 URL 地址。
method:
- GET: 数据跟在 URL 后面，适合搜索、查询（安全性低，有长度限制）。
- POST: 数据放在请求体中，适合注册、上传文件（安全性高，无长度限制）。

	form表单：
	action：表单数据提交的url地址
	method：提交方式
	 get：默认，表单数据会出现在url后面，形式：/save?name=Tom&age=18
	 特点：
	 1．如果表单中包含了隐私数据，get方式并不安全，不推荐使用该方式．
	 2．在浏览器中get请求的大小是有限制的，不适合提交大数据量的表单．
	 post：表单数据会在消息体/请求体中提交到服务器
	 特点：
	 1．安全．
	 2．请求大小没有限制
	注意：表单项要想能够采集数据，必须得设置name属性，表示当前表单项的名字

表单项

<label> 标签 (点击文字也能选中)

极力推荐使用。它能通过 for 属性绑定到对应的 input 的 id 上。

好处：点击“用户名”这三个字，光标也会跳进输入框，对移动端非常友好。

name 属性 (后端唯一标识)

这是表单项最核心的属性。后端程序只认 name。

💡 比喻：name 是变量名，用户输入的是变量值。没写 name，后端就收不到这个项的数据。

value 属性 (初始值/提交值)

对于文本框：它是默认填好的文字。
对于单选/复选框：它是选中后传给后端的“暗号”。

`<input>`

常用 Type	视觉效果	适用场景
`text`	单行输入框	用户名、地址
`password`	掩盖输入内容	密码、敏感信息
`radio`	圆形选择点	单选（必须设置相同 `name` 才能互斥）
`checkbox`	方形勾选框	多选（如爱好、协议确认）
`file`	文件选择按钮	上传头像、文档
`submit`	提交按钮	确认并发送整个表单

`<select> & <option>`

用于在有限的空间里提供大量选项。

	<select name="city">
	 <option value="bj">北京</option>
	 <option value="sh">上海</option>
	</select>

`<textarea>`

用于输入大量文字（如自我介绍、评价），支持换行。

表格

HTML 表格是由行（Row）组成的，行里面再拆分单元格（Cell）。

<table>: 表格的容器。
<tr> (Table Row): 定义一行。
<th> (Table Header): 表头单元格。文字默认加粗、居中。
<td> (Table Data): 普通单元格。承载具体内容。为了让长表格更易读、更符合标准，建议使用以下标签：

标签	作用
`<thead>`	包裹表头部分（通常是第一行）。
`<tbody>`	包裹表格主体（数据部分）。
`<tfoot>`	包裹表格页脚（如合计行）。
`<caption>`	表格的标题，紧跟在 `<table>` 之后。

单元格合并

这是表格布局中最常用的技巧，用于处理复杂的表头或跨行数据。

colspan (跨列)：将多个单元格水平合并。
rowspan (跨行)：将多个单元格垂直合并。

页脚

维度	`<footer>` (页面页脚)	`<tfoot>` (表格页脚)
所属父级	`<body>` 或 `<article>`	`<table>`
主要功能	放置版权、导航、作者信息	放置表格数据的合计、平均值
出现频率	一个页面通常只有一个主 `<footer>`	每个表格可以有一个 `<tfoot>`
布局技巧	常配合 CSS 固定在页面底部	常配合 `colspan` 合并单元格

CSS

Cascading Style Sheets

CSS 负责网页的表现（Presentation）。如果说 HTML 是建筑的骨架，那么 CSS 就是装修、油漆和家具布局。它通过选择器定位 HTML 元素，并应用样式属性。

CSS 引入方式

CSS 用于美化 HTML 页面，主要有三种引入手段：

行内样式 (Inline Styles)：直接写在标签的 style 属性中，优先级最高但不易维护。
内部样式表 (Internal Style Sheet)：写在 <head> 标签内的 <style> 标签中，适用于单页样式。
外部样式表 (External Style Sheet)：推荐做法。通过 <link rel="stylesheet" href="路径.css"> 引入独立的 .css 文件，实现结构与表现分离。

颜色表示

十六进制颜色值

这是目前网页开发中最常用的表达方式

格式：#RRGGBB（前缀为 #，后面跟着三组十六进制数）。
原理：使用十六进制（0-9, A-F）分别定义红 (Red)、绿 (Green)、蓝 (Blue) 三原色的强度。
示例：
- #FFFFFF：纯白色。
- #000000：纯黑色。

RGB 与 RGBA 模式

直接通过数字定义三原色的混合比例，更符合计算机颜色的底层逻辑。

RGB 格式：rgb(红色值, 绿色值, 蓝色值)。每个数值范围是 0-255。
- 示例：rgb(231, 76, 60) 等同于十六进制的 #e74c3c。
RGBA 格式：rgba(r, g, b, alpha)。多了一个 alpha 通道用于控制透明度。
- alpha 取值范围是 0（完全透明）到 1（完全不透明）。
- 示例：rgba(52, 152, 219, 0.5) 表示 50% 透明度的蓝色。

选择器

基本选择器

这是最常用、最基础的选择方法。

标签选择器 (1)：通过 HTML 标签名选择。
- 写法：p { color: red; }（选中页面上所有的 <p> 标签）。
类选择器 (10)：选择具有特定 class 属性的元素。
- 写法：.highlight { background: yellow; }（选中所有 class="highlight" 的元素）。
ID 选择器 (100)：选择具有特定 id 属性的唯一元素。
- 写法：#header { font-size: 24px; }（选中 id="header" 的元素）。注意：一个 ID 在 HTML 页面中应该是唯一的。
通配符选择器 (0)：选择页面上的所有元素。
- 写法：* { margin: 0; padding: 0; }（常用于重置页面默认边距）。

复合选择器

用于更精确地定位元素。

后代选择器 (Descendant Selector)：选择某个元素内部的所有指定后代。
- 写法：.container p { ... }（选中 .container 内部所有的 <p> 标签，无论嵌套多深）。
子元素选择器 (Child Selector)：仅选择某个元素的直接子元素。
- 写法：.container > p { ... }（只选中 .container 下的第一层 <p>）。
并集选择器 (Grouping Selector)：同时给多个选择器设置相同的样式。
- 写法：h1, h2, .title { ... }（用逗号分隔）。

伪类选择器

用于选择元素的特定状态，常用于交互效果。

:hover：鼠标悬停在元素上的状态。
- 写法：a:hover { text-decoration: underline; }（鼠标移上去显示下划线）。
:active：元素被激活（鼠标点击按下）的状态。
:nth-child(n)：选择父元素中的第 n 个子元素。
- 写法：li:nth-child(2) { color: blue; }（选中列表中的第二项）。

属性选择器

根据 HTML 标签的属性来选择，这在处理你之前提到的 contest.xml 这种结构化数据转换成的 HTML 时非常有用。

写法：[type="text"] { border: 1px solid #ccc; }（选中所有 type 属性为 text 的输入框）。

选择器的优先级

当多个选择器指向同一个元素并设置相同属性时，浏览器会根据“权重”来决定听谁的：

行内样式 (style="...")：权重最高 (1000)
ID 选择器 (#id)：权重高 (100)
类、伪类、属性选择器 (.class)：权重中 (10)
标签选择器 (div, p)：权重低 (1)
通配符 (*)：权重最低 (0)

原则：描述得越精准，权重越高。如果权重相同，则后写的样式会覆盖先写的样式。

正文样式

属性	功能说明	常见取值示例
`color`	设置字体颜色	`#e74c3c` (十六进制), `rgba(0,0,0,0.8)`
`font-size`	设置字体大小	`16px`, `1rem`, `1.2em`
`line-height`	设置行高（行间距）	`1.5`, `1.6` (通常为字号的倍数)
`letter-spacing`	设置字间距	`1px`, `2px`
`text-indent`	首行缩进	`2em` (缩进两个字符)
`text-align`	文本对齐方式	`left`, `center`, `right`, `justify`

盒子模型

在 CSS 中，所有的 HTML 元素都可以看作是一个矩形的“盒子”。这个盒子由内到外由四个部分（区域）组成。

内容 (Content)：盒子的核心，显示文本、图片等实际内容。
内边距 (Padding)：内容与边框之间的透明区域。
边框 (Border)：围绕在内边距和内容外的线。
外边距 (Margin)：边框外的区域，用于控制元素与其它元素之间的距离。

通过 box-sizing 属性切换计算逻辑，这是最容易出错的地方：

标准盒子模型 (`content-box`)

特性：width 只等于 Content。
总宽度公式：Width + Padding*2 + Border*2。
结果：加了边框或内边距，盒子会被“撑大”。

怪异盒子模型 (`border-box`)

特性：width 等于 Content + Padding + Border。
总宽度公式：等于你设置的 Width。
结果：加了边框或内边距，内容区会“向内压缩”，盒子总尺寸不变。

布局

布局标签

1.<div> 标签 (Division) —— 块级容器

<div> 是 “division”（部分、分区）的缩写，用于定义文档中的一个区块。

显示特性：块级元素 (Block-level)。
- 默认情况下，它会独占一行（宽度默认铺满父容器 100%）。
- 它可以设置宽度 (width)、高度 (height)、内边距 (padding) 和外边距 (margin)。
常用场景：
- 划分页面的大区域（如：页眉、导航栏、内容区、页脚）。
- 作为 CSS 布局（如 Flex 或 Grid）的父容器。
示例：

	<div class="team-card">
	<h2>Alpha Team</h2>
	<p>积分：1500</p>
	</div>

2. <span> 标签 —— 行内容器

<span> 用于组合文档中的行内元素，以便通过 CSS 修改局部样式。

显示特性：行内元素 (Inline)。
- 它不会换行，只会占据内容所需的宽度，与其他文本排在同一行。
- 默认情况下，设置宽高属性无效。
常用场景：
- 修改一段文字中某个词的颜色、字号或字体。
- 在一行内放置小图标或状态标签。
示例：

	<p>队伍 T001 的状态是 <span style="color: green;">AC</span></p>

特性	`<div>`	`<span>`
元素类型	块级元素 (Block)	行内元素 (Inline)
占用空间	独占一行，默认宽度 100%	随内容变化，不换行
嵌套规则	可以包含其它 `div` 或 `span`	只能包含文本或其它行内元素
布局用途	构建网页骨架、容器	局部修饰、修饰行内小部件

flex布局

flex是flexible Box的缩写，意为"弹性布局"，是一种一维的布局模型。flex布局可以为元素之间提供强大的空间分布和对齐能力。
通过给父容器添加flex的相关属性,来控制子元素的位置和排列方式，

理解 Flex 的关键在于明白它有两个轴：

主轴 (Main Axis)：默认是水平方向（从左到右）。
交叉轴 (Cross Axis)：默认是垂直方向（从上到下）。

可以通过 flex-direction 来交换这两个轴。

属性	作用	常用取值
`justify-content`	控制子元素在主轴（横向）上的对齐	`center`, `space-between`, `flex-end`
`align-items`	控制子元素在交叉轴（纵向）上的对齐	`center`, `flex-start`, `stretch`
`flex`	控制子元素如何分配剩余空间	`1` (平分), `2` (占两份)

flex布局相关的CSS样式

属性	说明	取值	含义
`display`	模式	`flex`	使用 flex 布局
`flex-direction`	设置主轴	`row`	主轴方向为 x 轴，水平向右（默认）
		`column`	主轴方向为 y 轴，垂直向下
`justify-content`	子元素在主轴上的对齐方式	`flex-start`	从头开始排列
		`flex-end`	从尾部开始排列
		`center`	在主轴居中对齐
		`space-around`	平分剩余空间
		`space-between`	先两边贴边，再平分剩余空间

HTML & CSS总览

JavaScript

组成

1. ECMAScript (核心语法)

这是 JavaScript 的大脑，定义了语言的基础规则。它不涉及浏览器，只规定语法。

包含内容：变量声明 (var, let, const)、数据类型、流程控制 (if/else, for)、函数、类 (Class)、对象等。
标准制定者：由 ECMA 国际组织负责更新（如 ES6, ES2023）。
通俗理解：就像汉语的语法字典，规定了怎么造句，但不规定这些句子是在书里还是在墙上。

2. DOM (文档对象模型)

DOM (Document Object Model) 是 JavaScript 操作网页内容的手脚。

功能：将 HTML 页面抽象为一棵“树”。JS 通过 DOM 接口可以增、删、改、查网页上的任何标签、属性和样式。
常见操作：
- document.getElementById()
- 修改文字内容 (innerText)
- 修改 CSS 样式 (style.display = 'none')
通俗理解：把 HTML 页面看作一间屋子，DOM 就是家具的控制面板，让你能随时换个沙发或者关上灯。

3. BOM (浏览器对象模型)

BOM (Browser Object Model) 是 JavaScript 与浏览器软件本身对话的窗口。

功能：提供与浏览器窗口交互的对象，不涉及页面内部的具体内容。
包含内容：
- window: 顶层对象（所有 JS 全局变量都在这里）。
- location: 获取或设置当前页面的 URL。
- navigation: 获取浏览器信息（版本、系统等）。
- history: 操作浏览器的前进和后退。
- screen: 获取屏幕分辨率。
通俗理解：它是浏览器的外壳控制，比如弹出一个警告框 (alert) 或开启一个新的标签页。

引入方式

行内引入

直接将 JS 代码写在 HTML 标签的事件属性中（如 onclick）

	<button onclick="alert('你点击了按钮！')">点击我</button>

优点：简单、快速，用于极少量的交互。
缺点：代码与 HTML 耦合度过高，极难维护，不推荐使用

内部引入

将代码写在 HTML 文档的 <script> 标签内。通常放在 </body> 标签之前。

代码示例：

	<body>
		<h1>标题</h1>
		<script>
			const title = document.querySelector('h1');
			console.log(title.innerText);
		</script>
	</body>

优点：不需要额外创建文件，适合单个页面的简短脚本。
缺点：如果脚本过长，会使 HTML 文件变得臃肿，无法在多个页面间复用代码。

外部引入–推荐

将 JS 代码写在独立的 .js 文件中，通过 <script> 标签的 src 属性引入。

HTML 部分：

<script src="js/main.js"></script>

JS 部分 (main.js)：

alert("这是来自外部文件的代码");

优点：
1. 代码复用：多个网页可以引用同一个 JS 文件。
2. 结构清晰：HTML 只负责结构，JS 负责逻辑，各司其职。
3. 缓存优化：浏览器会缓存外部 JS 文件，提高页面加载速度。

基础语法

1. 变量声明 (Variables)

在现代 JS 中，我们使用 let 和 const 来代替过时的 var。

const: 声明常量。一旦赋值，不能修改。优先使用。
let: 声明变量。值可以被重新覆盖。

const pi = 3.14; // 不可变
let score = 10; // 可变
score = 20; // 允许

2. 数据类型 (Data Types)

JS 的数据分为“简单”和“复杂”两类。

分类	数据类型	英文	说明 & 示例
基本类型	数字	`number`	数字（10, 3.14）
	字符串	`string`	字符串`("Hello", 'Hi')`
	布尔	`boolean`	布尔（true, false）
	空值	`null`	空值,`null != Null != NULL`
	未定义	`undefined`	该变量未初始化
引用类型	对象	`object`	对象，用 {} 表示，存储键值对
	数组	`array`	数组，用 [] 表示，存储有序列表

使用typeof运算符可以获取数据类型 typeof a -> number 避免使用 var，否则变量可能在声明前被访问而导致 undefined

[!WARNING] 注意

由字母、数字、下划线 _、美元符 $ 组成

不能以数字开头

严格区分大小写

不能是 JavaScript 关键字或保留字

建议见名知意，语义清晰

推荐使用小驼峰命名法，第一个单词小写，后面单词首字母大写

模板字符串

三种功能

变量嵌入通过 ${} 语法，可以直接在字符串中插入变量或表达式，不再需要用大量的 + 号

	const name = "Gemini";
	const version = 3.0;
	
	// 旧版写法
	console.log("你好，我是 " + name + "，当前版本是 " + version);
	
	// 模板字符串写法
	console.log(`你好，我是 ${name}，当前版本是 ${version}`);

多行字符串在传统字符串中，换行需要使用 \n。而在模板字符串中，可以直接按回车键换行

	// 自动保留换行格式
	const htmlTemplate = `
	 <div>
	 <h1>标题</h1>
	 <p>内容段落</p>
	 </div>
	`;

嵌入表达式 ${} 内部不仅可以放变量，还可以进行运算、调用函数或逻辑判断。

	const price = 100;
	const tax = 0.1;
	
	console.log(`总价是：${price * (1 + tax)} 元`); // 运算
	console.log(`状态：${price > 50 ? '昂贵' : '便宜'}`); // 三元运算

[!tip] 如果在模板字符串中需要显示反引号本身，请使用转义符：` \` `

如果在模板字符串中需要显示 ${} 原样字符，也需要转义：\${}

函数

在 JavaScript 中，函数（Function） 是执行特定任务的可重复调用的代码块。它是程序中最基本的“逻辑单元”。

函数声明 (Function Declaration)

最传统、最常用的方式。具有“声明提升”特性（可以在声明前调用）。

	function greet(name) {
		return `你好, ${name}!`;
	}
	console.log(greet("张三")); // 调用

匿名函数

匿名函数（Anonymous Function） 是指在定义时没有函数名称的函数。在 JavaScript 中，它们通常作为“工具人”使用，在需要的地方临时定义并立即执行或传递。

函数表达式 (Function Expression)

将函数赋值给一个变量。没有提升特性。

	const add = function(a, b) {
	 return a + b;
	};

箭头函数 (Arrow Function) —— 现代主流

ES6 引入的简洁写法。注意：它没有自己的 this，适合用作回调函数。

const multiply = (a, b) => a * b;

[!NOTE] 由于匿名函数没有名字，在复杂的报错调试（Debug）时，错误堆栈里可能只显示 anonymous，找起 Bug 来会比具名函数稍微麻烦一点。

自定义对象

在 JavaScript 中，自定义对象（Custom Objects） 是将相关数据（属性）和行为（方法）组织在一起的容器。它是 JS 模拟现实世界实体（如：用户、商品、订单）的核心方式。

	let 对象名 = {
		属性名1:属性值1;
		属性名2:属性值2;
		属性名3:属性值3;
		方法名:function(形参列表){}
	}
	
	// 调用格式
	对象名.属性名;
	对象名.方法名;

字面量方式（常用）

直接用大括号 {} 定义，适合创建一个独立、唯一的对象

	const phone = {
	 brand: "华为",
	 model: "Mate 60",
	 price: 5999,
	 // 方法：对象中的函数
	 call: function() {//不推荐使用箭头函数
		 console.log("正在拨打电话...");
	 }
	};

构造函数

当需要批量创建多个结构相似的对象时（如 100 个学生），使用构造函数约定：函数名首字母大写

	function Student(name, age) {
	 this.name = name;
	 this.age = age;
	 this.study = function() {
	 console.log(`${this.name} 正在学习`);
	 };
	}
	
	const s1 = new Student("小明", 18);
	const s2 = new Student("小红", 19);

类

ES6 引入的语法糖，逻辑更清晰，接近 Java/C# 的风格

	class Car {
	 constructor(color, speed) {
	 this.color = color;
	 this.speed = speed;
	 }
	 drive() {
	 console.log(`这辆${this.color}的车正在以${this.speed}码行驶`);
	 }
	}
	
	const myCar = new Car("白色", 120);

JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式

它基于 JavaScript 的一个子集，但它是独立于语言的文本格式，目前几乎所有的编程语言（Python, Java, PHP, Go 等）都支持 JSON

语法规则

JSON 的结构非常简单，主要由键值对组成。

数据在键值对中：键（Key）必须用双引号包裹。
数据由逗号分隔。
对象由大括号 {} 保存。
数组由方括号 [] 保存。

数据类型

类型	示例
字符串	`"Hello World"` (必须双引号)
数字	`123`, `45.6`
布尔值	`true`, `false`
数组	`["Apple", "Orange"]`
对象	`{"id": 1, "name": "Gemini"}`
空值	`null`

⚠️ 注意：JSON 不能包含函数、日期对象或 undefined

JavaScript 中的 JSON 操作

	// JSON.parse() 当从服务器收到一段 JSON 字符串时，需要用它将其解析为 JS 对象。
	const jsonStr = '{"name": "小明", "age": 18}';
	const obj = JSON.parse(jsonStr);
	console.log(obj.name); // 输出: 小明
	
	
	// JSON.stringify() 当准备把数据发送给服务器时，需要将 JS 对象转换为 JSON 字符串。
	const user = { name: "小明", age: 18 };
	const jsonString = JSON.stringify(user);
	console.log(jsonString); // 输出: '{"name":"小明","age":18}'

DOM

DOM (Document Object Model)，即文档对象模型，是 JavaScript 操作网页内容的“桥梁” 它将 HTML 文档表现为一个树状结构，让我们可以通过脚本动态地修改页面的内容、结构和样式。

DOM操作

根据CSS选择器获取DOM对象

document.querySelector('选择器')
- 作用：返回匹配到的第一个对象。
- 示例：document.querySelector('.my-class') 或 document.querySelector('#my-id p')。
document.querySelectorAll('选择器')
- 作用：返回匹配到的所有对象。
- 结果：一个 NodeList（类似数组的集合，可以用 forEach 遍历）
- 注意:得到的是一个NodeList节点集合，是一个伪数组(有长度、有索引的数组)

方法	获取依据	返回值类型	说明
`getElementById('id')`	唯一 ID	单个对象	速度最快，只能找 ID
`getElementsByClassName('class')`	类名	动态集合 (HTMLCollection)	实时更新的集合
`getElementsByTagName('标签名')`	标签名	动态集合 (HTMLCollection)	比如找所有的 `div`

事件监听

三要素

可以把事件监听想象成一个报警系统：

事件源 (Target)：谁触发了事件？（比如：一个 <button> 按钮）
- 事件源.addEventListener('事件类型',事件触发执行的函数);可以多次绑定同一事件
- 早期版本写法:事件源.on事件=function{}如果多次绑定同一事件，就会覆盖
事件类型 (Type)：发生了什么事？（比如：click 点击）
事件处理程序 (Handler)：要做什么？（通常是一个回调函数）

分类	事件名	触发时机
鼠标事件	`click`	鼠标点击
	`mouseenter` / `mouseleave`	鼠标移入 / 移出
键盘事件	`keydown` / `keyup`	按键按下 / 松开
表单事件	`input`	输入内容改变时（实时）
	`change`	内容改变并失去焦点时
	`submit`	表单提交时
窗口事件	`load`	整个页面加载完成
	`scroll`	页面滚动

JS优化

基础

Tue, 07 Apr 2026 00:00:00 +0000

本文更新于 2026-04-09

HTTP

HTTP 是互联网上应用最为广泛的一种网络协议。它定义了浏览器（客户端）与服务器之间交换数据的格式和规则

HTTP 的基本特性

应用层协议：运行在 TCP/IP 协议栈之上（默认端口 80，HTTPS 为 443）。
请求-响应模型：必须由客户端发起请求，服务器给出响应。
无状态 (Stateless)：协议本身不保留之前的事务记忆。
- 对策：在开发中通过 Cookie/Session 或 JWT (Token) 来维持登录状态。
灵活：允许传输任意类型的数据对象，通过 Content-Type 加以标记。

HTTP 请求报文结构

一个标准的 HTTP 请求由四部分组成：

请求行 (Request Line)： Method + URL + Version (如 GET /index.html HTTP/1.1)
请求头 (Request Headers)：键值对格式，描述客户端环境和偏好。
- Host: 目标主机。
- User-Agent: 浏览器标识。
- Accept: 客户端可接受的内容类型。
空行：必须存在，用于分隔头部和正文。
请求体 (Request Body)：仅 POST/PUT 等方法使用，存放要提交的数据（如 JSON）。

HTTP 响应报文与状态码

响应报文同样由 状态行、响应头、空行、响应体 组成。

核心状态码分类：

2xx (成功)：200 OK (请求成功)。
3xx (重定向)：301 (永久重定向)、302 (临时重定向)。
4xx (客户端错误)：
- 400 Bad Request: 请求语法错误。
- 403 Forbidden: 服务器拒绝执行。
- 404 Not Found: 资源不存在。
- 405 Method Not Allowed: 方法不支持（如用 GET 访问 POST 接口）。
5xx (服务器错误)：
- 500 Internal Server Error: 后端代码抛出未处理的异常。
- 502 Bad Gateway: 网关从后端收到了非法响应（如 Nginx 找不到 Java 服务）。
- 504 Gateway Timeout: 后端处理超时。

长链接与短链接

HTTP	应用层协议
TCP	传输层协议
ip	网络层协议

特性	短连接 (Short Connection)	长连接 (Keep-Alive)
底层表现	一次请求/响应消耗一个 TCP 连接	多次请求/响应复用一个 TCP 连接
HTTP 版本	HTTP/1.0 默认	HTTP/1.1 默认
HTTP Header	`Connection: close`	`Connection: keep-alive`
握手开销	高（每次请求都要三次握手）	低（仅首次建立需要）
服务器压力	CPU 压力较大（频繁建立/销毁连接）	内存压力较大（需维持空闲连接的 socket）
适用场景	偶尔交互的单次请求、请求频率极低的服务	Web 页面浏览、前后端高频 API 交互、图片服务器

JavaWeb on Creat

web后端实战

Restful

具体请求url

对应的注解

优点

数据封装

手动结果映射@Results @Result

起别名

开启驼峰命名自动转换 (最推荐)

使用 ResultMap (最强大、最灵活)

Nginx

各种注解

HttpServletRequest

@RequestParam

省略@RequestParam

指定默认值

@RequestBody

使用前提

@PathVariable

@DateTimeFormat

在实体类中使用（处理搜索条件）

直接在 Controller 参数中使用

@Options

XML形式的等价写法

将多个参数提取到实体类

注意事项

路径抽取

日志Logback

日志级别

PageHelper分页查询

原理

使用

Spring事务管理

@Transactional

rollbackFor

propagation

readOnly

失效场景

⭐Tips

文件上传

MultipartFile

问题及注意事项

存储在本地

OSS

批量注入值@ConfigurationProperties

全局异常处理器

注解

核心流程：

会话技术

Cookie

工作流程

缺点

典型场景与规避方案

Session

工作原理

生命周期

缺点

对比Cookie

⭐Token令牌（主流）

工作原理

JWT组成

Header（头部）—— “说明书”

Payload（有效载荷）—— “货物”

Signature（签名）—— “防伪封条”

总结外观

JWR生成/解析

Cookie,Session,Token对比

优点对比

过滤器Filter

核心作用

工作原理：责任链模式

执行顺序

注意事项

@PathVariable与@RequestParam

xml的更新语句

Web

SpringBootWeb基础

HTTP协议

请求协议

手动结果映射`@Results @Result`

`Cookie,Session,Token`对比

`xml`的更新语句

在`pom.xml`中的样子

断言`assert`

注解`Annotation`