【手撕 Spring - 深入篇】深入 IOC 的底层（让面试官瞠目结舌）

以你之姓@ 2024-05-04 08:03 81阅读 0赞

![在这里插入图片描述][120fec924ac54e2494a52ae76eba67a4.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [带你手撕 Spring][Spring]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java]

#### 文章目录 ####

*   *   *  一丶loC容器和依赖反转模式
         *  二、Ioc 容器的应用场景
         *  三、loC容器系列的设计与实现: BeanFactory和ApplicationContext
         *   *  3.1、Spring的loC容器系列
             *  3.2、Spring loC容器的设计
             *  3.3、BeanFactory的应用场景
             *  3.4、BeanFactory容器的设计原理
             *  3.5、ApplicationContext的应用场景
             *  3.6、ApplicationContext容器的设计原理

#### 一丶loC容器和依赖反转模式 ####

早在2004年，Martin Fowler就提出了“哪些方面的控制被反转了?”这个问题。他得出的结论是:依赖对象的获得被反转了。基于这个结论，他为控制反转创造了一个更好的名字:依赖注入。许多非凡的应用 (比HelloWorld,java更加优美、更加复杂)都是由两个或多个类通过彼此的合作来实现业务逻辑的，这使得每个对象都需要与其合作的对象 (也就是它所依赖的对象) 的引用。如果这个获取过程要靠自身实现，那么如你所见，这将导致代码高度耦合并且难以测试。

如果合作对象的引用或依赖关系的管理由具体对象来完成，会导致代码的高度耦合和可测试性的降低，这对复杂的面向对象系统的设计是非常不利的。在面向对象系统中，对象封装了数据和对数据的处理，对象的依赖关系常常体现在对数据和方法的依赖上。这些依赖关系可以通过把对象的依赖注入交给框架或IOC容器来完成，这种从具体对象手中交出控制的做法是非常有价值的，它可以在解耦代码的同时提高代码的可测试性。在极限编程中对单元测试和重构等实践的强调体现了在软件开发过程中对质量的承诺，这是软件项目成功的一个重要因素。

#### 二、Ioc 容器的应用场景 ####

Ioc（Inversion of Control，控制反转）容器是一种软件设计模式，它用于管理和组织应用程序中的对象依赖关系。Ioc 容器负责创建、配置和管理对象的生命周期，使开发人员能够更轻松地编写可维护和可扩展的代码。

Ioc 容器的应用场景包括：

1.  **依赖注入（Dependency Injection）**：Ioc 容器可以自动将依赖的对象注入到需要它们的地方，减少了手动管理对象之间的依赖关系的工作量。这样可以提高代码的可测试性和可复用性。
2.  **AOP（Aspect-Oriented Programming）**：Ioc 容器可以与 AOP 框架结合使用，实现横切关注点的统一管理。通过在容器中配置切面和通知，可以在不修改原始代码的情况下，实现日志记录、事务管理等横切逻辑。
3.  **插件化开发**：Ioc 容器可以用于实现插件化的开发模式。通过在容器中注册和管理插件，可以动态地扩展应用程序的功能，而无需修改主应用程序的代码。
4.  **配置管理**：Ioc 容器可以用于集中管理应用程序的配置信息。通过将配置信息放在容器中，并提供统一的访问接口，可以方便地修改和管理应用程序的配置。

Ioc 容器的应用场景非常广泛，可以提高代码的可维护性、可测试性和可扩展性，同时也可以简化开发人员的工作量。

#### 三、loC容器系列的设计与实现: BeanFactory和ApplicationContext ####

在Spring IoC容器的设计中，我们可以看到两个主要的容器系列，一个是实现BeanFactory接口的简单容器系列，这系列容器只实现了容器的最基本功能，另一个是ApplicationContext应用上下文，它作为容器的高级形态而存在。应用上下文在简单容器的基础上，增加了许多面向框架的特性，同时对应用环境作了许多适配。有了这两种基本的容器系列，基本上可以满足用户对IC容器使用的大部分需求了。下面，我们就对Spring IoC容器中这两种容器系列的设计与实现进行一个简要的分析。

