行业知识
SpringBootWeb学习笔记——12万字详细总结！
0. 写在前面
���：这套笔记是根据黑马程序员B站2023-3-21的视频学习的成果，其中省略了前端基础部分、Maven部分和数据库基础部分，详情可见目录。
注注：目前文章内结尾处多幅图片加载不出来，因为图片还存在本地没被传上来，过段时间再改~
所有的Spring项目都基于Spring Framework
Spring Framework配置繁琐，入门难度大
文章目录
- 0. 写在前面
- 1. SpringBootWeb入门
-
- 简单的构成分析
- 工程启动后
- 2. HTTP协议
-
- 特点
- 请求协议
- 相应协议
- 协议解析
- 3. Tomcat
-
- 基本使用
- 部署项目
- 4. SpringBootWeb入门程序解析
-
- 起步依赖
- 5. 请求响应
-
- 前端控制器
- 请求对象：获取请求数据
- 响应对象：设置响应数据
- B/S架构：浏览器/服务器架构模式。客户端只需要浏览器，应用程序和数据都存放在服务端。
- C/S架构：客户端/服务器架构模式。
- 工具
- 简单参数
- 实体参数
- 响应数据
- 案例
- 6. 分层解耦
-
- 三层架构
- IOC&DI引入
- IoC-DI入门
- IoC详解
- 组件扫描
- DI详解
- 7. SQL
-
- 语句分类
- DDL
- 事务
- 索引
- 索引结构
- 索引操作语法
- 8. Mybatis
-
- 快速入门
- 单元测试
- 配置注解SQL提示（23版IDEA自带，无需配置）
- JDBC介绍
- 数据库连接池
- Lombok工具包
- MyBatis基本操作案例，准备工作
- 删除
- 删除（预编译SQL）
- 新增
- 新增（主键返回）
- 更新
- 查询（根据id查询）
- 查询（条件查询）
- XML映射文件（也叫配置文件）
- 9. MyBatis动态SQL
-
- \
- \
- if案例
- \
- \
- \和\
- 10. 部门管理员工管理案例
-
- 环境搭建
- 开发规范restful
- 开发规范统一响应结果
- 开发流程
- 部门管理部分
- 员工管理部分
- 插播：文件上传
- 本地存储
- 插播结束：阿里云OSS
- 修改员工
- 参数配置化
- yml配置文件
- @ConfigurationProperties
- 登录功能
- 登录校验
- 11. 会话技术
-
- 客户端会话跟踪技术：Cookie
- 服务器会话跟踪技术：Session
- 令牌技术
- JWT令牌
- JWT生成和校验
- 登录后下发令牌（注意：令牌存储由前端负责，案例中存放在本地存储空间）
- 12. 统一拦截，过滤器Filter
-
- 过滤器Filter快速入门
- Filter执行流程
- Filter拦截路径
- 过滤器链
- 案例实现登录校验过滤器
- 13. 拦截器Interceptor快速入门
-
- 拦截器拦截路径
- 拦截器执行流程
- 案例实现登录校验拦截器
- 14. 异常处理
-
- 异常处理方案
- 15. 事务管理
-
- Spring事务管理
- 16. 事务进阶
-
- rollbackFor属性
- propagation属性
- 17. AOP
-
- AOP快速入门
- AOP核心概念
- AOP执行流程
- AOP通知类型
- AOP通知顺序
- 切入点表达式
- execution
- annotation
-
- 连接点
- AOP案例
- 终章：原理篇
-
- 配置优先级
- 获取bean
- bean作用域
- 第三方bean
- SpringBoot原理
-
- Spring家族
- 起步依赖原理
- 自动配置概述
- 自动配置原理
- 源码跟踪分析
- @Conditional
- 自定义starter
- Web总结
-
- 三层架构
1. SpringBootWeb入门
一个简单的应用：浏览器发起/hello请求后，给浏览器返回一个字符串Hello World~
步骤：
- 创建springboot工程，并勾选web开发相关依赖。
- 定义HelloController类，添加方法hello，并添加注解。
- 运行测试
简单的构成分析
- 一个自动生成的类，和模块名一致：启动类，用来启动springboot工程，想启动工程只需要运行这个main函数
package com.itheima;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;// 启动类 --- 启动springboot工程@SpringBootApplicationpublic class SpringBootQuickStartApplication { public static void main(String[] args) { SpringApplication.run(SpringBootQuickStartApplication.class, args); }} - resources/static和/templates暂时用不上
- .properties是默认配置文件，也支持一些其他的后缀格式
- 创建的HelloController类是一个普通的Java类，需要添加注解@RestController把他变成请求处理类。还需要指定当前方法处理的是那个请求，使用注解@RequestMapping('/hello')指定处理的请求路径，浏览器将来请求/hello这个地址时，最终就会调用这个方法
package com.itheima.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;// 请求处理类，加上注解后，这就是一个请求处理类，不加注解就是普通类@RestControllerpublic class HelloController { // 指定当前方法处理的是哪个请求，/hello请求。浏览器请求/hello地址时，最终就会调用这个hello方法 @RequestMapping("/hello") public String hello() { System.out.println("Hello World~"); return "Hello World~"; }}
工程启动后
工程如果成功启动，在浏览器输入localhost:8080就可以看到函数return的Hello World，也可以在控制台看到输出的Hello World，说明入门程序没有问题。
2. HTTP协议
超文本传输协议，规定了浏览器与服务器间数据传输的规则，实际上就是规定了数据格式
F12查看网络里的hello请求
request header是请求的数据
response header是响应的数据
特点
- 基于TCP协议：面向连接，安全
- 基于请求-响应模型：一次请求对应一次响应
- HTTP协议是无状态协议：对事物没有记忆力，每次请求-响应都是独立的
- 缺点：多次请求间不能共享数据
- 优点：速度快
请求协议
就是请求数据的格式，分为三个部分
- 请求行，数据第一行，请求方式+资源路径+协议
- 请求头，第二行开始，是key: value的格式
- 请求体，POST请求，存放请求参数
- GET：请求参数在请求行中，没有请求体，请求大小有限制
- POST：请求参数在请求体中，请求大小没有限制
相应协议
同样分为三个部分
- 响应行，数据第一行，协议+状态码+描述
- 响应头，第二行开始，是key: value的格式
- 响应体，最后一部分，存放响应数据
注意状态码200、404、500
协议解析
Tomcat
3. Tomcat
最流行的HTTP协议解析程序，使程序员不必直接对协议进行操作。主要功能是“提供网上信息浏览服务”，又称Servlet容器
安装：解压安装包
卸载：删除文件夹
基本使用
bin/startup.bat运行
bin/shutdown.bat关闭
常见问题：
- startup.bat闪退，检查环境变量是否有JAVA_HOME（不带bin）
- 端口号冲突，找到对应程序将其关闭（任务管理器、详细信息、找对应端口号的程序）或修改Tomcat使用的端口号conf/server.xml
注意：HTTP协议默认端口号为80，若将Tomcat端口号改为80，则访问Tomcat时，不用输入端口号
部署项目
将项目放置到webapps下就部署完成了
4. SpringBootWeb入门程序解析
起步依赖
- spring-boot-starter-web：包含了web应用开发所需要的常见依赖
- spring-boot-starter-test：包含了单元测试所需要的常见依赖
借助依赖传递特性将某个功能所需的常见依赖聚合到一起。
在pom中会看到起步依赖没有写，这是因为SpringBoot项目都有一个父工程，在pom中表现为标签里的内容，所有起步依赖的版本都在父工程中进行了统一管理，会自动引入和SpringBoot版本对应的起步依赖版本
可以看到spring-boot-starter-web中有一个tomcat相关的依赖，所以启动项目时会将内置的Tomcat启动起来并占用Tomcat默认端口号8080，这个Tomcat和外部安装的Tomcat不是同一个，外部的Tomcat会很少使用，多数都是使用内置的Tomcat
5. 请求响应
Tomcat不能识别我们写的如HelloController的controller程序，但Tomcat可以识别Servlet规范。SpringBoot底层提供了一个非常核心的Servlet程序DispatcherServlet，它实现了Servlet规范中的Servlet接口（可看继承体系）。
浏览器发起的请求都会先经过DispatcherServlet，由DispatcherServlet将请求转给controller程序进行处理，处理完的结果返回给DispatcherServlet，DispatcherServlet再给浏览器响应数据
前端控制器
`DispatcherServlet`
如何在Servlet中获取请求数据？浏览器发请求会携带HTTP请求数据，web服务器负责对请求协议的解析。Tomcat就会对数据进行解析，并将解析后所有请求信息封装到一个对象HttpServletRequest中，也叫请求对象
请求对象：获取请求数据
应用程序就可以从HttpServletRequest对象中获取请求数据了，然后对请求进行处理。然后Tomcat服务器需要根据响应数据的格式给浏览器响应数据。借助另一个对象设置响应数据，HttpServletResponse，Tomcat会根据在这个对象中设置的响应信息来响应数据给浏览器。
响应对象：设置响应数据
HttpServletResponse
B/S架构：浏览器/服务器架构模式。客户端只需要浏览器，应用程序和数据都存放在服务端。
C/S架构：客户端/服务器架构模式。
主要关注controller程序，最重要的是获取请求参数和设置响应数据
工具
postman或apifox
简单参数
get post方式的处理方法相同
发送的是普通数据如name=zhangsan，创建controller/RequestController类进行操作
-
原始方式获取请求参数：通过HttpServletRequest对象手动获取
请求地址：http://localhost:8080/simpleParam?name=tom&age=10
实现请求处理方法，处理对/simpleParam的请求package com.itheima.controller; import jakarta.servlet.http.HttpServletRequest; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class RequestController { // 原始方式获取简单参数 @RequestMapping("/simpleparam") public String simpleParam(HttpServletRequest request) { // 获取请求参数 String name = request.getParameter("name"); String ageStr = request.getParameter("age"); int age = Integer.parseInt(ageStr); System.out.println(name + ":" + age); return "OK"; } }缺点：繁琐，需要手动类型转换
-
SpringBoot方式
简单参数：参数名与形参变量名相同，即可自动接收参数
请求地址：http://localhost:8080/simpleParam，参数为name=Tom和age=20
示例如下：
修改RequestController 中的方法package com.itheima.controller;import jakarta.servlet.http.HttpServletRequest;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { // SpringBoot方式获取参数 @RequestMapping("/simpleParam") public String simpleParam(String name, Integer age) { System.out.println(name + ":" + age); return "OK"; }}如果参数名和形参名不同，默认情况下会接收不到，变量存储值为null。可以通过注解@RequestParam完成映射
@RequestMapping("/simpleParam")public String simpleParam(@RequestParam(name= "name") String username, Integer age) { System.out.println(username + ":" + age); return "OK";}注意：@RequestParam中的required默认为true，表示该参数必须传递，如果不传递则报错，若参数是可选的，可修改required为false。
实体参数
-
简单实体对象：请求参数名与形参对象属性名相同，定义一个POJO类接收即可。
注意：定义的类中属性名必须和请求参数名相同才能成功封装
示例如下：
请求地址：http://localhost:8080/simplePojo?name=ITCAST&age=16
定义一个User类，其中的属性名必须和请求参数名相同，这里为name、agepackage com.itheima.pojo;public class User { public String name; public Integer age; public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; }}修改RequestController中的方法，处理对/simple/Pojo的请求
package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { @RequestMapping("/simplePojo") public String simplePojo(User user) { System.out.println(user); return "OK"; }} -
复杂实体对象：按照对象层次关系接收嵌套POJO属性参数
示例如下：
请求地址：http://localhost:8080/complexPojo?name=ITCAST&age=16&address.province=北京&address.city=北京
写一个Address类package com.itheima.pojo;/** * Created with IntelliJ IDEA. * * @author : wu_qing * @version : 1.0 * @Project : LearnSpringBoot * @Package : com.itheima.pojo * @ClassName : .java * @createTime : 2024/2/10 21:58 * @Email : 1553232108@qq.com * @Description : */public class Address { public String province; public String city; public String getProvince() { return province; } public void setProvince(String province) { this.province = province; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } @Override public String toString() { return "Address{" + "province='" + province + '\'' + ", city='" + city + '\'' + '}'; }}将Address添加到User类的属性中
修改请求处理方法package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { @RequestMapping("/complexPojo") public String complexPojo(User user) { System.out.println(user); return "OK"; }} -
数组集合参数/多同名参数：
数组方法：请求参数名与数组名相同且请求参数为多个，定义数组类型形参即可
集合方法：使用@RequestParam绑定参数关系，将多个请求参数的值封装到集合
示例如下：
请求地址：http://localhost:8080/arrayParam?hobby=game&hobby=java&hobby=sing
http://localhost:8080/listParam?hobby=game&hobby=java&hobby=sing
修改请求处理方法package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { // 数组方法 @RequestMapping("/arrayParam") public String arrayParam(String[] hobby) { System.out.println(Arrays.toString(hobby)); return "OK"; } // 集合方法获取同名参数 @RequestMapping("/listParam") public String listParam(@RequestParam List hobby) { System.out.println(hobby); return "OK"; }} -
日期参数：使用@DateTimeFormat注解完成日期参数格式转换
需要指定传来的日期参数格式，如@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss)"
注意：这里写的是yyyy-MM-dd HH:mm:ss的格式，那么请求参数里也必须是4位-2位-2位 2位:2位:2位
请求地址：http://localhost:8080/dateParam?updateTime=2024-12-10 22:17:39，如这里的月份如果为1月必须写为01补全位数package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { // 日期参数 @RequestMapping("/dateParam") public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime) { System.out.println(updateTime); return "OK"; }} -
JSON参数：需要POST方式发送，要求JSON数据键名与对象属性名相同，定义POJO类型即可接收参数，需要使用@RequestBody标识，将JSON数据封装到实体对象中
示例如下：
请求地址：http://localhost:8080/jsonParam
数据：{ "name": "zhangsan", "age": 16, "address": { "province": "北京", "city": "北京" } }
实现请求处理方法package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { // JSON参数 @RequestMapping("/jsonParam") public String jsonParam(@RequestBody User user) { System.out.println(user); return "OK"; }} -
路径参数
通过请求URL直接传递参数，如http://localhost:8080/path/1，如果注解写@RequestMapping("/path/1")，将来/1变成/2、/3、/100那就不能再处理这个请求，所以这个参数应该是动态的。使用{...}来标识该路径参数，就可以写@RequestMapping("/path/{id})代表这地方不是固定值而是路径参数，参数名叫id，这样就可以在controller中声明一个形参叫id，使用@pathVariable来指定获取路径参数并将路径参数的id绑定给方法参数的id，路径参数参数名需要与方法形参参数名保持一致
示例如下：
请求地址：http://localhost:8080/path/1
实现请求处理方法package com.itheima.controller;import com.itheima.pojo.User;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class RequestController { // 路径参数 @RequestMapping("/path/{id}") public String pathParam(@PathVariable Integer id) { System.out.println(id); return "OK"; }}多路径参数：在请求路径中使用/分隔，再写其他的参数，请求路径也要相应改变@RequestMapping("/path/{id}/{name}")
注意：每个参数都需要使用@pathVariable来绑定
示例如下：
请求地址：http://localhost:8080/path/1/Tom
实现请求处理方法package com.itheima.controller;@RestControllerpublic class RequestController { // 多路径参数 @RequestMapping("/path/{id}/{name}") public String pathParam2(@PathVariable Integer id, @PathVariable String name) { System.out.println(id); System.out.println(name); return "OK"; }}
响应数据
controller程序的return值就是响应（返回给浏览器）的值。所有的响应数据都需要依赖核心的@ResponseBody注解，需要写在controller方法上或类上。他的作用就是将方法返回值直接作为响应数据给客户端浏览器，如果返回值类型是实体对象/集合，会转为JSON格式再响应，**但是似乎从来没见过？**事实上是因为@RestController = @Controller + @ResponseBody，已经包含了@ResponseBody注解。写@RestController等价于写@Controller + @ResponseBody。
在类上加了@ResponseBody注解，代表当前类下所有返回值都会作为响应数据，如果是对象或集合会先转JSON再来响应
示例如下：
请求地址分别为：
http://localhost:8080/hellohttp://localhost:8080/getAddrhttp://localhost:8080/listAddr
新建一个ResponseController类
package com.itheima.controller;import com.itheima.pojo.Address;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.ArrayList;import java.util.List;@RestControllerpublic class ResponseController { @RequestMapping("/hello") public String hello() { System.out.println("Hello World!"); return "Hello World~"; } @RequestMapping("/getAddr") public Address getAddr() { Address addr = new Address(); addr.setProvince("广东"); addr.setCity("深圳"); return addr; } @RequestMapping("/listAddr") public List listAddr() { List list = new ArrayList(); Address addr = new Address(); addr.setProvince("北京"); addr.setCity("北京"); Address addr2 = new Address(); addr2.setProvince("广东"); addr2.setCity("深圳"); list.add(addr); list.add(addr2); return list; }} 对这三个请求处理方法分别发出请求，可以看到第一个返回的就是一个字符串，第二个返回的是JSON格式的数据，第三个返回的是JSON数组的数据
说明：每个对外暴露的方法都称为功能接口，注解中写的路径为接口的访问路径。开发文档就是描述功能接口的请求路径，请求参数以及响应数据的。
可以发现每个接口响应的数据很随意，没有任何规范，前端很难解析响应回去的数据，开发成本会增加，项目不便管理且很难维护。
一般会给所有的功能接口设置统一的响应结果，可以考虑使用一个对象result来接收，主要有3个属性：
- int code，响应码，可以和前端约定：1表示成功，0表示失败
- string msg，提示信息
- object data，返回的数据
返回的result对象经过ResponseBody的处理后，就会响应一个JSON格式的数据，前端只会收到一种格式的数据，只需要根据这一种格式来解析。项目管理和维护就会更加方便。
示例如下：
实现一个Result类
package com.itheima.pojo;public class Result { private Integer code; // 验证码，1成功，0失败 private String msg; // 提示信息 private Object data; // 数据 public Result() { } public Result(Integer code, String msg, Object data) { this.code = code; this.msg = msg; this.data = data; } public Integer getCode() { return code; } public void setCode(Integer code) { this.code = code; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public static Result success(Object data) { return new Result(1, "success", data); } public static Result success() { return new Result(1, "success", null); } public static Result error(String msg) { return new Result(0, msg, null); } @Override public String toString() { return "Result{" + "code=" + code + ", msg='" + msg + '\'' + ", data=" + data + '}'; }} 类中写了三个静态方法，分别是成功且返回数据，成功且不返回数据，失败
再修改ResponseController类中的方法，使三个功能接口具有相同的响应数据格式
package com.itheima.controller;import com.itheima.pojo.Address;import com.itheima.pojo.Result;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.ArrayList;import java.util.List;@RestControllerpublic class ResponseController { /*@RequestMapping("/hello") public String hello() { System.out.println("Hello World!"); return "Hello World~"; } @RequestMapping("/getAddr") public Address getAddr() { Address addr = new Address(); addr.setProvince("广东"); addr.setCity("深圳"); return addr; } @RequestMapping("/listAddr") public List listAddr() { List list = new ArrayList(); Address addr = new Address(); addr.setProvince("北京"); addr.setCity("北京"); Address addr2 = new Address(); addr2.setProvince("广东"); addr2.setCity("深圳"); list.add(addr); list.add(addr2); return list; }*/ @RequestMapping("/hello") public Result hello() { System.out.println("Hello World!"); // return new Result(1, "success", "Hello World!"); return Result.success("Hello World!"); // 和上边的效果一样，一个用构造，一个用静态方法，都是返回一个result对象 } @RequestMapping("/getAddr") public Result getAddr() { Address addr = new Address(); addr.setProvince("广东"); addr.setCity("深圳"); return Result.success(addr); } @RequestMapping("/listAddr") public Result listAddr() { List list = new ArrayList(); Address addr = new Address(); addr.setProvince("北京"); addr.setCity("北京"); Address addr2 = new Address(); addr2.setProvince("广东"); addr2.setCity("深圳"); list.add(addr); list.add(addr2); return Result.success(list); }} 案例
- 在POM中引入dom4j，用来解析XML文件
org.dom4j dom4j 2.1.3
- 引入工具类XMLParserUtils，实体类Emp，XML文件emp.xml
- 引入静态页面，放在resources/static目录下
- 写controller程序
package com.itheima.controller;import com.itheima.pojo.Emp;import com.itheima.pojo.Result;import com.itheima.utils.XmlParserUtils;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class EmpController { @RequestMapping("/listEmp") // 和前端页面发送请求的路径相同 public Result list() { // 1. 加载解析XML文件 String file = this.getClass().getClassLoader().getResource("emp.xml").getFile(); System.out.println(file); List empList = XmlParserUtils.parse(file, Emp.class); // 2. 对数据进行转换处理 gender和job empList.stream().forEach(emp -> { // 处理gender 1男 2女 String gender = emp.getGender(); if ("1".equals(gender)) { emp.setGender("男"); } else if ("2".equals(gender)) { emp.setGender("女"); } // 处理job 1: 讲师, 2: 班主任 , 3: 就业指导 String job = emp.getJob(); if ("1".equals(job)) { emp.setJob("讲师"); } else if ("2".equals(job)) { emp.setJob("班主任"); } else if ("3".equals(job)) { emp.setJob("就业指导"); } }); // 3. 响应数据 return Result.success(empList); }} 说明：SpringBoot项目的静态资源默认存放目录为：classpath:/static、classpath:/public、classpath:/resources，classpath是类路径，对Maven项目来说resources目录就是类路径，一般就使用static目录
6. 分层解耦
EmpController中的代码包含数据访问，逻辑处理，接受请求和响应数据。需要尽量让每个类 接口 方法的职责更加单一，这是单一职责原则。能够使类 接口 方法的可读性 可维护性 拓展性更好
三层架构
- Controller：表示层/控制层，就是编写的Controller程序，负责接收请求、进行处理、响应数据。
- Service：逻辑层，处理具体的业务逻辑。
- Dao：数据访问层（Data Access Object）/持久层，负责数据访问操作，包括增删改查。
前端发起请求先到达Controller，调用Service进行逻辑处理，处理的前提是拿到数据，所以再调用Dao层去操作文件中的数据，拿到数据再返回给Service，处理之后的结果返回给Controller，再响应数据给前端。
数据访问Dao层的实现方式可能有很多，如访问文件的数据、数据库的数据、别人提供接口的数据，要灵活的切换各种实现，可以通过面向接口的方式进行编程
需要先定一个Dao的接口来增强灵活性和拓展性
- 先来一个dao包下的EmpDao接口
package com.itheima.dao;import com.itheima.pojo.Emp;import java.util.List;public interface EmpDao { // 获取员工列表 public List listEmp();} - 再来一个impl/EmpDaoA（方式很多所以叫A来区分）实现类来实现接口的方法，逻辑就是Controller中解析XML文件获取数据部分
package com.itheima.dao.impl;import com.itheima.dao.EmpDao;import com.itheima.pojo.Emp;import com.itheima.utils.XmlParserUtils;import java.util.List;public class EmpDaoA implements EmpDao { @Override public List listEmp() { // 1. 加载解析XML文件 String file = this.getClass().getClassLoader().getResource("emp.xml").getFile(); System.out.println(file); List empList = XmlParserUtils.parse(file, Emp.class); return empList; }} - 然后是Service层，先来一个接口增加灵活性EmpService
package com.itheima.service;import com.itheima.pojo.Emp;import java.util.List;public interface EmpService { // 获取员工列表 public List listEmp();} - 再来impl/EmpServiceA实现类来实现接口方法，逻辑就是Controller中数据处理部分，但是要从Dao中获取数据
package com.itheima.service.impl;import com.itheima.dao.EmpDao;import com.itheima.dao.impl.EmpDaoA;import com.itheima.pojo.Emp;import com.itheima.service.EmpService;import java.util.List;public class EmpServiceA implements EmpService { private EmpDao empDao = new EmpDaoA(); @Override public List listEmp() { // 1. 调用Dao获取数据 List empList = empDao.listEmp(); // 2. 对数据进行转换处理 gender和job empList.stream().forEach(emp -> { // 处理gender 1男 2女 String gender = emp.getGender(); if ("1".equals(gender)) { emp.setGender("男"); } else if ("2".equals(gender)) { emp.setGender("女"); } // 处理job 1: 讲师, 2: 班主任 , 3: 就业指导 String job = emp.getJob(); if ("1".equals(job)) { emp.setJob("讲师"); } else if ("2".equals(job)) { emp.setJob("班主任"); } else if ("3".equals(job)) { emp.setJob("就业指导"); } }); return empList; }} - 最后修改Controller程序，从Service中接收处理完的数据并响应给前端
package com.itheima.controller;import com.itheima.pojo.Emp;import com.itheima.pojo.Result;import com.itheima.service.EmpService;import com.itheima.service.impl.EmpServiceA;import com.itheima.utils.XmlParserUtils;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class EmpController { private EmpService service = new EmpServiceA(); @RequestMapping("/listEmp") // 和前端页面发送请求的路径相同 public Result list() { // 调用Service获取数据，然后响应 List empList = service.listEmp(); // 3. 响应数据 return Result.success(empList); }// @RequestMapping("/listEmp") // 和前端页面发送请求的路径相同// public Result list() { // // 1. 加载解析XML文件// String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();// System.out.println(file);// List empList = XmlParserUtils.parse(file, Emp.class);//// // 2. 对数据进行转换处理 gender和job// empList.stream().forEach(emp -> { // // 处理gender 1男 2女// String gender = emp.getGender();// if ("1".equals(gender)) { // emp.setGender("男");// } else if ("2".equals(gender)) { // emp.setGender("女");// }//// // 处理job 1: 讲师, 2: 班主任 , 3: 就业指导// String job = emp.getJob();// if ("1".equals(job)) { // emp.setJob("讲师");// } else if ("2".equals(job)) { // emp.setJob("班主任");// } else if ("3".equals(job)) { // emp.setJob("就业指导");// }// });//// // 3. 响应数据// return Result.success(empList);// }} 整体过程：前端发起请求之后，先到达Controller程序，他只负责接受请求响应数据，所以直接调用Service层中的方法，Service层只负责逻辑处理，所以直接调用Dao中的方法获取数据，由Dao层来负责数据访问操作，将查询的数据返回给Service，Service处理完后返回给Controller，Controller拿到结果再响应给前端页面。
IOC&DI引入
-
内聚：各个功能模块内部的功能联系
员工管理的Service中只会编写与员工相关的逻辑处理，与员工无关的逻辑处理不会放在这个类中。
-
耦合：衡量软件中各个层/模块之间的依赖、关联的程度
Controller中new了一个Service的实现类，如果Service层类名发生变化，Controller的代码也需要修改。Service与Dao也有这样的耦合关系。
-
软件设计原则：高内聚低耦合
解耦：不能直接new Service对象
提供一个容器来存储一些对象，如果想用EmpServiceA，只需要将其创建的对象A放在容器当中。Controller在运行时需要依赖于EmpService，就可以去容器中查找EmpService这个类型的对象，看到A就是这个类型，就可以从容器中找到对象然后将其赋值给Controller中的empService。
如果要切换实现类，从A切换为B，只需要将B创建的对象放到容器中，Controller运行时也只需要在容器中查找对象，找到对象后赋值给empService。这样即使Service发生变化，Controller代码也不需要修改。
两个问题：
- 对象怎么交给容器管理
- 容器怎么为程序提供它所依赖的资源
涉及到Spring中两个概念：
- 控制反转IoC（Inversion Of Control），Spring框架第一大核心，对象创建的控制权由应用程序转移到了外部容器。反转前由程序自身控制对象创建，反转后由容器控制。容器也叫IoC容器或Spring容器
- 依赖注入DI（Dependency Injection），容器为程序提供运行时依赖的资源，如Controller运行时依赖EmpService，就可以让容器为它提供。
- bean对象，IoC容器中创建管理的对象，称之为bean对象
IoC-DI入门
解耦Controller与Service，Service与Dao
-
将Service层及Dao层的实现类，交给IoC容器管理，为类加注解@Component
-
为Controller和Service注入运行时依赖的对象，为属性加注解@Autowired
package com.itheima.dao.impl;import com.itheima.dao.EmpDao;import com.itheima.pojo.Emp;import com.itheima.utils.XmlParserUtils;import org.springframework.stereotype.Component;import java.util.List;@Component // 将当前类交给IoC容器管理，成为IoC容器中的beanpublic class EmpDaoA implements EmpDao { @Override public List listEmp() { // 1. 加载解析XML文件 String file = this.getClass().getClassLoader().getResource("emp.xml").getFile(); System.out.println(file); List empList = XmlParserUtils.parse(file, Emp.class); return empList; }}
package com.itheima.service.impl;
import com.itheima.dao.EmpDao;
import com.itheima.dao.impl.EmpDaoA;
import com.itheima.pojo.Emp;
import com.itheima.service.EmpService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class EmpServiceA implements EmpService {
@Autowired
private EmpDao empDao;
@Override public List listEmp() { // 1. 调用Dao获取数据 List empList = empDao.listEmp(); // 2. 对数据进行转换处理 gender和job empList.stream().forEach(emp -> { // 处理gender 1男 2女 String gender = emp.getGender(); if ("1".equals(gender)) { emp.setGender("男"); } else if ("2".equals(gender)) { emp.setGender("女"); } // 处理job 1: 讲师, 2: 班主任 , 3: 就业指导 String job = emp.getJob(); if ("1".equals(job)) { emp.setJob("讲师"); } else if ("2".equals(job)) { emp.setJob("班主任"); } else if ("3".equals(job)) { emp.setJob("就业指导"); } }); return empList; } }
```javapackage com.itheima.controller;import com.itheima.pojo.Emp;import com.itheima.pojo.Result;import com.itheima.service.EmpService;import com.itheima.service.impl.EmpServiceA;import com.itheima.utils.XmlParserUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class EmpController { @Autowired // 运行时，IoC容器会提供该类型的bean对象，并赋值给该变量 private EmpService service; @RequestMapping("/listEmp") // 和前端页面发送请求的路径相同 public Result list() { // 调用Service获取数据，然后响应 List empList = service.listEmp(); // 3. 响应数据 return Result.success(empList); }} 这样就完成了控制反转和依赖注入，也完成了层与层之间的解耦，若要切换到EmpServiceB，只需要将A的@Component注释掉，给B添加上@Component注解和自动注入，Dao层和Controller层的代码都不需要改动。
IoC详解
除了@Component外，还提供了三个衍生注解@Controller @Service @Repository来表示bean对象到底归属于哪一层。实际上由于与Mybatis整合``@Repository`用的较少。
某一个类不能归到这三层，又想交给IoC容器管理，就可以使用@Component注解，典型的就是一些工具类。
另外，Controller程序也不需要使用@Controller注解，因为@RestController注解已经包括了@Controller注解。
bean对象的默认名字为类名首字母小写，可以手动指定名字@Repository(value = "daoA&
