1.SpringMVC自动配置
2.简单功能
1、静态资源目录
只要静态资源放在类路径下： called /static (or /public or /resources or /META-INF/resources
访问 ： 当前项目根路径/ + 静态资源名
访问地址：localhost:8080/bug.jpg
原理： 静态资源映射的是/**。
静态资源的默认根路径是：/resources/**
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面
也就是默认先查找动态资源
可以改变静态资源的访问前缀：
改变静态资源的访问前缀，默认是无前缀的。
添加相应的配置：
#修改静态资源的默认访问路径
spring:
mvc:
static-path-pattern: /res/**当前项目 + static-path-pattern + 静态资源名 = 静态资源文件夹下找
访问地址：localhost:8080/res/bug.jpg
改变默认的静态资源路径：
#修改静态资源的默认前缀
spring:
mvc:
static-path-pattern: /res/**
#表示改变默认的静态资源路径
resources:
static-locations: classpath:/haha/必须将资源文件放在resource/haha中才可以进行访问。
一般情况下是设置爱静态资源的访问前缀，不会设置静态资源的默认访问路径，一般就放在static目录下就可以了。
2.2、欢迎页支持
- 静态资源路径下 index.html (就是默认访问的主页)
- 可以配置静态资源路径
- 但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问
如果进行了配置： static-path-pattern: /res/**
那么在访问的时候输入localhost:8080/就会出错
spring:
#表示改变默认的静态资源路径
resources:
static-locations: classpath:/haha/如果设置了默认的静态资源路径，将index.html放在该静态资源路径下就可以直接访问
呈现的页面就是index.html
2.3、自定义 Favicon
favicon.ico 放在静态资源目录下即可。就会出现在访问地址栏前面有一个小图标。
但是需要打开新的浏览器窗口才能看到效果，该图标是在session对象中，所以生命周期是在一次会话。
静态资源路径前缀会影响Favicon的功能。
spring:
# mvc:
# static-path-pattern: /res/** 这个会导致 Favicon 功能失效3、请求参数处理
1.请求映射
1、rest使用与原理
@xxxMapping；
Rest风格支持（使用HTTP请求方式动词来表示对资源的操作
- 以前：/getUser 获取用户 /deleteUser 删除用户 /editUser 修改用户 /saveUser 保存用户
- 现在： /user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
只是SpringBoot给我们的一种风格，根据这样一种风格可以使我们跟方便的编写自己的业务程序。
核心Filter；HiddenHttpMethodFilter
用法：表单method=post，隐藏域 _method=put
SpringBoot中手动开启
@RequestMapping(value = "/user",method = RequestMethod.GET)
public String getUser(){
return "GET-张三";
}
@RequestMapping(value = "/user",method = RequestMethod.POST)
public String saveUser(){
return "POST-张三";
}
@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String putUser(){
return "PUT-张三";
}
@RequestMapping(value = "/user",method = RequestMethod.DELETE)
public String deleteUser(){
return "DELETE-张三";
}<h1>测试REST风格；</h1>
<form action="/user" method="get">
<input value="REST-GET 提交" type="submit"/>
</form>
<form action="/user" method="post">
<input value="REST-POST 提交" type="submit"/>
</form>
<form action="/user" method="post">
<input name="_method" type="hidden" value="delete"/>
<input value="REST-DELETE 提交" type="submit"/>
</form>
<form action="/user" method="post">
<input name="_method" type="hidden" value="PUT"/>
<input value="REST-PUT 提交" type="submit"/>
</form>
<hr/>开启filter：
spring:
mvc:
hiddenmethod:
filter:
enabled: true #开启页面表单的Rest功能
Rest原理（表单提交要使用REST的时候）
- 表单提交会带上_method=PUT
- 请求过来被HiddenHttpMethodFilter拦截
请求是否正常，并且是POST，请求就会进入。
- 获取到_method的值。
- 过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。
- 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
兼容以下请求；PUT.DELETE.PATCH
这种filter的方式只是对于表单的提交，rest风格的原理，如果是浏览器直接发的请求，就可以直接发送put。delete等方式的请求。不用filter
2.扩展：如何把_method 这个名字换成我们自己喜欢的
如果容器中已经有hiddenHttpMethodFilter，Springboot就不会再自动配置hiddenHttpMethodFilter，用自定义的filter。
//自定义filter
@Bean
public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
methodFilter.setMethodParam("_m");
return methodFilter;
}2.普通的参数与基本的注解
@PathVariable
获得路径变量
当使用@RequestMapping URI template 样式映射时， 即 someUrl/{paramId}, 这时的paramId可通过 @Pathvariable注解绑定它传过来的值到方法的参数上。
//localhost:8080/car/2/owner/zhangsan
@RestController
public class ParameterTestController {
// car/2/owner/zhangsan
//可以单独提取对应名字的路径变量的值，也可以通过map的方式获取全部的路径变量的值
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(@PathVariable("id") Integer id,
@PathVariable("username") String name,
@PathVariable Map<String,String> pv,
@RequestHeader("User-Agent") String userAgent,
@RequestHeader Map<String,String> header,
@RequestParam("age") Integer age,
@RequestParam("inters") List<String> inters,
@RequestParam Map<String,String> params,
@CookieValue("_ga") String _ga,
@CookieValue("_ga") Cookie cookie){
Map<String,Object> map = new HashMap<>();
map.put("id",id);
map.put("name",name);
map.put("pv",pv);
return map;
}
}@RequestHeader
获得请求头
可以把Request请求header部分的值绑定到方法的参数上。
@RestController
public class ParameterTestController {
// car/2/owner/zhangsan
//可以获得指定名字的请求头，也可以获得所有的请求头信息
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(@PathVariable("id") Integer id,
@PathVariable("username") String name,
@PathVariable Map<String,String> pv,
@RequestHeader("User-Agent") String userAgent,
@RequestHeader Map<String,String> header,
){
Map<String,Object> map = new HashMap<>();
map.put("id",id);
map.put("name",name);
map.put("pv",pv);
map.put("userAgent",userAgent);
map.put("headers",header);
return map;
}
}@RequestParam
获取请求参数：
<a href="car/3/owner/lisi?age=18&inters=basketball&inters=game">car/{id}/owner/{username}</a>
@RestController
public class ParameterTestController {
// car/3/owner/list?age=18&inters=basketball&inters=game
//可以获得指定请求参数的值，也可以获得所有的请求参数的值，存放在map中
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(
@RequestParam("age") Integer age,
@RequestParam("inters") List<String> inters,
@RequestParam Map<String,String> params,
Map<String,Object> map = new HashMap<>();
map.put("age",age);
map.put("inters",inters);
map.put("params",params);
return map;
}
}@CookieValue
可以把Request header中关于cookie的值绑定到方法的参数上。
@RestController
public class ParameterTestController {
// car/2/owner/zhangsan
//可以获取相应cookie的字符串值。也可以获得一个cookie的值
@GetMapping("/car/{id}/owner/{username}")
public Map<String,Object> getCar(
@CookieValue("_ga") String _ga,
@CookieValue("_ga") Cookie cookie){
Map<String,Object> map = new HashMap<>();
map.put("_ga",_ga);
System.out.println(cookie.getName()+"===>"+cookie.getValue());
return map;
}
}@RequestBody
获取请求体：只有post请求才有请求体，例如表单提交
@RestController
public class ParameterTestController {
@PostMapping("/save")
//就是将请求体的数据给参数的content
public Map postMethod(@RequestBody String content){
Map<String,Object> map = new HashMap<>();
map.put("content",content);
return map;
}
}通过这个请求可以获得表单的内容。
@RequestAttribute:
获取request域中保存的属性：一般是用在页面转发的时候，可以取出当前页面的数据。
@Controller
public class RequestController {
@GetMapping("/goto")
public String goToPage(HttpServletRequest request){
request.setAttribute("msg","成功了...");
request.setAttribute("code",200);
return "forward:/success"; //转发到 /success请求
}
@ResponseBody
@GetMapping("/success")
//获取请求域中的数据
public Map success(@RequestAttribute(value = "msg",required = false) String msg,
@RequestAttribute(value = "code",required = false)Integer code,
//也可以整体获得request，再用getAttribute的方式获得参数
HttpServletRequest request){
Object msg1 = request.getAttribute("msg");
Map<String,Object> map = new HashMap<>();
map.put("reqMethod_msg",msg1);
map.put("annotation_msg",msg);
return map;
}
}3.复杂参数
（map、model里面的数据会被放在request的请求域 request.getAttribute）
Map
Model
@Controller
public class RequestController {
@GetMapping("/params")
public String testParam(Map<String,Object> map,
Model model,
//给map和model中放数据，都会默认的存放在request中
HttpServletRequest request,
HttpServletResponse response){
map.put("hello","world666");
model.addAttribute("world","hello666");
request.setAttribute("message","HelloWorld");
Cookie cookie = new Cookie("c1","v1");
response.addCookie(cookie);
return "forward:/success";
}
@ResponseBody
@GetMapping("/success")
public Map success(
HttpServletRequest request){
Map<String,Object> map = new HashMap<>();
//可以通过request来获取map和model中的数据
Object hello = request.getAttribute("hello");
Object world = request.getAttribute("world");
Object message = request.getAttribute("message");
map.put("hello",hello);
map.put("world",world);
map.put("message",message);
return map;
}
}自定义参数类型的自动封装：
可以自动类型转换与格式化，可以级联封装。
/**
* 姓名： <input name="userName"/> <br/>
* 年龄： <input name="age"/> <br/>
* 生日： <input name="birth"/> <br/>
* 宠物姓名：<input name="pet.name"/><br/>
* 宠物年龄：<input name="pet.age"/>
*/
@Data
public class Person {
private String userName;
private Integer age;
private Date birth;
private Pet pet;
}
@Data
public class Pet {
private String name;
private String age;
}
result<hr/>
测试复杂类型：<hr/>
测试封装POJO；
<form action="/saveuser" method="post">
姓名： <input name="userName" value="zhangsan"/> <br/>
年龄： <input name="age" value="18"/> <br/>
生日： <input name="birth" value="2019/12/10"/> <br/>
宠物姓名：<input name="pet.name" value="阿猫"/><br/>
宠物年龄：<input name="pet.age" value="5"/>
<input type="submit" value="保存"/>
</form>
/**
* 数据绑定：页面提交的请求数据（GET、POST）都可以和对象属性进行绑定
* @param person
* @return
*/
@PostMapping("/saveuser")
public Person saveuser(Person person){
return person;
}如果不是用级联属性的绑定，name就需要自定义转换器：
<hr/>
测试复杂类型：<hr/>
测试封装POJO；
<form action="/saveuser" method="post">
姓名： <input name="userName" value="zhangsan"/> <br/>
年龄： <input name="age" value="18"/> <br/>
生日： <input name="birth" value="2019/12/10"/> <br/>
宠物： <input name="pet" value="啊猫,3"/>
<input type="submit" value="保存"/>
</form>如果不自定义转换器的话， 宠物： <input name="pet" value="啊猫,3"/>就会报错，因为SpringBoot中的转换器不会自动进行转换
因此编写自定义的转换器：SpringBoot现在容器中寻找是否有webMvcConfigurer，如果有就用自定义的转换器。如果没有SpringBoot就会自动的向容器中注入转换器。
//1、WebMvcConfigurer定制化SpringMVC的功能
@Bean
public WebMvcConfigurer webMvcConfigurer(){
return new WebMvcConfigurer() {
@Override
public void addFormatters(FormatterRegistry registry) {
registry.addConverter(new Converter<String, Pet>() {
@Override
public Pet convert(String source) {
// 啊猫,3
if(!StringUtils.isEmpty(source)){
Pet pet = new Pet();
String[] split = source.split(",");
pet.setName(split[0]);
pet.setAge(Integer.parseInt(split[1]));
return pet;
}
return null;
}
});
}
};
}
4.参数处理原理
- HandlerMapping中找到能处理请求的Handler（Controller.method()）就是在Ccontroller中找到能处理当前请求的方法
- 为当前Handler 找一个适配器 HandlerAdapter； RequestMappingHandlerAdapter
- 适配器执行目标方法并确定方法参数的每一个值
5.数据的响应与内容的协商：就是响应不同格式的数据
响应数据一般是用于前后端分离的模式进行数据的传输。
@ResponseBody：响应的注解
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
web场景自动引入了json场景
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.3.4.RELEASE</version>
<scope>compile</scope>
</dependency>@ResponseBody //利用返回值处理器里面的消息转换器进行处理
//会自动给浏览器返回json类型的参数
@GetMapping(value = "/test/person")
public Person getPerson(){
Person person = new Person();
person.setAge(28);
person.setBirth(new Date());
person.setUserName("zhangsan");
return person;
}
6.内容协商
根据客户端接收能力不同，服务器给客户端返回不同媒体类型的数据。
引入依赖：
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>可以利用postman分别测试返回json和xml
只需要改变请求头中Accept字段。Http协议中规定的，告诉服务器本客户端可以接收的数据类型是哪一种。
但是如果没有金西行内容协商的话，就会默认自动返回json类型的数据。
内容协商原理
1、判断当前响应头中是否已经有确定的媒体类型。MediaType
2、获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段）【application/xml】
contentNegotiationManager 内容协商管理器 默认使用基于请求头的策，请求头中的Accept是哪种类型就将类型进行返回。但是浏览器的Accept是无法自己规定的，浏览器自动带的。
HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型
3、遍历循环所有当前系统的 MessageConverter，看谁支持操作这个对象（Person），包含自定义的Converter
4、找到支持操作Person的converter，把converter支持的媒体类型统计出来。
5、客户端需要【application/xml】。服务端能力【10种、json、xml】
如何以参数的方式进行内容协商？
开启浏览器参数方式内容协商功能
为了方便内容协商，开启基于请求参数的内容协商功能。
spring:
contentnegotiation:
favor-parameter: true #开启请求参数内容协商模式发请求：
http://localhost:8080/test/person?format=json
http://localhost:8080/test/person?format=xml
也可以进行自定义的MessageConverter
7、视图解析与模板引擎
视图解析：SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。
- 视图处理方式
- 转发
- 重定向
- 自定义视图
1、模板引擎-Thymeleaf
1、thymeleaf简介
Thymeleaf is a modern server-side Java template engine for both web and standalone environments, capable of processing HTML, XML, JavaScript, CSS and even plain text.
现代化、服务端Java模板引擎
springboot自动配置了thymeleaf：
自动配好的策略
- 1、所有thymeleaf的配置值都在 ThymeleafProperties
- 2、配置好了 SpringTemplateEngine
- 3、配好了 ThymeleafViewResolver
- 4、我们只需要直接开发页面
//页面存放的位置：
public static final String DEFAULT_PREFIX = "classpath:/templates/";
//页面的后缀
public static final String DEFAULT_SUFFIX = ".html"; //xxx.html
3、设置属性值-th:attr
单个属性的值：
<form action="subscribe.html" th:attr="action=@{/subscribe}">
<fieldset>
<input type="text" name="email" />
<input type="submit" value="Subscribe!" th:attr="value=#{subscribe.submit}"/>
</fieldset>
</form>设置多个值：
<img src="../../images/gtvglogo.png" th:attr="src=@{/images/gtvglogo.png},title=#{logo},alt=#{logo}" />以上两个写法的代替写法：
<input type="submit" value="Subscribe!" th:value="#{subscribe.submit}"/>
<form action="subscribe.html" th:action="@{/subscribe}">4.迭代
<tr th:each="prod : ${prods}">
<td th:text="${prod.name}">Onions</td>
<td th:text="${prod.price}">2.41</td>
<td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr><tr th:each="prod,iterStat : ${prods}" th:class="${iterStat.odd}? 'odd'">
<td th:text="${prod.name}">Onions</td>
<td th:text="${prod.price}">2.41</td>
<td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>5.条件运算
<a href="comments.html"
th:href="@{/product/comments(prodId=${prod.id})}"
th:if="${not #lists.isEmpty(prod.comments)}">view</a><div th:switch="${user.role}">
<p th:case="'admin'">User is an administrator</p>
<p th:case="#{roles.manager}">User is a manager</p>
<p th:case="*">User is some other thing</p>
</div>属性的优先级：
简单的页面开发：
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<!--默认的是哈哈，可以通过thymeleaf动态的将值进行覆盖-->
<h1 th:text="${msg}">哈哈</h1>
<h2>
<!--当${link}中存放的是相当于一个变量值,x相当于超链接到该值-->
<a href="www.atguigu.com" th:href="${link}">去百度</a> <br/>
<!--当@{link}就把link相当于了一个连接-->
<a href="www.atguigu.com" th:href="@{link}">去百度2</a>
</h2>
</body>
</html>
8、拦截器（与MVC中的一样）
1、HandlerInterceptor 接口
preHandle：目标方法执行之前
postHandle：目标方法执行之后
afterCompletion：页面渲染完成之后
/**
* 登录检查
* 1、配置好拦截器要拦截哪些请求
* 2、把这些配置放在容器中
*/
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
/**
* 目标方法执行之前
* @param request
* @param response
* @param handler
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String requestURI = request.getRequestURI();
log.info("preHandle拦截的请求路径是{}",requestURI);
//登录检查逻辑
HttpSession session = request.getSession();
Object loginUser = session.getAttribute("loginUser");
if(loginUser != null){
//放行
return true;
}
//拦截住。未登录。跳转到登录页
request.setAttribute("msg","请先登录");
// re.sendRedirect("/");
request.getRequestDispatcher("/").forward(request,response);
return false;
}
/**
* 目标方法执行完成以后
* @param request
* @param response
* @param handler
* @param modelAndView
* @throws Exception
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
log.info("postHandle执行{}",modelAndView);
}
/**
* 页面渲染以后
* @param request
* @param response
* @param handler
* @param ex
* @throws Exception
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
log.info("afterCompletion执行异常{}",ex);
}
}2.配置拦截器
* 1、编写一个拦截器实现HandlerInterceptor接口
* 2、拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
* 3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】
/**
* 1、编写一个拦截器实现HandlerInterceptor接口
* 2、拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
* 3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】
*/
@Configuration
public class AdminWebConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LoginInterceptor())
.addPathPatterns("/**") //所有请求都被拦截包括静态资源
//斜杠表示请求的主页，一些静态资源，引入相关的连接之后需要访问，所以是需要放行的。
.excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**"); //放行的请求
}
}拦截器的原理:
1、根据当前请求，找到HandlerExecutionChain【可以处理请求的handler以及handler的所有 拦截器】
2、先来顺序执行 所有拦截器的 preHandle方法
- 1、如果当前拦截器prehandler返回为true。则执行下一个拦截器的preHandle
- 2、如果当前拦截器返回为false。直接 倒序执行所有已经执行了的拦截器的 afterCompletion；
3、如果任何一个拦截器返回false。直接跳出不执行目标方法
4、所有拦截器都返回True。执行目标方法
5、倒序执行所有拦截器的postHandle方法。
6、前面的步骤有任何异常都会直接倒序触发afterCompletion
7、页面成功渲染完成以后，也会倒序触发 afterCompletion
9.文件上传
页面表单：
<form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">multiple> 多文件上传
<form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">
<div class="form-group">
<label for="exampleInputEmail1">邮箱</label>
<input type="email" name="email" class="form-control" id="exampleInputEmail1" placeholder="Enter email">
</div>
<div class="form-group">
<label for="exampleInputPassword1">名字</label>
<input type="text" name="username" class="form-control" id="exampleInputPassword1" placeholder="Password">
</div>
<div class="form-group">
<label for="exampleInputFile">头像</label>
<input type="file" name="headerImg" id="exampleInputFile">
</div>
<div class="form-group">
<label for="exampleInputFile">生活照</label>
<input type="file" name="photos" multiple>
</div>
<div class="checkbox">
<label>
<input type="checkbox"> Check me out
</label>
</div>
<button type="submit" class="btn btn-primary">提交</button>
</form>文件上传的代码：
/**
* MultipartFile 自动封装上传过来的文件
* @param email
* @param username
* @param headerImg
* @param photos
* @return
*/
@PostMapping("/upload")
public String upload(@RequestParam("email") String email,
@RequestParam("username") String username,
@RequestPart("headerImg") MultipartFile headerImg,
@RequestPart("photos") MultipartFile[] photos) throws IOException {
log.info("上传的信息：email={}，username={}，headerImg={}，photos={}",
email,username,headerImg.getSize(),photos.length);
if(!headerImg.isEmpty()){
//保存到文件服务器，OSS服务器
String originalFilename = headerImg.getOriginalFilename();
headerImg.transferTo(new File("H:\\cache\\"+originalFilename));
}
if(photos.length > 0){
for (MultipartFile photo : photos) {
if(!photo.isEmpty()){
String originalFilename = photo.getOriginalFilename();
photo.transferTo(new File("H:\\cache\\"+originalFilename));
}
}
}
return "main";
}10.异常处理
1、错误处理
1、默认规则
- 默认情况下，Spring Boot提供
/error处理所有错误的映射 - 对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据
- 要对其进行自定义，添加
View解析为error - 要完全替换默认行为，可以实现
ErrorController并注册该类型的Bean定义，或添加ErrorAttributes类型的组件以使用现有机制但替换其内容。 - error/下的4xx，5xx页面会被自动解析；
2、定制错误处理逻辑
- 自定义错误页
- error/404.html error/5xx.html；有精确的错误状态码页面就匹配精确，没有就找 4xx.html；如果都没有就触发白页
- @ControllerAdvice+@ExceptionHandler处理全局异常；底层是 ExceptionHandlerExceptionResolver 支持的
- @ResponseStatus+自定义异常 ；底层是 ResponseStatusExceptionResolver ，把responsestatus注解的信息底层调用 response.sendError(statusCode, resolvedReason)；tomcat发送的/error
- Spring底层的异常，如 参数类型转换异常；DefaultHandlerExceptionResolver 处理框架底层的异常。
- response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage())
3、异常处理步骤流程
1、执行目标方法，目标方法运行期间有任何异常都会被catch、而且标志当前请求结束；并且用 dispatchException
2、进入视图解析流程（页面渲染？）
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
3、mv = processHandlerException；处理handler发生的异常，处理完成返回ModelAndView；
- 1、遍历所有的 handlerExceptionResolvers，看谁能处理当前异常【HandlerExceptionResolver处理器异常解析器】
- 1、DefaultErrorAttributes先来处理异常。把异常信息保存到rrequest域，并且返回null；
- 2、默认没有任何人能处理异常，所以异常会被抛出
- 1、如果没有任何人能处理最终底层就会发送 /error 请求。会被底层的BasicErrorController处理
- 2、解析错误视图；遍历所有的 ErrorViewResolver 看谁能解析。
- 3、默认的 DefaultErrorViewResolver ,作用是把响应状态码作为错误页的地址，error/500.html
- 4、模板引擎最终响应这个页面 error/500.html
11.Web原生组件注入（Servlet、Filter、Listener）
之前是在web.xml文件中写入相关的配置，注入到容器中。
在springBoot中可以有以下的方法进行注入
方式一：使用Servlet API
@ServletComponentScan(basePackages = "com.atguigu.admin") :指定原生Servlet组件都放在那里
@WebServlet(urlPatterns = "/my")：效果：直接响应，没有经过Spring的拦截器？默认是不生效的
需要在SpringbootWebApplication中加入@ServletComponentScan(扫描的包名)
//@WebServlet(urlPatterns = "/my")
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.getWriter().write("66666");
}
}@WebFilter(urlPatterns={"/css/*","/images/*"})
@WebListener
@Slf4j
//@WebListener
public class MySwervletContextListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
log.info("MySwervletContextListener监听到项目初始化完成");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
log.info("MySwervletContextListener监听到项目销毁");
}
}方式二：使用RegistrationBean
ServletRegistrationBean
FilterRegistrationBean
ServletListenerRegistrationBean
/**
* 1、MyServlet --> /my
* 2、DispatcherServlet --> /
*/
// (proxyBeanMethods = true)：保证依赖的组件始终是单实例的
@Configuration(proxyBeanMethods = true)
public class MyRegistConfig {
@Bean
public ServletRegistrationBean myServlet(){
MyServlet myServlet = new MyServlet();
return new ServletRegistrationBean(myServlet,"/my","/my02");
}
@Bean
public FilterRegistrationBean myFilter(){
MyFilter myFilter = new MyFilter();
// return new FilterRegistrationBean(myFilter,myServlet());
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css/*"));
return filterRegistrationBean;
}
@Bean
public ServletListenerRegistrationBean myListener(){
MySwervletContextListener mySwervletContextListener = new MySwervletContextListener();
return new ServletListenerRegistrationBean(mySwervletContextListener);
}
}
12.嵌入式Servlet容器
在Springboot中不用再另外的配置服务器，里面自带了服务器
原理：
- SpringBoot应用启动发现当前是Web应用。web场景包-导入tomcat
- web应用会创建一个web版的ioc容器
ServletWebServerApplicationContext -
ServletWebServerApplicationContext启动的时候寻找ServletWebServerFactory（Servlet 的web服务器工厂---> Servlet 的web服务器） - SpringBoot底层默认有很多的WebServer工厂；
TomcatServletWebServerFactory,JettyServletWebServerFactory, orUndertowServletWebServerFactory 底层直接会有一个自动配置类。ServletWebServerFactoryAutoConfigurationServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryConfiguration（配置类）ServletWebServerFactoryConfiguration 配置类 根据动态判断系统中到底导入了那个Web服务器的包。（默认是web-starter导入tomcat包），容器中就有 TomcatServletWebServerFactoryTomcatServletWebServerFactory 创建出Tomcat服务器并启动；TomcatWebServer 的构造器拥有初始化方法initialize---this.tomcat.start();内嵌服务器，就是手动把启动服务器的代码调用（tomcat核心jar包存在）
1、切换嵌入式Servlet容器
- 默认支持的webServer
-
Tomcat,Jetty, orUndertow ServletWebServerApplicationContext 容器启动寻找ServletWebServerFactory 并引导创建服务器
- 切换服务器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>2、定制Servlet容器
- 实现 WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>
- 把配置文件的值和
ServletWebServerFactory 进行绑定
- 修改配置文件 server.xxx
- 直接自定义 ConfigurableServletWebServerFactory
xxxxxCustomizer：定制化器，可以改变xxxx的默认规则
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;
@Component
public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory server) {
server.setPort(9000);
}
}13.定制化原理
1、定制化的常见方式
- 修改配置文件；
- xxxxxCustomizer；
- 编写自定义的配置类 xxxConfiguration；+ @Bean替换、增加容器中默认组件；视图解析器
- Web应用 编写一个配置类实现 WebMvcConfigurer 即可定制化web功能；+ @Bean给容器中再扩展一些组件
@Configuration
public class AdminWebConfig implements WebMvcConfigurer- @EnableWebMvc + WebMvcConfigurer —— @Bean 可以全面接管SpringMVC，所有规则全部自己重新配置； 实现定制和扩展功能
- 原理
- 1、WebMvcAutoConfiguration 默认的SpringMVC的自动配置功能类。静态资源、欢迎页.....
- 2、一旦使用 @EnableWebMvc 、。会 @Import(DelegatingWebMvcConfiguration.class)
- 3、DelegatingWebMvcConfiguration 的 作用，只保证SpringMVC最基本的使用
- 把所有系统中的 WebMvcConfigurer 拿过来。所有功能的定制都是这些 WebMvcConfigurer 合起来一起生效
- 自动配置了一些非常底层的组件。RequestMappingHandlerMapping、这些组件依赖的组件都是从容器中获取
- public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport
- 4、WebMvcAutoConfiguration 里面的配置要能生效 必须 @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
- 5、@EnableWebMvc 导致了 WebMvcAutoConfiguration 没有生效。
原理分析套路
场景starter - xxxxAutoConfiguration - 导入xxx组件 - 绑定xxxProperties -- 绑定配置文件项
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