##### 3.1、Spring的loC容器系列 #####

Spring框架是一个非常流行的Java开发框架，它提供了一个强大的IoC容器，被称为Spring IoC容器（或者ApplicationContext）。

Spring IoC容器的系列包括：

1.  BeanFactory：这是Spring IoC容器的基本接口，提供了最基本的IoC功能。它延迟加载Bean，当第一次请求获取Bean时才进行实例化。
2.  ApplicationContext：这是BeanFactory的一个扩展，提供了更多的功能和特性。它在应用程序启动时就实例化所有的Bean，并提供了更高级的特性，如国际化支持、事件发布、资源加载等。
3.  AnnotationConfigApplicationContext：这是基于注解的配置方式，通过扫描指定的包来自动注册和装配Bean。
4.  ClassPathXmlApplicationContext：这是基于XML配置文件的方式，通过解析XML文件来注册和装配Bean。
5.  WebApplicationContext：这是专门为Web应用程序设计的IoC容器，它继承自ApplicationContext，并提供了与Web相关的特性，如处理Web请求、管理Web会话等。

Spring IoC容器系列提供了灵活而强大的依赖注入功能，使得开发人员能够更轻松地管理和组织应用程序中的对象依赖关系。它可以帮助实现松耦合的设计，提高代码的可测试性和可维护性。

在这些Spring提供的基本IoC容器的接口定义和实现的基础上，Spring通过定义BeanDefinition来管理基于Spring的应用中的各种对象以及它们之间的相互依赖关系BeanDefinition抽象了我们对Bean的定义，是让容器起作用的主要数据类型。我们都知道在计算机世界里，所有的功能都是建立在通过数据对现实进行抽象的基础上的。IoC容器是用来管理对象依赖关系的，对IC容器来说，BeanDefinition就是对依赖反转模式中管理的对象依赖关系的数据抽象，也是容器实现依赖反转功能的核心数据结构，依赖反转功能都是围绕对这个BeanDefinition的处理来完成的。这些BeanDefinition就像是容器里装的水，有了这些基本数据，容器才能够发挥作用。

##### 3.2、Spring loC容器的设计 #####

IOC主要接口设计如下：  
![在这里插入图片描述][8cff67e0f9454523ae521978b2ab63c2.png]

