spring IOC:AbstractBeanFactory

最新推荐文章于 2023-05-18 17:48:57 发布
最新推荐文章于 2023-05-18 17:48:57 发布
阅读量488 收藏
点赞数
文章标签： spring ioc bean object string null

 

spring IOC:AbstractBeanFactory

接上篇 http://whoknow.javaeye.com/blog/487786
DefaultSingletonBeanRegistry可以简单的管理bean但是做为一个ioc容器来讲它的功能还远远不够。比如，在一个应用中，一些bean是始终存在的，一些则是随着当前线程的结束而结束，做为一个容器来讲，它需要可以管理整个bean的生命周期

Java代码 复制代码
  1. public   abstract   class  AbstractBeanFactory  extends  DefaultSingletonBeanRegistry  implements  ConfigurableBeanFactory {   
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements ConfigurableBeanFactory {


AbstractBeanFactory继承了DefaultSingletonBeanRegistry类，并进一步丰富了已有的功能，这个类提供了singleton/prototype的选择，单例cache,对于FactoryBean的处理，bean定义的处理以及bean 的销毁…
其中比较重要的功能是对BeanFactory中getBean方法的实现
Java代码 复制代码
  1. public  Object getBean(String name)  throws  BeansException {   
  2.          return  getBean(name,  null ,  null );   
  3.     }   
  4.            
  5.      public  Object getBean(String name, Class requiredType)  throws  BeansException {   
  6.          return  getBean(name, requiredType,  null );   
  7.     }   
  8.   
  9.      public  Object getBean(String name, Object[] args)  throws  BeansException {   
  10.          return  getBean(name,  null , args);   
  11.     }   
public Object getBean(String name) throws BeansException {
		return getBean(name, null, null);
	}
		
	public Object getBean(String name, Class requiredType) throws BeansException {
		return getBean(name, requiredType, null);
	}

	public Object getBean(String name, Object[] args) throws BeansException {
		return getBean(name, null, args);
	}


几个连续的重载，我们关心的是最后这个
Java代码 复制代码
  1. public  Object getBean(String name, Class requiredType,  final  Object[] args)  throws  BeansException {   
public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {

然后一点一点看这个方法，假如给自己这样一个问题，我们首先会做什么？这个方法打算写些什么呢？
很显然，在我们的父类DefaultSingletonBeanRegistry中，已经有了一些对于bean的操作的实现，比如getSingleton方法，让我们可以拿到一个bean,于是
Java代码 复制代码
  1. Object sharedInstance = getSingleton(beanName);   
  2. if  (sharedInstance !=  null ) {   
  3.      //一个简单的判断，先看一眼，map里是否有这个类了   
  4.      //如果有的话呢？直接返回？好像不太好，因为这个类可能是一个工厂类，所以我们还需要一个方法判断下，如果是工厂类的话，那么它应该返回一个产品   
  5.     bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);    
	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null) {
		//一个简单的判断，先看一眼，map里是否有这个类了
		//如果有的话呢？直接返回？好像不太好，因为这个类可能是一个工厂类，所以我们还需要一个方法判断下，如果是工厂类的话，那么它应该返回一个产品
		bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
}

看一下getObjectForBeanInstance这个方法
Java代码 复制代码
  1. protected  Object getObjectForBeanInstance(Object beanInstance, String name, RootBeanDefinition mbd) throws  BeansException {   
  2.   
  3.      //这里略去了很多代码，只是把最关键的几行取出   
  4.      if  (beanInstance  instanceof  FactoryBean) {     
  5.         FactoryBean factory = (FactoryBean) beanInstance;     
  6. object = getObjectFromFactoryBean(factory, beanName, mbd);     
  7. }      
  8.          return  object;   
  9.     }   
protected Object getObjectForBeanInstance(Object beanInstance, String name, RootBeanDefinition mbd)throws BeansException {

	//这里略去了很多代码，只是把最关键的几行取出
	if (beanInstance instanceof FactoryBean) {	
		FactoryBean factory = (FactoryBean) beanInstance;  
object = getObjectFromFactoryBean(factory, beanName, mbd);	
}	
		return object;
	}

那么这个getObjectFromFactoryBean方法又是？从参数来看，我们发现了一个factory，实际上在这个方法中会调用它
Java代码 复制代码
  1. object = factory.getObject();   
  2.          //之后   
  3.           return  object   
	object = factory.getObject();
         //之后
          return object


FactoryBean这个接口在DefaultSingletonBeanRegistry中的 public Object getSingleton(String beanName, ObjectFactory singletonFactory)方法中也出现过，由一个实现了FactoryBean的工厂来产生这个类

在if (sharedInstance != null) {}判断完成后，即我们当前没有这个类，接下来呢？这时该由容器将这个类实例化了，所以在}else之后
先判断是否有父容器，如果有则由父容器生产它
BeanFactory parentBeanFactory = getParentBeanFactory();
这里会调用父容器的getBean方法

如果没有则我们要创建这个类，spring在启动时首先会通过ResourceLoader读取其配置文件，然后由BeanDefinitionReader进行读取并保存到BeanDefinitionRegistry中。之后会对这些定义进行处理，这些beandefine中放置的就是xml的基本信息，如:class,scope,等等属性，结构如图：


Java代码 复制代码
  1. //得到bean的定义   
  2. final  RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName,  false );   
  3. 先拿到Bean的定义    
  4. getMergedBeanDefinition：还是先检查是否有父容器，有就调用父容器的getMergedBeanDefinition方法，没有调用当前的   
  5. protected  RootBeanDefinition getMergedBeanDefinition(String name,  boolean  includingAncestors)   
  6.          throws  BeansException {   
  7.         String beanName = transformedBeanName(name);   
  8.          if  (includingAncestors && !containsBeanDefinition(beanName) &&   
  9.                 getParentBeanFactory()  instanceof  AbstractBeanFactory) {   
  10.              return  ((AbstractBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName,  true );   
  11.         }   
  12.          return  getMergedBeanDefinition(beanName, getBeanDefinition(beanName));   
  13.     }   
//得到bean的定义
final RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
先拿到Bean的定义 
getMergedBeanDefinition：还是先检查是否有父容器，有就调用父容器的getMergedBeanDefinition方法，没有调用当前的
protected RootBeanDefinition getMergedBeanDefinition(String name, boolean includingAncestors)
	    throws BeansException {
		String beanName = transformedBeanName(name);
		if (includingAncestors && !containsBeanDefinition(beanName) &&
				getParentBeanFactory() instanceof AbstractBeanFactory) {
			return ((AbstractBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName, true);
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}

那么getMergedBeanDefinition中呢？这里主要就是拿到它的rootbean,如果是children则调用cbd.getParentName()方法最后返回root的定义.

这里return getMergedBeanDefinition(beanName,getBeanDefinition(beanName));
getBeanDefinition是一个抽象方法
protected abstract BeanDefinition getBeanDefinition(String beanName)
由具体的子类来实现.

一个类一个责任，AbstractBeanFactory的主要职责是bean的管理，其它职责由其子类完成，如：createBean, postProcessObjectFromFactoryBean, getBeanDefinition
Spring的设计清晰易读，很大程度上都是由于类的职责划分清晰造成的。BeanFactory 是一个基本的描述，接下来我们希望这个容器可以实现上下文关系，对一个类最简单的一些操作，所以就有了SingletonBeanRegistry，HierarchicalBeanFactory接口。然后再层层向下，通过接口描述主要的组件功能，具体类进行实现

拿到这个bean的定义后，就可以实例化它了
如果是一个单例：
Java代码 复制代码
  1.      if  (mergedBeanDefinition.isSingleton()) {   
  2.         sharedInstance = getSingleton(beanName,  new  ObjectFactory() {   
  3.              public  Object getObject()  throws  BeansException {   
  4.                  try  {   
  5.                  //createBean由其子类AbstractAutowireCapableBeanFactory来实现   
  6.                  return  createBean(beanName, mergedBeanDefinition, args);   
  7.                         }   
  8.                          catch  (BeansException ex) {   
  9.                             destroySingleton(beanName);   
  10.                              throw  ex;   
  11.                         }   
  12.                     }   
  13.                 });   
  14.                  //这里再次判断，如果该类是一个工厂则调用其getObject()方法   
  15. bean = getObjectForBeanInstance(sharedInstance, name,mergedBeanDefinition);   
  16.             }   
	if (mergedBeanDefinition.isSingleton()) {
		sharedInstance = getSingleton(beanName, new ObjectFactory() {
			public Object getObject() throws BeansException {
				try {
				//createBean由其子类AbstractAutowireCapableBeanFactory来实现
				return createBean(beanName, mergedBeanDefinition, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					}
				});
				//这里再次判断，如果该类是一个工厂则调用其getObject()方法
bean = getObjectForBeanInstance(sharedInstance, name,mergedBeanDefinition);
			}


这里使用了一个回调方法，在父类的DefaultSingletonBeanRegistry中的public Object getSingleton(String beanName, ObjectFactory singletonFactory) 需要一个ObjectFactory，我们用一个匿名类写入方法，并调用其子类的createBean方法，在这里createBean是AbstractBeanFactory的抽象方法

如果是Prototype的话：
Java代码 复制代码
  1. if  (mergedBeanDefinition.isPrototype()) {   
  2.                 Object prototypeInstance =  null ;   
  3.                  try  {   
  4.                     beforePrototypeCreation(beanName);   
  5.                     prototypeInstance = createBean(beanName, mergedBeanDefinition, args);   
  6.                 }   
  7.                  finally  {   
  8.                     afterPrototypeCreation(beanName);   
  9.                 }   
  10.                  // 又判断它是不是工厂类   
  11.                 bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);   
  12.             }   
if (mergedBeanDefinition.isPrototype()) {
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				// 又判断它是不是工厂类
				bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
			}


最后如果既不是Singleton也不是Prototype时，首先拿它的scope
Java代码 复制代码
  1. String scopeName = mergedBeanDefinition.getScope();   
  2.                  final  Scope scope = (Scope)  this .scopes.get(scopeName);   
  3.                 …   
  4.                  try  {   
  5.                 scope的get回调方法得到实例   
  6.                     Object scopedInstance = scope.get(beanName,  new  ObjectFactory() {   
  7.                          public  Object getObject()  throws  BeansException {   
  8.                             beforePrototypeCreation(beanName);   
  9.                              try  {   
  10.                                 Object bean = createBean(beanName, mergedBeanDefinition, args);   
  11.                                  if  (requiresDestruction(bean, mergedBeanDefinition)) {   
  12.                                     scope.registerDestructionCallback(beanName,   
  13.                                              new  DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));   
  14.                                 }   
  15.                                  return  bean;   
  16.                             }   
  17.                              finally  {   
  18.                                 afterPrototypeCreation(beanName);   
  19.                             }   
  20.                         }   
  21.                     });   
  22.                     bean = getObjectForBeanInstance(scopedInstance, name, mergedBeanDefinition);   
  23.                 }   
  24.                  catch  (IllegalStateException ex) {   
  25.                      throw   new  BeanCreationException(beanName,  "Scope '"  + scopeName +  "' is not active" , ex);   
  26.                 }   
String scopeName = mergedBeanDefinition.getScope();
				final Scope scope = (Scope) this.scopes.get(scopeName);
				…
				try {
				scope的get回调方法得到实例
					Object scopedInstance = scope.get(beanName, new ObjectFactory() {
						public Object getObject() throws BeansException {
							beforePrototypeCreation(beanName);
							try {
								Object bean = createBean(beanName, mergedBeanDefinition, args);
								if (requiresDestruction(bean, mergedBeanDefinition)) {
									scope.registerDestructionCallback(beanName,
											new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
								}
								return bean;
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						}
					});
					bean = getObjectForBeanInstance(scopedInstance, name, mergedBeanDefinition);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active", ex);
				}


这里有一行代码
Java代码 复制代码
  1. scope.registerDestructionCallback(beanName,   
  2.                                              new  DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));   
scope.registerDestructionCallback(beanName,
											new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));


注册它的销毁方法
Java代码 复制代码
  1. public   void  registerDestructionCallback(String name, Runnable callback) {   
  2.         RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();   
  3.         attributes.registerDestructionCallback(name, callback, getScope());   
  4.     }   
public void registerDestructionCallback(String name, Runnable callback) {
		RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
		attributes.registerDestructionCallback(name, callback, getScope());
	}

在这里首先通过RequestContextHolder得到当前的RequestAttributes。在RequestContextHolder中requestAttributesHolder 为ThreadLocal
之后在ServletRequestAttributes注册其回调销毁方法最后
Java代码 复制代码
  1. private   void  executeRequestDestructionCallbacks() {   
  2.          for  (Iterator it =  this .requestDestructionCallbacks.values().iterator(); it.hasNext();) {   
  3.             ((Runnable) it.next()).run();   
  4.         }   
  5. }   
private void executeRequestDestructionCallbacks() {
		for (Iterator it = this.requestDestructionCallbacks.values().iterator(); it.hasNext();) {
			((Runnable) it.next()).run();
		}
}


可以看到在DisposableBeanAdapter中
Java代码 复制代码
  1. public   void  run() {   
  2.         destroy();   
  3.     }   
public void run() {
		destroy();
	}

首先beanPostProcessors执行所有的DestructionAwareBeanPostProcessor，最后在最后执行invokeCustomDestroyMethod();所以客户定义的销毁方式是在最后的
Java代码 复制代码
  1. public   void  destroy() {   
  2.      if  ( this .beanPostProcessors !=  null ) {   
  3.          if  (logger.isDebugEnabled()) {   
  4.             logger.debug( "Applying DestructionAwareBeanPostProcessors to bean with name '"  +  this .beanName +  "'" );   
  5.         }   
  6.          for  ( int  i =  this .beanPostProcessors.size() -  1 ; i >=  0 ; i--) {   
  7.             Object beanProcessor =  this .beanPostProcessors.get(i);   
  8.              if  (beanProcessor  instanceof  DestructionAwareBeanPostProcessor) {   
  9.                 ((DestructionAwareBeanPostProcessor) beanProcessor).postProcessBeforeDestruction( this .bean,  this .beanName);   
  10.             }   
  11.         }   
  12.     }   
  13.   
  14.      if  ( this .bean  instanceof  DisposableBean) {   
  15.          if  (logger.isDebugEnabled()) {   
  16.             logger.debug( "Invoking destroy() on bean with name '"  +  this .beanName +  "'" );   
  17.         }   
  18.          try  {   
  19.             ((DisposableBean)  this .bean).destroy();   
  20.         }   
  21.          catch  (Throwable ex) {   
  22.             logger.error( "Couldn't invoke destroy method of bean with name '"  +  this .beanName +  "'" , ex);   
  23.         }   
  24.     }   
  25.   
  26.      if  ( this .mergedBeanDefinition !=  null ) {   
  27.         invokeCustomDestroyMethod();   
  28.     }   
  29. }  
	public void destroy() {
		if (this.beanPostProcessors != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Applying DestructionAwareBeanPostProcessors to bean with name '" + this.beanName + "'");
			}
			for (int i = this.beanPostProcessors.size() - 1; i >= 0; i--) {
				Object beanProcessor = this.beanPostProcessors.get(i);
				if (beanProcessor instanceof DestructionAwareBeanPostProcessor) {
					((DestructionAwareBeanPostProcessor) beanProcessor).postProcessBeforeDestruction(this.bean, this.beanName);
				}
			}
		}

		if (this.bean instanceof DisposableBean) {
			if (logger.isDebugEnabled()) {
				logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'");
			}
			try {
				((DisposableBean) this.bean).destroy();
			}
			catch (Throwable ex) {
				logger.error("Couldn't invoke destroy method of bean with name '" + this.beanName + "'", ex);
			}
		}

		if (this.mergedBeanDefinition != null) {
			invokeCustomDestroyMethod();
		}
	}
stairway2b612
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring源码分析：AbstractBeanFactory抽象实现分析
技术园
03-03 538
Spring源码分析：AbstractBeanFactory抽象实现分析1、AbstractBeanFactory概览1.1 AliasRegistry接口分析1.2 SingletonBeanRegistry接口分析2、AbstractBeanFactory源码实现2.1 SimpleAliasRegistry源码2.2 DefaultSingletonBeanRegistry源码2.3 FactoryBeanRegistrySupport源码2.4 AbstractBeanFactory源码 1、Abs
Spring IoC之AbstractBeanFactory
Herishwater的博客
01-06 928
文章目录获取 beanName缓存中获取单例bean原型模式依赖检查与 parentBeanFactory类型检查与依赖处理各 scope 的 bean 创建singleton原型模式其他作用域 AbstractBeanFactory 实现了依赖关系处理，它 继承了 DefaultSingletonBeanRegistry 类，并进一步丰富了已有的功能，这个类提供了 singleton/proto...
AbstractBeanFactory
qq_44587855的博客
05-12 310
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch) throws CannotLoadBeanClassException { try { if (mbd.hasBeanClass()) { return mbd.getBe...
AbstractBeanFactory 抽象bean工厂
如来#俏,米勒#笑 的博客
03-23 607
抽象工厂Bean，承上启下，定义架构 package com.geely.online.testdriver; import java.beans.PropertyEditor; import java.security.AccessControlContext; import java.security.AccessController; import java.security.PrivilegedAction; import java.security.PrivilegedActio.
深入解析Spring IoC：源码与实践指南
最新发布
12-13
Spring框架的核心在于其强大的IoC（控制反转）机制，该机制为Java应用提供了一种优雅的依赖注入方式。本文深入探讨了Spring IoC容器的加载过程及其源码实现，揭示了Spring中最为根本的概念之一。这包括从...
SpringIOC:springIOC的简单实现
04-30
springIOC的简单实现
SpringIOC：SpringIOC临时二进制简单实现
02-15
SpringIOC：SpringIOC临时二进制简单实现
spring_IoC:Spring IoC 演示
07-11
Spring IoC 演示
simple-springioc:这是一个简单的SpringIOC
05-11
simple-springioc This is a simple spring IOC. 参考资料：
Spring AbstractBeanFactory
demon7552003的小本本
12-21 460
目录 AbstractBeanFactory的作用 源码解析 属性 获取bean实例 Spring BeanFactory Spring AbstractBeanFactory Spring AbstractAutowireCapableBeanFactory Spring DefaultListableBeanFactory AbstractBeanFactory的...
源码解析：深入Spring中的BeanFactory
一名Java语言狂热分子。
05-18 963
如果你曾经接触过Java开发，那么您一定会很熟悉Spring框架。作为Java社区最流行的企业级开发框架之一，Spring提供了各种各样的功能和工具，可以帮助开发人员更快、更高效地构建稳健和可扩展的应用程序。在Spring框架中，BeanFactory是一个非常重要的组件，它负责管理和维护应用程序中所有的Bean对象。本文将介绍BeanFactory的概述，数据结构和源代码解析，以帮助您深入理解Spring框架的核心原理。
Spring IOC学习（4）——AbstractBeanFactory
Rylynn_plus的博客
01-14 183
AbstractBeanFactory：单例对象管理能力+可配置；获取bean的总体流程在doGetBean已经成型
IOC之AbstractBeanFactory源码详解
juziding的博客
03-14 216
AbstractBeanFactory源码 定义 //父类容器 parentBeanFactory //类加载器 beanClassLoader //临时加载器 tempClassLoader //bean元数据缓存 cacheBeanMetadata //bean的表达式解析器 beanExpressionResolver //类型转换器 conversionService //属性编辑器 propertyEditorRegistrars //类的属性编辑器 customEditors //类型转换器
Spring源码解读（四）Bean创建过程之加载——AbstractBeanFactory
lishuzhen5678的博客
02-23 842
前言 上文 Spring源码解读（三）Bean...
SpringMVC对异步请求的支持
IT搬砖工在路上
08-19 422
目录工具类 WebAsyncUtilsStandardServletAsyncWebRequest接下来看下它的抽象实现类：AbstractRequestAttributesServletRequestAttributesServletWebRequestStandardServletAsyncWebRequestWebAsyncManager超时处理异常处理请求完成SpringMVC中开启异步请求 工具类 WebAsyncUtils public abstract class WebAsyncUtils
AbstractBeanFactory.getBean获取bean逻辑(一)
lemon
05-10 1201
调用AbstractFactoryBean.getBean方法获取bean，实际上是调用doGetBean方法获取bean 下面进入到doGetBean所执行的操作如下： 1 、转换bean Name beanName可能是别名，也可能是FactoryBean ，所以需要进行一系列的解析。 (1)去除FactoryBean的修饰符，也就是如果name= "&b...
Spring4.3.x 容器中bean的创建过程（5）—— 注册bean的销毁方法
chyohn的博客
02-10 1383
概述在Spring4.3.x 容器中bean的创建过程（1）——走进初始化bean的主要战场一篇中我们找到了初始化bean的主要场所在AbstractAutowireCapableBeanFactory类中的doCreateBean方法中，在这个方法中首先调用createBeanInstance方法创建bean的实例；然后调用populateBean方法设置bean的属性；接着调用initializ
SpringFramework核心技术一（IOC：注册一个LoadTimeWeaver)
06-06
在Spring Framework中，LoadTimeWeaver是一个接口，用于在运行时加载类文件。要注册一个LoadTimeWeaver，可以通过在Spring的配置文件中配置一个InstrumentationLoadTimeWeaver bean来实现。 以下是一个示例配置： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值