跳到主要内容

Spring

Spring的定义

Spring是一个轻量级Java开发框架， 目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。

Spring的特点

  1. 轻量级、非侵入式：组件大小与开销两方面而言Spring都是轻量的，Spring应用中的对象不依赖于Spring特定的类
  2. 控制反转： Spring通过控制反转（IOC）技术实现解耦。一个对象依赖的其他对象会通过被动的方式传递进来，可以将所有对象的创建和依赖关系的维护，交给Spring管理，而不需要对象自己创建或者查找依赖。
  3. 面向切面： 支持切面（AOP）编程，并且把应用业务逻辑和系统服务区分开，可以方便的实现权限拦截、运 行监控等功能。
  4. 容器： Spring包含并管理应用对象的配置和生命周期，bean如何被创建、销毁，bean的作用范围是单例还是每次都创建一个新的实例，以及他们是如何相互关联。
  5. 声明式事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程。
  6. 方便程序的测试：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
  7. 方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持，如 MyBatis、Hibernate等。
  8. 降低JavaEE API的使用难度：Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

Spring用到的设计模式

  1. 工厂模式：Spring使用工厂模式，通过BeanFactory和ApplicationContext来创建对象
  2. 单例模式：Bean默认为单例模式
  3. 策略模式：例如Resource的实现类，针对不同的资源文件，实现了不同方式的资源获取策略
  4. 代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术
  5. 模板方法：可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中，用来解决代码重复的问题。比如RestTemplate, JmsTemplate, JpaTemplate
  6. 适配器模式：Spring AOP的增强或通知（Advice）使用到了适配器模式。
  7. 观察者模式：Spring事件驱动模型就是观察者模式的一个经典应用。
  8. 桥接模式：可以根据客户的需求能够动态切换不同的数据源。比如我们的项目需要连接多个数据库，客户在每次访问中根据需要会去访问不同的数据库

Spring核心组件

  1. spring core：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入 （Dependency Injection，DI）功能。
  2. spring beans：Spring将管理对象称为Bean，提供了BeanFactory，是工厂模式的一个经典实现。
  3. spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。
  4. spring aop：提供了面向切面的编程实现，可以自定义拦截器、切点等。
  5. spring jdbc：提供了一个JDBC的抽象层， 用于简化JDBC。
  6. spring Web：提供了针对 Web 开发的集成特性，例如文件上传。
  7. spring test：主要为测试提供支持的，支持使用JUnit对Spring组件进行单元测试和集成测试。

BeanFactory 和 ApplicationContext区别？

BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实

例化，控制bean的生命周期，维护bean之间的依赖关系。

ApplicationContext：接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的

框架功能：

  • 继承MessageSource，因此支持国际化。
  • 统一的资源文件访问方式。
  • 提供在监听器中注册bean的事件。

BeanFactroy：采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调getBean())，才对该Bean进

行加载实例化。

ApplicationContext：它是在容器启动时，一次性创建了所有的Bean 。

BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建。

SpringIOVC实现原理

BeanFactory-框架基础设施

  • BeanDefinitionRegistry 注册表：Spring 配置文件中每一个节点元素在 Spring 容器里都通过一个 BeanDefinition 对象表示，它描述了 Bean 的配置信息。而 BeanDefinitionRegistry 接口提供了向容器手工注册BeanDefinition 对象的方法。
  • BeanFactory 顶层接口：位于类结构树的顶端 ，它最主要的方法就是 getBean(String beanName)，该方法从容器中返回特定名称的 Bean，BeanFactory 的功能通过其他的接口得到不断扩展：
  • ListableBeanFactory：该接口定义了访问容器中 Bean 基本信息的若干方法，如查看 Bean 的个数、获取某一类型Bean 的配置名、查看容器中是否包括某一 Bean 等方法；
  • AutowireCapableBeanFactory 自动装配：定义了将容器中的 Bean 按某种规则（如按名字匹配、按类型匹配等）进行自动装配的方法；
  • SingletonBeanRegistry 运行期间注册单例 Bean：定义了允许在运行期间向容器注册单实例 Bean 的方法；对于单实例（ singleton）的 Bean 来说，BeanFactory 会缓存 Bean 实例，所以第二次使用 getBean() 获取 Bean 时将直接从IoC 容器的缓存中获取 Bean 实例。Spring 在 DefaultSingletonBeanRegistry 类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用 HashMap 实现的缓存器，单实例的 Bean 以beanName 为键保存在这个 HashMap 中。
  • 依赖日志框架：在初始化 BeanFactory 时，必须为其提供一种日志框架，比如使用 Log4J， 即在类路径下提供 Log4J 配置文件，这样启动 Spring 容器才不会报错。

