SpringBoot2（中）核心功能

---

web开发

SpringMVC自动配置概览

Spring Boot provides auto-configuration for Spring MVC that works well with most applications.(大多场景我们都无需自定义配置)
The auto-configuration adds the following features on top of Spring’s defaults:

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
  内容协商视图解析器和BeanName视图解析器
• Support for serving static resources, including support for WebJars (covered later in this document)).
  静态资源（包括webjars）
• Automatic registration of Converter, GenericConverter, and Formatter beans.
  自动注册 Converter，GenericConverter，Formatter
• Support for HttpMessageConverters (covered later in this document).
  支持 HttpMessageConverters （后来我们配合内容协商理解原理）
• Automatic registration of MessageCodesResolver (covered later in this document).
  自动注册 MessageCodesResolver （国际化用）
• Static index.html support.
  静态index.html 页支持
• Custom Favicon support (covered later in this document).
  自定义 Favicon
• Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).
  自动使用 ConfigurableWebBindingInitializer ，（DataBinder负责将请求数据绑定到JavaBean上）

简单功能分析

简单功能分析

• 静态资源目录

只要静态资源放在类路径下：
/static (or /public or /resources or /META-INF/resources

访问 ： 当前项目根路径/ + 静态资源名

原理： 静态映射/**。
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面
例如 localhost/bug.jpg会先匹配控制器，没有处理这个请求的控制权，再去找静态资源

改变默认的静态资源路径

spring:
  mvc:
    static-path-pattern: /res/**

  resources:
    static-locations: [classpath:/haha/]

• 静态资源访问前缀

默认无前缀

spring:
  mvc:
    static-path-pattern: /res/**

• webjar

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.5.1</version>
</dependency>

访问地址：http://localhost:8080/webjars/jquery/3.5.1/jquery.js 后面地址要按照依赖里面的包路径

欢迎页支持

• 静态资源路径下 index.html
  可以配置静态资源路径
  但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致welcome page功能失效

  resources:
    static-locations: [classpath:/haha/]

自定义 Favicon
favicon.ico 放在静态资源目录下即可。

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

静态资源配置原理(源码)

• SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类）
• SpringMVC功能的自动配置类 WebMvcAutoConfiguration，生效

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {}

给容器中配了什么。

	@Configuration(proxyBeanMethods = false)
	@Import(EnableWebMvcConfiguration.class)
	@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
	@Order(0)
	public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {}

• 配置文件的相关属性和xxx进行了绑定。WebMvcProperties==spring.mvc、ResourceProperties==spring.resources

• 配置类只有一个有参构造器

//有参构造器所有参数的值都会从容器中确定
//ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
//WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
//ListableBeanFactory beanFactory Spring的beanFactory
//HttpMessageConverters 找到所有的HttpMessageConverters
//ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器。=========
//DispatcherServletPath  
//ServletRegistrationBean   给应用注册Servlet、Filter....
	public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
				ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
				ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
				ObjectProvider<DispatcherServletPath> dispatcherServletPath,
				ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
			this.resourceProperties = resourceProperties;
			this.mvcProperties = mvcProperties;
			this.beanFactory = beanFactory;
			this.messageConvertersProvider = messageConvertersProvider;
			this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
			this.dispatcherServletPath = dispatcherServletPath;
			this.servletRegistrations = servletRegistrations;
		}

• 资源处理的默认规则

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
	if (!this.resourceProperties.isAddMappings()) {
		logger.debug("Default resource handling disabled");
		return;
	}
	Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
	CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
	//webjars的规则
          if (!registry.hasMappingForPattern("/webjars/**")) {
		customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
				.addResourceLocations("classpath:/META-INF/resources/webjars/")
				.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
	}
          
          //
	String staticPathPattern = this.mvcProperties.getStaticPathPattern();
	if (!registry.hasMappingForPattern(staticPathPattern)) {
		customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
				.addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
				.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
	}
}

spring:
#  mvc:
#    static-path-pattern: /res/**

  resources:
    add-mappings: false   禁用所有静态资源规则

这个方法就定义了三个默认静态资源路径

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

	private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
			"classpath:/resources/", "classpath:/static/", "classpath:/public/" };

	/**
	 * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
	 * /resources/, /static/, /public/].
	 */
	private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;

• 欢迎页的处理规则
  写死了“/**”才能使用欢迎页

HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。	

@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
		FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
	WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
			new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
			this.mvcProperties.getStaticPathPattern());
	welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
	welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
	return welcomePageHandlerMapping;
}

WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
	ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
          //要用欢迎页功能，必须是/**
	logger.info("Adding welcome page: " + welcomePage.get());
	setRootViewName("forward:index.html");
}
else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
          // 调用Controller  /index
	logger.info("Adding welcome page template: index");
	setRootViewName("index");
}
}

请求参数处理

请求映射

rest使用与原理

• @xxxMapping；
• Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）
  • 以前：/getUser 获取用户 /deleteUser 删除用户 /editUser 修改用户 /saveUser 保存用户
  • 现在： /user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
  • 核心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-张三";
}


@Bean
@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
@ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
return new OrderedHiddenHttpMethodFilter();
}

//主要是这个方法执行过滤，判断隐藏域的值，然后重新封装
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
		throws ServletException, IOException {

	HttpServletRequest requestToUse = request;

	if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
		String paramValue = request.getParameter(this.methodParam);
		if (StringUtils.hasLength(paramValue)) {
			String method = paramValue.toUpperCase(Locale.ENGLISH);
			if (ALLOWED_METHODS.contains(method)) {
			//里面用了包装模式，来重新包装这次请求的请求方法为put、delete
				requestToUse = new HttpMethodRequestWrapper(request, method);
			}
		}
	}

	filterChain.doFilter(requestToUse, response);
}

//自定义filter
@Configuration(proxyBeanMethods = false)
public class MVCConfig {
    @Bean
    public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
        HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
        methodFilter.setMethodParam("_m");
        return methodFilter;
    }
}

Rest原理（表单提交要使用REST的时候）

• 表单提交会带上_method=PUT
• 请求过来被HiddenHttpMethodFilter拦截
  • 请求是否正常，并且是POST
    • 获取到_method的值。
    • 兼容以下请求；PUT.DELETE.PATCH
    • 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
    • 过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。

Rest使用客户端工具，如PostMan直接发送Put、delete等方式请求，无需Filter。

spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true   #开启页面表单的Rest功能

请求映射原理 （源码）

springmvc中 所有的请求都会来到DispatcherServlet，而他本质是HttpServlet，所以他应该有doget和dopost方法，查看他的继承体系，FrameworkServlet实现了doget、dopost，而里面都是调用的processRequest，processRequest里最重要的方法是doService，doService是抽象方法，DispatcherServlet实现doService方法，而doService方法内重要的实现是doDispatch，所以所有的请求都会经过doDispatch

FrameworkServlet实现了doget、dopost

doDispatch方法中getHandler的英文注释：由哪个方法来处理这次请求，所以这个方法来决定本次映射的controller处理方法

所有的请求映射都在这里匹配，

其中RequestMappingHandlerMapping，保存了当前项目自己写的所有类和类能处理的请求

同样的请求，同样的请求方式，不能有多个方法处理，只能有一个，如果大于1就抛出异常，所以是这里规定了同种请求不能有多个方法。但是在启动的时候就会做检查。
若只匹配到一个，那么匹配成功

• 所有的请求映射都在HandlerMapping中。
• SpringBoot自动配置了默认 的 RequestMappingHandlerMapping
• 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。
  • 如果有就找到这个请求对应的handler
  • 如果没有就是下一个 HandlerMapping

普通参数与基本注解

@PathVariable、@RequestHeader、@ModelAttribute、@RequestParam、@MatrixVariable、@CookieValue、@RequestBody

@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,
	    @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);
//        map.put("userAgent",userAgent);
//        map.put("headers",header);
        map.put("age",age);
        map.put("inters",inters);
        map.put("params",params);
        map.put("_ga",_ga);
        System.out.println(cookie.getName()+"===>"+cookie.getValue());
        return map;
    }


    @PostMapping("/save")
    public Map postMethod(@RequestBody String content){
        Map<String,Object> map = new HashMap<>();
        map.put("content",content);
        return map;
    }


    //1、语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd
    //2、SpringBoot默认是禁用了矩阵变量的功能
    //      手动开启：原理。对于路径的处理。UrlPathHelper进行解析。
    //              removeSemicolonContent（移除分号内容）支持矩阵变量的
    //3、矩阵变量必须有url路径变量才能被解析
    @GetMapping("/cars/{path}")
    public Map carsSell(@MatrixVariable("low") Integer low,
                        @MatrixVariable("brand") List<String> brand,
                        @PathVariable("path") String path){
        Map<String,Object> map = new HashMap<>();

        map.put("low",low);
        map.put("brand",brand);
        map.put("path",path);
        return map;
    }

    // /boss/1;age=20/2;age=10

    @GetMapping("/boss/{bossId}/{empId}")
    public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,
                    @MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
        Map<String,Object> map = new HashMap<>();

        map.put("bossAge",bossAge);
        map.put("empAge",empAge);
        return map;

    }

}

参数处理原理（源码）

注解：

@PathVariable、@RequestHeader、@ModelAttribute、@RequestParam、@MatrixVariable、@CookieValue、@RequestBody

• HandlerMapping中找到能处理请求的Handler（Controller.method()）
• 为当前Handler 找一个适配器 HandlerAdapter； RequestMappingHandlerAdapter
• 适配器执行目标方法并确定方法参数的每一个值

上一步在DispatcherServlet的dispatch方法查看了源码中如何确定请求的处理器（请求处理原理），这一步就是确定请求中的参数（参数处理原理）

handlerAdapter处理适配器是一个接口两个方法，传入一个上一步找到的handler（哪个controller哪个方法），能处理就执行handle

在所有的适配器HandlerAdapter中来匹配（一共4种）
用得最多的是前两种
0 - 请求映射适配器，处理方法上标注了@RequestMapping的 (不管post还是get都是合成@RequestMapping)
1 - 支持函数式编程的

判断是否是HandlerMethod，携带了参数的请求属于HandlerMethod，返回到doDispatch

真正执行目标方法的地方，用刚才找到的适配器HandlerAdapter来执行，返回视图ModelAndView

handle方法实现内，都是由执行，返回ModelAndView
mav = invokeHandlerMethod(request, response, handlerMethod);

参数解析器、HandlerMethodArgumentResolver
invokeHandlerMethod方法内，获取到了springboot中27个参数解析器，确定将要执行的目标方法的每一个参数的值是什么。都是对参数的注解
SpringMVC目标方法能写多少种参数 ，取决于这27个参数解析器

参数解析器是一个接口，两个方法，第一个判断当前解析器是否支持解析这种参数，支持就调用第二个方法resolveArgument

invokeHandlerMethod真正来执行目标方法的地方
invocableMethod.invokeAndHandle(webRequest, mavContainer);

此方法实现内，invokeForRequest就是执行当前请求，放行当前方法就会来到控制器方法内，到这一步就会处理请求方法，并返回一个对象

invokeForRequest内部细节，getMethodArgumentValues获取了方法的所有参数值
反射的执行，

如何确定目标方法每一个参数的值

============InvocableHandlerMethod==========================
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {

//返回了所有的参数
	MethodParameter[] parameters = getMethodParameters();
	if (ObjectUtils.isEmpty(parameters)) {
	//如果参数为空就返回空
		return EMPTY_ARGS;
	}
//声明一个参数个数长度的数组
	Object[] args = new Object[parameters.length];
	//遍历所有参数
	for (int i = 0; i < parameters.length; i++) {
		MethodParameter parameter = parameters[i];
		parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
		args[i] = findProvidedArgument(parameter, providedArgs);
		if (args[i] != null) {
			continue;
		}
		if (!this.resolvers.supportsParameter(parameter)) {
			throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
		}
		try {
			args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
		}
		catch (Exception ex) {
			// Leave stack trace for later, exception may actually be resolved and handled...
			if (logger.isDebugEnabled()) {
				String exMsg = ex.getMessage();
				if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
					logger.debug(formatArgumentError(parameter, exMsg));
				}
			}
			throw ex;
		}
	}
	return args;
}

getMethodParameters 获取到方法上所有参数的详细信息，参数所用的注解，注解中的值

supportsParameter方法，判断当前springboot所拥有的27个解析是否之前当前参数类型

if (!this.resolvers.supportsParameter(parameter)) {

循环27个解析依次确定 ，先确定缓存里有没有（请求过一次就会放进缓存）

resolver.supportsParameter(parameter)挨个判断所有参数解析器哪个支持解析这个参数
27个解析器，每一个的supportsParameter判断方法都不相同

拿到解析器后，回到getMethodArgumentValues解析参数的值

resolveArgument方法中，先从缓存中拿到解析器，调用解析器的resolveArgument方法

每一个解析器获取参数值的方法都不一样，@PathVariable最后还是通过getAttribute来获取了参数值，而这个getAttribute就是实现的tomcat方法的getAttribute，本质就是ServletRequest

Servlet API：

WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

HttpServletRequest参数的方法

还是遍历27个解析器，发现ServletRequestMethodArgumentResolver解析器支持这个参数，缓存解析器

里面是这么判断的，参数HttpServletRequest本质就是ServletRequest，所以被支持

回到InvocableHandlerMethod，调用解析器解析

执行解析器的resolveArgument实现，返回了原生的request

所以，每一个参数最终都会落脚到resolveArgument进行解析，而27个解析器的resolveArgument都不相同

复杂参数：Map、Model类型的参数放入域对象的原理和源码

Map、Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、Errors/BindingResult、RedirectAttributes（ 重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

Map<String,Object> map,  Model model, HttpServletRequest request 
都是可以给request域中放数据，
request.getAttribute();

Map、Model类型的参数，会返回 mavContainer.getModel（）；—> BindingAwareModelMap 是Model 也是Map
mavContainer.getModel(); 获取到值的

@GetMapping("/params")
public String testParam(Map<String,Object> map,
                        Model model,
                        HttpServletRequest request,
                        HttpServletResponse response){
    map.put("hello","world666");
    model.addAttribute("world","hello666");
    request.setAttribute("message","HelloWorld");

    Cookie cookie = new Cookie("c1","v1" );
    cookie.setDomain("localhost");
    response.addCookie(cookie);
    return "forward:/success";
}

参数Model和Map处理是一样的

map和model是如何添加到请求域中的

这还判断是否是redirect请求，在这里封装

回到DispatcherServlet中，使用适配器执行方法就结束了，applyPostHandle 方法处理完后的操作主要是执行拦截器，此时还没有将model和map封装到域对象

而后又放行到DispatcherServlet的processDispatchResult处理派发到其他页面的结果

暴露模型作为请求域属性

最终就是在这里用原生的HttpServletRequest设置进了model和map的值，注意是在跳转之前渲染页面的时候放入域对象

自定义参数绑定原理

springboot是如何将表单提交的数据封装成指定的对象的

@PostMapping("/saveuser")
public Person saveuser(Person person){
    return person;
}

pojo的封装过程

debug进源码，发现是27个参数处理器的ServletModelAttributeMethodProcessor来处理的

这个参数处理判断参数是否是简单类型，非判断，只处理非简单类型

拿到ServletModelAttributeMethodProcessor 类中 resolveArgument开始解析参数

createAttribute方法返回了需要封装请求参数的空对象，准备封装页面带来的值

而后resolveArgument方法中

WebDataBinder :web数据绑定器，将请求参数的值绑定到指定的JavaBean里面
WebDataBinder 利用它里面的 Converters 将请求数据转成指定的数据类型。再次封装到JavaBean中

WebDataBinder对象中不仅有待封装的空JavaBean，还有各种转换器，因为http传输的数据都是文本和数字，所以转换器能把他转换成各种Java类型（有124种转换器）

设置属性值的细节，循环

利用反射设置值

这一步将字符串类型数据转换成对象中的integer类型

GenericConversionService：在设置每一个值的时候，找它里面的所有converter那个可以将这个数据类型（request带来参数的字符串）转换到指定的类型（JavaBean – Integer）byte – > file

136个转换器种循环查找能转换的

未来我们可以给WebDataBinder里面放自己的Converter；
private static final class StringToNumber implements Converter<String, T>

自定义 Converter

@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;
                }
            });
        }
    };
}

数据响应与内容协商

响应数据

响应JSON

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

给前端自动返回json数据；
15种返回值解析器

先执行目标方法，得到返回值对象，然后使用returnValueHandlers返回值处理器真正开始处理返回值

先循环15个找出那个返回值处理器，然后再执行这个处理器的handleReturnValue方法
（熟悉的操作），最终得到，是RequestResponseBodyMethodProcessor这个处理器来处理返回值，因为方法标注了@ResponseBody

15个返回值处理器，就是SpringMVC支持的所有返回值

1. 返回值处理器判断是否支持这种类型返回值 supportsReturnType
2. 返回值处理器调用 handleReturnValue 进行处理
3. RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody 注解的。
   1. 利用 MessageConverters 进行处理 将数据写为json
      1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）浏览器在请求头标注能接收的类型
      

2、服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，
3、SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理？
1、得到MappingJackson2HttpMessageConverter可以将对象写为json
2、利用MappingJackson2HttpMessageConverter将对象转为json再写出去。

SpringMVC到底支持哪些返回值

ModelAndView
Model
View
ResponseEntity 
ResponseBodyEmitter
StreamingResponseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
ListenableFuture
CompletionStage
WebAsyncTask
有 @ModelAttribute 且为对象类型的
@ResponseBody 注解 ---> RequestResponseBodyMethodProcessor；

HTTPMessageConverter原理

上一步拿到RequestResponseBodyMethodProcessor返回值处理后，进入他的处理返回值方法，利用 MessageConverters 进行处理 将数据写为json

内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）浏览器在请求头标注能接收的类型

还是熟悉的操作，循环默认的10个消息转换器，找到能处理的转换器

1、MessageConverter规范，那10个转换器都实现了这个接口和方法，来判断是否能处理当前返回值

0 - 只支持Byte类型的
1 - String
2 - String
3 - Resource
4 - ResourceRegion
5 - DOMSource.class \ SAXSource.class) \ StAXSource.class \StreamSource.class \Source.class
6 - MultiValueMap
7 - true
8 - true
9 - 支持注解方式xml处理的。

最终 MappingJackson2HttpMessageConverter 把对象转为JSON（利用底层的jackson的objectMapper转换的）它能处理任何对象，所以放在了最后

内容协商原理

配置xml依赖

<dependency>
	<groupId>com.fasterxml.jackson.dataformat</groupId>
	<artifactId>jackson-dataformat-xml</artifactId>
</dependency>

浏览器接收xml的等级优先于json，所以再发同样的请求，返回的是xml类型数据

springmvc在底层提供的内容协商功能，根据请求头设置的
Accept:application/xml或Accept:application/json 自动返回不同类型的数据

postman分别测试返回json和xml

内容协商原理

1. 判断当前响应头中是否已经有确定的媒体类型。MediaType

2. 获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段）【application/xml】
   contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略（开启请求参数协商后有两个管理器）
   

   HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型

3. HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型
4. 找到支持操作Person的converter，把converter支持的媒体类型统计出来。
5. 客户端需要【application/xml】。服务端能力【10种、json、xml】
   
6. 进行内容协商的最佳匹配媒体类型
7. 用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。

可以开启手动内容协商

spring:
    contentnegotiation:
      favor-parameter: true  #开启请求参数内容协商模式

发请求： http://localhost:8080/test/person?format=json
http://localhost:8080/test/person?format=xml
就可以携带协商模式

区别于基于accept多了一个parameter

Parameter策略优先确定是要返回json数据（获取请求头中的format的值）
最终进行内容协商返回给客户端json即可。

自定义 MessageConverter

实现多协议数据兼容。json、xml、x-guigu
0、@ResponseBody 响应数据出去 调用 RequestResponseBodyMethodProcessor 处理
1、Processor 处理方法返回值。通过 MessageConverter 处理
2、所有 MessageConverter 合起来可以支持各种媒体类型数据的操作（读、写）
3、内容协商找到最终的 messageConverter；

SpringMVC的什么功能。一个入口给容器中添加一个 WebMvcConfigurer

@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {

        /**
         * 自定义内容协商策略
         * @param configurer
         */
        @Override
        public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
            //Map<String, MediaType> mediaTypes
            Map<String, MediaType> mediaTypes = new HashMap<>();
            mediaTypes.put("json",MediaType.APPLICATION_JSON);
            mediaTypes.put("xml",MediaType.APPLICATION_XML);
            mediaTypes.put("gg",MediaType.parseMediaType("application/x-guigu"));
            //指定支持解析哪些参数对应的哪些媒体类型
            ParameterContentNegotiationStrategy parameterStrategy = new ParameterContentNegotiationStrategy(mediaTypes);
//                parameterStrategy.setParameterName("ff");

            HeaderContentNegotiationStrategy headeStrategy = new HeaderContentNegotiationStrategy();

            configurer.strategies(Arrays.asList(parameterStrategy,headeStrategy));
        }

        @Override
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
            converters.add(new GuiguMessageConverter());
        }
    }
}

