Spring Boot2 核心技术与响应式编程

凡心...大约 20 分钟

Spring Boot2 核心技术与响应式编程

第一季：SpringBoot2 核心技术-基础入门

01、Spring 与 SpringBoot

1、课程介绍

**本视频文档地址：**https://yuque.com/atguigu/springboot

**本视频源码地址：**https://gitee.com/leifengyang/springboot2

2、Spring 生态圈

Spring 可以做什么：Microservices（微服务）、Reactive（响应式编程）、Cloud（分布式）、Web apps、Serverless（无服务开发、函数式开发）、Event Driver（事件驱动）、Batch（批处理）

2.1 SpringBoot 目的、优点、缺点

02、SpringBoot2 入门

1.系统要求

Java8&兼容 Java14
Maven 3.3+
idea 2019.1.2

2.HelloWorld

需求：浏览器发送/hello 请求，相应 Hello

参照官方文档 4.Deceloping Your First Spring Boot Application

2.1 创建 Maven 工程

2.2 引入依赖

2.3 创建主程序

2.4 编写业务

2.5 测试

2.6 简化配置

application.properties
可以配置哪些东西，参考官方文档：Application Properties

2.7 简化部署

 添加依赖，打成jar包，clean、package

注意点：取消掉 cmd 的快速编辑模式，不然鼠标点一下命令行窗口，就停止运行了

03、了解自动配置原理

1.1 依赖管理

父项目做依赖管理几乎声明了所有开发中常用的依赖版本号，自动版本仲裁机制；也可以自定义修改版本
开发导入 starter 场景启动器
- 只需要导入 spring-boot-starter（场景启动器）
- 参考官方文档 using-spring-boot，spring-boot-starter-*。就代表某种场景，这个场景的所有常规需要的依赖都会自动引入。右键-Diagrams-Show Dependencies：分析依赖树
- 所有场景启动器最底层的依赖：SpringBoot 自动配置的核心依赖 spring-boot-starter
无需关注版本号，自动版本仲裁引入非版本仲裁的 jar，要写版本号

1.2 自动配置

自动配好 Tomcat
1. 引入 Tomcat 依赖
2. 配置 tomcat
自动配好 springMVC 在主程序类中
1. 引入了 SpringMVC 全套组件
2. 自动配好 SpringMVC 常用组件（功能）：
3. 在 spring springmvc 整合中要写一大堆，最先配置的是 dispatcherServlet，解决字符乱码要配置 characterEncodingFilter(返回中文时候不乱码)，视图解析器……
自动配好 Web 常见功能，如：字符编码问题
默认的包结构
1. 在 spring springmvc 中要配置包路径扫描
2. 主程序所在的包及其下面所有子包都可以默认扫描，无需配置以前的包扫描
3. 也可以自己配置，通过注解配置默认扫描包 @SpringBootApplication(scanBasePackages="")、@ComponentScan
各种配置拥有默认值
1. 默认配置最终都是映射到某一个类上的
2. 配置文件的值最终会绑定某个类上，这个类会在容器中创建对象
3. 要用到这个值的时候，在 springboot 底层拿到这个类的对象，提取它的默认值就行了
按需加载所有自动配置项
1. 非常多的场景，引入哪个场景，这个场景的自动配置才会开启
2. SpringBoot 所有自动配置功能都在 spring-boot-autoconfigure 包里面

2.1.1 @Configuration

Spring：在 spring 中给容器添加组件需要创建 spring 配置 xml 文件，使用 bean 进行配置

SpringBoot：使用 @Configuration 创建一个配置类（本身也是一个组件），等同于配置文件，使用 @Bean 标注方法添加组件（默认是单实例）

@Configuration 有一个属性 proxyBeanMethods=true：代理 bean 的方法。可以直接调用配置类的方法获取组件，但外部无论对配置类中的这个组件注册方法调用多少次，获取的都是之前注册容器中的单实例对象
proxyBeanMethods=true：因为配置类是代理对象，代理对象调用方法，SpringBoot 总会检查这个组件是否已经有了，有的话就会直接取该组件
SpringBoot2 的一大更新，配置类的 Full 模式（proxyBeanMethods=true）和 Lite 模式（proxyBeanMethods=false），解决的问题是组件依赖
配置类组件之间无依赖关系，用 Lite 模式加速容器启动过程，减少判断
配置类组件之间有依赖关系，方法会被调用得到之前的单实例组件，用 Full 模式

2.1.2 @Import

在配置类上使用，@Import（{User.class, DBHelper.class}），给容器中自动创建出这两个类型的组件，默认组件的名字就是全类名

2.1.3 @Conditional

条件装配：满足 Conditional 指定的条件，则进行组件注入

Ctrl+H 打开继承树

2.2.1 @ImportResource

在配置类上 @ImportResource("classpath:beans.xml")导入 Spring 的配置文件

2.3 配置绑定

将 JavaBean 与配置文件绑定：

在 JavaBean 中使用 @Component+@ConfigurationProperties：将组件实例中的值跟配置文件绑定，prefix 代表前缀
在配置类中使用 @EnableConfigurationProperties(Car.class)