ApplicationContext 面向开发应用

  • ClassPathXmlApplicationContext：默认从类路径加载配置文件
  • FileSystemXmlApplicationContext：默认从文件系统中装载配置文件
  • ApplicationEventPublisher：让容器拥有发布应用上下文事件的功能，包括容器启动事件、关闭事件等。
  • MessageSource：为应用提供 i18n 国际化消息访问的功能；
  • LifeCycle：该接口是 Spring 2.0 加入的，该接口提供了 start()和 stop()两个方法，主要用于控制异步处理过程。在具体使用时，该接口同时被 ApplicationContext 实现及具体Bean 实现， ApplicationContext 会将 start/stop 的信息传递给容器中所有实现了该接口的 Bean，以达到管理和控制 JMX、任务调度等目的。
  • ConfigurableApplicationContext ：扩展于 ApplicationContext，它新增加了两个主要的方法：refresh()和 close()，让 ApplicationContext 具有启动、刷新和关闭应用上下文的能力。在应用上下文关闭的情况下调用 refresh()即可启动应用上下文，在已经启动的状态下，调用 refresh()则清除缓存并重新装载配置信息，而调用 close()则可关闭应用上下文。

Spring依赖注入

让容器全权负责依赖查询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造器或者接口，使容器可以

在初始化时组装对象的依赖关系 。

注入方式主要有两种：

  1. 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖
  2. Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该 bean的setter方法，即实现了基于setter的依赖注入

接口注入由于在灵活性和易用性比较差，现在从Spring4开始已被废弃。

循环依赖

循环依赖根据注入的时机分成两种类型：

  1. 构造器循环依赖。依赖的对象是通过构造器传入的，发生在实例化 Bean 的时候。
  2. 设值循环依赖。依赖的对象是通过 setter 方法传入的，对象已经实例化，发生属性填充和依赖注入的时候。

Spring 框架只支持单例下的设值循环依赖。Spring 通过对还在创建过程中的单例，缓存并提前暴露该单例，使得 其他实例可以引用该依赖。

循环依赖的原理

Spring控制了bean的生命周期，先实例化bean，后注入bean的属性。Spring中记录了正在创建中的bean（已经

实例化但还没初始化完毕的bean），所以可以在注入属性时，从记录的bean中取依赖的对象。

Spring Bean 作用域

  1. singleton：单例模式（多线程下不安全）。Spring IoC 容器中只会存在一个共享的 Bean 实例，无论有多少 个Bean 引用它，始终指向同一对象。
  2. prototype:原型模式每次使用时创建。
  3. Request：一次 request 一个实例。
  4. session：在一次 Http Session 中，容器会返回该 Bean 的同一实例。且实例仅在自己的 session 请求内有 效，请求结束，则实例将被销毁。
  5. global Session：在一个全局的 Http Session 中，容器会返回该 Bean 的同一个实例。

Spring处理线程并发问题

在一般情况下，只有无状态的Bean才可以在多线程环境下共享，Spring对一些Bean中非线程安全状态采用

ThreadLocal进行处理，解决线程安全问题。

Springbean的生命周期

  1. 实例化一个 Bean，也就是我们常说的 new。
  2. 按照 Spring 上下文对实例化的 Bean 进行配置，也就是 IOC 注入。
  3. 如果这个 Bean 已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String) 方法。
  4. 如果这个 Bean 已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory，
  5. 如果这个Bean已经实现了 ApplicationContextAware 接口，会调用 setApplicationContext(ApplicationContext) 方法，传入 Spring 上下文
  6. 如果 Bean 在 Spring 配置文件中配置了 init-method 属性会自动调用其配置的初始化方法。
  7. 当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了 DisposableBean 这个接口，会调用 destroy()方法。
  8. 最后，如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方法。

什么是Spring内部bean

在Spring框架中，当一个bean仅被用作另一个bean的属性时，它能被声明为一个内部bean。

自动装配和手动装配

手动装配是基于 xml 装配、构造方法、setter 方法。

自动装配有五种方式：

  1. no ：默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配。
  2. byName ：通过参数名自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byName，
  3. 之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean。
  4. byType ：通过参数类型自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、装配和该 bean 的属性具有相同类型的 bean。如果有多个 bean 符合条件，则抛出错误。 constructor ：这个方式类似于 byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数 类型，将会抛出异常。
  5. autodetect ：首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式。

使用@Autowired注解自动装配的过程

