1.5.Spring中事务失效的场景

---

 

这种情况下，自己把异常处理了，导致@Transactional没有发现异常，事务没有回滚。

Spring默认只会回滚非检查异常也就是runtime异常。而这里的FileNotFound是一个检查异常，并不能被捕获。

Spring为方法创建代理，添加事务通知，前提条件都是该方法是public修饰的！

1.6.Bean的生命周期

---

1.BeanDefinition

2.构造函数

在此期间，调用Bean的构造函数，实例化对象 (但是还未赋值！)

3.依赖注入

Spring容器会将Bean的属性设置为Bean定义中指定的值。这个过程也被称为依赖注入，因为Spring容器会自动寻找并注入Bean所依赖的其他Bean。

4.Aware接口

用于增强Bean的功能

如果Bean实现了以Aware结尾的接口，就要重写里面的方法。图中三个接口，就是分别用于在Bean的初始化过程中，用于获取：Bean的名字、Bean的工厂、容器的上下文对象（Spring容器本身）。

5.BeanPostProcessor#before

bean的后置处理器，在初始化方法调用之前执行。

6.初始化方法

        1.InitalizingBean接口，实现了该接口，就要实现里面的方法。而在这一步就会执行重写方法。

        2.自定义init：在bean中某个方法上标注了@PostConstruct注解。就会在这一步执行这个方法。

7.BeanPostProcessor#before

bean的后置处理器，在初始化方法调用之后执行。

当一个类的功能被增强了使用到了AOP，大概率就是使用后置处理器被增强的。

  

8.销毁Bean

如果在哪个方法上标注了@PreDestroy方法，Spring容器在关闭前就会调用该方法。

注：

1.Bean的创建和初始化是分开的，第2步是创建bean，3-7是初始化赋值

2.第5步和第7步的两个后置处理器。都是某个类实现了BeanPostProcessor接口，所重写的两个方法。分别在初始化方法前后执行。

测试代码：

第一个类User类，作为我们测试的Bean

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class User implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {

    public User() {
        System.out.println("1.User的构造方法执行了.........");
    }

    private String name;

    @Value("张三")
    public void setName(String name) {
        System.out.println("2.依赖注入执行了..........");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3.BeanNameAware的实现方法执行了.......");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("3.BeanNameAware的实现方法执行了.......");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("3.ApplicationContextAware的实现方法执行了.......");
    }

    @PostConstruct
    public void init() {
        System.out.println("5.自定义初始化方法执行了..........");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.InitializingBean的实现方法执行了..........");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("7.destroy方法执行了.........");
    }
}

第二个类：实现了BeanPostProcessor重写了其中方法的类。里面是两个后置处理器。

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("4.postProcessBeforeInitialization方法执行了 -> user对象初始化方法之前执行");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("user")) {
            System.out.println("6.postProcessAfterInitialization方法执行了 -> user对象初始化方法之后执行");
        }
        return bean;
    }
}

执行结果

destroy方法要在容器关闭时执行

总结：

        1.首先会通过一个非常重要的类，叫做BeanDefinition获取bean的定义信息， 这里面就封装了bean的所有信息，比如，类的全路径，是否是延迟加载，是否是单例等等这些信息。        

        2.在创建bean的时候，第一步是调用构造函数实例化bean

        3.第二步是bean的依赖注入，比如一些set方法注入，像平时开发用的@Autowire都是这一步完成。

        4.第三步是处理Aware接口，如果某一个bean实现了Aware接口就会重写方法执行。

        5.第四步是bean的后置处理器BeanPostProcessor，这个是前置处理器。

        6.第五步是初始化方法，比如实现了接口InitializingBean或者自定义了方init-method标签或@PostContruct。

        7.第六步是执行了bean的后置处理器BeanPostProcessor，主要是对bean进行增强，有可能在这里产生代理对象。

        8.最后一步是销毁bean。

1.7.Spring中bean的循环引用

---

        在Spring中bean的生命周期中的构造方法执行时，只是把bean对象创建出来了。但还未进行初始化。初始化的第一步就是进行依赖注入，对当前bean所需要的bean进行注入。这个时候，如果出现：A依赖注入B，B就会去创建并初始化。但如果此时出现了：B初始化时，也需要A的实例。两个半成品Bean，就会死循环，谁都创建不出来！

解决循环依赖的方法：

注：这里的一级缓存中，存放的是单例的Bean。对于多例Bean，则是在获取Bean的时候才会被创建，并不会提前被创建存放在一级缓存中。

三级缓存解决循环依赖图解：

注意：这里三级缓存相较于二级缓存的有点就是：三级缓存中的ObjectFactory既可以生成A(原始对象)也可以生成A的代理对象。而二级缓存是没法把代理对象放入二级缓存中。

而在这个过程中：我们ObjectFactory产生的B的半成品Bean和A的代理对象半成品Bean都会放在二级缓存中，之后往A中注入B从而产生完整的A，就是从二级缓存中拿B的半成品Bean。因为，如果多次调用ObjectFactory，就可能产生多例的情况！

总的来说：要解决循环依赖问题，1、2、3级缓存需要相互配合，都必不可少！

三级缓存能解决的是出现在Bean初始化时的循环依赖问题，但如果是在构造方法时出现的循环依赖，就要我们手动解决了。如：

当Bean被注入到另一个Bean中时，Spring并不是直接将这个Bean实例化并注入到另一个Bean中，而是使用一个代理对象来代替实际的Bean。在这里就是：创建A实例的时候，Spring先创建一个B的代理对象用于A的构造方法初始化。从而解决了循环依赖问题。

总结：

1.循环依赖：

循环依赖其实就是循环引用 , 也就是两个或两个以上的 bean 互相持

有对方 , 最终形成闭环。比如 A 依赖于 B,B 依赖于 A循环依赖在spring 中是允许存在， spring 框架依据三级缓存已经解决了大部分的循环依赖

① 一级缓存：单例池，缓存已经经历了完整的生命周期，已经初始化完成的

bean 对象

② 二级缓存：缓存早期的 bean 对象（生命周期还没走完）

③ 三级缓存：缓存的是 ObjectFactory ，表示对象工厂，用来创建某个对象的

2.三级缓存解决循环依赖的具体流程：

第一，先实例 A 对象，同时会创建 ObjectFactory 对象存入三级缓存singletonFactories

第二， A 在初始化的时候需要 B 对象，这个走 B 的创建的逻辑

第三， B 实例化完成，也会创建 ObjectFactory 对象存入三级缓存singletonFactories

第四， B 需要注入 A ，通过三级缓存中获取 ObjectFactory 来生成一个 A 的对象同时存入二级缓存，这个是有两种情况，一个是可能是A 的普通对象，另外一个是A 的代理对象，都可以让 ObjectFactory 来生产对应的对象，这也是三级缓存的关键

第五， B 通过从通过二级缓存 earlySingletonObjects 获得到 A 的对象后可以正常注入，B 创建成功，存入一级缓存 singletonObjects

第六，回到 A 对象初始化，因为 B 对象已经创建完成，则可以直接注入 B ， A创建成功存入一次缓存singletonObjects

第七，二级缓存中的临时对象 A 清除