【框架系列：Spring+SpringMVC+SpringBoot】_springboot+springmvc

1.MVC和三层架构

1.1MVC

1.2 三层架构

1. Spring

概述：

1. Spring 为开发者提供一个一站式轻量级应用开发平台；
2. Spring 框架的核心：IoC 容器和 AOP 模块；
3. 通过 IoC 容器管理 POJO 对象以及他们之间的耦合关系；通过 AOP 以动态非侵入的方式增强服务。
4. IoC 让相互协作的组件保持松散的耦合，而 AOP 编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。

1.1 Spring 的优缺点是什么？

优点：

1. 方便解耦，简化开发。Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护，交给Spring 管理。
2. AOP 编程的支持。Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
3. 声明式事务的支持。只需要通过配置就可以完成对事务的管理，而无需手动编程。
4. 方便程序的测试。Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序。
5. 方便集成各种优秀框架。Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如：Struts、Hibernate、MyBatis 等）
6. 降低 JavaEE API 的使用难度。Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低。

缺点：

1. Spring 依赖反射，反射影响性能;
2. 使用门槛升高，入门 Spring 需要较长时间;
3. Spring 明明一个很轻量级的框架，却给人感觉大而全.

1.2 Spring 框架中都用到了哪些设计模式？

1. 工厂模式：BeanFactory 就是简单工厂模式的体现，用来创建对象的实例；
2. 单例模式：Bean 默认为单例模式。
3. 代理模式：Spring 的 AOP 功能用到了 JDK 的动态代理和 CGLIB 字节码生成技术；
   
   
4. 模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。AbstractPlatformTransactionManager，
   
5. 观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如 Spring 中listener 的实现–ApplicationListener。
6. 策略模式：Spring中提供了InstantiationStrategy（实例化策略接口，子类被用来根据rootBeanDefinition来创建实例对象）实例化策略接口，其中有两个实现，分别是SimpleInstantiationStrategy以及CglibSubclassingInstantiationStrategy。
7. 适配器模式：
8. https://zhuanlan.zhihu.com/p/545864894

1.3 IOC（Inversion of Control）控制反转

概述：是一种思想，控制反转，控制对象的创建权，反转对象的创建与管理；

• IOC 的优点是什么？

• IOC 或 依赖注入把应用的代码量降到最低。
• 它使应用容易测试，单元测试不再需要单例和 JNDI 查找机制。
• 最小的代价和最小的侵入性使松散耦合得以实现。
• IOC 容器支持加载服务时的饿汉式初始化和懒加载。

• IOC的实现原理：

1. 工厂模式加反射机制：通过工厂的指定方法获取对象。反射创建对象
2. 将对象的控制权交给Spring容器，由Spring容器创建及管理对象。Spring容器创建的对象称为bean对象。Spring容器也叫IOC容器；降低耦合度。

• Spring 的 IoC 设计支持以下功能：

• 依赖注入
• 依赖检查
• 自动装配
• 支持集合
• 指定初始化方法和销毁方法
• 支持回调某些方法（但是需要实现 Spring 接口，略有侵入）

• DI （Dependency Injection，依赖注入）

1. 注解注入
   
2. 注入方式：
   依赖注入是时下最流行的 IoC 实现方式，依赖注入分为接口注入（Interface Injection），Setter 方法注入（Setter Injection）和构造器注入（Constructor Injection）三种方式。其中接口注入由于在灵活性和易用性比较差，现在从 Spring4 开始已被废弃。
3. 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
4. Setter 方法注入：Setter 方法注入是容器通过调用无参构造器或无参 static 工厂 方法实例化 bean 之后，调用该 bean 的 setter 方法，即实现了基于 setter的依赖注入。
5. 构造器依赖注入和 Setter 方法注入的区别：
   
6. 两种依赖方式都可以使用，构造器注入和 Setter 方法注入。最好的解决方案是用构造器参数实现强制依赖，setter 方法实现可选依赖。

1.4 AOP

概述：是一种思想，面向切面编程。SpringAOP是对AOP思想提供了实现

• 底层原理：动态代理

1. JDK动态代理： JDK 动态代理只提供接口的代理，不支持类的代理。
2. CGLIB动态代理：CGLIB 是通过继承的方式做的动态代理，因此如果某个类被标记为 final，那么它是无法使用 CGLIB 做动态代理的。
   

• 项目中哪些地方使用到了AOP？

1. 拦截器
2. 过滤器
3. 异常处理器
4. 声明式事务

• AOP进阶：

1. AOP术语：
   
2. 切面执行顺序：
   
3. 五种通知类型：

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

4. 切点表达式：

• 1. execution
• 2. @annotation
     
     

5. AOP相关注解：
   

1.5 Bean

• Spring 框架中的单例 bean 是线程安全的吗？

1. spring 中的 bean 默认是单例模式，spring 框架并没有对单例 bean 进行多线程的封装处理。
2. 开发者自己去保证线程安全了，最简单的就是改变 bean 的作用域，变更为“prototype”。
   