有可能我们添加的自定义的功能会覆盖默认很多功能，导致一些默认的功能失效。
大家考虑，上述功能除了我们完全自定义外？SpringBoot有没有为我们提供基于配置文件的快速修改媒体类型功能？怎么配置呢？【提示：参照SpringBoot官方文档web开发内容协商章节】

视图解析与模板引擎

视图解析原理流程

• 目标方法处理的过程中，所有数据都会被放在 ModelAndViewContainer 里面。包括数据和视图地址

• 方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer

• 任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）。

• processDispatchResult 处理派发结果（页面改如何响应）

  render(mv, request, response); 进行页面渲染逻辑
  根据方法的String返回值得到 View 对象【定义了页面的渲染逻辑】
  1、所有的视图解析器尝试是否能根据当前返回值得到View对象
  2、得到了 redirect:/main.html --> Thymeleaf new RedirectView()
  3、ContentNegotiationViewResolver 里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象。
  4、view.render(mv.getModelInternal(), request, response); 视图对象调用自定义的render进行页面渲染工作
  RedirectView 如何渲染【重定向到一个页面】
  获取目标url地址
  response.sendRedirect(encodedURL);

模板引擎-Thymeleaf

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模板引擎

基本语法

1、表达式

表达式名字	语法	用途
变量取值	${…}	获取请求域、session域、对象等值
选择变量	*{…}	获取上下文对象值
消息	#{…}	获取国际化等值
链接	@{…}	生成链接
片段表达式	~{…}	jsp:include 作用，引入公共页面片段

