SpringBoot（四）web开发

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">

  <input type="file" name="photos" 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, or UndertowServletWebServerFactory
• 底层直接会有一个自动配置类。ServletWebServerFactoryAutoConfiguration
• ServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryConfiguration（配置类）
• ServletWebServerFactoryConfiguration 配置类 根据动态判断系统中到底导入了那个Web服务器的包。（默认是web-starter导入tomcat包），容器中就有 TomcatServletWebServerFactory
• TomcatServletWebServerFactory 创建出Tomcat服务器并启动；TomcatWebServer 的构造器拥有初始化方法initialize---this.tomcat.start();
• 内嵌服务器，就是手动把启动服务器的代码调用（tomcat核心jar包存在）

1、切换嵌入式Servlet容器

• 默认支持的webServer

• • Tomcat, Jetty, or Undertow
  • 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 -- 绑定配置文件项