[转帖]对Spring IoC容器实现的结构分析_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方-国内领先的云技术服务提供商
»  游客             当前位置:  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
1
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 5081 | 回复: 0   主题: [转帖]对Spring IoC容器实现的结构分析        下一篇 
    本主题由 红与黑 于 2013-2-27 16:20:27 置为精华
mingrui.li
注册用户
等级:少校
经验:1356
发帖:95
精华:11
注册:2013-1-4
状态:离线
发送短消息息给mingrui.li 加好友    发送短消息息给mingrui.li 发消息
发表于: IP:您无权察看 2013-1-9 9:31:48 | [全部帖] [楼主帖] 楼主

本文的目标:
从实现的角度来认识SpringIoC容器。
观察的角度:
从外部接口,内部实现,组成部分,执行过程四个方面来认识SpringIoC容器。
本文的风格:
首先列出SpringIoC的外部接口及内部实现所涉及到的组件列表;
其次介绍组件之间的相互关系以对整个执行过程有所把握;
然后针对每一个组件的简单介绍,包括组件的类结构图,核心功能描述,重要接口的重要方法描述;
接下来看SpringIoC容器实现对面向对象基本设计原则的遵守;
最后是后记部分。
术语约定:
组件:本文中的组件是指在功能概念上具有相对独立性的功能单元,物理结构上的特征一般由一组接口、一组抽象类、一组具体实现类、异常类、工具类所组成;
这里的组件是一种相当狭义的描述,根据上下文的不同,组件可以有不同的表现形式,如:相对于Spring框架,SpringIoC容器就是Spring框架的一个组件,
相对于系统的整体框架设计,Spring框架就是整体框架的一个组件,这里组件与模块的概念基本等同。
接口方法:一般定义在接口中,提供给外部调用的方法,接口方法最重要的在于接口提供者以清晰、简洁的定义提供了接口使用者所必需的功能特征;
基础方法:首先基础方法也是一个接口方法,但和接口方法的差别在于接口方法的直接实现依赖于基础方法(参见BeanDefintionReader接口中的方法定义);
钩子方法:超类留给子类需要实现或重写的方法,
默认实现钩子方法:超类提供默认实现,子类可以选择是否有必要重写,
默认空实现钩子方法:超类提供一个空实现方法,子类可以选择是否有必要重写,
抽象钩子方法:超类留给子类必须���现的方法,
内部实现方法:对某一相对独立的处理逻辑的封装,以便增强代码的可读性、可修改性、可重用性,达到代码的清晰性、简洁性。
注:
本文的源代码基于Spring2.x。Spring的源代码也处于演变中,但对基础代码的影响并不大。
正文:
Spring IoC容器的外部接口:

ApplicationContext
BeanFactory
WebApplicationContext


BeanFactory是IoC容器的核心组件,其它组件都是在为BeanFactory提供服务.

ConfigurableBeanFactory
AutowireCapableBeanFactory
ListableBeanFactory
HierarchicalBeanFactory
AbstractBeanFactory
AbstractAutowireCapableBeanFactory
DefaultListableBeanFactory


SingletonBeanRegistry接口,
BeanDefintionRegistry接口,
Resource组件,
ResourceLoader组件,
BeanDefintion组件,
BeanDefintionReader组件,
XmlBeanDefinitionParser组件,
BeanDefintionParser组件,
NamespaceHandler组件,
NamespaceHandlerResolver组件,
BeanWrapper组件,

------------------------------------------------
ApplicationContext
ConfigurableApplicationContext
AbstractApplicationContext
AbstractRefreshApplicationContext
AbstractXmlApplicationContext
ClassPathXmlApplicationContext
FileSystemXmlApplicationContext


Lifecycle接口
ApplicationEventPublisher接口
ApplicationEventMulticaster组件
MessageSource组件
MessageSourceResolvable组件

-----------------------------------------------
WebApplicationContext
ConfigurableWebApplicationContext
AbstractRefreshWebApplicationContext
XmlWebApplicationContext


ContextLoader组件

ContextLoaderListener
ContextLoaderServlet
------------------------------------------------------------------------------------------
FactoryBean


一组回调接口,