2、字面量
文本值: ‘one text’ , ‘Another one!’ ,…数字: 0 , 34 , 3.0 , 12.3 ,…布尔值: true , false
空值: null
变量： one，two，… 变量不能有空格
3、文本操作
字符串拼接: +
变量替换: |The name is ${name}|

4、数学运算
运算符: + , - , * , / , %

5、布尔运算
运算符: and , or
一元运算: ! , not

6、比较运算
比较: > , < , >= , <= ( gt , lt , ge , le )等式: == , != ( eq , ne )

7、条件运算
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)

8、特殊操作
无操作： _

设置属性值-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}" />

以上两个的代替写法 th:xxxx

<input type="submit" value="Subscribe!" th:value="#{subscribe.submit}"/>
<form action="subscribe.html" th:action="@{/subscribe}">

所有h5兼容的标签写法官方文档

循环

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

条件运算

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

属性优先级

thymeleaf使用

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

ThymeleafAutoConfiguration中 自动配置好了thymeleaf

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ThymeleafProperties.class)
@ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })
@AutoConfigureAfter({ WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })
public class ThymeleafAutoConfiguration { }

自动配好的策略
1、所有thymeleaf的配置值都在 ThymeleafProperties
2、配置好了 SpringTemplateEngine
3、配好了 ThymeleafViewResolver
4、我们只需要直接开发页面
ThymeleafProperties中的默认配置