3.1 源码-引导加载自动配置类

SpringBoot 的核心注解：@SpringBootApplication 等同于三个注解

@SpringBootConfiguration 本质上就是 @Configuration，代表当前类是一个配置类
@ComponentScan 指定扫描包
@EnableAutoConfiguration 它是由两个注解组成的

 @AutoConfigurationPackage
 @Import(AutoConfigurationImportSelector.class)
 public @interface EnableAutoConfiguration {}
 - @AutoConfigurationPackage

自动配置包，指定了默认的包规则

 @Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
 public @interface AutoConfigurationPackage {}
 
 //利用Registrar给容器中导入一系列组件
 //将指定的一个包下的所有组件导入进来？MainApplication 所在包下。
 - @Import(AutoConfigurationImportSelector.class)
 1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
 2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
 3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
 4、从META-INF/spring.factories位置来加载一个文件。
   默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
     spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
     这个文件中写死了spring-boot一启动就要给容器加载的所有配置类

3.2 源码-按需开启自动配置项

 虽然我们127个场景的所有自动配置启动的时候默认全部加载，但是最终会按需配置
     -按照条件装配@Conditional进行按需配置

3.3 源码-定制化修改自动配置

SpringBoot 默认会在底层配好所有的组件，但是如果用户自己配置了以用户的优先，因为 @ConditionalOnMissingBean

总结：

SpringBoot 先加载所有的自动配置类 xxxAutoConfiguration
每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值 xxxProperties
生效的配置类就会给容器中装配很多组件
只要容器中有这些组件，相当于这些功能就有了
定制化配置
- 用户直接自己 @Bean 替换底层的组件
- 用户去看这个组件时获取的配置文件什么值就去修改

xxxAutoConfiguration--->组件--->xxxProperties 中取值--->application.properties

3.4 最佳实践

引入场景依赖
- 官方文档
查看自动配置做了哪些（选做）
- 自己分析，引入场景对应的自动配置一般都生效了
- 配置文件中 debug=true 开启自动配置报告。Negative（不生效）/ Positive（生效）
是否需要修改
- 参照文档修改配置项
  - 参照官方文档
  - 自己分析，xxxProperties 绑定了配置文件的哪些
- 自定义加入或替换组件
  - @Bean、@Component
- 自定义器 xxxCustomizer

4.1 Lombok

简化 JavaBean 开发

步骤：1.引入依赖 2.idea 安装 lombok 插件

常用注解：

@Data：Getter And Setter
@ToString
@NoArgsConstructor：无参构造器
@AllArgsConstructor：全参构造器
@EqualsAndHashCode
@Slf4j：简化日志开发

4.2 dev-tools

开发者工具-热更新（重新编译一下，如果是静态页面不用重启，静态替换一下。真正的热更新付费的）

Ctrl+F9

4.3 Spring Initailizr（项目初始化向导）

自动依赖引入
自动创建项目结构
自动编写好主配置类

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(); 获取到值的

3.3.4 自定义对象参数

