spring初始化源码分析

发布时间：2023-04-28 11:19:54 作者：iii
来源：亿速云阅读：111

Spring初始化源码分析

Spring框架是Java开发中最流行的框架之一，其核心功能包括依赖注入（DI）和面向切面编程（AOP）。Spring的初始化过程是理解其工作原理的关键。本文将通过分析Spring的源码，深入探讨Spring的初始化过程。

1. Spring初始化的入口

Spring的初始化过程通常从ApplicationContext的创建开始。ApplicationContext是Spring的核心接口，它代表了Spring IoC容器。常见的实现类有ClassPathXmlApplicationContext、AnnotationConfigApplicationContext等。

以ClassPathXmlApplicationContext为例，其初始化过程如下：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

1.1 `ClassPathXmlApplicationContext`的构造方法

ClassPathXmlApplicationContext的构造方法会调用refresh()方法，这是Spring初始化的核心方法。

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
        throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

1.2 `refresh()`方法

refresh()方法是Spring初始化的核心方法，它负责加载配置文件、解析Bean定义、初始化Bean等操作。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备刷新上下文
        prepareRefresh();

        // 2. 获取BeanFactory并加载Bean定义
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. 准备BeanFactory
        prepareBeanFactory(beanFactory);

        try {
            // 4. 允许子类对BeanFactory进行后处理
            postProcessBeanFactory(beanFactory);

            // 5. 调用BeanFactoryPostProcessor
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册BeanPostProcessor
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化消息源
            initMessageSource();

            // 8. 初始化事件广播器
            initApplicationEventMulticaster();

            // 9. 初始化其他特殊的Bean
            onRefresh();

            // 10. 注册监听器
            registerListeners();

            // 11. 初始化所有单例Bean
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新
            finishRefresh();
        } catch (BeansException ex) {
            // 处理异常
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
    }
}

2. 详细步骤分析

2.1 准备刷新上下文

prepareRefresh()方法负责初始化一些环境变量和属性源。

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);

    // 初始化属性源
    initPropertySources();

    // 验证必要的属性
    getEnvironment().validateRequiredProperties();
}

2.2 获取BeanFactory并加载Bean定义

obtainFreshBeanFactory()方法负责创建并配置BeanFactory，并加载Bean定义。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
}

refreshBeanFactory()方法会创建一个新的DefaultListableBeanFactory，并加载Bean定义。

protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        customizeBeanFactory(beanFactory);
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    } catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

2.3 准备BeanFactory

prepareBeanFactory()方法负责配置BeanFactory，包括设置类加载器、注册一些内置的BeanPostProcessor等。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 注册BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // 注册一些内置的Bean
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
}

2.4 调用BeanFactoryPostProcessor

invokeBeanFactoryPostProcessors()方法负责调用所有注册的BeanFactoryPostProcessor，这些处理器可以修改Bean定义。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}

2.5 注册BeanPostProcessor

registerBeanPostProcessors()方法负责注册所有BeanPostProcessor，这些处理器可以在Bean初始化前后执行一些操作。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

2.6 初始化消息源

initMessageSource()方法负责初始化消息源，用于国际化支持。

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    } else {
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

2.7 初始化事件广播器

initApplicationEventMulticaster()方法负责初始化事件广播器，用于发布和监听事件。

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    } else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}

2.8 初始化其他特殊的Bean

onRefresh()方法是一个钩子方法，子类可以重写它来初始化一些特殊的Bean。

protected void onRefresh() throws BeansException {
    // 默认实现为空
}

2.9 注册监听器

registerListeners()方法负责注册所有的事件监听器。

protected void registerListeners() {
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
}

2.10 初始化所有单例Bean

finishBeanFactoryInitialization()方法负责初始化所有非懒加载的单例Bean。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)) {
        beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class);
    }
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }
    beanFactory.setTempClassLoader(null);
    beanFactory.freezeConfiguration();
    beanFactory.preInstantiateSingletons();
}

2.11 完成刷新

finishRefresh()方法负责完成刷新过程，包括发布ContextRefreshedEvent事件。

protected void finishRefresh() {
    clearResourceCaches();
    initLifecycleProcessor();
    getLifecycleProcessor().onRefresh();
    publishEvent(new ContextRefreshedEvent(this));
    LiveBeansView.registerApplicationContext(this);
}

3. 总结

Spring的初始化过程是一个复杂的过程，涉及到多个步骤和组件的协作。通过分析refresh()方法的源码，我们可以清晰地看到Spring是如何一步步完成初始化的。理解这些步骤对于深入掌握Spring框架的工作原理至关重要。