spring作为java开发里的神器，怎么说都是必须了解到。spring如今发展的规模已经十分庞大，全部叙述不太可能。今天主要针对spring的生命周期和aop方面进行介绍，有一句话叫做spring在手，天下我有。

spring的整体架构如图，主要分为上面几个模块，其实目前已经发展到了20来个了。

core container:包含了beans,core,context,expression

data:(主要用于数据层的集合)，包括jdbc,还有orm映射框架（mybatis,hibernate等等)，

另外还有trasations,主要用于数据库事务的管理

web:包含webmvc,web,websocker(网络编程套件（

Aop:这个也是很重要的一个，主要是针对于面向切面编程

下面我们来介绍一下spring的整个生命周期，这个大家一定要了若指掌，如数家珍才行

图 1 Bean 的生命周期

Bean 生命周期的整个执行过程描述如下。
1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。
2）利用依赖注入完成 Bean 中所有属性值的配置注入。
3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。
7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。
10）如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。
11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

整个图起来还是步骤蛮多的，但是我们其实上本质上就是4步曲

1.实例化（instantiation)

2.属性赋值（populate)

3.初始化（initialization)

4.销毁（destruction)

主要流程是 实例化 -> 属性赋值 -> 初始化 -> 销毁

其中又2个扩展点特别重要

BeanPostProcessor

这两个接口一个作用于实例化的前后，一个作用于初始化的前后

InstantiationAwareBeanPostProcessor实际上继承了BeanPostProcessor接口，严格意义上来看他们不是两兄弟，而是两父子。但是从生命周期角度我们重点关注其特有的对实例化阶段的影响，图中省略了从BeanPostProcessor继承的方法。

另外还有很多接口也是非常的重要，这个也是spring方便扩展的关键所在

1. Aware类型的接口
2. 生命周期接口

这些接口的作用主要就是可以拿到spring容器里面的一些资源，比如之前的BeanNameAware ，

BeanFactoryAware,ApplicationContextAware这些就能分别拿到BeanName,BeanFactory,

还有ApplicationContext

因为这一类的接口又有加载上的顺序，所有可以继续分类

第一类

1.BeanNameAware

2.BeanClassLoaderAware

3.BeanFactoryAware

第二类

1.EnvironmentAware

2.EmbeddedValueResolverAware 这个接口可以获取配置文件，相当于@value这个注解，因为这个aware能够获取一个etl解析器，十分的方便

3.ApplicationContextAware这个接口可以获取applicationContext这个上下文

    // 见名知意，初始化阶段调用的方法
    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

        // 这里调用的是Group1中的三个Bean开头的Aware
        invokeAwareMethods(beanName, bean);

        Object wrappedBean = bean;
        
        // 这里调用的是Group2中的几个Aware，
        // 而实质上这里就是前面所说的BeanPostProcessor的调用点！
        // 也就是说与Group1中的Aware不同，这里是通过BeanPostProcessor（ApplicationContextAwareProcessor）实现的。
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        // 下文即将介绍的InitializingBean调用点
        invokeInitMethods(beanName, wrappedBean, mbd);
        // BeanPostProcessor的另一个调用点
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

        return wrappedBean;
    }

通过源码我们很容易可以发现，aware方法的调用是在invokeInitMethods中，是在bean的初始化之前，所以我们在初始化的时候可以可以aware接口获取资源。比较特殊一点的是ApplicationContextAware这个aware,这个接口的话，我们是通过BeanPostProcessor.postProcessBeforeInitialization()来实现的。另外还有一点需要注意的BeanPostProcessor有很多个，而且每个BeanPostProcessor都影响多个Bean，其执行顺序至关重要，必须能够控制其执行顺序才行。关于执行顺序这里需要引入两个排序相关的接口：PriorityOrdered、Ordered

剩下的两个生命周期就比较简单

主要就是初始化和销毁

InitializingBean 对应生命周期的初始化阶段，在上面源码的invokeInitMethods(beanName, wrappedBean, mbd);方法中调用。

