暗中观察

Spring之IOC源码解析
一、原理剖析1IoC（Inversion of Control）是一种软件设计原则，它体现了控制反转的思想。传统的...
扫描右侧二维码阅读全文
19
2023/04

Spring之IOC源码解析

  1.  Home
  2. Text  
    3. Share to：

一、原理剖析1

IoC（Inversion of Control）是一种软件设计原则，它体现了控制反转的思想。传统的程序设计中，对象之间的依赖关系由开发者在代码中直接管理，即对象自己创建和管理它所依赖的对象。而在IoC的思想下，控制权被反转，对象的创建和管理由容器来负责，对象只需要声明它所依赖的其他对象，容器会自动注入这些依赖。

IoC的核心思想是将对象之间的依赖关系交给容器来管理，通过配置文件或注解等方式告诉容器哪些对象需要被创建和注入，容器会根据配置信息自动创建对象，并将依赖注入到相应的位置。这样可以降低对象之间的耦合度，提高代码的可维护性和可扩展性。

IOC(Inversion of Control，控制倒转)，意思是对象之间的关系不再由传统的程序来控制，而是由spring容器来统一控制这些对象创建、协调、销毁，而对象只需要完成业务逻辑即可。IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

什么是IoC容器
IoC（Inversion of Control）容器是一个软件组件，用于管理和组织应用程序中的对象和依赖关系。它实现了控制反转（Inversion of Control）的概念，即将对象的创建和依赖关系的管理交给容器来完成，而不是由开发人员手动管理。

通过使用IoC容器，开发者可以将关注点从对象的创建和依赖管理中解脱出来，更专注于业务逻辑的实现。同时，IoC容器也提供了更灵活的配置方式，可以根据不同的环境和需求进行配置，使系统更易于扩展和维护。

IoC容器的主要功能包括：

对象的实例化和生命周期管理： IoC容器负责创建对象的实例，并管理对象的生命周期，包括对象的初始化、依赖注入和销毁等操作。
依赖关系的管理： IoC容器负责管理对象之间的依赖关系，通过依赖注入的方式将依赖的对象注入到目标对象中。
配置的集中管理： IoC容器通过配置文件或注解等方式，集中管理应用程序中的各种配置信息，包括对象的创建方式、依赖关系的配置等。
AOP（Aspect-Oriented Programming）的支持： IoC容器通常也提供了对AOP的支持，可以通过配置方式实现横切关注点的管理。
在Spring框架中，IoC容器被称为ApplicationContext，它是Spring框架的核心部分。通过配置文件或注解等方式，开发人员可以将对象的创建和依赖关系的管理交给Spring容器来完成，从而实现松耦合、可维护和可测试的应用程序。

BeanFactory与ApplicationContext
　　BeanFactory是Spring里面最底层的接口，包含了各种Bean的定义，Spring 使用 BeanFactory 来实例化、配置和管理 Bean。BeanFactory 只能管理单例（Singleton）Bean 的生命周期。它不能管理原型(prototype,非单例)Bean 的生命周期。这是因为原型 Bean 实例被创建之后便被传给了客户端,容器失去了对它们的引用。

1.BeanFactory
BeanFactory是Spring Framework提供的一个接口，它是Spring容器的基础接口。BeanFactory接口定义了Spring容器中Bean对象的基本操作，例如获取Bean对象、销毁Bean对象等。BeanFactory接口的实现类包括：DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等。

BeanFactory接口定义了以下方法：

getBean(String name)：根据Bean的名称获取Bean对象。
getBean(String name, Class<T> requiredType)：根据Bean的名称和类型获取Bean对象。
getBean(Class<T> requiredType)：根据类型获取Bean对象。
containsBean(String name)：判断容器中是否包含指定名称的Bean对象。
isSingleton(String name)：判断指定名称的Bean对象是否为单例。
isPrototype(String name)：判断指定名称的Bean对象是否为原型。
destroyBean(Object bean)：销毁指定的Bean对象。
destroy()：销毁容器中的所有Bean对象。
BeanFactory接口的实现类可以通过ApplicationContext接口来获取，例如：

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

在这个例子中，通过ClassPathXmlApplicationContext类创建了一个Spring容器，并通过getBeanFactory()方法获取了该容器的BeanFactory实现类。

BeanFactory接口是Spring Framework中最基本的容器接口，它提供了获取Bean对象、销毁Bean对象等最基本的操作。开发人员可以使用BeanFactory接口来手动创建和管理Bean对象。但是，BeanFactory接口相对较为底层，使用起来比较繁琐，需要手动进行Bean对象的管理和依赖注入等操作。

通常情况下，开发人员更倾向于使用BeanFactory接口的子接口，例如ApplicationContext接口或ListableBeanFactory接口。这些接口提供了更加便捷的Bean管理和依赖注入功能，可以大大提高开发效率。

