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\>
    • \<where\>
    • if案例
    • \<set\>
    • \<foreach\>
    • \<sql\>和\<include\>
  • 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~
在这里插入图片描述
步骤:

  1. 创建springboot工程,并勾选web开发相关依赖。
  2. 定义HelloController类,添加方法hello,并添加注解。
  3. 运行测试

简单的构成分析

  • 一个自动生成的类,和模块名一致:启动类,用来启动springboot工程,想启动工程只需要运行这个main函数
    package com.itheima;import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;// 启动类 --- 启动springboot工程
    @SpringBootApplication
    public 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;// 请求处理类,加上注解后,这就是一个请求处理类,不加注解就是普通类
    @RestController
    public 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是响应的数据

特点

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

请求协议

就是请求数据的格式,分为三个部分

  1. 请求行,数据第一行,请求方式+资源路径+协议
  2. 请求头,第二行开始,是key: value的格式
  3. 请求体,POST请求,存放请求参数
    • GET:请求参数在请求行中,没有请求体,请求大小有限制
    • POST:请求参数在请求体中,请求大小没有限制

相应协议

同样分为三个部分

  1. 响应行,数据第一行,协议+状态码+描述
  2. 响应头,第二行开始,是key: value的格式
  3. 响应体,最后一部分,存放响应数据
    注意状态码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中会看到起步依赖没有写<version>,这是因为SpringBoot项目都有一个父工程,在pom中表现为<parent>标签里的内容,所有起步依赖的版本都在父工程中进行了统一管理,会自动引入和SpringBoot版本对应的起步依赖版本

可以看到spring-boot-starter-web中有一个tomcat相关的依赖,所以启动项目时会将内置的Tomcat启动起来并占用Tomcat默认端口号8080,这个Tomcat和外部安装的Tomcat不是同一个,外部的Tomcat会很少使用,多数都是使用内置的Tomcat

5. 请求响应

Tomcat不能识别我们写的如HelloControllercontroller程序,但Tomcat可以识别Servlet规范。SpringBoot底层提供了一个非常核心的Servlet程序DispatcherServlet,它实现了Servlet规范中的Servlet接口(可看继承体系)。
浏览器发起的请求都会先经过DispatcherServlet,由DispatcherServlet将请求转给controller程序进行处理,处理完的结果返回给DispatcherServletDispatcherServlet再给浏览器响应数据

前端控制器

`DispatcherServlet`

如何在Servlet中获取请求数据?浏览器发请求会携带HTTP请求数据,web服务器负责对请求协议的解析。Tomcat就会对数据进行解析,并将解析后所有请求信息封装到一个对象HttpServletRequest中,也叫请求对象

请求对象:获取请求数据

应用程序就可以从HttpServletRequest对象中获取请求数据了,然后对请求进行处理。然后Tomcat服务器需要根据响应数据的格式给浏览器响应数据。借助另一个对象设置响应数据,HttpServletResponse,Tomcat会根据在这个对象中设置的响应信息来响应数据给浏览器。

响应对象:设置响应数据

HttpServletResponse

B/S架构:浏览器/服务器架构模式。客户端只需要浏览器,应用程序和数据都存放在服务端。

C/S架构:客户端/服务器架构模式。

主要关注controller程序,最重要的是获取请求参数和设置响应数据

工具

postmanapifox

简单参数

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;@RestControllerpublic 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=Tomage=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;@RestController
    public 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,表示该参数必须传递,如果不传递则报错,若参数是可选的,可修改requiredfalse

实体参数

  • 简单实体对象:请求参数名与形参对象属性名相同,定义一个POJO类接收即可。
    注意:定义的类中属性名必须和请求参数名相同才能成功封装
    示例如下:
    请求地址:http://localhost:8080/simplePojo?name=ITCAST&age=16
    定义一个User类,其中的属性名必须和请求参数名相同,这里为name、age

    package 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;}@Overridepublic 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;@RestController
    public 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;}@Overridepublic 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;@RestController
    public 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;@RestController
    public class RequestController {// 数组方法@RequestMapping("/arrayParam")public String arrayParam(String[] hobby) {System.out.println(Arrays.toString(hobby));return "OK";}// 集合方法获取同名参数@RequestMapping("/listParam")public String listParam(@RequestParam List<String> 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;@RestController
    public 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;@RestController
    public 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;@RestController
    public 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/hello
http://localhost:8080/getAddr
http://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;@RestController
public 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<Address> listAddr() {List<Address> 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个属性:

  1. int code,响应码,可以和前端约定:1表示成功,0表示失败
  2. string msg,提示信息
  3. 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);}@Overridepublic 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;@RestController