public static final String DEFAULT_PREFIX = "classpath:/templates/";

public static final String DEFAULT_SUFFIX = ".html";  //xxx.html

拦截器

HandlerInterceptor 接口

@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    //目标方法执行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();

        Object loginUser = session.getAttribute("loginUser");
        if (loginUser != null) {
            return true;
        }

//        request.setAttribute("msg","请登录aaaa");
        response.sendRedirect("/");
//        request.getRequestDispatcher("/").forward(request,response);

        return false;
    }

    //目标方法执行完成以后
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandle执行{}",modelAndView);
    }

    //页面渲染以后
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("afterCompletion执行异常{}",ex);
    }
}

配置拦截器

/**
 * 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

doDispatch方法中，到applyPreHandle执行拦截器方法
该方法执行容器中所有拦截器preHandle方法，若有一个拦截器拦截成功，则倒叙执行已经执行到的拦截器中的afterCompletion方法，然后返回false，doDispatch方法就结束了

文件上传

<form method="post" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file"><br>
    <input type="submit" value="提交">
</form>

/**
 * MultipartFile 自动封装上传过来的文件
 */
@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";
}

自动配置原理

文件上传自动配置类-MultipartAutoConfiguration-MultipartProperties
自动配置好了 StandardServletMultipartResolver 【文件上传解析器】
原理步骤
1、请求进来使用文件上传解析器判断（isMultipart）并封装（resolveMultipart，返回MultipartHttpServletRequest）文件上传请求
2、参数解析器来解析请求中的文件内容封装成MultipartFile
3、将request中文件信息封装为一个Map；MultiValueMap<String, MultipartFile>
FileCopyUtils。实现文件流的拷贝