2.ListableBeanFactory
ListableBeanFactory是Spring Framework提供的一个接口，它继承了BeanFactory接口，并添加了一些额外的方法，用于获取容器中的Bean对象。ListableBeanFactory接口定义了以下方法：

getBeanDefinitionCount()：获取容器中Bean定义的数量。
getBeanDefinitionNames()：获取容器中所有Bean定义的名称。
getBeanNamesForType()：获取指定类型的所有Bean定义的名称。
getBeansOfType()：获取指定类型的所有Bean对象。
getBeanNamesForAnnotation()：获取被指定注解标注的所有Bean定义的名称。
getBeansWithAnnotation()：获取被指定注解标注的所有Bean对象。
ListableBeanFactory接口的实现类可以通过ApplicationContext接口来获取，例如：

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

在这个例子中，通过ClassPathXmlApplicationContext类创建了一个Spring容器，并通过getBeanFactory()方法获取了该容器的ListableBeanFactory实现类。

ListableBeanFactory接口提供了一些方便的方法，可以用于检查和获取容器中的Bean对象。例如，getBeanDefinitionNames()方法可以获取容器中所有Bean定义的名称；getBeansOfType()方法可以获取指定类型的所有Bean对象。这些方法可以帮助开发人员对容器中的Bean对象进行统计、查询和管理。

需要注意的是，ListableBeanFactory接口并不是BeanFactory接口的替代品，它只是对BeanFactory接口进行了扩展。 在实际开发中，开发人员可以根据需要选择使用BeanFactory接口或ListableBeanFactory接口。如果需要获取容器中的所有Bean对象，或者需要根据类型或注解查询Bean对象，就应该使用ListableBeanFactory接口。

3.HierarchicalBeanFactory
HierarchicalBeanFactory是Spring Framework提供的一个接口，它继承了BeanFactory接口，并添加了一些额外的方法，用于处理父子容器之间的Bean对象关系。HierarchicalBeanFactory接口的实现类包括：DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等。

HierarchicalBeanFactory接口定义了以下方法：

getParentBeanFactory()：获取当前容器的父容器。
containsLocalBean(String name)：判断当前容器是否包含指定名称的Bean对象。
getBean(String name, Class<T> requiredType, Object[] args)：根据名称、类型和构造参数获取Bean对象。
getParent()：获取当前容器的父容器。
containsBean(String name)：判断当前容器及其父容器中是否包含指定名称的Bean对象。
HierarchicalBeanFactory接口的实现类可以通过ApplicationContext接口来获取，例如：

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

在这个例子中，通过ClassPathXmlApplicationContext类创建了一个Spring容器，并通过getBeanFactory()方法获取了该容器的BeanFactory实现类，然后将其转换为HierarchicalBeanFactory接口类型。

HierarchicalBeanFactory接口是BeanFactory接口的扩展，它可以处理父子容器之间的Bean对象关系。在Spring Framework中，可以使用父子容器来实现Bean对象的层次结构，从而更好地管理Bean对象和依赖关系。HierarchicalBeanFactory接口提供了一些方法，可以用于获取父容器、判断容器中是否包含指定名称的Bean对象等操作，方便开发人员进行容器的管理和维护。

需要注意的是，HierarchicalBeanFactory接口并不是所有Spring容器都支持的接口。只有一些特定的容器，例如XmlBeanFactory和ApplicationContext等，才支持HierarchicalBeanFactory接口。如果需要使用HierarchicalBeanFactory接口的功能，需要使用支持该接口的容器。

4.ApplicationContext
ApplicationContext是Spring Framework提供的一个接口，它继承了BeanFactory接口，并添加了一些额外的功能，例如消息国际化、事件发布、资源加载等。 ApplicationContext接口的 实现类包括：ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext等。

ApplicationContext接口定义了以下方法：

getBean(String name)：根据名称获取Bean对象。
getBean(String name, Class requiredType)：根据名称和类型获取Bean对象。
getBean(Class requiredType)：根据类型获取Bean对象。
containsBean(String name)：判断容器中是否包含指定名称的Bean对象。
getApplicationName()：获取应用程序名称。
getMessage(String code, Object[] args, String defaultMessage, Locale locale)：获取国际化消息。
publishEvent(ApplicationEvent event)：发布应用程序事件。
getResource(String location)：获取资源。
ApplicationContext接口的实现类可以通过不同的方式来创建，例如通过XML配置文件、Java配置类或注解等方式。例如：

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

在这个例子中，通过ClassPathXmlApplicationContext类创建了一个Spring容器，它会读取classpath下的applicationContext.xml文件，并根据该文件中的配置创建Bean对象。