• Spring 框架支持以下五种 bean 的作用域：

• singleton : bean 在每个 Spring ioc 容器中只有一个实例。
• prototype：一个 bean 的定义可以有多个实例。
• request：每次 http 请求都会创建一个 bean，该作用域仅在基于 web 的Spring ApplicationContext 情形下有效。
• session：在一个 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的 Spring ApplicationContext 情形下有效。
• global-session：在一个全局的 HTTP Session 中，一个 bean 定义对应一个实例

• Bean的初始化过程：

1. 初始化过程：
   
2. 初始化过程描述：
   

• Bean的生命周期：
  
• BeanFactory 和 FactoryBean

1. BeanFactory

• 1. spring容器的顶层接口，负责创建与管理bean。
• 2. 使用的是延迟加载的方式创建bean。一般我们都使用其子接口 ApplicationContext，该接口默认是即可加载bean
• 3. 提供了 getBean 方法，用于获取bean实例

2. FactoryBean

• 1. spring中的一个接口，用来创建复杂的bean
• 2. 提供了一个getObject方法，该方法用来创建bean实例，并交给spring容器来管理

1.6 循环依赖问题?

概述：A、B都是spring容器中的bean，A中有一个属性是B【A依赖于B】，B同样依赖于A。就会出现循环依赖问题？

1. 使用@lazy注解，延迟加载，当使用时才延迟加载进来，这时A与B的对象已经创建完成，虽然成员变量还是空值，但是当时用时两个对象的属性都会装载完成。(底层是代理的方式实现)
2. 使用@autowire注解，spring使用三级缓存解决循环依赖的问题。

• 1. 不能解决的循环依赖问题?

1. 构造器注入的 Bean 的情况，不能解决循环依赖问题
2. 多例 Bean 通过 setter 注入的情况，不能解决循环依赖问题
3. 单例的代理 Bean 通过 Setter 注入的情况，不能解决循环依赖问题
4. 设置了@DependsOn 的 Bean 的情况，不能解决循环依赖问题

• 2. set的依赖注入，spring通过三级缓存【三个map】解决的

1. 解决循环依赖：
2. 话术： 循环依赖就是在A创建对象的时候会依赖B，在创建B对象的时候会创建A，解决的原理是spring的三级缓存，第一级缓存存放完整的bean对象，二级缓存存放的是早期暴露出来的bean对象，bean的生命周期并未结束（属性还没有填充完整），三级缓存存放的是创建bean的工厂。具体的创建流程就是当创建A对象是，会发现需要创建B对象，这是A对象将自己放入到三级缓存中去创建B对象，B对象在创建时发现需要A对象，会先到一级缓存去找，没有去找二级缓存，还是没有，再去找三级缓存，找到了A，将A放入到二级缓存中，B创建完成，将自己放入一级缓存中，这是的A还没有创建完成，继续创建A，会直接到一级缓存中找到B，然后A也创建完成。
3. 解决没有AOP的循环依赖问题(二级缓存)
   

2.SpringMVC

• 拦截器执行流程
  
• 过滤器Filter详解：

1. web三大开发规范之一：拦截资源，根据需求实现特殊功能；（servlet，listenter）
2. 过滤器执行流程：
   
3. Filter方法：
   
4. 常见功能：登录校验，统一编码处理，敏感字符处理；

• 拦截器和过滤器的区别：

1. 过滤器是基于servlet的，是方法回调机制，执行先于拦截器；
2. 一般拦截的是全部资源
3. 拦截器是基于Java的反射机制的，拦截的是处理器。
4. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
5. https://www.cnblogs.com/hanease/p/15894116.html

2.1 web服务器：

• 常见的web服务器：
  
• IO模式：

1. BIO：阻塞IO
2. NIO：非阻塞IO
3. AIO：异步非阻塞IO

3. SpringBoot

• 自动化配置原理：

1. 主要是引导类的一个核心注解：@SpringBootApplication
2. 它是一个复合注解，有三个注解组成：
3. @SpringBootConfiguration：他底层是一个@Configuration注解，表示当前引导类也是一个配置类，可以在内部定义bean；
4. @ComponentSan：表示当前引导类所在的包或者子包会进行组件扫描
5. @EnableAutoConfiguration：主要就是该注解实现了自动化配置
6. 他的底层使用了一个@Import注解，他会加载AutoConfigurationImportSelector这个配置类，自动去执行selectImports这个方法。
7. 这个方法最终会调用那个SpringFactoriesLoader的loadFactoriesNames方法。然后这个方法就会加载META-INF目录下spring.factories这个文件中的数据，然后就将该文件中Key为EnableAutoConfiguration的字符串值封装成一个字符串数组。
8. 最终Spring容器就会根据起步依赖，和@Conditional相关的注解来进行过滤，会将满足条件的字符串数组内部封装的全类名通过反射的方式创建对象并注入到我们的容器之中。