从实现的角度来认识SpringIoC容器

观察的角度：

从外部接口，内部实现，组成部分，执行过程四个方面来认识SpringIoC容器。

本文的风格：

首先列出SpringIoC的外部接口及内部实现所涉及到的组件列表；

其次介绍组件之间的相互关系以对整个执行过程有所把握；

然后针对每一个组件的简单介绍，包括组件的类结构图，核心功能描述，重要接口的重要方法描述；

接下来看SpringIoC容器实现对面向对象基本设计原则的遵守；

最后是后记部分。

术语约定：

组件：本文中的组件是指在功能概念上具有相对独立性的功能单元，物理结构上的特征一般由一组接口、一组抽象类、一组具体实现类、异常类、工具类所组成；

这里的组件是一种相当狭义的描述，根据上下文的不同，组件可以有不同的表现形式，如：相对于Spring框架，SpringIoC容器就是Spring框架的一个组件，

相对于系统的整体框架设计，Spring框架就是整体框架的一个组件，这里组件与模块的概念基本等同。

接口方法：一般定义在接口中，提供给外部调用的方法，接口方法最重要的在于接口提供者以清晰、简洁的定义提供了接口使用者所必需的功能特征；

基础方法：首先基础方法也是一个接口方法，但和接口方法的差别在于接口方法的直接实现依赖于基础方法(参见BeanDefintionReader接口中的方法定义)；

钩子方法：超类留给子类需要实现或重写的方法，

默认实现钩子方法：超类提供默认实现，子类可以选择是否有必要重写，

默认空实现钩子方法：超类提供一个空实现方法，子类可以选择是否有必要重写，

抽象钩子方法：超类留给子类必须实现的方法，

内部实现方法：对某一相对独立的处理逻辑的封装，以便增强代码的可读性、可修改性、可重用性，达到代码的清晰性、简洁性。注：

本文的源代码基于Spring2.x。Spring的源代码也处于演变中，但对基础代码的影响并不大。

正文：

SpringIoC容器的外部接口:

ApplicationContextBeanFactoryWebApplicationContext

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

ConfigurableBeanFactoryAutowireCapableBeanFactoryListableBeanFactoryHierarchicalBeanFactoryAbstractBeanFactoryAbstractAutowireCapableBeanFactoryDefaultListableBeanFactorySingletonBeanRegistry接口，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。

下面来关注这两行代码的执行都发生了那些事情，以了解容器的整个执行过程。

ApplicationContextapplicationContext=newClassPathXmlApplicationContext("applicationContext.xml");