*  从接口BeanFactory到HierarchicalBeanFactory，再到ConfigurableBeanFactory，是–条主要的BeanFactory设计路径。在这条接口设计路径中，BeanFactory接口定义了基本的IoC容器的规范。在这个接口定义中，包括了getBean0这样的IoC容器的基本方法通过这个方法可以从容器中取得Bean)。而HierarchicalBeanFactory接口在继承了BeanFactory的基本接口之后，增加了getParentBeanFactory()的接口功能，使BeanFactory具备了双亲IoC容器的管理功能。在接下来的ConfigurableBeanFactory接口中，主要定义了一些对BeanFactory的配置功能，比如通过setParentBeanFactory()设置双亲IoC容器，通过addBeanPostProcessor0)配置Bean后置处理器，等等。通过这些接口设计的叠加，定义了BeanFactory就是简单IoC容器的基本功能。
 *  第二条接口设计主线是，以ApplicationContext应用上下文接口为核心的接口设计，这里涉及的主要接口设计有，从BeanFactory到ListableBeanFactory，再到ApplicationContext，再到我们常用的WebApplicationContext或者ConfigurableApplicationContext接口。我们常用的应用上下文基本上都是ConfigurableApplicationContext或者WebApplicationContext的实现。在这个接口体系中，ListableBeanFactory和HierarchicalBeanFactory两个接口，连接BeanFactory接口定义和ApplicationConext应用上下文的接口定义。在ListableBeanFactory接口中，细化了许多BeanFactory的接口功能，比如定义了getBeanDefinitionNames()接口方法;对于HierarchicalBeanFactory接口，我们在前文中已经提到过，对于ApplicationContext接口，它通过继承MessageSource、ResourceLoader.ApplicationEventPublisher接口，在BeanFactory简单IoC容器的基础上添加了许多对高级容器的特性的支持。
 *  这里涉及的是主要接口关系，而具体的IoC容器都是在这个接口体系下实现的，比如DefaultListableBeanFactory，这个基本IoC容器的实现就是实现了ConfigurableBeanFactory，从而成为一个简单IoC容器的实现。像其他IoC容器，比如XmlBeanFactory，都是在DefaultListableBeanFactory的基础上做扩展，同样地ApplicationContext的实现也是如此
 *  这个接口系统是以BeanFactory和ApplicationContext为核心的。而BeanFactory又是IoC容器的最基本接口，在ApplicationContext的设计中，一方面，可以看到它继承了BeanFactory接口体系中的ListableBeanFactory、AutowireCapableBeanFactoryHierarchicalBeanFactory等BeanFactory的接口，具备了BeanFactory IoC容器的基本功能，另一方面，通过继承MessageSource、ResourceLoadr、ApplicationEventPublisher这些接口，BeanFactory为ApplicationContext赋予了更高级的IoC容器特性。对于ApplicationContext而言，为了在Web环境中使用它，还设计了WebApplicationContext接口，而这个接口通过继承ThemeSource接口来扩充功能。

##### 3.3、BeanFactory的应用场景 #####

BeanFactory中看到BeanFactory提供的是最基本的IoC容器的功能，关于这些功能定义，我们可以在接口。

BeanFactory接口定义了IoC容器最基本的形式，并且提供了IoC容器所应该遵守的最基本的服务契约，同时，这也是我们使用IOC容器所应遵守的最底层和最基本的编程规范，这些接口定义勾画出了IoC的基本轮廓。很显然，在Spring的代码实现中，BeanFactory只是一个接口类，并没有给出容器的具体实现，而我们在图2-1中看到的各种具体类，比如DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等都可以看成是容器附加了某种功能的具体实现，也就是容器体系中的具体容器产品。下面我们来看看BeanFactory是怎样定义IoC容器的基本接口的。

用户使用容器时，可以使用转义符“&”来得到FactoryBean本身，用来区分通过容器来获取FactoryBean产生的对象和获取FactoryBean本身。举例来说，如果myJndiObject是一个FactoryBean,那么使用&myJndiObject得到的是FactoryBean，而不是myJndiObject这个FactoryBean产生出来的对象。

BeanFactory接口设计了getBean方法，这个方法是使用IoC容器AP的主要方法，通过这个方法，可以取得IoC容器中管理的Bean，Bean的取得是通过指定名字来索引的。如果需要在获取Bean时对Bean的类型进行检查，BeanFactory接口定义了带有参数的getBean方法，这个方法的使用与不带参数的getBean方法类似，不同的是增加了对Bean检索的类型的要求。

用户可以通过BeanFactory接日方法中的getBean来使用Bean名字，从而在获取Bean时如果需要获取的Bean是prototype类型的，用户还可以为这个prototype类型的Bean生成指定构造函数的对应参数。这使得在一定程度上可以控制生成prototype类型的Bean。有了BeanFactory的定义，用户可以执行以下操作:

*  通过接口方法containsBean让用户能够判断容器是否含有指定名字的Bean。
 *  通过接口方法isSingleton来查询指定名字的Bean是否是Singleton类型的Bean。对于Singleton属性，用户可以在BeanDefinition中指定。
 *  通过接口方法isPrototype来查询指定名字的Bean是否是prototype类型的。与Singleton属性一样，这个属性也可以由用户在BeanDefinition中指定。
 *  通过接口方法isTypeMatch来查询指定了名字的Bean的Class类型是否是特定的CIass类型。这个Class类型可以由用户来指定
 *  通过接口方法getType来查询指定名字的Bean的Class类型
 *  通过接口方法getAliases来查询指定了名字的Bean的所有别名，这些别名都是用户在BeanDefinition中定义的。