InitializingBean
DisposableBean
BeanPostProcessor
BeanFactoryPostProcessor
BeanNameAware
BeanFactoryAware
ResourceLoaderAware
ApplicationContextPublisherAware
MessageSourceAware
ApplicationContextAware
ApplicationContextAwareProcessor
ServletContextAware
ServletConfigAware
ServletContextAwareProcessor
------------------------------------------------------------------------------------------------


对这三个接口(ApplicationContext、BeanFactory、WebApplicationContext)的讨论:
ApplicationContext接口是IoC容器概念的直接对应物,包括容器自身生命周期的管理(容器的启动,容器的初始化,容器的销毁)
一些便利功能的提供如:资源文件的读取,容器级事件的发布。
BeanFactory接口是IoC容器的核心,其它组件都为此组件提供支持,如Resource组件,ResourceLoader组件,BeanDefintionReader组件,
BeanDefintion组件,BeanWrapper组件等。BeanFactory接口相对于容器的概念太过低级,以至于直接使用需要应对较复杂的API。
WebApplicationContext接口提供IoC容器对Web环境的支持,与ServletAPI的集成工作。普通Java应用程序选择IoC容器使用ApplicationContext,
Web环境下的IoC容器使用WebApplicationContext。
下面来关注这两行代码的执行都发生了那些事情,以了解容器的整个执行过程。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Foo foo = (Foo)applicationContext.getBean("foo");


1.首先实例化一个容器对象,
2.然后由ResourceLoader组件对参数"applicationContext.xml"进行解析,将此路径上指定的文件解析为Resource对象。
3.BeanDefinitionReader将Resource资源对象内的bean元素数据封装到BeanDefintion组件中,并通过BeanDefintionRegistry将BeanDefintion注册到
BeanFactory中,
4.对Resource的��析工作主要包括三个主要部分,
a:对xml文档的schema验证,
b:对默认命名空间元素的解析,这部分委托给XmlBeanDefintionParser组件完成,
c:对客户化命名空间元素的解析,这部分工作委托给BeanDefintionParser完成,NamespaceHadler组件和NamespaceHandlerResolver组件对BeanDefintionParser提供支持工作。
这里需要提到的是一些特殊元素的解析如:import元素的解析;另外一点是对applicationContext.xml文件中的bean元素的实际解析工作是委托给
XmlBeanDefintionParserHelper类完成的;上面提到的组件接口列表中与BeanDefinition相关的组件有BeanDefinition组件,BeanDefintionRegistry接口,
除了这两个最重要的,还有如:BeanDefintionBuilder,BeanDefintionDecorator,BeanDefinitionValueResolver,BeanDefinitionRegistryBuilder等其它与BeanDefintion相关组件,
都对BeanDefintion的操作提供支持。
至此,已经完成了阶段性工作,就是已经将类型信息从applicationContext.xml配置文件bean元素中读取到内存对象的BeanDefinition组件中,接下来的工作就是如何将
BeanDefintion组件中所保存的类型信息实例化为最终的对象。
5.接下来是容器的初始化工作:
调用BeanFactoryPostProcessor接口,
注册BeanPostProcessor接口,
初始化MessageSource组件,
初始化ApplicationEventMulticaster,
注册容器级监听器,
发布容器已刷新的事件,
ApplicationContext接口对bean对象的初始化采取一种积极初始化策略,这样做容器初始化过程虽然比较慢,但后续的每一次bean访问相对较快,因为可以从singletonCache缓存中直接获取,
6.
至此下面这行代码的执行��程已结束,

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


接下来看这行代码的执行过程,

 Foo foo = (Foo)applicationContext.getBean("foo");
7.


getBean(String)的目标很明确,就是根据bean的名称得到一个bean对象,
对bean对象的不同角度的分类,
首先可以分为普通的非FactoryBean类型的bean对象和FactoryBean类型的bean对象,
其次可以分为singleton类型的bean对象和非singleton类型的bean对象,
但是这些分类是建立在一个已创建的bean对象基础之上。
8.下面来看创建一个bean对象的过程,

 createBean();


首先容器对BeanDefintion进行整理,根据依赖、继承关系进行合并以得到最终的BeanDefintion,
然后进行bean对象的实例化、初始化、对需要销毁操作的bean对象进行注册。
在这一过程中涉及到一组回调接口的调用,包括实例化前后的处理逻辑,初始化前后的处理逻辑,初始化过程的回调逻辑,销毁操作执行逻辑,
主要的回调接口有

 InitializingBean