Foofoo=(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.

至此下面这行代码的执行过程已结束，

ApplicationContextapplicationContext=newClassPathXmlApplicationContext("applicationContext.xml");

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

Foofoo=(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. publicinterfaceResourceLoader{
2. publicResourcegetResource(Stringlocation);
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. publicinterfaceBeanDefintionReader{
3. BeanDefinitionRegistrygetBeanFactory();
4. ResourceLoadergetResourceLoader();
5. intloadBeanDefinitions(Resource[]resources)throwsBeanDefinitionStoreException;
6. intloadBeanDefinitions(Stringlocation)throwsBeanDefinitionStoreException;
7. intloadBeanDefinitions(String[]locations)throwsBeanDefinitionStoreException;
8. /*
9. *这是一个基础方法，从Resource中加载BeanDefinition；
10. *这三个方法loadBeanDefintions(Resources[]),loadBeanDefintions(String[]),loadBeanDefintion(String)的实现
11. *依赖于此方法的实现；
12. *上面三个方法的实现在AbstractBeanDefinitionReader骨架类中完成，此方法的实现在XmlBeanDefintionReader中完成。
13. */
14. intloadBeanDefinitions(Resourceresource)throwsBeanDefinitionStoreException;
15. }

//将Resource中的内容通过BeanDefintionRegistry注册到BeanFactory中。

public interfaceBeanDefintionReader {

BeanDefinitionRegistry getBeanFactory();

ResourceLoader getResourceLoader();

int loadBeanDefinitions(Resource[] resources) throwsBeanDefinitionStoreException;

int loadBeanDefinitions(String location) throwsBeanDefinitionStoreException;

int loadBeanDefinitions(String[] locations) throwsBeanDefinitionStoreException;

/*

*这是一个基础方法，从Resource中加载BeanDefinition；

*这三个方法loadBeanDefintions(Resources[]),loadBeanDefintions(String[]),loadBeanDefintion(String)的实现

*依赖于此方法的实现；

*上面三个方法的实现在AbstractBeanDefinitionReader骨架类中完成，此方法的实现在XmlBeanDefintionReader中完成。

*/

int loadBeanDefinitions(Resource resource) throwsBeanDefinitionStoreException;

}

Java代码

1. //XmlBeanDefinitionParser组件处理配置文件中默认命名空间的元素解析，
2. publicinterfaceXmlBeanDefinitionParser{
3. //对Document文档的解析，将解析出的内容封装到BeanDefintion中。
4. voidregisterBeanDefinitions(Documentdoc,ReaderContextreaderContext)throwsBeanDefinitionStoreException;
5. }

//XmlBeanDefinitionParser组件处理配置文件中默认命名空间的元素解析，

public interface XmlBeanDefinitionParser{

//对Document文档的解析，将解析出的内容封装到BeanDefintion中。

void registerBeanDefinitions(Document doc, ReaderContextreaderContext)throws BeanDefinitionStoreException;

}

这三个组件(BeanDefintionParser组件，NamespaceHandler组件，NamespaceHandlerResolver组件)处理客户化的命名空间元素的解析，

此机制使用配置文件易于书写，具有可扩展性。

如spring提供的实现：<util:list>，<aop:config>，<tx:annotation-driven>，<context:annotation-config>，

第三方组件提供的实现：<jaxws:endpoint>，<amq:broker>等其它实现。

Java代码

1. //对客户化命名空间的bean元素进行解析操作。
2. publicinterfaceBeanDefintionParser{
3. //对Element的解析。
4. BeanDefinitionparse(Elementelement,ParserContextparserContext);
5. }
6. //根据元素命名空间得到此元素的BeanDefinitionParser处理程序；此类是BeanDefintionParser的工厂类。
7. publicinterfaceNamespaceHandler{
8. voidinit();
9. BeanDefinitionParserfindParserForElement(Elementelement);
10. BeanDefinitionDecoratorfindDecoratorForElement(Elementelement);
11. }
12. //解析META-INF/spring.handlers中的配置信息；此类是NamespaceHandler的工厂，
13. publicinterfaceNamespaceHandlerResolver{
14. //根据命名空间指示符得到指定的命名空间处理器。
15. NamespaceHandlerresolve(StringnamespaceUri);
16. }

BeanWrapper组件，

对javabean对象提供设置属性值、获取属性值操作，并能够将字符串类型值转换为正确的类型，这个工作依赖于PropertyEditor。

操作示例：

beanWrapper.setPropertyValue("name","foo");

beanWrapper.setPropertyValue("address.country","China");

beanWrapper.setPropertyValue("array[2]","arrayValue");

Java代码

1. //PropertyEditor注册器；提供注册、获取PropertyEditor操用。
2. publicinterfacePropertyEditorRegistry{
3. voidregisterCustomEditor(ClassrequiredType,PropertyEditorpropertyEditor);
4. voidregisterCustomEditor(ClassrequiredType,StringpropertyPath,PropertyEditorpropertyEditor);
5. PropertyEditorfindCustomEditor(ClassrequiredType,StringpropertyPath);
6. }
7. //bean对象的属性访问器。
8. publicinterfacePropertyAccessor{
9. publicbooleanisReadableProperty(Stringname);
10. publicbooleanisWritableProperty(Stringname);
11. publicClass<?>getPropertyType(Stringname);
12. publicObjectgetPropertyValue(Stringname);
13. publicvoidsetPropertyValues(PropertyValuespvs);
14. publicvoidsetPropertyValues(Map<String,Object>pvs);
15. publicvoidsetPropertyValue(PropertyValuepv);
16. publicvoidsetPropertyValue(Stringname,Objectvalue);
17. }
18. //对PropertyEditor增加管理功能。
19. publicinterfaceConfigurablePropertyAccessorextendsPropertyEditorRegistry,PropertyAccessor{
20. voidsetExtractOldValueForEditor(booleanextractOldValueForEditor);
21. booleanisExtractOldValueForEditor();
22. }
23. //对bean对象进行管理。
24. publicinterfaceBeanWrapperextendsConfigurablePropertyAccessor{
25. //设置所在包装的object
26. voidsetWrappedInstance(Objectobj);
27. //返回包装对象.
28. ObjectgetWrappedInstance();
29. //返回包装对象类型
30. ClassgetWrappedClass();
31. //返回包装对象属性描述..
32. PropertyDescriptor[]getPropertyDescriptors()throwsBeansException;
33. //根据属性名返回特定的属性描述对象.
34. PropertyDescriptorgetPropertyDescriptor(StringpropertyName)throwsBeansException;
35. }

Java代码

1. //IoC容器的核心接口，提供访问IoC容器的基本操作。
2. publicinterfaceBeanFactory{
3. //根据bean名称获取相应的bean对象.此方法在AbstractBeanFactory骨架类中实现，
4. publicObjectgetBean(Stringname)throwsBeansException;
5. }
6. //定义分层的BeanFactory容器结构。
7. publicinterfaceHierarchicalBeanFactoryextendsBeanFactory{
9. }
10. //对BeanFactory提供配置信息.
11. publicinterfaceConfigurableBeanFactoryextendsHierarchicalBeanFactory{
12. voidsetParentBeanFactory(BeanFactoryparentBeanFactory);
13. //注册客户化属性编辑器.
14. voidregisterCustomEditor(ClassrequiredType,PropertyEditorpropertyEditor);
15. //添加BeanPostProcessor.
16. voidaddBeanPostProcessor(BeanPostProcessorbeanPostProcessor);
17. //销毁所有singleton类型bean对象.
18. voiddestroySingletons();
19. }
20. //主要逻辑有创建一个bean对象实例的过程，根据不同的WireMode(byName、byType)完成不同的操作。
21. publicinterfaceAutowireCapableBeanFactoryextendsBeanFactory{
22. //创建一个bean对象.
23. ObjectcreateBean(ClassbeanClass,intautowireMode,booleandependencyCheck)throwsBeansException;
24. //配置一个bean对象.
25. ObjectconfigureBean(ObjectexistingBean,StringbeanName)throwsBeansException;
26. //初始化bean对象.
27. ObjectinitializeBean(ObjectexistingBean,StringbeanName)throwsBeansException;
28. ObjectapplyBeanPostProcessorsBeforeInitialization(ObjectexistingBean,StringbeanName)throwsBeansException;
29. ObjectapplyBeanPostProcessorsAfterInitialization(ObjectexistingBean,StringbeanName)throwsBeansException;
30. }
31. /*
32. *提供对BeanDefintion对象的管理操作。
33. *对通过BeanDefintionRegistry注册器注册到BeanFactory中的BeanDefintion对象进行管理，但注意此接口
34. *并不依赖于BeanDefintion接口API；
35. *此接口在操作上与BeanDefintionRegistry接口有重叠部分，但此接口的职责重在管理操作，而BeanDefintionRegistry重在注册操作，并且
36. *BeanDefintionRegistry接口直接依赖于BeanDefintion接口API。
37. */
38. publicinterfaceListableBeanFactory{
39. booleancontainsBeanDefinition(StringbeanName);
40. intgetBeanDefinitionCount();
41. String[]getBeanDefinitionNames();
42. String[]getBeanNamesForType(Classtype);
43. String[]getBeanNamesForType(Classtype,booleanincludePrototypes,booleanincludeFactoryBeans);
44. MapgetBeansOfType(Classtype)throwsBeansException;
45. MapgetBeansOfType(Classtype,booleanincludePrototypes,booleanincludeFactoryBeans)throwsBeansException;
46. }
47. //
48. publicinterfaceConfigurableListableBeanFactory
49. extendsListableBeanFactory,AutowireCapableBeanFactory,ConfigurableBeanFactory,SingletonBeanRegistry{
50. voidignoreDependencyType(Classtype);
51. voidignoreDependencyInterface(Classifc);
52. BeanDefinitiongetBeanDefinition(StringbeanName)throwsNoSuchBeanDefinitionException;
53. //在容器启动过程中实例化singleton类型bean对象。
54. voidpreInstantiateSingletons()throwsBeansException;
55. }
56. //注册BeanDefintion对象，并进行管理操作。
57. publicinterfaceBeanDefinitionRegistry{
58. intgetBeanDefinitionCount();
59. String[]getBeanDefinitionNames();
60. booleancontainsBeanDefinition(StringbeanName);
61. BeanDefinitiongetBeanDefinition(StringbeanName)throwsNoSuchBeanDefinitionException;
62. voidregisterBeanDefinition(StringbeanName,BeanDefinitionbeanDefinition)throwsBeansException;
63. String[]getAliases(StringbeanName)throwsNoSuchBeanDefinitionException;
64. voidregisterAlias(StringbeanName,Stringalias)throwsBeansException;
65. }
66. /*
67. *注册singleton类型对象，并进行管理操作；BeanDefinitionRegistry接口将BeanDefinition注册到BeanFactory中，此接口将singleton类型
68. *对象注册到BeanFactory中。
69. */
70. publicinterfaceSingletonBeanRegistry{
72. }

ApplicationEventPublisher接口是容器事件发布接口,

ApplicationEventPublisher接口的功能是委托给ApplicationEventMulticaster组件实现的，

ApplicationEventMulticaster组件提供对监听器的完整操作，包括新增监听器、移除单个或全部监听器、通知监听器。

Java代码

1. //容器事件发布器。
2. publicinterfaceApplicationEventPublisher{
3. voidpublishEvent(ApplicationEventevent);
4. }
5. //一个完整的事件模型实现。
6. publicinterfaceApplicationEventMulticaster{
7. voidaddApplicationListener(ApplicationListenerlistener);
8. voidremoveApplicationListener(ApplicationListenerlistener);
9. voidremoveAllListeners();
10. /*
11. *事件发布方法，通知所有监听器；
12. *ApplicationEventPublisher.publishEvent(ApplicationEvent)方法的实现委托给此方法完成。
13. */
14. voidmulticastEvent(ApplicationEventevent);
15. }
16. //监听器.
17. publicinterfaceApplicationListenerextendsjava.util.EventListener{
18. }
19. //事件对象.
20. publicclassextendsApplicationEventextendsjava.util.EventObject{
21. }

//容器事件发布器。

public interfaceApplicationEventPublisher {

voidpublishEvent(ApplicationEvent event);

}

//一个完整的事件模型实现。

public interfaceApplicationEventMulticaster {

voidaddApplicationListener(ApplicationListener listener);

voidremoveApplicationListener(ApplicationListener listener);

voidremoveAllListeners();

/*

*事件发布方法，通知所有监听器；

*ApplicationEventPublisher.publishEvent(ApplicationEvent)方法的实现委托给此方法完成。

*/

voidmulticastEvent(ApplicationEvent event);

}

//监听器.

public interfaceApplicationListener extends java.util.EventListener {

}

//事件对象.

public class extendsApplicationEvent extends java.util.EventObject {

}

MessageSource组件

MessageSourceResolvable组件

这是一个接口复用与组合复用协同工作的好例子，ApplicationContext接口继承了MessageSource接口，对外提供信息源处理操作，但内部实现委托给MessageSource组件完成。

Java代码

1. //SpringIoC容器的顶级接口.
2. publicinterfaceApplicationContextextendsListableBeanFactory,HierarchicalBeanFactory,
3. MessageSource,ApplicationEventPublisher,ResourcePatternResolver{
4. ApplicationContextgetParent();
5. AutowireCapableBeanFactorygetAutowireCapableBeanFactory()throwsIllegalStateException;
6. StringgetDisplayName();
7. longgetStartupDate();
8. }
9. //对容器对象进行配置化、初始化工作.
10. publicinterfaceConfigurableApplicationContextextendsApplicationContext,Lifecycle{
11. voidsetParent(ApplicationContextparent);
12. voidaddBeanFactoryPostProcessor(BeanFactoryPostProcessorbeanFactoryPostProcessor);
13. //此方法是核心方法，内部生成一个BeanFactory对象，并完成对BeanFactory对象的初始化和容器的初始化工作。
14. voidrefresh()throwsBeansException,IllegalStateException;
15. ConfigurableListableBeanFactorygetBeanFactory()throwsIllegalStateException;
16. voidclose();
17. }
18. //生命周期管理接口.
19. publicinterfaceLifecycle{
20. voidstart();
21. voidstop();
22. booleanisRunning();
23. }

WebApplicationContext

ConfigurableWebApplicationContext

AbstractRefreshWebApplicationContext

XmlWebApplicationContext

Java代码

1. //提供SpringIoC容器对Web环境ServletAPI的集成。
2. publicinterfaceWebApplicationContextextendsApplicationContext{
3. ServletContextgetServletContext();
4. }
5. //提供WebApplicationContext的配置工作。
6. publicinterfaceConfigurableWebApplicationContextextendsWebApplicationContext,ConfigurableApplicationContext{
7. voidsetServletContext(ServletContextservletContext);
8. voidsetServletConfig(ServletConfigservletConfig);
9. voidsetNamespace(Stringnamespace);
10. voidsetConfigLocations(String[]configLocations);
11. }

//提供SpringIoC容器对Web环境ServletAPI的集成。

public interfaceWebApplicationContext extends ApplicationContext {

ServletContext getServletContext();

}

//提供WebApplicationContext的配置工作。

public interfaceConfigurableWebApplicationContext 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. publicclassContextLoader{
3. publicWebApplicationContextinitWebApplicationContext(ServletContextservletContext){
4. //code.
5. }
6. publicvoidcloseWebApplicationContext(ServletContextservletContext){
7. //code.
8. }
9. }

//ContextLoader组件从ServletContext初始化配置参数中获取Spring的配置文件路径信息，并进行IoC容器的实例化、初始化、销毁操作。

public class ContextLoader {

public WebApplicationContextinitWebApplicationContext(ServletContext servletContext){

//code.

}

public void closeWebApplicationContext(ServletContextservletContext) {

//code.

}

}

ContextLoaderListener和ContextLoaderServlet提供两种方式将IoC容器集成到ServletContext缓存中。

从面向对象基本设计原则角度来看SpringIoC容器的设计：

最基本的两条设计原则--编程到接口、首选组合复用：

编程到接口，

在SpringIoC容器实现中，interface关键字随处可见，但是有一点需要注意的就是：并不是使用了interface关键字，就能保证编程到接口，

但一般来说对编程到接口原则的遵守，inteface关键字的使用是必须的。编程到接口所描述的实质是要将组件的外部接口和内部实现分离

开来，这将带来一系列的好处：可扩展性，可重用性，可维护性，依赖性，内聚性，耦合性，清晰性，简洁性，可读性，可修改性，

抽象性，封装性，模块化，层次化，测试性，其它特性。

首选组合复用，

面向对象的复用方式主要分两种--组合复用、继承复用，继承复用可以细分为两种--接口复用、具体复用，

这条原则关注的组合复用与具体复用之间的区别，

事实上这条原则针对复用方式的选择上意义并不大，因为这三种复用方式所处理的是不同的复用问题，一旦能够从has-a、is-like-a、is-a的角度

区分开，问题就不大了。

这条原则真正有意义的在于它的教训意义，可以借此了解这条原则形成的原因，全面了解复用的方式，了解每一种复用方式的特点，了解不同

复用方式之间的差别。

SpringIoC容器的设计很好的体现了这两条原则，如ApplicationContext接口

Java代码

1. publicinterfaceApplicationContextextendsListableBeanFactory,HierarchicalBeanFactory,
2. ssageSource,ApplicationEventPublisher,ResourcePatternResolver{
3. }

public interface ApplicationContext extendsListableBeanFactory, HierarchicalBeanFactory,

MessageSource, ApplicationEventPublisher, ResourcePatternResolver{

}

这是一个基于接口的设计，并且是一个接口复用，

ApplicationContext接口继承了ListableBeanFactory,HierarchicalBeanFactory,MessageSource,ApplicationEventPublisher,ResourcePatternResolver

接口，那么就意味着ApplicationContext可以提供这些接口中定义的所有功能，但是这些功能的实际实现并不是由ApplicationContext的实现类

提供的，而是以组合复用的方式委托给了各个接口的实际实现类来完成；

具体复用在接口的实现过程中所使用，以便将接口的设计层次与接口的实现层次分离开来，如：

Java代码

1. publicabstractclassAbstractAutowireCapableBeanFactoryextendsAbstractBeanFactoryimplementsAutowireCapableBeanFactory{
2. }

public abstract classAbstractAutowireCapableBeanFactory extends AbstractBeanFactory implementsAutowireCapableBeanFactory {

}

更为全面的设计原则描述：

单一职责、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、组合复用原则、迪米特法则；

共同重用原则、共同封闭原则，无环依赖原则、稳定依赖原则、稳定抽象原则，

总结：

要全面理解IOC容器，回答下述问题是必须的。

1。IOC容器是什么，

2。IOC容器提供什么样的功能，

3。IOC容器的特征是什么，

4。IOC容器设计的理论依据是什么，

5。IOC容器的设计需要注意的问题是什么，

6。如何实现一个IOC容器，

7。不同容器、不同IOC容器之间的比较，

参考目录：

《ExpertOne-on-OneJ2EEDesignandDevelopment》

《ExpertOne-on-OneJ2EEDevelopmentwithoutEJB》

《ProfessionalJavaDevelopmentwiththeSpringFramework》

《EffectiveJava》

《Refactoring-ImprovingtheDesignofExistingCode》

《AgileSoftwareDevelopmentPrinciples,Patterns,andPractices》

《Code CompleteII》