BeanFactory 源码如下：

//
 // Source code recreated from a .class file by IntelliJ IDEA
 // (powered by FernFlower decompiler)
 //
 
 package org.springframework.beans.factory;
 
 import org.springframework.beans.BeansException;
 import org.springframework.core.ResolvableType;
 import org.springframework.lang.Nullable;
 
 public interface BeanFactory {
 
 	/**
 	 * 定义了一个常量，表示工厂Bean的前缀
 	 **/
 String FACTORY_BEAN_PREFIX = "&";
 
 	/**
 	 * 根据Bean的名称获取Bean对象
 	 **/
 Object getBean(String var1) throws BeansException;
 		
 	/**
 	 * 根据Bean的名称和类型获取Bean对象
 	 **/
 <T> T getBean(String var1, Class<T> var2) throws BeansException;
 
 	/**
 	 * 根据Bean的名称和类型获取Bean对象
 	 **/
 Object getBean(String var1, Object... var2) throws BeansException;
 	
 	/**
 	 * 根据Bean的名称和类型获取Bean对象
 	 **/
 <T> T getBean(Class<T> var1) throws BeansException;
 
 	/**
 	 * 根据Bean的名称和类型获取Bean对象
 	 **/
 <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
 
 	/**
 	 * 获取指定类型的BeanProvider
 	 **/
 <T> ObjectProvider<T> getBeanProvider(Class<T> var1);
 
 	/**
 	 * 获取指定类型的BeanProvider
 	 **/
 <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
 
 	/**
 	 * 判断是否包含指定名称的Bean
 	 **/
 boolean containsBean(String var1);
 
 	/**
 	 * 判断指定名称的Bean是否为单例模式
 	 **/
 boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
 
 	/**
 	 * 判断指定名称的Bean是否为原型模式
 	 **/
 boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
 
 	/**
 	 * 判断指定名称的Bean是否与指定类型匹配
 	 **/
 boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
 
 	/**
 	 * 判断指定名称的Bean是否与指定类类型匹配
 	 **/
 boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
 
 	/**
 	 * 获取指定名称的Bean的类型
 	 **/
 @Nullable
 Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
 
 	/**
 	 * 获取指定名称的Bean的别名数组
 	 **/
 String[] getAliases(String var1);
 }

可以看到，这里定义的只是一系列的接口方法，通过这一系列的BeanFactory接口，可以使用不同的Bean的检索方法，很方便地从IoC容器中得到需要的Bean，从而忽略具体的IoC容器的实现，从这个角度上看，这些检索方法代表的是最为基本的容器入口。

##### 3.4、BeanFactory容器的设计原理 #####

BeanFactory接口提供了使用IoC容器的规范。在这个基础上，Spring还提供了符合这个IoC容器接口的一系列容器的实现供开发人员使用。我们以 XmlBeanFactory的实现为例来说明简单IC容器的设计原理。如图2-3所示为XmlBeanFactory设计的类继承关系。  
![在这里插入图片描述][0f824d56e9674a9084a44e88953b40cc.png]

可以看到，作为一个简单IoC容器系列最底层实现的XmlBeanFactory，与我们在Spring应用中用到的那些上下文相比，有一个非常明显的特点:它只提供最基本的IC容器的功能理解这一点有助于我们理解ApplicationContext与基本的BeanFactory之间的区别和联系。我们可以认为直接的BeanFactory实现是IoC容器的基本形式，而各种ApplicationContext的实现是IoC容器的高级表现形式。