DisposableBean
BeanPostProcessor
XXXXXXAware


配置风格的回调机制(init-method,destroy-method)
对bean对象的初始化工作依赖于BeanWrapper组件,BeanWrapper组件以反射的方式将BeanDefintion组件中保存的属性信息设置到bean对象中。
组件描述:
北京联动北方科技有限公司
Resource组件与ResourceLoader组件一起工作,将字符串格式指示的资源解析为Resource对象。
事实上ResourceLoader是Resource的工厂类,
Java代码 北京联动北方科技有限公司

  1. publicinterface ResourceLoader { 
  2.       public Resource getResource(String location); 
  3. }

public interface ResourceLoader {
       public Resource getResource(String location);
}


ResourceLoader的核心工作就是解析location,
location示例:"classpath:applicationContext.xml","classpath*:applicationContext-*.xml","file:/some/resource/path/myTemplate.txt","http://myhost.com/resource/path/myTemplate.txt"
ResourceLoader根据所指示的前缀返回特定的Resource对象。
北京联动北方科技有限公司
BeanDefintionReader组件,
Java代码 北京联动北方科技有限公司

  1. //将Resource中的内容通过BeanDefintionRegistry注册到BeanFactory中。 
  2. publicinterface BeanDefintionReader { 
  3.       BeanDefinitionRegistry getBeanFactory(); 
  4.       ResourceLoader getResourceLoader(); 
  5.       int loadBeanDefinitions(Resource[] resources) throws BeanDefinitionStoreException; 
  6.       int loadBeanDefinitions(String location) throws BeanDefinitionStoreException; 
  7.       int loadBeanDefinitions(String[] locations) throws BeanDefinitionStoreException; 
  8.       /* 
  9.       *这是一个基础方法,从Resource中加载BeanDefinition; 
  10.       *这三个方法loadBeanDefintions(Resources[]),loadBeanDefintions(String[]),loadBeanDefintion(String)的实现 
  11.       *依赖于此方法的实现; 
  12.       *上面三个方法的实现在AbstractBeanDefinitionReader骨架类中完成,此方法的实现在XmlBeanDefintionReader中完成。 
  13.       */
  14.       int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException; 
  15. }

//将Resource中的内容通过BeanDefintionRegistry注册到BeanFactory中。
public interface BeanDefintionReader {
       BeanDefinitionRegistry getBeanFactory();
       ResourceLoader getResourceLoader();
       int loadBeanDefinitions(Resource[] resources) throws BeanDefinitionStoreException;
       int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
       int loadBeanDefinitions(String[] locations) throws BeanDefinitionStoreException;
       /*
       *这是一个基础方法,从Resource中加载BeanDefinition;
       *这三个方法loadBeanDefintions(Resources[]),loadBeanDefintions(String[]),loadBeanDefintion(String)的实现
       *依赖于此方法的实现;
       *上面三个方法的实现在AbstractBeanDefinitionReader骨架类中完成,此方法的实现在XmlBeanDefintionReader中完成。
       */
       int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
}


北京联动北方科技有限公司
Java代码 北京联动北方科技有限公司

  1. //XmlBeanDefinitionParser组件处理配置文件中默认命名空间的元素解析, 
  2. publicinterface XmlBeanDefinitionParser { 
  3.       //对Document文档的解析,将解析出的内容封装到BeanDefintion中。 
  4.       void registerBeanDefinitions(Document doc, ReaderContext readerContext)throws BeanDefinitionStoreException; 
  5. }

//XmlBeanDefinitionParser组件处理配置文件中默认命名空间的元素解析,
public interface XmlBeanDefinitionParser {
       //对Document文档的解析,将解析出的内容封装到BeanDefintion中。
       void registerBeanDefinitions(Document doc, ReaderContext readerContext)throws BeanDefinitionStoreException;
}


