Spring

Spring IoC 的初始化过程：

1. XML
2. 读取
3. Resource
4. 解析
5. BeanDefinition
6. 注册
7. BeanFactory

Spring AOP：
Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDK Proxy，去创建代理对象，
⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤Cglib ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理

Spring AOP 和 AspectJ AOP 有什么区别：

• Spring AOP 属于运行时增强，而 AspectJ 是编译时增强，SpringAOP 基于代理（Proxying），而 Aspect 基于字节码操作（Bytecode Manipulation）
• Spring AOP 已经集成了 AspectJ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了，AspectJ 相比与 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单

Spring Bean 的作用域：

• singleton
• prototype：每次请求都会创建一个新的 Bean 实例
• request：每一次 HTTP 请求都会产生一个新的 Bean，该 Bean 仅在当前 HTTP request 内有效
• session：每一次 HTTP 请求都会产生一个新的 Bean，该 Bean 仅在当前 HTTP session 内有效
• global-session：全局的 session 作用域，仅仅在基于 portlet 的 web 应用中才有意义， Spring5 已经没有了，Portlet 是能够生成语义代码（例如 HTML）片段的小型 Java Web 插件，他它们属于 protlet 容器，可以像 servlet 一样处理 HTTP 请求。但是与 servlet 不同，每个 portlet 都有不同的会话

Spring 中 bean 的生命周期：

1. Bean 容器找到配置文件中 Spring Bean 的定义
2. Bean 容器利用 Java Reflection API 创建一个 Bean 的实例
3. 如果涉及到一些属性值利用 set()方法设置一些属性值
4. 如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName() 方法，传入 Bean 的名字
5. 如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClass() ，传入 ClassLoader 对象的实例
6. 与上面的类似，如果实现了其它 *Aware 接口，就调用相应的方法
7. 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行 postProcessBeforeInitialization() 方法
8. 如果 Bean 实现了 InitializingBean 接口，执行 afterPropertiesSet() 方法
9. 如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法
10. 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcess 对象，执行 postProcessAfterInitialization() 方法
11. 当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法
12. 当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含了 destroy-method 属性，执行指定的方法

SpringMVC 流程：

1. 客户端（浏览器）发送请求，直接请求到 DispatcherServlet
2. DispatcherServlet 根据请求信息调用 HandlerMapping， 解析请求对应的 Handler
3. 解析到对应的 Handler（Controller 控制器）后，开始由 HandlerAdapter 适配器处理
4. HandlerAdapter 会根据 Handler 来调用真正的处理器处理请求，并处理相应的业务逻辑
5. 处理器处理完业务后，会返回一个 ModelAndView 对象，Model 是返回的数据对象， View 是逻辑上的 View
6. ViewResolver 会根据逻辑的 View 查找实际的 View
7. DispatcherServlet 把返回的 Model 传给 View（视图渲染）
8. 把 View 返回给请求者（浏览器）

Spring 框架中用到的设计模式：

• 工厂模式：Spring 使用工厂模式通过 BeanFactory 、 ApplicationContext 创建 bean 对象
• 代理模式
• 单例模式
• 包装器模式：我们的项⽬需要连接多个数据库，⽽且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源。
• 观察者模式：Spring 事件驱动模型就是观察者模式很经典的一个应用
• 适配器模式：SpirngAOP 的增强或通知（Advice）是使用到了适配器模式、SpringMVC 中也是用到了适配器模式适配 Controller

Spring 事务：
Spring 管理事务的方式：

• 编程式事务
• 声明式事务：
  • 基于 XML 的声明式事务
  • 基于注解的声明式事务

Spring 事务隔离级别：

public interface TransactionDefinition {
    int PROPAGATION_REQUIRED      = 0; // 如果当前存在事务，则加入该事务；如果没有事务，则创建一个新的事务
    int PROPAGATION_SUPPORTS      = 1; // 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行
    int PROPAGATION_MANDATORY     = 2; // 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常（mandatory 强制的）
    int PROPAGATION_REQUIRES_NEW  = 3; // 创建一个新的事务，如果当前存在事务，则把当前事务挂起
    int PROPAGATION_NOT_SUPPORTED = 4; // 以非事务方式运行，如果当前存在事务，则把当前事务挂起
    int PROPAGATION_NEVER         = 5; // 以非事务方式运行，如果当前存在事务，则抛出异常。
    int PROPAGATION_NESTED        = 6; // 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来执行；如果当前没有事务，则该值等价于 TransactionDefinition.PROPAGATION_REQUIRED
    int ISOLATION_DEFAULT          = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;  // same as java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
    int ISOLATION_READ_COMMITTED   = 2;  // same as java.sql.Connection.TRANSACTION_READ_COMMITTED;
    int ISOLATION_REPEATABLE_READ  = 4;  // same as java.sql.Connection.TRANSACTION_REPEATABLE_READ;
    int ISOLATION_SERIALIZABLE     = 8;  // same as java.sql.Connection.TRANSACTION_SERIALIZABLE;
    ......
}

Spring 循环依赖：
先调用构造函数进行实例化，然后填充属性，再接着进行其他附加操作和初始化，正是这样的生命周期，才有了Spring的解决循环依赖，这样的解决机制是根据Spring框架内定义的三级缓存来实现的，也就是说：三级缓存解决了Bean之间的循环依赖。