接上篇
http://whoknow.javaeye.com/blog/487786
DefaultSingletonBeanRegistry可以简单的管理bean但是做为一个ioc容器来讲它的功能还远远不够。比如,在一个应用中,一些bean是始终存在的,一些则是随着当前线程的结束而结束,做为一个容器来讲,它需要可以管理整个bean的生命周期
AbstractBeanFactory继承了DefaultSingletonBeanRegistry类,并进一步丰富了已有的功能,这个类提供了singleton/prototype的选择,单例cache,对于FactoryBean的处理,bean定义的处理以及bean 的销毁…
其中比较重要的功能是对BeanFactory中getBean方法的实现
几个连续的重载,我们关心的是最后这个
然后一点一点看这个方法,假如给自己这样一个问题,我们首先会做什么?这个方法打算写些什么呢?
很显然,在我们的父类DefaultSingletonBeanRegistry中,已经有了一些对于bean的操作的实现,比如getSingleton方法,让我们可以拿到一个bean,于是
看一下getObjectForBeanInstance这个方法
那么这个getObjectFromFactoryBean方法又是?从参数来看,我们发现了一个factory,实际上在这个方法中会调用它
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,等等属性,结构如图:
那么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的定义后,就可以实例化它了
如果是一个单例:
这里使用了一个回调方法,在父类的DefaultSingletonBeanRegistry中的public Object getSingleton(String beanName, ObjectFactory singletonFactory) 需要一个ObjectFactory,我们用一个匿名类写入方法,并调用其子类的createBean方法,在这里createBean是AbstractBeanFactory的抽象方法
如果是Prototype的话:
最后如果既不是Singleton也不是Prototype时,首先拿它的scope
这里有一行代码
注册它的销毁方法
在这里首先通过RequestContextHolder得到当前的RequestAttributes。在RequestContextHolder中requestAttributesHolder 为ThreadLocal
之后在ServletRequestAttributes注册其回调销毁方法最后
可以看到在DisposableBeanAdapter中
首先beanPostProcessors执行所有的DestructionAwareBeanPostProcessor,最后在最后执行invokeCustomDestroyMethod();所以客户定义的销毁方式是在最后的
DefaultSingletonBeanRegistry可以简单的管理bean但是做为一个ioc容器来讲它的功能还远远不够。比如,在一个应用中,一些bean是始终存在的,一些则是随着当前线程的结束而结束,做为一个容器来讲,它需要可以管理整个bean的生命周期
- 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方法的实现
- 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);
- }
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);
}
几个连续的重载,我们关心的是最后这个
- 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,于是
- Object sharedInstance = getSingleton(beanName);
- if (sharedInstance != null ) {
- //一个简单的判断,先看一眼,map里是否有这个类了
- //如果有的话呢?直接返回?好像不太好,因为这个类可能是一个工厂类,所以我们还需要一个方法判断下,如果是工厂类的话,那么它应该返回一个产品
- bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null) {
//一个简单的判断,先看一眼,map里是否有这个类了
//如果有的话呢?直接返回?好像不太好,因为这个类可能是一个工厂类,所以我们还需要一个方法判断下,如果是工厂类的话,那么它应该返回一个产品
bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
}
看一下getObjectForBeanInstance这个方法
- 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;
- }
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,实际上在这个方法中会调用它
- object = factory.getObject();
- //之后
- 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,等等属性,结构如图:
- //得到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));
- }
//得到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的定义后,就可以实例化它了
如果是一个单例:
- 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);
- }
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的话:
- if (mergedBeanDefinition.isPrototype()) {
- Object prototypeInstance = null ;
- try {
- beforePrototypeCreation(beanName);
- prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
- }
- finally {
- afterPrototypeCreation(beanName);
- }
- // 又判断它是不是工厂类
- bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
- }
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
- 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);
- }
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);
}
这里有一行代码
- scope.registerDestructionCallback(beanName,
- new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
注册它的销毁方法
- public void registerDestructionCallback(String name, Runnable callback) {
- RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
- attributes.registerDestructionCallback(name, callback, getScope());
- }
public void registerDestructionCallback(String name, Runnable callback) {
RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
attributes.registerDestructionCallback(name, callback, getScope());
}
在这里首先通过RequestContextHolder得到当前的RequestAttributes。在RequestContextHolder中requestAttributesHolder 为ThreadLocal
之后在ServletRequestAttributes注册其回调销毁方法最后
- private void executeRequestDestructionCallbacks() {
- for (Iterator it = this .requestDestructionCallbacks.values().iterator(); it.hasNext();) {
- ((Runnable) it.next()).run();
- }
- }
private void executeRequestDestructionCallbacks() {
for (Iterator it = this.requestDestructionCallbacks.values().iterator(); it.hasNext();) {
((Runnable) it.next()).run();
}
}
可以看到在DisposableBeanAdapter中
- public void run() {
- destroy();
- }
public void run() {
destroy();
}
首先beanPostProcessors执行所有的DestructionAwareBeanPostProcessor,最后在最后执行invokeCustomDestroyMethod();所以客户定义的销毁方式是在最后的
- 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();
- }
- }
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();
}
}