spring启动过程详解

1、启动spring容器的方法：
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();            //以无参构造器生成上下文对象
        register(annotatedClasses);    //将配置类注册到容器中
        refresh();    //启动容器具体过程
}        

Refresh:

//为执行refresh做准备，比如：设置容器状态，将配置文件和环境变量加载到spring容器中，并且验证是否设置了必须的属性
prepareRefresh();

//更新BeanFactory状态，获得spring容器的beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//为BeanFactory做准备工作，比如设置类加载器、spel表达式解析器、部分Aware接口的后置处理器、注册依赖和环境变量
prepareBeanFactory(beanFactory);

//允许在子上下文中使用BeanFactoryPostProcessor处理BeanFactory,此处是个空实现
postProcessBeanFactory(beanFactory);

//在AbstractApplicationContext中的invokeBeanFactoryPostProcessors方法中调用PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())来进行BeanFactory的后置处理。
进行BeanFactory的后置处理主要通过BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor
先执行的BeanDefinitionRegistryPostProcessor：首先调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，其次调用实现Ordered接口的BeanDefinitionRegistryPostProcessor，最后是一般的BeanDefinitionRegistryPostProcessor（invokeBeanDefinitionRegistryPostProcessors方法是实现ImportBeanDefinitionRegistrar重要步骤，比如启用AOP的AspectJAutoProxyRegistrar）。
其后执行的BeanFactoryPostProcessor：首先调用实现PriorityOrdered接口的BeanFactoryPostProcessor，其次调用实现Ordered接口的BeanFactoryPostProcessor，最后是一般的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);

//获取Bean的后置处理器定义，然后首先将实现PriorityOrdered接口的BeanPostProcessor排序后注册到容器，其次将实现Ordered接口的BeanPostProcessor排序后注册到容器，然后将一般的BeanPostProcessor注册到容器，最后将spring内部的BeanPostProcessor注册到容器。
registerBeanPostProcessors(beanFactory);

// 初始化国际化资源，首先判断容器中是否有id为messageSource的，有的话则使用容器中的MessageSource来做国际化，否则使用DelegatingMessageSource作为初始化MessageSource的类。所以如果要自定义国际化资源，注入的实例id必须为messageSource，否则不生效。
initMessageSource();

// 初始化应用事件广播器，如果用户没有注入，默认使用SimpleApplicationEventMulticaster的multicastEvent方法进行事件广播（使用多线程的方法向所有监听器发送通知），
initApplicationEventMulticaster();

// 在特殊的上下文子类中初始化其他特殊的bean，默认为空实现
onRefresh();

// 注册监听器，默认只有ScheduledAnnotationBeanPostProcessor(@Schedule注解的实现)，用户可以通过注入ApplicationListener的子类来注册监听器。
registerListeners();

// 初始化还未初始化的实例并且注入（必须是非懒加载模式的）。
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 如果容器中注入了ConversionService的实现类，则将该实例作为应用的类型转化方案
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    // 如果没有Bean的后置处理器（例如PropertyPlaceholderConfigurer）注册，则注入一个StringValueResolver的实例来解析配置文件。PropertyPlaceholderConfigurer中会生成一个StringValueResolver实例用于解析。
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }
    //LoadTimeWeaver用于当类被载入jvm时，动态转化类。实现了LoadTimeWeaverAware接口的bean可以接收一个指向载入时织入实例的引用。在Spring的JPA支持中，载入时织入对于JPA类转化是必要的。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    // 不在使用临时类加载器进行类型匹配
    beanFactory.setTempClassLoader(null);
    // 冻结配置信息，不在允许改变所有的bean定义
    beanFactory.freezeConfiguration();
    // 初始化剩下非懒加载的单实例。首先判断判断bean定义是否是懒加载、单实例和抽象的，是的话对于实现SmartInitializingSingleton接口的调用afterSingletonsInstantiated方法；否则判断是不是工厂bean，不是的话则创建调用getBean方法，在doGetBean方法中，对于满足sharedInstance != null && args == null条件的通过getObjectForBeanInstance创建实例，否则对于单实例bean，调用AbstractBeanFactory.this.createBean方法生成实例。
AbstractAutowireCapableBeanFactory：
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;
    Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var7) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
    }

    Object beanInstance;
    try {
//对于实现InstantiationAwareBeanPostProcessor接口的类进行如下操作，调用相应的postProcessBeforeInstantiation
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        if (beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var8) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
    }
    beanInstance = this.doCreateBean(beanName, mbdToUse, args);

doCreateBean的部分实现
                            try {
对实例进行属性赋值
                                this.populateBean(beanName, mbd, instanceWrapper);
                                if (exposedObject != null) {
//初始化bean
                                    exposedObject = this.initializeBean(beanName, exposedObject, mbd);
                                }

initializeBean的方法：
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            public Object run() {
                AbstractAutowireCapableBeanFactory.this.invokeAwareMethods(beanName, bean);
                return null;
            }
        }, this.getAccessControlContext());
    } else {
        this.invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
//对实例调用postProcessorsBeforeInitialization方法
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }

    try {
 //调用类的初始化方法
        this.invokeInitMethods(beanName, wrappedBean, mbd);

  invokeInitMethods代码：
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {
    boolean isInitializingBean = bean instanceof InitializingBean;
//对实现InitializingBean的子类调用afterPropertiesSet方法
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }

        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    public Object run() throws Exception {
                        ((InitializingBean)bean).afterPropertiesSet();
                        return null;
                    }
                }, this.getAccessControlContext());
            } catch (PrivilegedActionException var6) {
                throw var6.getException();
            }
        } else {
            ((InitializingBean)bean).afterPropertiesSet();
        }
    }

//对采用了@Bean中initMethod调用对应的初始化方法
    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
            this.invokeCustomInitMethod(beanName, bean, mbd);
        }
    }

}

    } catch (Throwable var6) {
        throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
    }

    if (mbd == null || !mbd.isSynthetic()) {
//对实例调用postProcessorsAfterInitialization方法
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

} catch (Throwable var18) {
                            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                        throw (BeanCreationException)var18;
                        }

                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

    beanFactory.preInstantiateSingletons();
}

// Last step: publish corresponding event.
finishRefresh();

 

更多问题可以加公众号：代码小栈，期待为您解决更多问题