DisposableBean 类似于InitializingBean，对应生命周期的销毁阶段，以ConfigurableApplicationContext#close()方法作为入口，实现是通过循环取所有实现了DisposableBean接口的Bean然后调用其destroy()方法

另外我们可能会需要对spring进行一些扩展，这些扩展点我们肯定要都掌握

可以选择如下一些扩展点：

通过BeanPostProcessor及其子类

1.BeanPostProcessor

提供了在bean初始化之前和之后插入自定义逻辑的能力。与BeanFactoryPostProcessor的区别是处理的对象不同，BeanFactoryPostProcessor是对beanfactory进行处理，BeanPostProcessor是对bean进行处理。

2.BeanFactoryPostProcessor
是beanFactory后置处理器，支持在bean factory标准初始化完成后，对bean factory进行一些额外处理。

3.BeanDefinitionRegistryPostProcessor

它扩展自BeanFactoryPostProcessor，在执行BeanFactoryPostProcessor的功能前，提供了可以添加bean definition的能力，允许在初始化一般bean前，注册额外的bean。例如可以在这里根据bean的scope创建一个新的代理bean。

注：上面这三个扩展点，可以通过实现Ordered和PriorityOrdered接口来指定执行顺序。实现PriorityOrdered接口的processor会先于实现Ordered接口的执行。

第二类，通过Aware接口来实现扩展

ApplicationContextAware

可以获得ApplicationContext及其中的bean，当需要在代码中动态获取bean时，可以通过实现这个接口来实现。

BeanNameAware接口

(bean加载的过程中获取到bean的ID)实现setBeanName()方法

还有其他的EnvironmentAware，beanFactoryAware等等

第三类，生命周期接口

InitializingBean

可以在bean初始化完成，所有属性设置完成后执行特定逻辑，例如对自动装配对属性进行验证等等。

DisposableBean

用于在bean被销毁前执行特定的逻辑，例如做一些回收工作等。

第四类，其他接口

ApplicationListener

用来监听spring的标准应用事件或者自定义事件。

spring事务是如何实现的？