在启动spring IoC时，容器自动装载了一个 AutowiredAnnotationBeanPostProcessor 后置处理器，当容器扫描到 @Autowied 、 @Resource 或 @Inject 时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用 @Autowired 时，首先在容器中查询对应类型的bean：

  • 如果查询结果刚好为一个，就将该bean装配给 @Autowired 指定的数据；
  • 如果查询的结果不止一个，那么 @Autowired 会根据名称来查找；
  • 如果上述查找的结果为空，那么会抛出异常。解决方法时，使用 required=false 。

SpringAOP概念

OOP(Object-Oriented Programming)面向对象编程，允许开发者定义纵向的关系，但并适用于定义横向的关系， 导致大量代码的重复，而不利于各个模块的重用。

AOP(Aspect-Oriented Programming)，一般称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影 响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复 代码，降低了模块间的耦合度，同时提高了系统的可维护性。

AOP 主要应用场景有：运行监控，权限拦截、事务等。

AOP核心概念

  1. 切面（aspect）：拦截到的方法的抽象。

  2. 连接点（joinpoint）：被拦截到的方法。

  3. 切入点（pointcut）：对连接点进行拦截的定义。

  4. 通知（advice）：拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

  5. 目标对象：代理的目标对象。

  6. 织入（weave）：将切面应用到目标对象并导致代理对象创建的过程

    编译期：切面在目标类编译时被织入。

    类加载期：切面在目标类加载到JVM时被织入。

    运行期：切面在应用运行的某个时刻被织入。

AOP的实现方式

AspectJ 静态代理，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他

会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。

Spring AOP动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为

方法生成一个AOP对象。

AOP的动态代理

JDK 动态代理主要涉及到 java.lang.reflflect 包中的两个类：Proxy 和 InvocationHandler。

InvocationHandler是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态将横切

逻辑和业务逻辑编制在一起。Proxy 利用 InvocationHandler 动态创建一个符合某一接口的实例，生成目标类的代

理对象。

JDK 创建代理有一个限制，就是只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，则可以通过

CGLib 创建动态代理。

Spring通知类型

  1. 前置通知（Before）：在目标方法被调用之前调用通知功能；
  2. 后置通知（After）：在目标方法完成之后调用通知；
  3. 返回通知（After-returning ）：在目标方法成功执行之后调用通知；
  4. 异常通知（After-throwing）：在目标方法抛出异常后调用通知；
  5. 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

同一个aspect，不同advice的执行顺序

没有异常情况下的执行顺序：

around before advice

before advice

target method 执行

around after advice

after advice

afterReturning

有异常情况下的执行顺序：

around before advice

before advice

target method 执行

around after advice

after advice

afterThrowing:异常发生

java.lang.RuntimeException: 异常发生

Spring注解有哪些

声明bean的注解@Component @Service @Repository @Controller @RestController

注入bean的注解

@Autowired @Resource @Inject （需要导入javax.inject.Inject jar ）

java配置类相关注解

@Confifiguration @Bean @ComponentScan @WishlyConfifiguration

切面（AOP）相关注解

@Aspect @After @Before @Around @PointCut

Bean的作用域相关注解

Singleton Protetype Request Session Global @PostConstruct @PreDestory

SpringMVC常用注解

@Controller @RequestMapping @ResponseBody @RequestBody @RestController @ExceptionHandler

Springboot常用注解

@SpringBootApplication，

@SpringBootConfifiguration配置类、componentScan扫描包、 EnableAutoConfifiguration:导入其他配置类

@GetMapping、@PostMapping、@PutMapping、 @DeleteMapping： 映射请求，只能接收的对应的请求。 @Qualififier： 和AutoWired联合使用，在按照类型匹配 的基础上，在按照名称匹配。

Spring事务传播属性

  1. REQUIRED（默认属性）如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
  2. REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。
  3. MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
  4. NEVER以非事务方式执行，如果当前存在事务，则抛出异常。
  5. SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。
  6. NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  7. NESTED支持当前事务，新增Savepoint点，与当前事务同步提交或回滚。

Spring事务隔离级别

  1. DEFAULT （默认）：使用数据库默认的事务隔离级别。另外四个与JDBC的隔离级别相对应。
  2. READ_UNCOMMITTED （读未提交）：这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未
  3. 提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
  4. READ_COMMITTED （读已提交）：保证一个事务修改的数据提交后才能被另外一个事务读取，另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像 读。
  5. REPEATABLE_READ （可重复读）：这种事务隔离级别可以防止脏读、不可重复读，但是可能出现幻像读。 它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了不可重复读。
  6. SERIALIZABLE（串行化）：这是花费最高代价但是最可靠的事务隔离级别，事务被处理为顺序执行。除了防止脏读、不可重复读外，还避免了幻像读。

