• 首页 首页 icon
  • 工具库 工具库 icon
    • IP查询 IP查询 icon
  • 内容库 内容库 icon
    • 快讯库 快讯库 icon
    • 精品库 精品库 icon
    • 问答库 问答库 icon
  • 更多 更多 icon
    • 服务条款 服务条款 icon

Spring源码-Spring IOC

武飞扬头像
小蚂蚁技术
帮助17

觉得不错请按下图操作,掘友们,哈哈哈!!!

一:目录以及简述

前四篇Spring文章可以先阅读下哦掘友们,

学新通技术网

一. 基础知识

1.1 什么是 Spring IOC ?

IOC 不是⼀种技术,只是⼀种思想,⼀个重要的⾯向对象编程的法则,它能指导我们如何设计出松耦合、更优良的 程序。

传统应⽤程序都是由我们在类内部主动创建依赖对象,从⽽导致类与类之间⾼耦合,难于测试。

有了 IOC 容器后,把创建和查找依赖对象的控制权交给了容器,由容器进⾏注⼊组合对象,所以对象与对象之间是 松散耦合,便于测试和功能复⽤,整个体系结构更加灵活。

理解 IOC 的关键是要明确 “谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些⽅⾯反转了”,我 们浅析⼀下:

2.2 容器创建过程

在看源码之前,⾸先搞清楚 Spring IOC 容器的创建过程,然后再深⼊源码。

IOC 容器如婚姻介绍所:

学新通技术网

从婚姻介绍所的例⼦可以⼤概知道 Spring IOC 是存储、定制、管理等功能的各种定制化的 bean 对象容器,下图 是 Spring IOC 容器创建基本流程。

学新通技术网

三. 核⼼知识

3.1 相关对象

3.1.1 ApplicationContext

ApplicationContext 接⼝是 BeanFactory 的⼦接⼝,也被称为 Spring 上下⽂,与 BeanFactory ⼀样,可以加载配 置⽂件中定义的 bean,并进⾏管理。

它还加强了企业所需要的功能,如从属性⽂件中解析⽂本信息和将事件传递给所有指定的监视器,下图是 ApplicationContext 接⼝的继承关系。

学新通技术网

ApplicationContext 接⼝主要的 5 个作⽤如表所示:

学新通技术网

3.1.2 BeanDefinitionReader

// 示例
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

配置⽂件解析器,如将配置⽂件中的 bean 信息解析成对应的 BeanDefinition 对象。

学新通技术网

xml ⽂件解析使⽤是就是BeanDefinitionReader 实现类 XmlBeanDefinitionReader。

3.1.3 BeanFactoryPostProcessor

可以修改 Spring 上下⽂中 BeanDefinition 信息。

如下图 BeanFactoryPostProcessor 的⼦类 PropertySourcesPlaceholderConfigurer 的作⽤可以为数据库连接池 ${} 占位符赋值等等。

学新通技术网

3.1.4 BeanFactory

是所有 Bean 容器的根接⼝,定义了 spring 容器基本⽅法。

如使⽤ getBean(beanName,Class) 获取对象。

学新通技术网

3.2 源码核⼼流程

容器初始化的核⼼源码,都在 refresh() ⽅法中:

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //1:准备刷新上下⽂环境
        prepareRefresh();
        //2:获取初始化Bean⼯⼚
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        //3:对bean⼯⼚进⾏填充属性
        prepareBeanFactory(beanFactory);
        try {
            //4:Spring开放接⼝ 留给⼦类去实现该接⼝
            postProcessBeanFactory(beanFactory);
            //5:调⽤我们的bean⼯⼚的后置处理器
            invokeBeanFactoryPostProcessors(beanFactory);
            //6:注册我们bean后置处理器
            registerBeanPostProcessors(beanFactory);
            //7:初始化国际化资源处理器
            initMessageSource();
            //8:初始化事件多播器
            initApplicationEventMulticaster();
            //9:这个⽅法同样也是留个⼦类实现,其中springboot也是从这个⽅法进⾏tomcat的启动
            onRefresh();
            //10:把我们的事件监听器注册到多播器上
            registerListeners();
            //11:实例化所有的⾮懒加载的单实例bean
            finishBeanFactoryInitialization(beanFactory);
            //12:最后刷新容器 发布刷新事件(Spring cloud eureka也是从这⾥启动的)
            finishRefresh();
        } catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization -
                        "  
                        "cancelling refresh attempt: "   ex);
            }
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();
            // Reset 'active' flag.
            cancelRefresh(ex);
            // Propagate exception to caller.
            throw ex;
        } finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