从中可以清楚地看到类之间的联系，它们都是IoC容器系列的组成部分。在设计这个容器系列时，我们可以从继承体系的发展上看到IoC容器各项功能的实现过程。如果要扩展自己的容器产品，建议读者最好在继承体系中检查下，看看Spring是不是已经提供了现成的或相近的容器实现供我们参考。下面就从我们比较熟悉的XmlBeanFactory的实现入手进行分析，来看看一个基本的IoC容器是怎样实现的。

package org.springframework.beans.factory.xml;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.core.io.Resource;
 
 /**
 * Convenience extension of {@link DefaultListableBeanFactory} that reads bean definitions
 * from an XML document. Delegates to {@link XmlBeanDefinitionReader} underneath; effectively
 * equivalent to using an XmlBeanDefinitionReader with a DefaultListableBeanFactory.
 *
 * The structure, element and attribute names of the required XML document
 * are hard-coded in this class. (Of course a transform could be run if necessary
 * to produce this format). "beans" doesn't need to be the root element of the XML
 * document: This class will parse all bean definition elements in the XML file.
 *
 * This class registers each bean definition with the {@link DefaultListableBeanFactory}
 * superclass, and relies on the latter's implementation of the {@link BeanFactory} interface.
 * It supports singletons, prototypes, and references to either of these kinds of bean.
 * See {@code "spring-beans-3.x.xsd"} (or historically, {@code "spring-beans-2.0.dtd"}) for
 * details on options and configuration style.
 *
 * For advanced needs, consider using a {@link DefaultListableBeanFactory} with
 * an {@link XmlBeanDefinitionReader}. The latter allows for reading from multiple XML
 * resources and is highly configurable in its actual XML parsing behavior.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Chris Beams
 * @since 15 April 2001
 * @see org.springframework.beans.factory.support.DefaultListableBeanFactory
 * @see XmlBeanDefinitionReader
 * @deprecated as of Spring 3.1 in favor of {@link DefaultListableBeanFactory} and
 * {@link XmlBeanDefinitionReader}
 */
 @Deprecated
 @SuppressWarnings({
 "serial", "all"})
 public class XmlBeanFactory extends DefaultListableBeanFactory {
 
 
 	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
 
 
 	/**
 	 * Create a new XmlBeanFactory with the given resource,
 	 * which must be parsable using DOM.
 	 * @param resource the XML resource to load bean definitions from
 	 * @throws BeansException in case of loading or parsing errors
 	 */
 	public XmlBeanFactory(Resource resource) throws BeansException {
 
 		this(resource, null);
 	}
 
 	/**
 	 * Create a new XmlBeanFactory with the given input stream,
 	 * which must be parsable using DOM.
 	 * @param resource the XML resource to load bean definitions from
 	 * @param parentBeanFactory parent bean factory
 	 * @throws BeansException in case of loading or parsing errors
 	 */
 	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
 
 		super(parentBeanFactory);
 		this.reader.loadBeanDefinitions(resource);
 	}
 
 }

仔细阅读XmlBeanFactory的源码，在一开始的注释里会看到对 XmlBeanFactory功能的简要说明，从代码的注释还可以看到，这是Rod Johnson在2001年就写下的代码，可见这个类应该是Spring的元老类了。XmlBeanFactory继承自DefaultListableBeanFactory这个类，后者非常重要，是我们经常要用到的一个IoC容器的实现，比如在设计应用上下文ApplicationContext时就会用到它。我们会看到这个DefaultListableBeanFactory实际上包含了基本IOC容器所具有的重要功能，也是在很多地方都会用到的容器系列中的一个基本产品。

在Spring中，实际上是把DefaultListableBeanFactory作为一个默认的功能完整的IoC容器来使用的。XmlBeanFactory在继承了DefaultListableBeanFactory容器的功能的同时，增加了新的功能，这些功能很容易从XmlBeanFactory的名字上猜到。它是一个与XML相关的BeanFactory，也就是说它是一个可以读取以XML文件方式定义的BeanDefinition的IoC容器