可以自动类型转换与格式化，可以级联封装。

 /**
  *     姓名： <input name="userName"/>
  *     年龄： <input name="age"/>
  *     生日： <input name="birth"/>
  *     宠物姓名：<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

3.4 POJO 封装过程

ServletModelAttributeMethodProcessor

3.5 源码-参数处理原理：

根据注解，自动确定值和源码的过程原理

所有的源码肯定是从 DispatcherServlet 开始，因为这是处理请求的整个入口

DispatcherServlet--->doDispatche()--->mappedHandler--->HandlerMappings--->HandlerAdapter(封装大的反射工具用来调用 Controller 方法)--->执行目标方法

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

3.5.1 HandlerAdapter

0 - 支持方法上标注 @RequestMapping 1 - 支持函数式编程的 xxxxxx

3.5.2 执行目标方法

 // Actually invoke the handler.
 //DispatcherServlet -- doDispatch
 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 mav = invokeHandlerMethod(request, response, handlerMethod); //执行目标方法
 //第一步
 //ServletInvocableHandlerMethod
 Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
 //第二步获取方法的参数值
 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

3.5.3 参数解析器-HandlerMethodArgumentResolver

确定将要执行的目标方法的每一个参数的值是什么; SpringMVC 目标方法能写多少种参数类型。取决于参数解析器。

当前解析器是否支持解析这种参数
支持就调用解析方法 resolveArgument

3.5.4 返回值处理器

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

 ============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;
   }

挨个判断所有参数解析器那个支持解析这个参数解析这个参数的值

   @Nullable
   private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
     HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
     if (result == null) {
       for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
         if (resolver.supportsParameter(parameter)) {
           result = resolver;
           this.argumentResolverCache.put(parameter, result);
           break;
         }
       }
     }
     return result;
   }

解析这个参数的值

 调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可

自定义类型参数封装 POJO ServletModelAttributeMethodProcessor 这个参数处理器支持是否为简单类型。 WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name); WebDataBinder :web 数据绑定器，将请求参数的值绑定到指定的 JavaBean 里面 WebDataBinder 利用它里面的 Converters 将请求数据转成指定的数据类型。再次封装到 JavaBean 中 GenericConversionService：在设置每一个值的时候，找它里面的所有 converter 那个可以将这个数据类型（request 带来参数的字符串）转换到指定的类型（JavaBean -- Integer） byte -- > file @FunctionalInterfacepublic interface Converter<S, T>

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

 public static boolean isSimpleValueType(Class<?> type) {
     return (Void.class != type && void.class != type &&
         (ClassUtils.isPrimitiveOrWrapper(type) ||
         Enum.class.isAssignableFrom(type) ||
         CharSequence.class.isAssignableFrom(type) ||
         Number.class.isAssignableFrom(type) ||
         Date.class.isAssignableFrom(type) ||
         Temporal.class.isAssignableFrom(type) ||
         URI.class == type ||
         URL.class == type ||
         Locale.class == type ||
         Class.class == type));
   }
 @Override
   @Nullable
   public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
       NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
 
     Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
     Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");
 
     String name = ModelFactory.getNameForParameter(parameter);
     ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
     if (ann != null) {
       mavContainer.setBinding(name, ann.binding());
     }
 
     Object attribute = null;
     BindingResult bindingResult = null;
 
     if (mavContainer.containsAttribute(name)) {
       attribute = mavContainer.getModel().get(name);
     }
     else {
       // Create attribute instance
       try {
         attribute = createAttribute(name, parameter, binderFactory, webRequest);
       }
       catch (BindException ex) {
         if (isBindExceptionRequired(parameter)) {
           // No BindingResult parameter -> fail with BindException
           throw ex;
         }
         // Otherwise, expose null/empty value and associated BindingResult
         if (parameter.getParameterType() == Optional.class) {
           attribute = Optional.empty();
         }
         bindingResult = ex.getBindingResult();
       }
     }
 
     if (bindingResult == null) {
       // Bean property binding and validation;
       // skipped in case of binding failure on construction.
       WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
       if (binder.getTarget() != null) {
         if (!mavContainer.isBindingDisabled(name)) {
           bindRequestParameters(binder, webRequest);
         }
         validateIfApplicable(binder, parameter);
         if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
           throw new BindException(binder.getBindingResult());
         }
       }
       // Value type adaptation, also covering java.util.Optional
       if (!parameter.getParameterType().isInstance(attribute)) {
         attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
       }
       bindingResult = binder.getBindingResult();
     }
 
     // Add resolved attribute and BindingResult at the end of the model
     Map<String, Object> bindingResultModel = bindingResult.getModel();
     mavContainer.removeAttributes(bindingResultModel);
     mavContainer.addAllAttributes(bindingResultModel);
 
     return attribute;
   }

 //1、WebMvcConfigurer定制化SpringMVC的功能
     @Bean
     public WebMvcConfigurer webMvcConfigurer(){
         return new WebMvcConfigurer() {
             @Override
             public void configurePathMatch(PathMatchConfigurer configurer) {
                 UrlPathHelper urlPathHelper = new UrlPathHelper();
                 // 不移除；后面的内容。矩阵变量功能就可以生效
                 urlPathHelper.setRemoveSemicolonContent(false);
                 configurer.setUrlPathHelper(urlPathHelper);
             }
 
             @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;
                     }
                 });
             }
         };
     }

3.6 目标方法执行完成

将所有的数据都放在 ModelAndViewContainer；包含要去的页面地址 View。还包含 Model 数据。

3.7 处理派发结果

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);

 InternalResourceView：
 @Override
   protected void renderMergedOutputModel(
       Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
 
     // Expose the model object as request attributes.
     exposeModelAsRequestAttributes(model, request);
 
     // Expose helpers as request attributes, if any.
     exposeHelpers(request);
 
     // Determine the path for the request dispatcher.
     String dispatcherPath = prepareForRendering(request, response);
 
     // Obtain a RequestDispatcher for the target resource (typically a JSP).
     RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
     if (rd == null) {
       throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
           "]: Check that the corresponding file exists within your web application archive!");
     }
 
     // If already included or response already committed, perform include, else forward.
     if (useInclude(request, response)) {
       response.setContentType(getContentType());
       if (logger.isDebugEnabled()) {
         logger.debug("Including [" + getUrl() + "]");
       }
       rd.include(request, response);
     }
 
     else {
       // Note: The forwarded resource is supposed to determine the content type itself.
       if (logger.isDebugEnabled()) {
         logger.debug("Forwarding to [" + getUrl() + "]");
       }
       rd.forward(request, response);
     }
   }
 暴露模型作为请求域属性
 // Expose the model object as request attributes.
     exposeModelAsRequestAttributes(model, request);
 protected void exposeModelAsRequestAttributes(Map<String, Object> model,
       HttpServletRequest request) throws Exception {
 
     //model中的所有数据遍历挨个放在请求域中
     model.forEach((name, value) -> {
       if (value != null) {
         request.setAttribute(name, value);
       }
       else {
         request.removeAttribute(name);
       }
     });
   }

按正序
按倒序
按热度

Spring Boot2 核心技术与响应式编程

预览: