开始Spring Bean的生命周期

专栏第一篇文章介绍了生命周期的流程有哪些步骤，第二篇文章介绍了将JavaBean 注册成了一个beanDefinition。

这篇文章我们将具体的步骤展开

我们从refresh 的 finishBeanFactoryInitalization();开始

protected void finishBeanFactoryInitialization(){
    for (String beanName : beanFactory.getBeanNames()) {
        this.getBean(beanName);
    }
}


public Object getBean(String name) {
    return beanFactory.getBean(name);
}


public Object getBean(String currentBeanName){
    Object sharedInstance = getSingleton(currentBeanName);
    return getObjectForBeanInstance(sharedInstance,currentBeanName);
}


public Object getSingleton(String currentBeanName){
    final String beanName = GenerateBeanNameUtils.transformedBeanName(currentBeanName);
    Object singletonObject = this.singletonObjects.get(beanName);
    if(Objects.isNull(singletonObject)){
        beforeSingletonCreation(currentBeanName);
        singletonObject = capableBeanFactory.createBean(beanName);
    }
    return singletonObject;
}

public void beforeSingletonCreation(String beanName){
    if(!this.isSingletonCurrentlyInCreation.add(beanName)){
        throw new RuntimeException(beanName+" Requested bean is currently in creation: Is there an unresolvable circular reference?");
    }
}

private Object getObjectForBeanInstance(Object sharedInstance,String name) {
    if(XxFactoryBean.class.isAssignableFrom(sharedInstance.getClass())){
        XxFactoryBean<?> factory = (XxFactoryBean<?>) sharedInstance;
        try {
            if(GenerateBeanNameUtils.isContainsAnd(name)){
                return sharedInstance;
            }
            return factory.getObject();
        } catch (Exception ignored) {
        }
    }
    return sharedInstance;
}

beforeSingletonCreation(currentBeanName); 处理构造方法的循环依赖。直接报错

getObjectForBeanInstance 处理 实现了FactoryBean接口的对象

singletonObject = capableBeanFactory.createBean(beanName); 去创建bean

第一步处理aop通知

for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
    if(xxBeanPostProcessor instanceof XxHandleAdviceBeanPostProcessor){
        ((XxHandleAdviceBeanPostProcessor) xxBeanPostProcessor).beforeHandleAdvice(beanName,instance);
        break;
    }
}

第二步实例化对象

XxBeanDefinition xxBeanDefinition = beanFactory.getXxBeanDefinitionMaps().get(beanName);
Class<?> beanClass = xxBeanDefinition.getBeanClass();
try {
    Constructor<?> constructorToUse = findCandidateConstructor(beanClass);
    instance = constructorToUse.newInstance(wrapperConstructor(constructorToUse));
} catch (Exception e) {
    throw new RuntimeException(beanClass.getName()+" Requested bean is currently in creation: Is there an unresolvable circular reference?");
}
beanFactory.getSingletonObjects().put(beanName,instance);

推断构造方法并实例化是仿 Spring 的逻辑。直接在实例化完成后就将该对象放到了单例池里面就是为了下一个步骤，解决填充属性时候的循环依赖问题（但是有个小bug）

第三步填充属性

populateBean(beanName,instance);

public void populateBean(String beanName,Object instance){
    for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
        if(xxBeanPostProcessor instanceof XxAutowireAnnotationBeanPostProcessor){
            xxBeanPostProcessor.applyObjectBeforeInstance(beanName,instance);
            break;
        }
    }
}

那个小bug是这样的场景

@XxComponent
public class Order02 {

    @XxAutowired
    private Order03 order03;

    @XxAutowired
    public Order02(Order03 order03){
        System.out.println("Order02");
    }
}

@XxComponent
public class Order03 {

    @XxAutowired
    private Order02 order02;

    @XxAutowired
    public Order03(){
        System.out.println("Order03");
    }
}

执行的结果是System.out.println("Order02"); 打印了两次

第四步调用aware接口执行aware方法

public Object initializeBean(String beanName ,Object instance){
    invokeAwareMethods(beanName,instance);
    Object o = applyBeanPostProcessorsBeforeInitialization(beanName, instance);//invokeAwareInterfaces();
    invokeInitMethods(beanName,o);
    return applyBeanPostProcessorsAfterInitialization(beanName, o);//aop
}

invokeAwareMethods(beanName,instance);就是填充抽象方法的参数属性

private void invokeAwareMethods(String beanName,Object instance) {//系统内置的 aware 接口
    for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
        if(xxBeanPostProcessor instanceof XxRootAwareBeanPostProcessor){
            xxBeanPostProcessor.applyObjectBeforeInstance(beanName,instance);
            break;
        }
    }
}

第五步执行初始化之前的方法

private Object applyBeanPostProcessorsBeforeInitialization(String beanName,Object instance) {
    for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
        if(xxBeanPostProcessor instanceof XxApplicationContextAwareProcessor){
            if(instance instanceof XxApplicationContextAware){
                xxBeanPostProcessor.applyObjectBeforeInstance(beanName,instance);
            }
        }
    }
    return instance;
}

第六步执行初始化方法

自己写的是执行 @PostConstruct 和实现了InitializingBean接口，源码里面是分开的但是顺序还是注解大于接口大于xml

private void invokeInitMethods(String beanName, Object instance) {
    for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
        if(xxBeanPostProcessor instanceof XxInitializingBeanPostProcessor){
            xxBeanPostProcessor.applyObjectBeforeInstance(beanName,instance);
        }
    }
}

第七步执行初始化之后的方法

private Object applyBeanPostProcessorsAfterInitialization(String beanName,Object instance) {
    Object result = instance;
    for (XxBeanPostProcessor xxBeanPostProcessor : beanFactory.getXxBeanPostProcessors()) {
        Object current = xxBeanPostProcessor.applyObjectAfterInstance(beanName, instance);
        if(Objects.isNull(current)){
            return result;
        }
        result = current;
    }
    return result;
}

详情可看gitee源码 https://gitee.com/wanganfen/xx-spring/tree/master