这些实现XML读取的功能是怎样实现的呢?对这些XML文件定义信息的处理并不是由XmlBeanFactory直接完成的。在XmlBeanFactory中，初始化了一个XmlBeanDefinitionReader对象，有了这个Reader对象，那些以XML方式定义的BeanDefinition就有了处理的地方。我们可以看到，对这些XML形式的信息的处理实际上是由这个XmlBeanDefinitionReader来完成的。

构造XmlBeanFactory这个IoC容器时，需要指定BeanDefinition的信息来源，而这个信息来源需要封装成Spring中的Resource类来给出。Resource是Spring用来封装I/0操作的类。比如我们的BeanDefinition信息是以XML文件形式存在的，那么可以使用像“ClassPath-Resourceres =new ClassPathResource(“beansxm”);”这样具体的ClassPathResource来构造需要的Resource，然后将Resource作为构造参数传递给XmlBeanFactory构造函数。这样，IoC容器就可以方便地定位到需要的BeanDefinition信息来对Bean完成容器的初始化和依赖注入过程。

XmlBeanFactory的功能是建立在DefaultListableBeanFactory这个基本容器的基础上的并在这个基本容器的基础上实现了其他诸如XML读取的附加功能。对于这些功能的实现原理，看一看XmlBeanFactory的代码实现就能很容易地理解。在XmlBeanFactory构造方法中需要得到Resource对象。对XmlBeanDefinitionReader对象的初始化，以及使用这个对象来完成对loadBeanDefinitions的调用，就是这个调用启动从Resource中载入BeanDefinitions的过程，LoadBeanDefinitions同时也是IoC容器初始化的重要组成部分。

我们看到XmlBeanFactory使用了DefaultListableBeanFactory作为基类，DefaultListableBeanFactory是很重要的一个IoC实现，在其他IoC容器中，比如ApplicationContext，其实现的基本原理和XmlBeanFactory一样，也是通过持有或者扩展DefaultListableBeanFactory来获得基本的IoC容器的功能的。

参考XmlBeanFactory的实现，我们以编程的方式使用DefaultListableBeanFactory。从中我们可以看到IOC容器使用的一些基本过程。尽管我们在应用中使用IOC容器时很少会使用这样原始的方式，但是了解一下这个基本过程，对我们了解IoC容器的工作原理是非常有帮助的。因为这个编程式使用容器的过程，很清楚揭示了在IoC容器实现中的那些关键的类 (比如Resource、DefaultListableBeanFactory和BeanDefinitionReader)之间的相互关系，例如它们是如何把IOC容器的功能解耦的，又是如何结合在一起为IoC容器服务的，

ClassPathResource res = new ClassPathResource("beans.xml");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    reader.loadBeanDefinitions(res);

从 beans.xml 文件中加载Bean的定义，并将其注册到 DefaultListableBeanFactory 中。这样就可以通过 factory 对象来获取和管理这些Bean对象。 ClassPathResource 用于指定从类路径中加载资源文件， XmlBeanDefinitionReader 用于读取XML文件中的Bean定义，并将其注册到 factory 中。最后，通过调用 loadBeanDefinitions 方法来加载Bean定义。

我们就可以通过factory对象来使用 DefaultListableBeanFactory这个IoC容器了在使用IoC容器时，需要如下几个步骤:

1.  创建loC配置文件的抽象资源，这个抽象资源包含了BeanDefinition的定义信息
2.  创建一个BeanFactory，这里使用DefaultListableBeanFactory。
3.  创建一个载入BeanDefinition的读取器，这里使用XmlBeanDefinitionReader来载入XML文件形式的BeanDefinition，通过一个回调配置给BeanFactory。
4.  从定义好的资源位置读入配置信息，具体的解析过程由XmlBeanDefinitionReader来完成。完成整个载入和注册Bean定义之后，需要的IOC容器就建立起来了。这个时候就可以直接使用IoC容器了。

##### 3.5、ApplicationContext的应用场景 #####