脏读：一个事务正在对数据进行更新操作，但是更新还未提交，另一个事务这时也来操作这组数据，并且读取了前 一个事务还未提交的数据，而前一个事务如果操作失败进行了回滚，后一个事务读取的就是错误数据，这样就造成 了脏读。

不可重复读：一个事务多次读取同一数据，在该事务还未结束时，另一个事务也对该数据进行了操作，而且在第一 个事务两次次读取之间，第二个事务对数据进行了更新，那么第一个事务前后两次读取到的数据是不同的，这样就 造成了不可重复读。

幻像读：第一个事务正在查询符合某一条件的数据，这时，另一个事务又插入了一条符合条件的数据，第一个事务 在第二次查询符合同一条件的数据时，发现多了一条前一次查询时没有的数据，仿佛幻觉一样，这就是幻像读。

springMVC的理解?

是基于java的MVC设计模式的轻量级MVC框架，通过对Model、view、Controller分离，把web应用分成逻辑清晰

的几部分，简化了开发，方便了开发人员的配合。

SpringMVC的重要组件及其作用

  1. 前端控制器(DispatcherServlet)： 接收请求、响应结果，解耦了其他组件。
  2. 处理器映射器(HandlerMapping)： 根据url去查找对应的处理器(Handler)。
  3. 处理器适配器(HandlerAdapter)： 执行处理器(Handler)。
  4. 处理器(Handler)： 处理业务逻辑的类。
  5. 视图解析器(ViewResolver)： 进行视图的解析，根据视图逻辑将ModelAndView解析成真正的视图(view)。
  6. 视图(View)： 是一个接口，它的实现类支持不同类型的视图，jsp，pdf等。

springMVC中DispatcherServlet初始化过程

  1. DispatcherServlet 的初始化，调用Servlet 的 init 方法
  2. 在GenericServlet 中 对 init 方法进行了实现，但是在GenericServlet 中并没有对 init() 方法有具体的代码实现， 而在HttpServletBean类中对 init() 方法进行了重写
  3. 在HttpServletBean中 调用 init() 方法，在 init() 方法中，又调用了initServletBean() 方法，该方法由它的子类 FrameworkServlet进行重写实现。
  4. FrameworkServlet 重写 initServletBean()，在initServletBean()方法中进行了创建并初始化 WebApplicationContext（上下文），再调用onRefresh方法刷新，但是在FrameworkServlet 中没有对
  5. onRefresh方法进行具体的代码实现，而是由DispatcherServlet 进行重写并调用 onRefresh(WebApplicationwac) 方法。
  6. 通过DispatcherServlet调用到 initStrategies(context)方法，里面对DispatcherServlet 各种组件进行了初始化。

Springboot的理解

是一站式解决方案，简化了spring繁重的配置，提供了各种启动器，让开发者更好上手。

springBoot的优点

  1. 解决maven依赖版本冲突问题
  2. 解决jar过多问题
  3. 自动配置解决配置文件过多问题
  4. 通过内置tomcat，不需要其他外 置tomcat，也能运行javaEE。

springBoot的核心配置文件

application 和 bootstrap 配置文件。

application： 用于项目的自动化配置。

bootstrap： 一些不能被覆盖的属性和加密或解密的场景。比application要先加载。

springBoot怎么实现热部署

修改代码不需要重启，就可以实现编译并部署到服务器上

①使用devtools。在配置文件中把devtools.restart.enabled 设置为 true。每次都需要build一下才行。

②idea设置实现热部署。

如何在 Spring Boot 启动的时候运行一些特定的代码？

可以实现接口 ApplicationRunner或者 CommandLineRunner，这两个接口实现方式一样(项目启动完成后执行)

，它们 都只提供了一个 run 方法，在run方法写你的业务逻辑。

springBoot的全局异常处理

@ControllerAdvice：开启了全局异常的捕获。然后自定义一个方法使用@ExceptionHandler注解然后定义捕获异

常的类型即可对这些捕获的异常进行统一的处理。