这三个组件(BeanDefintionParser组件,NamespaceHandler组件,NamespaceHandlerResolver组件)处理客户化的命名空间元素的解析,
此机制使用配置文件易于书写,具有可扩展性。
如spring提供的实现:<util:list>,<aop:config>,<tx:annotation-driven>,<context:annotation-config>,
第三方组件提供的实现:<jaxws:endpoint>,<amq:broker>等其它实现。
Java代码 北京联动北方科技有限公司

  1. //对客户化命名空间的bean元素进行解析操作。 
  2. publicinterface BeanDefintionParser { 
  3.       //对Element的解析。 
  4.       BeanDefinition parse(Element element, ParserContext parserContext); 
  5.  } 
  6. //根据元素命名空间得到此元素的BeanDefinitionParser处理程序;此类是BeanDefintionParser的工厂类。 
  7. publicinterface NamespaceHandler { 
  8.       void init(); 
  9.       BeanDefinitionParser findParserForElement(Element element); 
  10.       BeanDefinitionDecorator findDecoratorForElement(Element element); 
  11. //解析META-INF/spring.handlers中的配置信息;此类是NamespaceHandler 的工厂, 
  12. publicinterface NamespaceHandlerResolver { 
  13.       //根据命名空间指示符得到指定的命名空间处理器。 
  14.       NamespaceHandler resolve(String namespaceUri); 
  15. }

//对客户化命名空间的bean元素进行解析操作。
public interface BeanDefintionParser {
       //对Element的解析。
       BeanDefinition parse(Element element, ParserContext parserContext);
}
//根据元素命名空间得到此元素的BeanDefinitionParser处理程序;此类是BeanDefintionParser的工厂类。
public interface NamespaceHandler {
       void init();
       BeanDefinitionParser findParserForElement(Element element);
       BeanDefinitionDecorator findDecoratorForElement(Element element);
}
//解析META-INF/spring.handlers中的配置信息;此类是NamespaceHandler 的工厂,
public interface NamespaceHandlerResolver {
       //根据命名空间指示符得到指定的命名空间处理器。
       NamespaceHandler resolve(String namespaceUri);
}


北京联动北方科技有限公司
BeanWrapper组件,
对java bean对象提供设置属性值、获取属性值操作,并能够将字符串类型值转换为正确的类型,这个工作依赖于PropertyEditor。
操作示例:

beanWrapper.setPropertyValue("name","foo");
beanWrapper.setPropertyValue("address.country","China");
beanWrapper.setPropertyValue("array[2]","arrayValue");


Java代码 北京联动北方科技有限公司

  1. //PropertyEditor注册器;提供注册、获取PropertyEditor操用。 
  2. publicinterface PropertyEditorRegistry { 
  3.       void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor); 
  4.       void registerCustomEditor(Class requiredType, String propertyPath, PropertyEditor propertyEditor); 
  5.       PropertyEditor findCustomEditor(Class requiredType, String propertyPath); 
  6. //bean对象的属性访问器。 
  7. publicinterface PropertyAccessor { 
  8.       publicboolean isReadableProperty(String name); 
  9.       publicboolean isWritableProperty(String name); 
  10.       public Class<?> getPropertyType(String name); 
  11.       public Object getPropertyValue(String name); 
  12.       publicvoid setPropertyValues(PropertyValues pvs); 
  13.       publicvoid setPropertyValues(Map<String,Object> pvs); 
  14.       publicvoid setPropertyValue(PropertyValue pv); 
  15.       publicvoid setPropertyValue(String name,Object value); 
  16. //对PropertyEditor增加管理功能。 
  17. publicinterface ConfigurablePropertyAccessor extends PropertyEditorRegistry,PropertyAccessor { 
  18.       void setExtractOldValueForEditor(boolean extractOldValueForEditor); 
  19.       boolean isExtractOldValueForEditor(); 
  20. //对bean对象进行管理。 
  21. publicinterface BeanWrapper extends ConfigurablePropertyAccessor { 
  22.       //设置所在包装的object 
  23.       void setWrappedInstance(Object obj); 
  24.       //返回包装对象. 
  25.       Object getWrappedInstance(); 
  26.       //返回包装对象类型 
  27.       Class getWrappedClass(); 
  28.       //返回包装对象属性描述.. 
  29.       PropertyDescriptor[] getPropertyDescriptors() throws BeansException; 
  30.       //根据属性名返回特定的属性描述对象. 
  31.       PropertyDescriptor getPropertyDescriptor(String propertyName) throws BeansException; 
  32. }

//PropertyEditor注册器;提供注册、获取PropertyEditor操用。
public interface PropertyEditorRegistry {
       void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor);
       void registerCustomEditor(Class requiredType, String propertyPath, PropertyEditor propertyEditor);
       PropertyEditor findCustomEditor(Class requiredType, String propertyPath);
}
//bean对象的属性访问器。
public interface PropertyAccessor {
       public boolean isReadableProperty(String name);
       public boolean isWritableProperty(String name);
       public Class<?> getPropertyType(String name);
       public Object getPropertyValue(String name);
       public void setPropertyValues(PropertyValues pvs);
       public void setPropertyValues(Map<String,Object> pvs);
       public void setPropertyValue(PropertyValue pv);
       public void setPropertyValue(String name,Object value);
}
//对PropertyEditor增加管理功能。
public interface ConfigurablePropertyAccessor extends PropertyEditorRegistry,PropertyAccessor {
       void setExtractOldValueForEditor(boolean extractOldValueForEditor);
       boolean isExtractOldValueForEditor();
}
//对bean对象进行管理。
public interface BeanWrapper extends ConfigurablePropertyAccessor {
       //设置所在包装的object
       void setWrappedInstance(Object obj);
       //返回包装对象.
       Object getWrappedInstance();
       //返回包装对象类型
       Class getWrappedClass();
       //返回包装对象属性描述..
       PropertyDescriptor[] getPropertyDescriptors() throws BeansException;
       //根据属性名返回特定的属性描述对象.
       PropertyDescriptor getPropertyDescriptor(String propertyName) throws BeansException;
}


北京联动北方科技有限公司
Java代码 北京联动北方科技有限公司

  1. //IoC容器的核心接口,提供访问IoC容器的基本操作。 
  2. publicinterface BeanFactory { 
  3.       //根据bean名称获取相应的bean对象. 此方法在AbstractBeanFactory骨架类中实现, 
  4.       public Object getBean(String name) throws BeansException; 
  5. //定义分层的BeanFactory容器结构。 
  6. publicinterface HierarchicalBeanFactoryextends BeanFactory { 
  7.       
  8. //对BeanFactory提供配置信息. 
  9. publicinterface ConfigurableBeanFactory extends HierarchicalBeanFactory { 
  10.       void setParentBeanFactory(BeanFactory parentBeanFactory); 
  11.       // 注册客户化属性编辑器. 
  12.       void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor); 
  13.       //添加BeanPostProcessor. 
  14.       void addBeanPostProcessor(BeanPostProcessor beanPostProcessor); 
  15.       //销毁所有singleton类型bean对象. 
  16.       void destroySingletons(); 
  17. //主要逻辑有创建一个bean对象实例的过程,根据不同的WireMode(byName、byType)完成不同的操作。 
  18. publicinterface AutowireCapableBeanFactory extends BeanFactory { 
  19.       //创建一个bean对象. 
  20.       Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException; 
  21.       //配置一个bean对象. 
  22.       Object configureBean(Object existingBean, String beanName) throws BeansException; 
  23.       //初始化bean对象. 
  24.       Object initializeBean(Object existingBean, String beanName) throws BeansException; 
  25.       Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException; 
  26.       Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException; 
  27. /* 
  28. *提供对BeanDefintion对象的管理操作。 
  29. *对通过BeanDefintionRegistry注册器注册到BeanFactory中的BeanDefintion对象进行管理,但注意此接口 
  30. *并不依赖于BeanDefintion接口API; 
  31. *此接口在操作上与BeanDefintionRegistry接口有重叠部分,但此接口的职责重在管理操作,而BeanDefintionRegistry重在注册操作,并且 
  32. *BeanDefintionRegistry接口直接依赖于BeanDefintion接口API。 
  33. */
  34. publicinterface ListableBeanFactory { 
  35.       boolean containsBeanDefinition(String beanName); 
  36.       int getBeanDefinitionCount(); 
  37.       String[] getBeanDefinitionNames(); 
  38.       String[] getBeanNamesForType(Class type); 
  39.       String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean includeFactoryBeans); 
  40.       Map getBeansOfType(Class type) throws BeansException; 
  41.       Map getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans) throws BeansException; 
  42. // 
  43. publicinterface ConfigurableListableBeanFactory 
  44. extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory,SingletonBeanRegistry { 
  45.       void ignoreDependencyType(Class type); 
  46.       void ignoreDependencyInterface(Class ifc); 
  47.       BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; 
  48.       //在容器启动过程中实例化singleton类型bean对象。 
  49.       void preInstantiateSingletons() throws BeansException; 
  50. //注册BeanDefintion对象,并进行管理操作。 
  51. publicinterface BeanDefinitionRegistry { 
  52.       int getBeanDefinitionCount(); 
  53.       String[] getBeanDefinitionNames(); 
  54.       boolean containsBeanDefinition(String beanName); 
  55.       BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; 
  56.       void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeansException; 
  57.       String[] getAliases(String beanName) throws NoSuchBeanDefinitionException; 
  58.       void registerAlias(String beanName, String alias) throws BeansException; 
  59. /* 
  60.  *注册singleton类型对象,并进行管理操作;BeanDefinitionRegistry接口将BeanDefinition注册到BeanFactory中,此接口将singleton类型 
  61.  *对象注册到BeanFactory中。 
  62.  */
  63. publicinterface SingletonBeanRegistry { 
  64.       
  65. }

//IoC容器的核心接口,提供访问IoC容器的基本操作。
public interface BeanFactory {
       //根据bean名称获取相应的bean对象. 此方法在AbstractBeanFactory骨架类中实现,
       public Object getBean(String name) throws BeansException;
}
//定义分层的BeanFactory容器结构。
public interface HierarchicalBeanFactory extends BeanFactory {
}
//对BeanFactory提供配置信息.
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory {
       void setParentBeanFactory(BeanFactory parentBeanFactory);
       // 注册客户化属性编辑器.
       void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor);
       //添加BeanPostProcessor.
       void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
       //销毁所有singleton类型bean对象.
       void destroySingletons();
}
//主要逻辑有创建一个bean对象实例的过程,根据不同的WireMode(byName、byType)完成不同的操作。
public interface AutowireCapableBeanFactory extends BeanFactory {
       //创建一个bean对象.
       Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
       //配置一个bean对象.
       Object configureBean(Object existingBean, String beanName) throws BeansException;
       //初始化bean对象.
       Object initializeBean(Object existingBean, String beanName) throws BeansException;
       Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;
       Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;
}
/*
*提供对BeanDefintion对象的管理操作。
*对通过BeanDefintionRegistry注册器注册到BeanFactory中的BeanDefintion对象进行管理,但注意此接口
*并不依赖于BeanDefintion接口API;
*此接口在操作上与BeanDefintionRegistry接口有重叠部分,但此接口的职责重在管理操作,而BeanDefintionRegistry重在注册操作,并且
*BeanDefintionRegistry接口直接依赖于BeanDefintion接口API。
*/
public interface ListableBeanFactory {
       boolean containsBeanDefinition(String beanName);
       int getBeanDefinitionCount();
       String[] getBeanDefinitionNames();
       String[] getBeanNamesForType(Class type);
       String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean includeFactoryBeans);
       Map getBeansOfType(Class type) throws BeansException;
       Map getBeansOfType(Class type, boolean includePrototypes, boolean includeFactoryBeans) throws BeansException;
}
//
public interface ConfigurableListableBeanFactory
extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory,SingletonBeanRegistry {
       void ignoreDependencyType(Class type);
       void ignoreDependencyInterface(Class ifc);
       BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
       //在容器启动过程中实例化singleton类型bean对象。
       void preInstantiateSingletons() throws BeansException;
}
//注册BeanDefintion对象,并进行管理操作。
public interface BeanDefinitionRegistry {
       int getBeanDefinitionCount();
       String[] getBeanDefinitionNames();
       boolean containsBeanDefinition(String beanName);
       BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
       void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeansException;
       String[] getAliases(String beanName) throws NoSuchBeanDefinitionException;
       void registerAlias(String beanName, String alias) throws BeansException;
}
/*
*注册singleton类型对象,并进行管理操作;BeanDefinitionRegistry接口将BeanDefinition注册到BeanFactory中,此接口将singleton类型
*对象注册到BeanFactory中。
*/
public interface SingletonBeanRegistry {
}


北京联动北方科技有限公司
ApplicationEventPublisher接口是容器事件发布接口,
ApplicationEventPublisher接口的功能是委托给ApplicationEventMulticaster组件实现的,
ApplicationEventMulticaster组件提供对监听器的完整操作,包括新增监听器、移除单个或全部监听器、通知监听器。
Java代码 北京联动北方科技有限公司

  1. //容器事件发布器。 
  2. publicinterface ApplicationEventPublisher { 
  3.       void publishEvent(ApplicationEvent event); 
  4. //一个完整的事件模型实现。 
  5. publicinterface ApplicationEventMulticaster { 
  6.       void addApplicationListener(ApplicationListener listener); 
  7.       void removeApplicationListener(ApplicationListener listener); 
  8.       void removeAllListeners(); 
  9.       /* 
  10.       *事件发布方法,通知所有监听器; 
  11.       *ApplicationEventPublisher.publishEvent(ApplicationEvent)方法的实现委托给此方法完成。 
  12.       */
  13.       void multicastEvent(ApplicationEvent event); 
  14. //监听器. 
  15. publicinterface ApplicationListener extends java.util.EventListener { 
  16. //事件对象. 
  17. publicclassextends ApplicationEvent extends java.util.EventObject { 
  18. }

//容器事件发布器。
public interface ApplicationEventPublisher {
       void publishEvent(ApplicationEvent event);
}
//一个完整的事件模型实现。
public interface ApplicationEventMulticaster {
       void addApplicationListener(ApplicationListener listener);
       void removeApplicationListener(ApplicationListener listener);
       void removeAllListeners();
       /*
       *事件发布方法,通知所有监听器;
       *ApplicationEventPublisher.publishEvent(ApplicationEvent)方法的实现委托给此方法完成。
       */
       void multicastEvent(ApplicationEvent event);
}
//监听器.
public interface ApplicationListener extends java.util.EventListener {
}
//事件对象.
public class extends ApplicationEvent extends java.util.EventObject {
}


北京联动北方科技有限公司
MessageSource组件
MessageSourceResolvable组件
这是一个接口复用与组合复用协同工作的好例子,ApplicationContext接口继承了MessageSource接口,对外提供信息源处理操作,但内部实现委托给MessageSource组件完成。
北京联动北方科技有限公司
Java代码 北京联动北方科技有限公司

  1. //SpringIoC容器的顶级接口. 
  2. publicinterface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory, 
  3. MessageSource, ApplicationEventPublisher, ResourcePatternResolver { 
  4.       ApplicationContext getParent(); 
  5.       AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException; 
  6.       String getDisplayName(); 
  7.       long getStartupDate(); 
  8. //对容器对象进行配置化、初始化工作. 
  9. publicinterface ConfigurableApplicationContext extends ApplicationContext, Lifecycle { 
  10.       void setParent(ApplicationContext parent); 
  11.       void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor); 
  12.       //此方法是核心方法,内部生成一个BeanFactory对象,并完成对BeanFactory对象的初始化和容器的初始化工作。 
  13.       void refresh() throws BeansException, IllegalStateException; 
  14.       ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException; 
  15.       void close(); 
  16. //生命周期管理接口. 
  17. publicinterface Lifecycle { 
  18.       void start(); 
  19.       void stop(); 
  20.       boolean isRunning(); 
  21. }

//SpringIoC容器的顶级接口.
public interface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
       ApplicationContext getParent();
       AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
       String getDisplayName();
       long getStartupDate();
}
//对容器对象进行配置化、初始化工作.
public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle {
       void setParent(ApplicationContext parent);
       void addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor);
       //此方法是核心方法,内部生成一个BeanFactory对象,并完成对BeanFactory对象的初始化和容器的初始化工作。
       void refresh() throws BeansException, IllegalStateException;
       ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
       void close();
}
//生命周期管理接口.
public interface Lifecycle {
       void start();
       void stop();
       boolean isRunning();
}


北京联动北方科技有限公司

WebApplicationContext
ConfigurableWebApplicationContext
AbstractRefreshWebApplicationContext
XmlWebApplicationContext


Java代码 北京联动北方科技有限公司

  1. //提供SpringIoC容器对Web环境ServletAPI的集成。 
  2. publicinterface WebApplicationContext extends ApplicationContext { 
  3.       ServletContext getServletContext(); 
  4. //提供WebApplicationContext的配置工作。 
  5. publicinterface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext { 
  6.       void setServletContext(ServletContext servletContext); 
  7.       void setServletConfig(ServletConfig servletConfig); 
  8.       void setNamespace(String namespace); 
  9.       void setConfigLocations(String[] configLocations); 
  10. }

//提供SpringIoC容器对Web环境ServletAPI的集成。
public interface WebApplicationContext extends ApplicationContext {
       ServletContext getServletContext();
}
//提供WebApplicationContext的配置工作。
public interface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext {
       void setServletContext(ServletContext servletContext);
       void setServletConfig(ServletConfig servletConfig);
       void setNamespace(String namespace);
       void setConfigLocations(String[] configLocations);
}


Java代码 北京联动北方科技有限公司

  1. //ContextLoader组件从ServletContext初始化配置参数中获取Spring的配置文件路径信息,并进行IoC容器的实例化、初始化、销毁操作。 
  2. publicclass ContextLoader { 
  3.       public WebApplicationContext initWebApplicationContext(ServletContext servletContext){ 
  4.             //code. 
  5.       } 
  6.       publicvoid closeWebApplicationContext(ServletContext servletContext) { 
  7.             //code. 
  8.       } 
  9. }

//ContextLoader组件从ServletContext初始化配置参数中获取Spring的配置文件路径信息,并进行IoC容器的实例化、初始化、销毁操作。
public class ContextLoader {
       public WebApplicationContext initWebApplicationContext(ServletContext servletContext){
             //code.
       }
       public void closeWebApplicationContext(ServletContext servletContext) {
             //code.
       }
}


ContextLoaderListener和ContextLoaderServlet提供两种方式将IoC容器集成到ServletContext缓存中。
从面向对象基本设计原则角度来看SpringIoC容器的设计:
最基本的两条设计原则--编程到接口、首选组合复用:
编程到接口,
在SpringIoC容器实现中,interface 关键字随处可见,但是有一点需要注意的就是:并不是使用了interface关键字,就能保证编程到接口,
但一般来说对编程到接口原则的遵守,inteface关键字的使用是必须的。编程到接口所描述的实质是要将组件的外部接口和内部实现分离
开来,这将带来一系列的好处:可扩展性,可重用性,可维护性,依赖性,内聚性,耦合性,清晰性,简洁性,可读性,可修改性,
抽象性,封装性,模块化,层次化,测试性,其它特性。
首选组合复用,
面向对象的复用方式主要分两种--组合复用、继承复用,继承复用可以细分为两种--接口复用、具体复用,
这条原则关注的组合复用与具体复用之间的区别,
事实上这条原则针对复用方式的选择上意义并不大,因为这三种复用方式所处理的是不同的复用问题,一旦能够从has-a、is-like-a、is-a的角度
区分开,问题就不大了。
这条原则真正有意义的在于它的教训意义,可以借此了解这条原则形成的原因,全面了解复用的方式,了解每一种复用方式的特点,了解不同
复用方式之间的差别。
SpringIoC容器的设计很好的体现了这两条原则,如ApplicationContext接口
Java代码 北京联动北方科技有限公司

  1. publicinterface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory, 
  2. ssageSource, ApplicationEventPublisher, ResourcePatternResolver { 
  3. }

public interface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory,
MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
}


这是一个基于接口的设计,并且是一个接口复用,
ApplicationContext接口继承了ListableBeanFactory,HierarchicalBeanFactory,MessageSource,ApplicationEventPublisher,ResourcePatternResolver
接口,那么就意味着 ApplicationContext可以提供这些接口中定义的所有功能,但是这些功能的实际实现并不是由ApplicationContext的实现类
提供的,而是以组合复用的方式委托给了各个接口的实际实现类来完成;
具体复用在接口的实现过程中所使用,以便将接口的设计层次与接口的实现层次分离开来,如:
Java代码




赞(0)    操作        顶端 
总帖数
1
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码: 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论