ApplicationContext接口是Spring Framework中最常用的容器接口之一，它提供了更加便捷的Bean管理和依赖注入功能，可以大大提高开发效率。ApplicationContext接口除了继承了BeanFactory接口的基本功能外，还添加了一些额外的功能，例如国际化消息、事件发布、资源加载等。开发人员可以使用ApplicationContext接口来管理和维护Bean对象，同时也可以使用它的其他功能来实现更加丰富的应用程序功能。

需要注意的是，ApplicationContext接口是BeanFactory接口的扩展，因此它也继承了BeanFactory接口的所有功能。同时，ApplicationContext接口还提供了一些额外的功能，因此它通常会被开发人员优先选择使用。

5.常用的ApplicationContext的实现类
ClassPathXmlApplicationContext（基于XML配置）
ClassPathXmlApplicationContext是Spring Framework提供的一个实现ApplicationContext接口的类，它用于从classpath中加载XML配置文件，并创建Spring容器。 ClassPathXmlApplicationContext类继承了XmlApplicationContext类，因此它也支持从文件系统、URL、字节数组等方式加载XML配置文件。

ClassPathXmlApplicationContext类的构造函数有多种重载方式，最常见的是只传入一个String类型的参数，该参数表示classpath下的XML配置文件路径。例如：

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

在这个例子中，ClassPathXmlApplicationContext类会在classpath下查找名为applicationContext.xml的XML配置文件，并根据该文件中的配置创建Spring容器。

ClassPathXmlApplicationContext类在创建Spring容器时会自动读取指定的XML配置文件，并根据文件中的配置创建Bean对象。开发人员可以在XML配置文件中定义Bean对象及其依赖关系，并使用Spring容器来管理和维护这些Bean对象。同时，ClassPathXmlApplicationContext类还提供了一些配置选项，例如是否自动刷新容器、是否启用AOP等，可以根据需要进行设置。

需要注意的是，ClassPathXmlApplicationContext类只是Spring Framework中创建容器的一种方式，开发人员可以根据需要选择不同的实现方式，例如使用AnnotationConfigApplicationContext类创建基于注解的配置容器，或使用WebApplicationContext类创建Web应用程序容器等。

AnnotationConfigApplicationContext（基于注解）
AnnotationConfigApplicationContext是Spring Framework提供的一个实现ApplicationContext接口的类，它用于基于注解的配置方式创建Spring容器。 AnnotationConfigApplicationContext类可以通过Java类来定义Bean对象及其依赖关系，而无需使用XML配置文件。

AnnotationConfigApplicationContext类的构造函数有多种重载方式，最常见的是只传入一个Class类型的参数，该参数表示使用注解配置的Java类。例如：

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

在这个例子中，AnnotationConfigApplicationContext类会读取名为AppConfig的Java类，并根据该类中的注解配置创建Spring容器。

AnnotationConfigApplicationContext类支持以下几种注解：

@Configuration：用于标注配置类，指示该类包含Bean对象的定义。
@Bean：用于标注方法，指示该方法返回一个Bean对象。
@Import：用于导入其他配置类。
AnnotationConfigApplicationContext类可以通过Java类来定义Bean对象及其依赖关系，而无需使用XML配置文件。开发人员可以在Java类中使用注解来定义Bean对象及其依赖关系，并使用AnnotationConfigApplicationContext类来创建Spring容器。AnnotationConfigApplicationContext类还提供了一些配置选项，例如是否自动刷新容器、是否启用AOP等，可以根据需要进行设置。

需要注意的是，AnnotationConfigApplicationContext类只是Spring Framework中创建容器的一种方式，开发人员可以根据需要选择不同的实现方式，例如使用ClassPathXmlApplicationContext类创建基于XML配置的容器，或使用WebApplicationContext类创建Web应用程序容器等。

二、原理剖析2

　　IOC(Inversion of Control，控制倒转)，意思是对象之间的关系不再由传统的程序来控制，而是由spring容器来统一控制这些对象创建、协调、销毁，而对象只需要完成业务逻辑即可。IOC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

BeanFactory与ApplicationContext

　　BeanFactory是Spring里面最底层的接口，包含了各种Bean的定义，Spring 使用 BeanFactory 来实例化、配置和管理 Bean。BeanFactory 只能管理单例（Singleton）Bean 的生命周期。它不能管理原型(prototype,非单例)Bean 的生命周期。这是因为原型 Bean 实例被创建之后便被传给了客户端,容器失去了对它们的引用。

1034836-20210224230057380-2101217900.png

　　ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：
继承MessageSource，因此支持国际化。
统一的资源文件访问方式。
提供在监听器中注册bean的事件。
同时加载多个配置文件。
载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。
　　与 BeanFactory 懒加载的方式不同，它是预加载，所以，每一个 bean 都在 ApplicationContext 启动之后实例化

容器初始化分析