什么,内容不够细致?那我再给⼤家上⼀个⽜逼的思维导图:

学新通技术网

四. 源码解析

下⾯主要对 refresh() 的 12 个流程进⾏讲解。

4.1 prepareRefresh()

准备刷新上下⽂环境:

protected void prepareRefresh() {
    // Switch to active.
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    if (logger.isInfoEnabled()) {
        logger.info("Refreshing "   this);
    }
    /**
     * 初始化上下⽂环境
     */
    initPropertySources();
    /**
     * ⽤来校验我们容器启动必须依赖的环境变量的值
     */
    getEnvironment().validateRequiredProperties();
    /**
     * 创建⼀个早期事件监听器对象
     */
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>
                (this.applicationListeners);
    } else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }
    /**
     * 创建⼀个容器⽤于保存早期待发布的事件集合 什么是早期事件了?
     * 就是我们的事件监听器还没有注册到事件多播器上的时候都称为早期事件
     */
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

4.2 ConfigurableListableBeanFactory()

获取初始化的 Bean 的⼯⼚:

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //刷新bean⼯⼚()
    refreshBeanFactory();
    //返回之前容器准备⼯作的时候创建的的bean⼯⼚也就是DefaultListableBeanFactory(很重要)
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for "   getDisplayName()   ": "   beanFactory);
    }
    return beanFactory;
}
protected final void refreshBeanFactory() throws IllegalStateException {
    //由于BeanFactory只能刷新⼀次,多线程情况下可能导致线程安全问题,所有使⽤cas原⼦操作来保证
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
                "GenericApplicationContext does not support multiple refresh
                attempts: just call 'refresh' once");
    }
    //指定Bean⼯⼚的序列化Id
    this.beanFactory.setSerializationId(getId());
}

4.3 prepareBeanFactory()

对 Bean ⼯⼚进⾏填充属性:

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //设置bean⼯⼚的类加载器为当前application应⽤上下⽂的加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    //为bean⼯⼚设置SPEL表达式解析器对象StandardBeanExpressionResolver
    beanFactory.setBeanExpressionResolver(new
            StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    //为我们的bean⼯⼚设置了⼀个propertyEditor属性资源编辑器对象(⽤于后⾯的给bean对象赋值使⽤)
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this,
            getEnvironment()));
    //注册ApplicationContextAwareProcessor后置处理器⽤来处理ApplicationContextAware接⼝
    的回调⽅法
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    /**
     * 当Spring将ApplicationContextAwareProcessor注册后,那么在invokeAwarelnterfaces⽅
     法中调⽤的Aware类已经不是普通的bean了 ,
     * 如ResourceLoaderAware、ApplicationEventPublisherAware、
     ApplicationContextAware等,那么当然需要在Spring做bean的依赖注⼊的时候忽略它们。
     * 这个就是ignoreDependencyInterface的作⽤
     */
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    /**
     * 注册了依赖解析,例如当注册BeanFactory.class的解析依赖后,
     * 当bean的属性注⼊的时候,⼀旦检测到属性为BeanFactory类型便会将beanFactory的实例注⼊进
     去。
     */
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,
            this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    //注册了⼀个事件监听器探测器后置处理器接⼝
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new
                LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new
                ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,
                getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,
                getEnvironment().getSystemEnvironment());
    }
}

4.4 postProcessBeanFactory()

Spring 开放接⼝留给⼦类去实现该接⼝,主要⽤来改变 BeanFactory。

⽐如给 BeanFactory 添加⼀些⾃⼰的 BeanPostProcessor(Bean的后置处理器)

4.5 invokeBeanFactoryPostProcessors()

调⽤我们的 bean ⼯⼚的后置处理器,⾥⾯逻辑⾮常复杂,需要的同学可以和我联系,有详细讲解,就不扩展了。

4.6 registerBeanPostProcessors()

注册我们 bean 后置处理器:

/**
 * 往容器中注册了我们的bean的后置处理器
 * bean的后置处理器在什么时候进⾏调⽤?在bean的⽣命周期中
 * @param beanFactory
 * @param applicationContext
 */
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext
        applicationContext) {
    //去容器中获取所有的BeanPostProcessor的bean名称
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    /**
     * beanFactory.getBeanPostProcessorCount()获取的是已经添加在beanFactory的
     beanPostProcessors集合中的
     * postProcessorNames.length beanFactory⼯⼚中BeanPostProcessor个数  1 ⼜注册了
     BeanPostProcessorChecker的后置处理器
     */
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount()   1  
            postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory,
            beanProcessorTargetCount));
    /**
     * 按照BeanPostProcessor实现的优先级接⼝来分离我们的后置处理器
     */
    //保存实现了priorityOrdered接⼝的
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    //容器内部的
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    //实现了我们ordered接⼝的
    List<String> orderedPostProcessorNames = new ArrayList<>();
    //实现了我们任何优先级的
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    //循环我们的bean定义(BeanPostProcessor)
    for (String ppName : postProcessorNames) {
        //若实现了PriorityOrdered接⼝的
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            //显示的调⽤getBean流程创建bean的后置处理器
            BeanPostProcessor pp = beanFactory.getBean(ppName,
                    BeanPostProcessor.class);
            //加⼊到集合中
            priorityOrderedPostProcessors.add(pp);
            //判断是否实现了MergedBeanDefinitionPostProcessor
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                //加⼊到集合中
                internalPostProcessors.add(pp);
            }
        }
        //判断是否实现了Ordered
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    //把实现了priorityOrdered注册到容器中
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    //处理实现Ordered的bean后置处理器
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        //显示调⽤getBean⽅法
        BeanPostProcessor pp = beanFactory.getBean(ppName,
                BeanPostProcessor.class);
        //加⼊到集合中
        orderedPostProcessors.add(pp);
        //判断是否实现了MergedBeanDefinitionPostProcessor
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            //加⼊到集合中
            internalPostProcessors.add(pp);
        }
    }
    //排序并且注册我们实现了Order接⼝的后置处理器
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    // 实例化我们所有的⾮排序接⼝的
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        //显示调⽤
        BeanPostProcessor pp = beanFactory.getBean(ppName,
                BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        //判断是否实现了MergedBeanDefinitionPostProcessor
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    //注册我们普通的没有实现任何排序接⼝的
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    //注册MergedBeanDefinitionPostProcessor类型的后置处理器
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    //注册ApplicationListenerDetector应⽤监听器探测器的后置处理器
    beanFactory.addBeanPostProcessor(new
            ApplicationListenerDetector(applicationContext));
}

4.7 initMessageSource()

初始化国际化资源处理器:

/**
 * Initialize the MessageSource.
 * Use parent's if none defined in this context.
 */
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME,
                MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof
                HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource)
                    this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent
                MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using MessageSource ["   this.messageSource   "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME,
                this.messageSource);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '"  
                    MESSAGE_SOURCE_BEAN_NAME  
                    "': using default ["   this.messageSource   "]");
        }
    }
}

4.8 initApplicationEventMulticaster()

初始化事件多播器:

/**
 * 从bean⼯⼚中获取或者直接显示的new⼀个事件多播器赋值给applicatoinContext对象的
 applicationEventMulticaster属性
 * 事件多播器采⽤典型的设计模式就是观察者模式 多播器作为的是⼀个被观察者
 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 */
protected void initApplicationEventMulticaster() {
    //获取我们的bean⼯⼚对象
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断容器中是否包含了applicationEventMulticaster事件多播器组件
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        //直接显示的调⽤我们的getBean获取出来赋值给我们的applicationContext对象
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
                        ApplicationEventMulticaster.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster ["  
                    this.applicationEventMulticaster   "]");
        }
    }
    //容器中没有的话
    else {
        //直接new⼀个
        this.applicationEventMulticaster = new
                SimpleApplicationEventMulticaster(beanFactory);
        //并且注⼊到容器中
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
                this.applicationEventMulticaster);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '"
                     
                    APPLICATION_EVENT_MULTICASTER_BEAN_NAME  
                    "': using default ["   this.applicationEventMulticaster   "]");
        }
    }
}

4.9 onRefresh()

这个⽅法很重要,同样也是留个⼦类实现,其中 Spring Boot 就是从这个⽅法进⾏ tomcat 的启动。

4.10 registerListeners()

把我们的事件监听器注册到事件多播器上:

protected void registerListeners() {
    //获取容器中所有的监听器对象
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        //把监听器挨个的注册到我们的事件多播器上去
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    //获取bean定义中的监听器对象
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class,
            true, false);
    //把监听器的名称注册到我们的事件多播器上
    for (String listenerBeanName : listenerBeanNames) {

        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    //在这⾥获取我们的早期事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        //通过多播器进⾏播发早期事件
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

如何发布事件,通过事件多播器⽅法:multicastEvent(),进⼊⽅法。

@Override
public void multicastEvent(ApplicationEvent event) {
    multicastEvent(event, resolveDefaultEventType(event));
}
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType
        eventType) {

    ResolvableType type = (eventType != null ? eventType :
            resolveDefaultEventType(event));
    //从事件多播器中获取出所有的监听器
    for (final ApplicationListener<?> listener : getApplicationListeners(event,
            type)) {
        //判断多播器中是否⽀持异步多播的
        Executor executor = getTaskExecutor();
        if (executor != null) {
            //异步播发事件
            executor.execute(() -> invokeListener(listener, event));
        }
        else {//同步播发
            invokeListener(listener, event);
        }
    }
}
/**
 * Invoke the given listener with the given event.
 * @param listener the ApplicationListener to invoke
 * @param event the current event to propagate
 * @since 4.1
 */
protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent
        event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            doInvokeListener(listener, event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        doInvokeListener(listener, event);
    }
}

doInvokeListener() ⽅法,Spring有⼀个特点,涉及到以 do 开头的⽅法都是真正⼲活的。

@SuppressWarnings({"rawtypes", "unchecked"})
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
    try {
        listener.onApplicationEvent(event);
    }
    catch (ClassCastException ex) {
        String msg = ex.getMessage();

        if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
            // Possibly a lambda-defined listener which we could not resolve the generic
            event type for
            // -> let's suppress the exception and just log a debug message.
            Log logger = LogFactory.getLog(getClass());
            if (logger.isTraceEnabled()) {
                logger.trace("Non-matching event type for listener: "   listener, ex);
            }
        }
        else {
            throw ex;
        }
    }
}

4.11 finishBeanFactoryInitialization()

实例化所有的⾮懒加载的单实例 bean,我们前⼏篇源码,其实都是讲的⾥⾯的⽅法,最重要的就是 getBean()。 这个⽅法必须掌握,可以查看我的前⼏篇源码系列⽂章

4.12 finishRefresh()

最后刷新容器发布刷新事件(Spring cloud eureka 也是从这⾥启动的)。

protected void finishRefresh() {
    //初始化⽣命周期处理器
    initLifecycleProcessor();
    //调⽤⽣命周期处理器的onRefresh⽅法
    getLifecycleProcessor().onRefresh();
    //发布ContextRefreshedEvent事件
    publishEvent(new ContextRefreshedEvent(this));
    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}

(1) 初始化⽣命周期处理器:initLifecycleProcessor() ⽅法。

protected void initLifecycleProcessor() {
    //获取beanFactory⼯⼚
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断容器中是否有lifecycleProcessor,有就直接从容器中拿
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        this.lifecycleProcessor =
                beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME,
                        LifecycleProcessor.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using LifecycleProcessor ["   this.lifecycleProcessor  
                    "]");
        }
    }
    //没有创建⼀个DefaultLifecycleProcessor,然后注册到容器中
    else {
        DefaultLifecycleProcessor defaultProcessor = new
                DefaultLifecycleProcessor();
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME,
                this.lifecycleProcessor);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate LifecycleProcessor with name '"  
                    LIFECYCLE_PROCESSOR_BEAN_NAME  
                    "': using default ["   this.lifecycleProcessor   "]");
        }
    }
}

(2) 调⽤⽣命周期处理器的 getLifecycleProcessor().onRefresh() ⽅法。

@Override
public void onRefresh() {
    startBeans(true);
    this.running = true;
}

startBeans(true) ⽅法,主要的功能是找到 Spring 容器的 Lifecycle 类型的 Bean,然后调⽤ start() 去启动。