ApplicationContext是Spring框架中的一个核心接口，它是BeanFactory的子接口。它提供了更加高级和全面的功能，用于管理和配置Spring应用程序中的Bean。

ApplicationContext的应用场景包括：

1.  **Bean的管理和获取**：ApplicationContext可以管理和获取应用程序中的Bean对象。通过ApplicationContext，我们可以根据名称、类型、参数等条件获取Bean对象，方便地进行依赖注入和组件的使用。
2.  **配置文件的加载和解析**：ApplicationContext可以加载和解析各种类型的配置文件，包括XML、注解和Java配置等。它提供了灵活的配置方式，可以根据需求选择合适的配置方式。
3.  **生命周期管理**：ApplicationContext可以管理Bean的生命周期，包括初始化和销毁。它可以在Bean实例化后执行特定的初始化方法，并在应用程序关闭时执行销毁方法，释放资源。
4.  **事件发布和监听**：ApplicationContext可以发布和监听应用程序中的事件。它提供了事件机制，可以在特定的时机发布事件，其他组件可以注册监听器来处理这些事件，实现组件之间的解耦和通信。
5.  **国际化支持**：ApplicationContext提供了国际化的支持，可以根据不同的语言环境加载相应的资源文件，实现多语言的应用程序。

##### 3.6、ApplicationContext容器的设计原理 #####

在ApplicationContext容器中，我们以常用的FileSystemXmlApplicationContext的实现为例来说明ApplicationContext容器的设计原理。

在FileSystemXmlApplicationContext的设计中，我们看到ApplicationContext应用上下文的主要功能已经在FileSystemXmlApplicationContext的基类AbstractXmlApplicationContext中实现了，在FileSystemXmlApplicationContext中，作为一个具体的应用上下文，只需要实现和它自身设计相关的两个功能。

一个功能是，如果应用直接使用FileSystemXmlApplicationContext，对于实例化这个应用上下文的支持，同时启动IoC容器的refresh()过程。这在FileSystemApplicationContext的代码实现中可以看到，代码如下：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
        
       super(parent);
       this.setConfigLocations(configLocations);
       if (refresh) {
        
           this.refresh();
       }
    }

这个refresh()过程会牵涉IC容器启动的一系列复杂操作 **（refresh 就是 ioc 源码的核心）**，同时，对于不同的容器实现这些操作都是类似的，因此在基类中将它们封装好。所以，我们在FileSystemXml的设计中看到的只是一个简单的调用。关于这个refresh0在IoC容器启动时的具体实现，是后面要分析的主要内容，这里就不详细展开了。

另一个功能是与FileSystemXmlApplicationContext设计具体相关的功能，这部分与怎样从文件系统中加载XML的Bean定义资源有关。

通过这个过程，可以为在文件系统中读取以XML形式存在的BeanDefinition做准备，因为不同的应用上下文实现对应着不同的读取BeanDefinition的方式，在FileSystemXmlApplicationContext中的实现代码如下:

protected Resource getResourceByPath(String path) {
        
        if (path != null && path.startsWith("/")) {
        
            path = path.substring(1);
        }
        return new FileSystemResource(path);
    }

这段代码的功能是根据给定的路径获取资源对象。如果路径不为空且以斜杠开头，则将斜杠去掉。然后使用去掉斜杠后的路径创建一个 FileSystemResource 对象，并返回该对象。 FileSystemResource 用于表示文件系统中的资源。

可以看到，调用这个方法，可以得到FileSystemResource的资源定位。

>  精彩专栏推荐订阅：在下方专栏??

>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[120fec924ac54e2494a52ae76eba67a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/4a60418cfed8413faa73fe81cc52ca2e.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[Java]: https://blog.csdn.net/qq_37967783/article/details/130940512
[8cff67e0f9454523ae521978b2ab63c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/d3684ee90ff144e6b14b138b0965e4b0.png
[0f824d56e9674a9084a44e88953b40cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/8d7a8928b36443b49ccf05c600990fa9.png
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center