public 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<Address> listAddr() {List<Address> 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<Address> 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文件
<!-- 解析XML -->
<dependency><groupId>org.dom4j</groupId><artifactId>dom4j</artifactId><version>2.1.3</version>
</dependency>
  • 引入工具类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;@RestController
public class EmpController {@RequestMapping("/listEmp") // 和前端页面发送请求的路径相同public Result list() {// 1. 加载解析XML文件String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> empList = XmlParserUtils.parse(file, Emp.class);// 2. 对数据进行转换处理 gender和jobempList.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<Emp> 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 {@Overridepublic List<Emp> listEmp() {// 1. 加载解析XML文件String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> 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<Emp> 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();@Overridepublic List<Emp> listEmp() {// 1. 调用Dao获取数据List<Emp> empList = empDao.listEmp();// 2. 对数据进行转换处理 gender和jobempList.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;@RestController
public class EmpController {private EmpService service = new EmpServiceA();@RequestMapping("/listEmp") // 和前端页面发送请求的路径相同public Result list() {// 调用Service获取数据,然后响应List<Emp> 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<Emp> 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容器中的bean
    public class EmpDaoA implements EmpDao {@Overridepublic List<Emp> listEmp() {// 1. 加载解析XML文件String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();System.out.println(file);List<Emp> 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;

  @Overridepublic List<Emp> listEmp() {// 1. 调用Dao获取数据List<Emp> empList = empDao.listEmp();// 2. 对数据进行转换处理 gender和jobempList.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;}

}


```java
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.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;@RestController
public class EmpController {@Autowired // 运行时,IoC容器会提供该类型的bean对象,并赋值给该变量private EmpService service;@RequestMapping("/listEmp") // 和前端页面发送请求的路径相同public Result list() {// 调用Service获取数据,然后响应List<Emp> 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&

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/693840.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

升级到PHP8.X的原因和方法

上周有一个使用Hostease美国主机服务器多年的客户&#xff0c;反馈需要升级到PHP8.x&#xff0c;原因是站点程序已升级&#xff0c;并希望站点运行在更高也稳定的PHP8.x上。在升级PHP8.x的过程中&#xff0c;联系我们并反馈在升级过程中遇到了问题&#xff0c;需求解决方案。 升…

雷池社区版WAF:开源护网,共筑网络安全长城

雷池社区版WAF&#xff08;Web Application Firewall&#xff09;是一款开源的网络应用防火墙&#xff0c;旨在为网站和网络应用提供安全防护&#xff0c;以抵御各种网络攻击&#xff0c;如SQL注入、跨站脚本攻击&#xff08;XSS&#xff09;、文件包含、以及其他常见的安全威胁…

Linux 常用命令100+

Linux 运维/开发/测试 常用命令100 线上查询及帮助命令(2个) 命令功能说明示例man 命令查看普通命令帮助&#xff0c;命令的词典&#xff0c;更复杂的还有info&#xff0c;但不常用。rootbrLinux ~]#man lshelp 命令查看Linux内置命令的帮助&#xff0c;比如cd命令。[rootbrL…

comsol燃料电池+锂离子电池

电化学仿真技术通过对电池微观行为进行研究&#xff0c;明晰电池内部多现象机理&#xff0c;并将其数值化&#xff0c;通过数值法实现对物理特征联合计算&#xff0c;建立完整的电池模型。COMSOL Multiphysics 具有强大的多物理场全耦合仿真分析功能、高效的计算性能&#xff0…

低代码中的工作流:简化开发流程,提升效率

低代码开发平台近年来在软件开发领域引起了广泛的关注和应用。它以提高开发效率、降低开发成本为目标&#xff0c;通过简化开发过程&#xff0c;使非专业开发者也能快速构建高品质的应用程序。其中&#xff0c;工作流引擎作为低代码开发平台的重要组成部分&#xff0c;对于提升…

文件上传漏洞--Upload-labs--Pass17--条件竞争

一、条件竞争原理&#xff08;结合代码审计&#xff09; 1、首先进行代码审计&#xff0c;查看源代码。 我们可知&#xff0c;将文件上传至服务器后&#xff0c;不会被立即删除&#xff0c;而是做短暂的停留&#xff0c;中间会有一小部分时间差&#xff0c;这部分时间差是代码…

华为OD机试真题C卷-篇4

200分值题 员工派遣快递员的烦恼符号运算伐木工反射计数分披萨推荐多样性贪心的歌手螺旋数组矩阵(100) 员工派遣 nums [int(x) for x in input().split(" ")] x nums[0] y nums[1] count_x nums[2] count_y nums[3] left 1 right pow(10, 9) while (True) :if…

vue 实现docx文件在线预览

预览请求步骤&#xff1a; 准备一个需要预览的文件地址【如:https://usdoc.cn/vw/文件模板.docx】GET 参数到请求地址将拼接好的地址放在浏览器中&#xff0c;开始预览 请求地址&#xff1a;https://vw.usdoc.cn/ 请求方式&#xff1a;GET 请求参数: 字段名称字段类型必填参数…

2024年单服务器部署Mongodb三节点副本集自动化部署脚本

该脚本是为了方便自己学习和工作中部署服务器从而节省时间进行编写&#xff0c;目前能正常部署&#xff0c;创建集群&#xff0c;管理员用户&#xff0c;以及连接都没问题&#xff0c;但是没有开启验证&#xff0c;后续找时间补充。 完整的教程请参考一下我写的技术文章。 20…

渲染效果图有哪几种分类?效果图为什么用云渲染更快

云渲染利用了集群化的云端服务器资源&#xff0c;通过并行计算充分发挥了高性能硬件的优势&#xff0c;显著提升了渲染的速度。这一技术特别适用于处理规模庞大或细节丰富的渲染任务&#xff0c;在缩短项目完成时间方面表现卓越。无论是用于为建筑提供精确的可视化效果图&#…

【Python Scrapy】分布式爬虫利器

在当今信息爆炸的时代&#xff0c;获取大规模数据对于许多应用至关重要。而分布式爬虫作为一种强大的工具&#xff0c;在处理大量数据采集和高效爬取方面展现了卓越的能力。 本文将深入探讨分布式爬虫的实际应用场景&#xff0c;通过代码示例演示其在提升爬取效率、保障系统稳定…

牛刀小试 - C++ 学生信息管理系统

参考文档&#xff1a; C实现&#xff1a;学生管理系统&#xff08;详细解析&#xff09; 关于switch中的default里面的break是否可以省略这件事 需求要求&#xff1a; &#xff08;1&#xff09;增加记录 &#xff08;2&#xff09;查找记录 &#xff08;3&#xff09;删除…

FFmpeg进阶-给视频添加马赛克效果

很多时候为了隐藏视频中的敏感信息如人脸、身份证号、车牌号等,我们会采用马赛克算法对视频帧中的一部分内容进行处理。这里介绍一下如何采用FFmpeg实现马赛克效果。 马赛克效果算法的原理如下: 1.分块处理:首先将图像划分为多个小块或区域 2.像素替换:对于每个小块,算法会将…

【Windows11】内存使用率只有总内存容量的一半

硬件配置&#xff1a;2根16G的内存条&#xff08;金百达DDR4 3600, 海力士颗粒&#xff0c;灯条刃&#xff09;&#xff0c;插在2和4通道上 系统配置&#xff1a;windows11 问题描述&#xff0c;我和这位网友的问题一模一样&#xff1a; 系统32G内存&#xff0c;开机完全识别&…

实习日志17

1.测试公司服务器 1.1.太卡了&#xff0c;点一下卡半天 上传项目源码和文件&#xff1a; 将活字格项目源码和所有相关文件上传到服务器的指定目录。可以使用向日葵远程控制或者版本控制系统来进行文件上传。 重新配置活字格项目&#xff1a; 根据服务器环境&#xff0c;需要对…

Java 学习和实践笔记(14):用表格来理解类、对象、属性以及动作(方法)很容易

OOP :面向对象编程&#xff0c;object oriented programming. 用表格就可以很好地理解类、对象、属性、以及动作这些概念。 一个表&#xff08;结构&#xff09;就对应一个类&#xff08;结构&#xff09;。所以凡叫什么类&#xff0c;自己就在心里把它叫什么表。反过来&…

vue 非父子通信-event bus 事件总线

1.作用 非父子组件之间&#xff0c;进行简易消息传递。(复杂场景→ Vuex) 2.步骤 创建一个都能访问的事件总线 &#xff08;空Vue实例&#xff09; import Vue from vue const Bus new Vue() export default Bus A组件&#xff08;接受方&#xff09;&#xff0c;监听Bus的…

【图与网络数学模型】3.Ford-Fulkerson算法求解网络最大流问题

【图与网络数学模型】3.Ford-Fulkerson算法求解网络最大流问题 一、网络流模型1. 概述2. 可行流3. 增广链 二、示例1. 最大流问题2. Alternate Formulation&#xff1a;最小截量问题 三、Ford-Fulkerson 算法1. 导入库2. 初始化残差图3. 定义查找增广路径4. 定义循环5. 程序运行…

ubuntu22.04@Jetson Orin Nano之OpenCV安装

ubuntu22.04Jetson Orin Nano之OpenCV安装 1. 源由2. 分析3. 证实3.1 jtop安装3.2 jtop指令3.3 GPU支持情况 4. 安装OpenCV4.1 修改内容4.2 Python2环境【不需要】4.3 ubuntu22.04环境4.4 国内/本地环境问题4.5 cudnn版本问题 5. 总结6. 参考资料 1. 源由 昨天用Jetson跑demo程…

《英伟达-本地AI》--NVIDIA Chat with RTX-本机部署

阿丹&#xff1a; 突然发现公司给配置的电脑是NVIDIA RTX 4060的显卡&#xff0c;这不搞一搞本地部署的大模型玩一玩&#xff1f;&#xff1f;&#xff1f; 从0-》1记录一下本地部署的全过程。 本地模型下载地址&#xff1a; Build a Custom LLM with Chat With RTX | NVIDIA…