Spring 流程图

AbstractAutoProxyCreator

postProcessAfterInitialization(){span style=\"font-size: inherit;\

循环依赖检查：满足所有条件，将MyBeanA加入二级缓存，然后返回MyBeanA

解析Bean 转换成BeanDefinition

从三级缓存中获取Bean的ObjectFactory

循环依赖处理：处理后会将Bean放到二级缓存中需要依次满足以下条件：1、一级、二级缓存没有该Bean2、该Bean 处于创建中3、配置了Spring允许循环依赖4、该Bean在三级缓存中存在

第一次循环：创建MyBeanA

MyAop：为这个Bean创建AOP的切点、切面

@Aspect@Componentpublic class MyAop { @Pointcut(value = \"execution(public String example.my.test.MyBean.show(String))\") public void pointcut() { } @Before(value = \"pointcut()\") public void before() {  System.out.println(\"Aop-before\"); } @After(value = \"pointcut()\") public void after() {  System.out.println(\"Aop-after\"); } @AfterReturning(value = \"pointcut()\") public void afterReturning() {  System.out.println(\"Aop-afterReturning\"); } @AfterThrowing(value = \"pointcut()\") public void afterThrowing() {  System.out.println(\"Aop-afterThrowing\"); }}

将Bean 添加到创建中的Bean的集合：           this.singletonsCurrentlyInCreation.add(beanName)此时Bean的状态为创建中

循环依赖检查：MyBeanB不满足条件2，返回null

JdkDynamicAopProxy

getProxy()

标记MyBeanB 为创建中

解析Bean的属性

获取到了，返回Bean

将MyBeanB 加入三级缓存

结束：返回结果

调用MyBeanA 的初始化方法

//创建一个最普通的Bean@Componentpublic class MyBean{}//创建Spring 容器new AnnotationConfigApplicationContext(MyWebApplication.class);

AbstractAutowireCapableBeanFactory

DefaultSingletonBeanRegistry

Bean创建完成后：将Bean从singletonsCurrentlyInCreation移除标志着Bean的创建完成

调用MyBeanB 的初始化方法

创建Bean 的实例

定义Bean

ProxyCreatorSupport

createAopProxy(){    .....    //调用工厂并获取aop 代理    return getAopProxyFactory().createAopProxy(this);}

解析MyBeanA 的Autowrite 属性

定义自己的AIP

DefaultAopProxyFactory

createAopProxy(){    //config.isOptimize() 是否对生成代理策略进行优化    //config.isProxyTargetClass() 用此属性控制了代理bean的类型，例如class以.cglib.proxy.Factory 结尾的bean，这这里就会返回false    //hasNoUserSuppliedProxyInterfaces(config) 没有需要代理去实现的接口，或者这个仅有的接口是SpringProxy 相关接口，就会返回true    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {        Class<?> targetClass = config.getTargetClass();        if (targetClass == null) {            throw new AopConfigException(\"TargetSource cannot determine target class: \" +                \"Either an interface or a target is required for proxy creation.\");        }        //如果这个class是接口，或者这个class 继承了java的动态代理类（proxy）那么就创建jdk动态代理，否则创建cglib代理        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {            return new JdkDynamicAopProxy(config);        }        return new ObjenesisCglibAopProxy(config);    }else {       return new JdkDynamicAopProxy(config);    }}

从二级缓存（earlySingletonObjects）获取Bean

不允许：返回null

MyBeanA 和 MyBean B 互相依赖

解析MyBeanB 的Autowrite 属性

1、通过ObjectFactory.getObject得到这个Bean2、将这个Bean放入二级缓存3、将这个Bean从三级缓存中移除

getSingleton：用于控制Bean的创建流程

尝试获取MyBeanA

AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement

resolveFieldValue(){    ......     beanFactory.resolveDependency()    ......}

MyConfig：创建注解启动用到的配置

@EnableAspectJAutoProxy@ComponentScan(\"example.my.test\")@Configurationpublic class MyConfig {}

解析Bean

singletonFactory.getObject() --

标记MyBeanA 为创建中

对这个bean 添加同步锁：synchronized

解析Autowrite 属性

Bean创建完成后：将Bean添加到一级缓存（singletonObjects）并且将Bean从二三级缓存中移除

没获取到：返回null

未获取到

从一级缓存(singletonObjects)中获取Bean

没有在创建中，返回null

处理循坏依赖的三次循坏逻辑

createBean

没获取到获取到

MyBeanB 创建完成，返回MyBeanA

ProxyFactory

getProxy(){    //创建并获取AOP代理对象    return createAopProxy().getProxy(classLoader);}

AbstractApplicationContext------------------------------finishBeanFactoryInitialization(){    ........    // 加载所有非延迟加载的单例Bean    beanFactory.preInstantiateSingletons();}

创建Bean的流程

解析注入的Bean

CglibAopProxy

循坏依赖的运行流程

inject(){    ......    resolveFieldValue();    ......}

AbstractApplicationContext------------------------------refresh(){    ........    // 加载所有非延迟加载的Bean    finishBeanFactoryInitialization(beanFactory);    ........}

createProxy(){    ......    //创建并初始化代理代理工厂    ProxyFactory proxyFactory = new ProxyFactory();    proxyFactory.copyFrom(this);    ......    //返回代理工厂创建的代理对象    return proxyFactory.getProxy(getProxyClassLoader());}

获取到了

循环依赖检查：MyBeanA不满足条件2，返回null

DefaultListableBeanFactory

resolveDependency(){    ......    doResolveDependency()    ......}

检查是否允许循环依赖

使用代理工厂，创建代理对象

开启创建MyBeanA 的流程

----------------------------------------------------Spring 实现AOP的流程----------------------------------------------------

结束：返回创建的对象

开启创建MyBeanB 的流程

创建Bean完成

----------------------------------------------------Spring 实现解决循环依赖的流程----------------------------------------------------

回调lambda:createBean创建一个Bean

AnnotationConfigApplicationContext-----------------------------------public AnnotationConfigApplicationContext(String... basePackages) {     this();     //注册并加载解析你的启动类     register(componentClasses);     //刷新(加载)spring 容器     refresh(); }

允许

AOP 代码示例

解析之后调用：BeanFactory.getBean(beanName)创建Bean

返回Bean

解析Bean：BeanDefinition

MyApplication：创建并启动spring 容器

public class MyApplication { public static void main(String[] args) {  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);  MyBean bean = context.getBean(MyBean.class);  bean.show(\"hello aop\"); }}

创建Bean的实例instanceWrapper = createBeanInstance

创建Bean

第二次循环：创建MyBeanB

MyBeanA 创建完成，返回MyBeanA

getSingleton(beanName)

----------------------------------------------------Spring 加载一个普通Bean的流程----------------------------------------------------

MyBean：创建一个普通的Bean

@Componentpublic class MyBean { public String show(String msg) {  System.out.println(\"==== show my message：\" + msg + \" ===\");  return msg; }}

尝试获取MyBeanB

调用Bean的初始化方法

解析Autowrite属性

再次对一二级缓存进行检查，尝试获取Bean

在创建中

MyBeanA 优先创建

循坏依赖的源码运行过程

DefaultListableBeanFactory-----------------------------preInstantiateSingletons(){    ......    //遍历beanNames 集合    for (String beanName : beanNames) {        ......        //开始加载一个Bean        getBean(beanName);    }}

将MyBeanA 加入三级缓存

尝试获取Bean 

第三次循环：创建MyBeanA

使用AspjectJ 解析、匹配切面，创建代理工厂

InjectionMetadata

doResolveDependency(){    ......    //DependencyDescriptor    descriptor.resolveCandidate()    ......}

AutowiredAnnotationBeanPostProcessor

DependencyDescriptor

resolveCandidate(){    return beanFactory.getBean(beanName);}

省略前期创建Bean的流程

检查这个Bean是否在创建中

调用AOP 的BeanPostProcess 实现：AbstractAutoProxyCreator

没获取到

resolveMethodArguments(){    ......    beanFactory.resolveDependency()    ......}

AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement

inject(){    ......        ......}