　　在SpringBoot（一）原理剖析：SpringApplication启动原理 中，分析SpringBoot启动流程时，有3个步骤与容器的创建和初始化有关，分别是createApplicationContext()、prepareContext()和refreshContext()。因此着重从这3个方法看SpringBoot如何初始化IOC容器。

　　creatApplicationContext

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }

ConfigurableApplicationContext

this.applicationContextClass由SpringApplicationBuilder类中的contextClass()方法赋值的，默认为空；
webApplicationType变量是SpringApplication.run()方法调用构造方法时赋值的，本项目中是SERVLET，生成的容器是AnnotationConfigServletWebServerApplicationContext
通过BeanUtils工具类将获取到的容器类转换成ConfigurableApplicationContext类的实例，返回给应用使用

prepareContext

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
            SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        postProcessApplicationContext(context);
        applyInitializers(context);
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
        // Add boot specific singleton beans
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) beanFactory)
                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // Load the sources
        Set<Object> sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[0]));
        listeners.contextLoaded(context);
    }

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        if (this.beanNameGenerator != null) {
            context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                    this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            if (context instanceof GenericApplicationContext) {
                ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
            }
            if (context instanceof DefaultResourceLoader) {
                ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
            }
        }
        if (this.addConversionService) {
            context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());
        }
    }

protected void load(ApplicationContext context, Object[] sources) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
        }
        BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
        if (this.beanNameGenerator != null) {
            loader.setBeanNameGenerator(this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            loader.setResourceLoader(this.resourceLoader);
        }
        if (this.environment != null) {
            loader.setEnvironment(this.environment);
        }
        loader.load();
    }

1.context.setEnvironemnt：为容器设置环境，和webApplicationType有关，在本项目中为StandardServletEnvironment；
2.postProcessApplicationContext：在ApplicationContext中应用任何相关的后期处理，beanNameGenerator默认为空；
3.applyInitializers：初始化context容器
4.listeners.contextPrepared：将事件广播器注册到Spring容器中；
5.logStartupInfo：记录启动信息：[Starting App on ... with PID 2536...] ；
6.logStartupProfileInfo：记录活动配置文件信息： [No active profile set, falling back to default profiles: default]；
7.beanFactory.registerSingleton：往容器中注册指定接口实现类的单例；
8.getAllSources：启动类信息；
9.load：从上面获取的启动类注册到ApplicationContext的BeanFactory中；
10.listeners.contextLoaded：广播出ApplicationPreparedEvent事件给相应的监听器执行

refreshContext

　　采用了模板方法模式，实际是调用如下AbstractApplicationContext的refresh方法：

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                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();
            }
        }
    }

1.prepareRefresh：设置容器的状态 、初始化属性设置（应用监听器）、检查必备属性是否存在；
2.obtainFreshBeanFactory：设置beanFactory序列化id、获取beanFactory；
3.prepareBeanFactory：主要是对beanFactory做一些配置包括各种类加载器和需要忽略的依赖；
4.postProcessBeanFactory：允许上下文子类对bean工厂进行后置处理；
5.invokeBeanFactoryPostProcessors：调用BeanDefinitionRegistryPostProcessor实现向容器内添加bean的定义；
6.registerBeanPostProcessors：注册后置处理器，用于拦截bean的创建，AOP原理的的核心方法AspectJAutoProxyRegistrar.registerBeanDefinitions在此执行；
7.initMessageSource：初始化国际化相关属性；
8.initApplicationEventMulticaster：初始化事件广播器；
9.onRefresh：该方法是一个空实现，是留给子类实现的，主要内容是创建web容器；
10.registerListeners：添加容器内事件监听器至事件广播器中；
11.finishBeanFactoryInitialization：初始化所有剩下的单例bean；
12.finishRefresh：清空缓存、初始化生命周期处理器、调用化生命周期处理器onRfresh方法、发布ContextRefreshedEvent事件、JXM相关处理

ApplicationContextAware实例
　　Spring容器初始化过程中会检测容器中的所有Bean，如果发现某个Bean实现了ApplicationContextAware接口，Spring容器会在创建该Bean之后，自动调用该Bean的setApplicationContextAware()方法。调用该方法时，会将容器本身作为参数传给该方法——该方法中的实现部分将Spring传入的参数（容器本身）赋给该类对象的applicationContext实例变量，因此接下来可以通过该applicationContext实例变量来访问容器本身。

三、参考

https://blog.csdn.net/Tracycoder/article/details/131628457
https://www.cnblogs.com/ryjJava/p/14438824.html

版权属于：sunjianhua

本文链接：https://sunjianhua.cn/archives/spring-ioc.html

转载时须注明出处及本声明，如果不小心侵犯了您的权益，请联系邮箱：NTA2MTkzNjQ1QHFxLmNvbQ==

Last modification：November 29th, 2023 at 04:22 pm
© The copyright belongs to the author
If you think my article is useful to you, please feel free to appreciate

Leave a Comment