private void startBeans(boolean autoStartupOnly) {
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
    for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet())
    {
        Lifecycle bean = entry.getValue();
        if (!autoStartupOnly || (bean instanceof SmartLifecycle &&
                ((SmartLifecycle) bean).isAutoStartup())) {
            int phase = getPhase(bean);
            LifecycleGroup group = phases.get(phase);
            if (group == null) {
                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase,
                        lifecycleBeans, autoStartupOnly);
                phases.put(phase, group);
            }
            group.add(entry.getKey(), bean);
        }
    }
    if (!phases.isEmpty()) {
        List<Integer> keys = new ArrayList<Integer>(phases.keySet());
        Collections.sort(keys);
        for (Integer key : keys) {
            phases.get(key).start();
        }
    }
}

phases.get(key).start() ⽅法。

public void start() {
    if (this.members.isEmpty()) {
        return;
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Starting beans in phase "   this.phase);
    }
    Collections.sort(this.members);
    for (LifecycleGroupMember member : this.members) {
        doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
    }
}
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName,
                     boolean autoStartupOnly) {
    Lifecycle bean = lifecycleBeans.remove(beanName);
    if (bean != null && bean != this) {
        String[] dependenciesForBean =
                getBeanFactory().getDependenciesForBean(beanName);
        for (String dependency : dependenciesForBean) {
            doStart(lifecycleBeans, dependency, autoStartupOnly);
        }
        //bean不在运⾏中并且(autoStartupOnly=false 或者 不是SmartLifecycle类型 或者
        isAutoStartup() = true)
        if (!bean.isRunning() &&
                (!autoStartupOnly || !(bean instanceof SmartLifecycle) ||
                        ((SmartLifecycle) bean).isAutoStartup())) {
            if (logger.isDebugEnabled()) {
                logger.debug("Starting bean '"   beanName   "' of type ["  
                        bean.getClass().getName()   "]");
            }
            try {
                //调⽤⽣命周期Lifecycle Bean的start()⽅法
                bean.start();
            }
            catch (Throwable ex) {
                throw new ApplicationContextException("Failed to start bean '"  
                        beanName   "'", ex);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Successfully started bean '"   beanName   "'");
            }
        }
    }
}

(3) 发布 ContextRefreshedEvent 事件:主要就是调⽤前⾯第⼋步创建的事件多播器的发布事件⽅法。

protected void publishEvent(Object event, ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");
    if (logger.isTraceEnabled()) {
        logger.trace("Publishing event in "   getDisplayName()   ": "   event);
    }
    // Decorate event as an ApplicationEvent if necessary
    ApplicationEvent applicationEvent;
    if (event instanceof ApplicationEvent) {
        applicationEvent = (ApplicationEvent) event;
    }
    else {
        applicationEvent = new PayloadApplicationEvent<Object>(this, event);
        if (eventType == null) {
            eventType = ((PayloadApplicationEvent)
                    applicationEvent).getResolvableType();
        }
    }
    // Multicast right now if possible - or lazily once the multicaster is
    initialized
    if (this.earlyApplicationEvents != null) {
        this.earlyApplicationEvents.add(applicationEvent);
    }
    else {
        getApplicationEventMulticaster().multicastEvent(applicationEvent,
                eventType);
    }
    // Publish event via parent context as well...
    if (this.parent != null) {
        if (this.parent instanceof AbstractApplicationContext) {
            ((AbstractApplicationContext) this.parent).publishEvent(event,
                    eventType);
        }
        else {
            this.parent.publishEvent(event);
        }
    }
}

五:总要有总结

总结⼀下本⽂内容:

  • 讲述了 IOC 的基础知识,并通过婚介所的示例,讲解容器的创建过程;
  • 介绍容器创建的 4 个相关对象,以及 refresh() 的主流程;
  • 给出 refresh() 的 12 个主流程的核⼼源码,并附上详细注释。

⼤家主要看 IOC 容器创建的思想和过程,以及 refresh() 的 12 个主流程即可,⾄于⾥⾯每⼀步流程,如果深究下去,内容⾮常非常多,而且有的很有细节,后续如果需要,可以继续深⼊学习。

⾄此,我的源码系列总结全部结束了,建议下掘友们如果有时间⾃⼰动⼿运⾏debug下,这样印象会更加深刻。

这篇好文章是转载于:学新通技术网

  • 版权申明: 本站部分内容来自互联网,仅供学习及演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系,请提供相关证据及您的身份证明,我们将在收到邮件后48小时内删除。
  • 本站站名: 学新通技术网
  • 本文地址: /boutique/detail/tanffhib
系列文章
更多 icon
同类精品
更多 icon
继续加载