Spring的加载流程

  1. 实例化BeanFactory工厂，用于生成Bean对象
  2. 实例化BeanDefinitionReader注解配置读取器，用于对特定注解的类进行读取转化成BeanDefinition对象。
  3. 实例化ClassPathBeanDefinitionScanner路径扫描器，用于对特定的包目录进行扫描查找bean对象
  4. 将BeanDefinition注册到容器中
  5. 调用refresh()方法，用于刷新applicationContext容器。
  6. 调用 prepareRefresh()方法，用于刷新前的预处理
  7. 调用obtainFreshBeanFactory()方法，用于获取在容器初始化时创建的BeanFactory 工厂。
  8. 调用prepareBeanFactory(beanFactory)方法：BeanFactory的预处理操作，用于向容器中添加组件。
  9. 在BeanFactory标准初始化之后调用BeanFactoryPostProcessor方法，即BeanFactory的后置处理器。
  10. 向容器中注册Bean的后置处理器BeanPostProcessor，用于干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能 。
  11. 调用 initMessageSource()方法，初始化MessageSource组件，主要用于做国际化功能。
  12. 调用onRefresh()：留给子容器、子类重写这个方法，用于容器刷新的时候自定义逻辑。
  13. 调用registerListeners()方法：用于注册监听器。
  14. 调用getBean()方法创建对象，用于初始化所有剩下的单例bean。
  15. 最后调用finishRefresh()方法：用于发布BeanFactory容器刷新完成事件。

SpringMVC的工作流程或原理

①用户发送请求，前端控制器接到请求。
②前端控制器把请求分发给处理器映射器。
③处理器映射器根据url去找对应的处理器。
④获取处理器，返回给处理器映射器。
⑤处理器映射器返回给前端控制器。
⑥前端控制发给处理器适配器，请求执行处理器。
⑦处理器适配器通知处理器执行业务逻辑。
⑧然后处理器返回ModelAndView。
⑨处理器适配器把ModelAndView返回给前端控制器。
⑩前端控制器发给视图解析器，视图解析器根据视图名称去查询视图。
⑪返回真正的视图。
⑫渲染视图。
⑬返回视图，给前端控制器。
⑭然后响应用户的请求。

Spring Boot 自动装配原理

  1. 首先，先看SpringBoot的主配置类。 核心配置@SpringBootApplication 是一个组合注解
  2. 首先我们先来看 @SpringBootConfifiguration： 这个注解相当于@Confifiguration，所以这两个注解作用是一 样的，它让我们能够去注册一些额外的Bean，并且导入一些额外的配置。 还有一个作用就是把该类变成一个配置类，不需要额外的XML进行配置
  3. 继续来看下一个@EnableAutoConfifiguration,这个注解是开启自动配置的功能。 可以看到它是由 @AutoConfifigurationPackage，@Import这两个而组成的。
  4. @AutoConfifigurationPackage，让包中的类以及子包中的类能够被自动扫描到spring容器中。
  5. @Import来给Spring容器中导入一个组件，Registrar.class。通过registerBeanDefifinitions 方法获取扫描的包路径，其实就是将主配置类所在包及子包里面所有组件扫描加载到Spring容器。因此我们要把DemoApplication放在项目的最高级中（最外层目录）。
  6. 接下来看@ComponentScan注解， 这个注解就是扫描包，然后放入spring容器。

总结下@SpringbootApplication：就是说，他已经把很多东西准备好，具体是否使用取决于我们的程序或者置。

执行run方法

  1. 首先进入 refreshContext(context); 刷新context
  2. 他会调用 refresh();方法，就是一个spring的bean的加载过程
  3. 继续调用下一个方法onRefresh()。他的具体实现可以是ServletWebServerApplicationContext，可以看到有一个 createWebServer()方法，他是创建web容器的 ，factory.getWebServer(getSelfInitializer());通过工厂的方式创建 的并且他是一个接口，实现类有Jetty 、tomcat等，进入TomcatServletWebServerFactory ，getWebServer 方法
  4. 创建内置tomcat。

springboot四大组件

  1. starter组件 starter包的内容就是pom文件，就是一个依赖传递包。 帮我们封装好了所有需要的依赖，避免我们自己添加导致的一些Jar包冲突或者缺少包的情况。

  2. Autoconfigure 组件：autoconfifigure就是帮我们自动把bean注入到IOC容器中。

  3. actuator组件： actuator是Spring Boot的监控插件，本身提供了很多接口可以获取当前项目的各项运行状态指标。

    Actuator端点可以监控应用程序并与之交互。Spring Boot包括许多内置的端点， 比如health端点提供基本的应用程序运行状况信息，并允许添加自定义端点。

  4. Spring Boot CLI组件 ：Spring Boot CLI 是运行 SpringBoot 命令的命令行工具，能够帮助你快速的构建 Spring Boot 项目。只需要编写简单的 groovy 脚本，即可用最少的代码构建并运行一个完整的 Spring Boot 项目。