Spring自用

Bean的生命周期：

分为4个阶段：

1.      
Bean的实例化阶段

2.      
Bean的设置属性阶段

3.      
Bean的初始化阶段

4.      
Bean的销毁阶段

在设置属性阶段后，postProcessBeforeInitialization方法执行前，会执行很多Aware类型的接口，这种类型接口作用是加载资源到Spring容器中，Aware前面的名字就对应哪种资源，依次加载的是：

BeanNameAware

BeanClassLoaderAware

BeanFactoryAware

EnvironmentAware

ResourceLoaderAware

ApplicationEventPublisherAware

ApplicationContextAware

看到这里应该明白BeanFactory和ApplicationContext的区别了：

BeanFactoryAware之前加载的资源都是公共的。BeanFactoryAware后面加载的资源都是ApplicationContext独有的。

1.      
Bean容器找到Spring的配置文件中的Bean的定义。

2.      
Bean容器利用反射机制实例化Bean。

3.      
Bean容器为实例化的Bean设置属性值

4.      
如果实现了BeanNameAware接口，则执行setBeanName方法

5.      
如果Bean实现了BeanClassLoaderAware，则执行setBeanClassLoader方法。

6.      
如果Bean实现了BeanFactoryAware，则执行setBeanFactory方法。

7.      
如果Bean实现了ApplicationContext方法，执行setApplicationContext方法

8.      
如果加载了BeanPostProcessor方法，则执行postBeanBeforeInitialization方法

9.      
如果Bean实现了InitailBean接口，则执行afterProcessAfterIntialzation方法；

10.  
如果Bean定义初始化方法，PostConstruct注解，则执行自定义的初始化方法。

11.  
如果加载了BeanPostProcesser相关实现类，则执行postProcessAfterInitialzation方法。

12.  
当要销毁这个Bean时，如果Bean实现了DisposableBean接口，则执行destory方法。

13.  
当要销毁这个Bean时，如果自定义了销毁方法，则执行定义的销毁方法。

JDK动态代理：只能对实现了接口的类生成代理，而不是针对类，该目标类型实现的接口都将被代理，原理是通过在运行期间创建一个接口的实现类来完成对目标对象的代理，实现步骤大概如下：

1．  定义一个实现接口，InvocationHandler的类。

2．  通过构造函数，注入被代理的类。

3．  实现invke（Object proxy， Method
method，
Object【】 args）方法

4．  在主函数中获得被代理类的类加载器。

5．  通过Proxy.newProxyIntance()产生一个代理对象。

6．  通过代理对象调用各种方法

Cglib主要针对类实现代理，对是否接口实现无要求，原理是对指定的类生成一个子类，覆盖其中方法，因为是继承，所以被代理的类或者方法不能声明为final，实现步骤大概如下：

1．  定义一个实现了MethodInterceptor接口的类

2．  实现其intercept()方法在其中调用

AOP对两种代理类的选择：

如果目标对象实现了接口，默认情况下都会用JDK动态代理实现AOP，也可以强制使用cglib

2如果目标对象没有实现接口，必须使用cglib。

IOC容器的初始化过程。

主要包括Resource资源定位，载入和注册三个步骤。

Resource资源定位：

Resource资源定位使之BeanDefinition的资源定位，也就是IOC容器找数据的一个过程，Spring中使用外部资源来描述一个Bean对象，IOC容器第一步就是需要定位Resource的外部资源，通过

BeanDefinition的载入

载入过程就是把定义好的Bean表示成IOC容器内部的数据结构，即BeanDefiniton，在配置文件中对每一个Bean都对应着一个BeanDefinition对象，通过BeanDefinitionReader读取，解析Resource定位的资源，将用户定义好的Bean表示成IOC容器中的内部数据结构BeanDefintion。

在IOC容器中维护了一个Map。

BeanDefinition的注册，

注册就是讲前面的Definition保存到Map中的过程，通过BeanDefinitionRegistry接口来实现注册。

（1）BeanFactory是Spring里面最底层的接口，是IoC的核心，定义了IoC的基本功能，包含了各种Bean的定义、加载、实例化，依赖注入和生命周期管理。ApplicationContext接口作为BeanFactory的子类，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：

继承MessageSource，因此支持国际化。

资源文件访问，如URL和文件（ResourceLoader）。

提供在监听器中注册bean的事件。

①BeanFactroy采用的是延迟加载形式来注入Bean的，只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能提前发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。

②ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。

③ApplicationContext启动后预载入所有的单实例Bean，所以在运行的时候速度比较快，因为它们已经创建好了。相对于BeanFactory，ApplicationContext 唯一的不足是占用内存空间，当应用程序配置Bean较多时，程序启动较慢。

Spring事务

Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。Spring只提供统一事务管理接口，具体实现都是由各数据库自己实现，数据库事务的提交和回滚是通过binlog或者undo log实现的。Spring会在事务开始时，根据当前环境中设置的隔离级别，调整数据库隔离级别，由此保持一致。

Spring支持编程式事务管理和声明式事务管理两种方式：

①编程式事务管理使用TransactionTemplate。

②声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

事务的传播机制：

Propagation_required:默认传播行为，如果当前没有事务，就创建一个新的事务，如果当前存在事务，就加入该事务。

Propagation_requires_new:无论当前存不存在事务，都新建一个事务。

Propagation_supports：如果当前存在事务，就加入该事物，如果不存在，就以非事务执行。

事务的隔离级别：

Isolation——default：默认隔离级别，使用数据库的隔离级别

② ISOLATION_READ_UNCOMMITTED：读未提交，允许事务在执行过程中，读取其他事务未提交的数据。

③ ISOLATION_READ_COMMITTED：读已提交，允许事务在执行过程中，读取其他事务已经提交的数据。

④ ISOLATION_REPEATABLE_READ：可重复读，在同一个事务内，任意时刻的查询结果都是一致的。

⑤ ISOLATION_SERIALIZABLE：所有事务逐个依次执行。