事务你可以理解位一个动作或者一件事。事务是为解决数据安全操作提出的，事务控制实际上就是控制数据的安全访问。有着ACID(院子，一致，隔离，持久）四个特性

spring事务分为声明式和编程式，如果系统比较复杂，建议使用声明式事务

声明式事务管理只需要用到@Transactional 注解和@EnableTransactionManagement。它是基于 Spring AOP 实现的。Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给mybatis等持久化机制所提供的相关平台框架的事务来实现

TransactionManager是做什么的？它保存着当前的数据源连接，对外提供对该数据源的事务提交回滚操作接口，同时实现了事务相关操作的方法。一个数据源DataSource需要一个事务管理器。

整个事务的一个流程是怎么样的

protected doBegin 开始事务,主要是执行了JDBC的con.setAutoCommit(false)方法。同时处理了很多和数据库连接相关的ThreadLocal变量。

protected doCommit 提交事务
protected doRollback 回滚事务
protected doGetTransaction() 获取事务信息
final getTransaction 获取事务状态

然后再讲下spring事务的传播机制

1.PROPAGATION_REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启

2.PROPAGATION_REQUIRES_NEW：总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起

3.PROPAGATION_SUPPORTS：如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行

4.PROPAGATION_NOT_SUPPORTED：总是非事务地执行，并挂起任何存在的事务

5.PROPAGATION_MANDATORY:如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常

6.PROPAGATION_NEVER： 总是非事务地执行，如果存在一个活动事务，则抛出异常

7.PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, PROPAGATION_REQUIRED 属性执行

Spring事务的事务隔离级别：

1.ISOLATION_DEFAULT:这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别

2. ISOLATION_READ_UNCOMMITTED ：这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

3. ISOLATION_READ_COMMITTED ：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。：

4. ISOLATION_REPEATABLE_READ ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。

5. ISOLATION_SERIALIZABLE ：这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻读。

spring如何解决循环依赖？

首先我们要了解整个bean的生命周期，才能很好的对症下药

第一种：构造器参数循环依赖

表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyIn CreationException异常表示循环依赖。

如在创建TestA类时，构造器需要TestB类，那将去创建TestB，在创建TestB类时又发现需要TestC类，则又去创建TestC，最终在创建TestC时发现又需要TestA，从而形成一个环，没办法创建。

第二种：setter方式原型，prototype

对于"prototype"作用域bean，Spring容器无法完成依赖注入，因为Spring容器不进行缓存"prototype"作用域的bean，因此无法提前暴露一个创建中的bean。

第三种，属性注入，作用域是单例

这主要是通过多级缓存达到目的的

一级一级向下寻找，找出了前面提到的三级缓存，也就是三个Map集合类：

singletonObjects：第一级缓存，里面放置的是实例化好的单例对象；

earlySingletonObjects：第二级缓存，里面存放的是提前曝光的单例对象；

singletonFactories：第三级缓存，里面存放的是要被实例化的对象的对象工厂。

所以当一个Bean调用构造函数进行实例化后，即使属性还未填充，就可以通过三级缓存向外暴露依赖的引用值（所以循环依赖问题的解决也是基于Java的引用传递），这也说明了另外一点，基于构造函数的注入，如果有循环依赖，Spring是不能够解决的。还要说明一点，Spring默认的Bean Scope是单例的，而三级缓存中都包含singleton，可见是对于单例Bean之间的循环依赖的解决，Spring是通过三级缓存来实现的。

springAop实现原理

AOP的专业术语

连接点（JoinPoint）：增强执行的位置（增加代码的位置），Spring只支持方法；
切点（PointCut）：具体的连接点；一般可能通过一个表达式来描述；
增强（Advice）：也称为消息，指的是增加的额外的代码，Spring中，增强除了包含代码外，还包含位置信息；

Spring中一共有四种增强：

• MethodBeforeAdvice:前置增强
• MethodInterceptor：环绕增强
• ThrowsAdvice：异常增强
• AfterReturingAdvice：返回值增强

织入（Weaving）：将增强加入到目标类的过程，织入分为三种时期

• 编译器:AspectJ
• 类加载
• 运行期：jdk动态代理（实现接口），CGlib（子类，不能用final）

目标对象（Target）：原始对象
代理对象（Proxy）：加入了增强的对象，是生成的；
切面（Aspect）：切点+增强

JDK动态代理（实现接口）

什么是代理模式呢？

代理模式有三个角色，分别是

• 抽象角色：接口
• 目标角色：实现类
• 代理角色：实现接口（InvocationHandler），并引用目标角色

代理模式与装饰者模式的区别
类图（结构）基本一样，但目的不同，装饰模式的前提是已经所有的类，并进行组装；
而使用代理模式时，我们不能直接访问目标角色或没有权限访问时，可以使用代理模式

代理模式分为两种

• 静态代理：需要为每个目标角色，创建一个对应的代理角色；类的数量会急剧膨胀
• 动态代理：自动为每个目标角色生成对应的代理角色

AOP技术，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。比如权限认证、日志、事务处理

Spring AOP代理对象的生成

Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中，直接上相关代码：

java动态代理的关键-创建的类得需要实现InvocationHandler,并重写invoke()方法

具体实现代理类有的方法

public static Object newProxyInstance(ClassLoader loader,

        Class<?>[] interfaces,

        InvocationHandler h)

        throws IllegalArgumentException

        }

newProxyInstance，方法有三个参数：

loader: 用哪个类加载器去加载代理对象

interfaces:动态代理类需要实现的接口

h:动态代理方法在执行时，会调用h里面的invoke方法去执行

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { method.invoke(obj, args); return null; }

如果不能实现接口的时候，这个时候就可以考虑使用一个cglib来实现代理