异常处理

错误处理

默认规则
默认情况下，Spring Boot提供/error处理所有错误的映射
对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据


要对其进行自定义，添加View解析为error

要完全替换默认行为，可以实现 ErrorController 并注册该类型的Bean定义，或添加ErrorAttributes类型的组件以使用现有机制但替换其内容。
error/下的4xx，5xx页面会被自动解析；

源码流程】异常处理流程

1、执行目标方法，目标方法运行期间有任何异常都会被catch、而且标志当前请求结束；并且用 dispatchException

2、进入视图解析流程（页面渲染？）
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
3、mv = processHandlerException；处理handler发生的异常，处理完成返回ModelAndView；
遍历所有的 handlerExceptionResolvers，看谁能处理当前异常【HandlerExceptionResolver处理器异常解析器】

系统默认的 异常解析器；

1、DefaultErrorAttributes先来处理异常。把异常信息保存到rrequest域，并且返回null；
2、默认没有任何人能处理异常，所以异常会被抛出

1、如果没有任何人能处理最终底层就会发送 /error 请求。会被底层的BasicErrorController处理
2、解析错误视图；遍历所有的  ErrorViewResolver  看谁能解析。
3、默认的 DefaultErrorViewResolver ,作用是把响应状态码作为错误页的地址，error/500.html 
4、模板引擎最终响应这个页面 error/500.html 

Web原生组件注入（Servlet、Filter、Listener）

使用Servlet API
启动类上@ServletComponentScan(basePackages = “com.atguigu.admin”) :指定原生Servlet组件都放在那里

@WebServlet(urlPatterns = "/my")：效果：直接响应，没有经过Spring的拦截器？
@WebFilter(urlPatterns={"/css/*","/images/*"})
@WebListener

扩展：DispatchServlet 如何注册进来
容器中自动配置了 DispatcherServlet 属性绑定到 WebMvcProperties；对应的配置文件配置项是 spring.mvc。
通过 ServletRegistrationBean 把 DispatcherServlet 配置进来。
默认映射的是 / 路径。

end