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

1. //将Resource中的内容通过BeanDefintionRegistry注册到BeanFactory中。 
2. public interface 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中加载BeanDefinition；

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

 *依赖于此方法的实现；

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

 */
      int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
}

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

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

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

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

*提供对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 {
}

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

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

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

 */
      void multicastEvent(ApplicationEvent event);
}
//监听器.
public interface ApplicationListener extends java.util.EventListener {
}
//事件对象.
public class extends ApplicationEvent extends java.util.EventObject {
}

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

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

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

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