接下去说,上一次最后一个函数里面有三个函数调用,即
destroyBeans(); createBeanFactory() ; loadBeanDefinitions(beanFactory);
1.2.2.1.1 destroyBeans() : 清除当前上下文的所有 bean ,默认的实现为:清除当前上下文的所有缓存的单例 bean ,默认的实现在父类: AbstractApplicationContext ,代码为:
getBeanFactory (). destroySingletons ();
其中: getBeanFactory () 在子类 AbstractRefreshableApplicationContext 中实现,返回该类的一个
DefaultListableBeanFactory 类型的 字段 beanFactory ;
其中: destroySingletons () 定义在接口 ConfigurableBeanFactory 中,由类图发现 DefaultListableBeanFactory 实现了 ConfigurableBeanFactory 接口,该方法在其父类: DefaultSingletonBeanRegistry 里有实现。定义如下:
====================================================================
public void destroySingletons() {
if ( logger .isInfoEnabled()) {
logger .info( "Destroying singletons in " + this );
}
/** singletonObjects 为一个 MAP 对象,缓存当前的单体实例。 */
synchronized ( this . singletonObjects ) {
/**
* singletonsCurrentlyInDestruction : 我们目前是否在 destroySingletons 。
*/
this . singletonsCurrentlyInDestruction = true ;
}
/**
* disposableBeans 为一个 MAP 对象,缓存当前的一次性 bean 。
*/
synchronized ( this . disposableBeans ) {
String[] disposableBeanNames = StringUtils.toStringArray ( this . disposableBeans .keySet());
for ( int i = disposableBeanNames. length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
}
this . containedBeanMap .clear();
this . dependentBeanMap .clear();
this . dependenciesForBeanMap .clear();
synchronized ( this . singletonObjects ) {
this . singletonObjects .clear();
this . singletonFactories .clear();
this . earlySingletonObjects .clear();
this . registeredSingletons .clear();
this . singletonsCurrentlyInDestruction = false ;
}
}
====================================================================
1.2.2.1.1.1 destroySingleton(disposableBeanNames[i]) : 如果给定的 bean 存在则,销毁给定的 bean ,定义如下:
====================================================================
public void destroySingleton(String beanName) {
// 根据给定的名字删除给定 bean
// 销毁相应的一次性 bean 实例
DisposableBean disposableBean = null ;
synchronized ( this . disposableBeans ) {
disposableBean = (DisposableBean) this . disposableBeans .remove(beanName);
destroyBean(beanName, disposableBean);
}
====================================================================
1.2.2.1.1.1.1 protected void removeSingleton(String beanName) :从当前的 factory 中删除给定名字的 bean 。定义如下:
singletonObjects— 缓存单例 bean 的 map
singletonFactories— 缓存单例工厂 bean 的 map
earlySingletonObjects— 缓存早期的单例 bean 的 map
registeredSingletons— 注册的单例 bean 名字的集合,按照注册的顺序存放的 Set
====================================================================
protected void removeSingleton(String beanName) {
synchronized ( this . singletonObjects ) {
this . singletonObjects .remove(beanName);
this . singletonFactories .remove(beanName);
this . earlySingletonObjects .remove(beanName);
this . registeredSingletons .remove(beanName);
}
}
====================================================================
1.2.2.1.1.1.2 destroyBean (beanName, disposableBean); 先销毁依赖于给定 bean 的 bean ,再销毁给定的 bean 。代码如下:
====================================================================
protected void destroyBean(String beanName, DisposableBean bean) {
// 首先销毁依赖 bean
// dependentBeanMap—bean 的 name 和依赖于该 bean 的 bean 的 name 的集合的 map
Set dependencies = (Set ) this . dependentBeanMap .remove(beanName);
if (dependencies != null ) {
if ( logger .isDebugEnabled()) {
logger .debug( "Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (Iterator it = dependencies.iterator(); it.hasNext();) {
String dependentBeanName = (String) it.next();
// 递归调用
destroySingleton(dependentBeanName);
}
}
// 真正开始销毁 bean
if (bean != null ) {
try {
bean.destroy();
}
catch (Throwable ex) {
logger .error( "Destroy method on bean with name '" + beanName + "' threw an exception" , ex);
}
}
// 触发销毁包含的 bean
// containedBeanMap—bean 的 name 和该 bean 所包含的 bean 的 name 的集合的 map
Set containedBeans = (Set ) this . containedBeanMap .remove(beanName);
if (containedBeans != null ) {
for (Iterator it = containedBeans.iterator(); it.hasNext();) {
String containedBeanName = (String) it.next();
/ 递归调用
destroySingleton(containedBeanName);
}
}
// Remove destroyed bean from other beans' dependencies.
synchronized ( this . dependentBeanMap ) {
for (Iterator it = this . dependentBeanMap .entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry ) it.next();
Set dependenciesToClean = (Set ) entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// Remove destroyed bean's prepared dependency information.
// dependenciesForBeanMap—bean 的 name 和该 bean 的依赖关系的 bean 的 name 集合的 map
this . dependenciesForBeanMap .remove(beanName);
}
====================================================================
本站支持 pay for your wishes
相关推荐
### Spring源码分析_Spring_IOC:深入理解Spring的IOC容器机制 #### 基本概念与核心作用 在探讨Spring框架的核心组件之一——IOC(Inversion of Control,控制反转)容器之前,首先需要理解它在Spring框架中的角色...
Spring 框架系列(7)- Spring IOC 实现原理详解之 IOC 初始化流程 本文将详细解释 Spring 框架中的 IOC...IOC 容器的初始化流程是 Spring 框架中的关键部分,用于将资源配置文件中的信息加载到 IOC 容器中。
3、源码分析-IOC容器的初始化 4、源码分析-IOC容器的依赖注入 5、源码分析-IOC容器的高级特性 三阶段 Spring AOP的涉及原理及具体实践 SpringJDBC的涉及原理及二次开发 SpringMVC框架设计原理及手写实现 四阶段 ...
《Spring IOC容器实现分析》 在Java开发领域,Spring框架无疑是使用最为广泛的轻量级框架之一,其中的核心组件就是IOC(Inversion of Control)容器。本文将深入剖析Spring的IOC容器,理解其工作原理和重要功能,以...
根据提供的文件信息,本次解读将围绕Spring框架的核心概念与源码分析进行展开。Spring框架作为Java企业级开发中不可或缺的一部分,其源码的学习对于深入理解框架机制、提高开发效率具有重要意义。下面,我们将从以下...
通过分析BeanFactory,我们可以了解对象的创建、初始化和依赖注入过程。 - **AOP**:面向切面编程允许我们定义横切关注点,如日志记录、事务管理,然后将其模块化为可重用的组件。 - **Data Access/...
文档可能将深入探讨Spring IoC容器初始化、Bean生命周期管理、依赖注入等关键概念,并以2021年的开源版本为背景进行分析。 从提供的部分文档内容来看,我们可以提炼出以下几个知识点: 1. **BeanFactory与...
2. 提升了性能,尤其是在初始化和装配阶段,通过优化算法和减少不必要的对象创建,提高了运行效率。 3. 强化了安全特性,包括对Spring Security的升级和集成,增强了对OAuth2、JWT等身份验证和授权机制的支持。 4. ...
5. **Bean管理**:最后,容器会管理Bean的生命周期,包括初始化、使用和销毁。 在实际开发中,Spring使用了更加高效和灵活的方式来实现这些功能,比如使用`ApplicationContext`接口作为IOC容器的入口,以及`...
1. **ApplicationContext**:这是Spring的核心接口,负责初始化、加载配置文件,管理Bean的生命周期。源码中可以看到它是如何解析XML或Java配置,创建并管理Bean的。 2. **BeanFactory**:作为ApplicationContext的...
2. **Spring Beans**:实现了IoC容器,通过XML或注解方式配置bean,并负责bean的初始化、装配和销毁。 3. **Spring AOP**:面向切面编程模块,允许定义方法拦截器和切入点,实现代码的解耦和模块化。 4. **Spring ...
1. **初始化流程**:从`org.springframework.context.support.ClassPathXmlApplicationContext`或`org.springframework.web.context.ContextLoader`开始,理解如何加载配置并创建Bean定义。 2. **依赖注入**:研究`...
通过阅读和学习这些源码,开发者可以了解到Spring如何实现IoC容器、AOP代理、事件机制、任务调度等多个关键功能。同时,这也有助于开发者更好地理解和使用Spring提供的API,以及在实际项目中如何定制和扩展Spring。 ...
在深入探讨Spring框架的核心组件和工作...在分析或运行Spring源码时,确保正确引入这两个库是确保项目正常运行的关键。通过深入了解这些工具库,开发者可以更好地理解和运用Spring框架,从而提高开发效率和应用性能。
IoC容器是Spring框架的心脏,它负责管理对象的生命周期和依赖关系,使得开发者能够实现松耦合和高可测试性的应用程序。 首先,我们来理解什么是IoC。IoC,也被称为依赖注入(Dependency Injection),是一种设计...
通过XML配置文件或Java注解,我们可以定义bean的创建、初始化和销毁过程,实现依赖注入,从而降低代码的耦合度。 2. AOP:Spring的AOP模块允许开发者定义横切关注点,如日志记录、事务管理等,将这些关注点与业务...
通过配置文件或者注解,开发者可以定义对象及其依赖关系,Spring容器会自动管理这些对象的生命周期,包括实例化、初始化、装配和销毁。 **Bean** 在Spring中,业务逻辑的组件被称为Bean。Bean是Spring容器管理的...
本文将基于Spring 2.0版本的源码,深入分析Spring IOC容器的内部实现机制,帮助读者更好地理解和使用这一强大的工具。 #### 二、核心概念与术语 在深入探讨Spring IOC容器之前,我们首先需要了解几个核心的概念: ...
《简易Spring-ioc详解》 在Java开发领域,Spring框架以其强大的功能和广泛的应用而备受开发者喜爱。...此外,掌握这些核心概念后,无论是使用Spring框架还是其他类似的IoC容器,都将更加得心应手。