- 浏览: 160079 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
fengwuqing40:
zxh277100963 写道有个bug String输入数字 ...
pinyin4j 中文转成拼音(支持多音字输出) -
pimkle:
楼主说的很好 评论补充的也好 像是解决了多音字的问题 可是还需 ...
pinyin4j 中文转成拼音(支持多音字输出) -
yangjianzhouctgu:
请问org.rut.util.algorithm.SortUt ...
java排序归总 -
zxh277100963:
有个bug String输入数字 报错
修改一下
...
pinyin4j 中文转成拼音(支持多音字输出) -
gejialun88:
java环境下使用jQuery进行JSON数据传送的交互过程
——摘自网络
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的工厂类,
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组件,
这三个组件(BeanDefintionParser组件,NamespaceHandler组件,NamespaceHandlerResolver组件)处理客户化的命名空间元素的解析,
此机制使用配置文件易于书写,具有可扩展性。
如spring提供的实现:<util:list>,<aop:config>,<tx:annotation-driven>,<context:annotation-config>,
第三方组件提供的实现:<jaxws:endpoint>,<amq:broker>等其它实现。
BeanWrapper组件,
对java bean对象提供设置属性值、获取属性值操作,并能够将字符串类型值转换为正确的类型,这个工作依赖于PropertyEditor。
操作示例:
beanWrapper.setPropertyValue("name","foo");
beanWrapper.setPropertyValue("address.country","China");
beanWrapper.setPropertyValue("array[2]","arrayValue");
ApplicationEventPublisher接口是容器事件发布接口,
ApplicationEventPublisher接口的功能是委托给ApplicationEventMulticaster组件实现的,
ApplicationEventMulticaster组件提供对监听器的完整操作,包括新增监听器、移除单个或全部监听器、通知监听器。
MessageSource组件
MessageSourceResolvable组件
这是一个接口复用与组合复用协同工作的好例子,ApplicationContext接口继承了MessageSource接口,对外提供信息源处理操作,但内部实现委托给MessageSource组件完成。
WebApplicationContext
ConfigurableWebApplicationContext
AbstractRefreshWebApplicationContext
XmlWebApplicationContext
ContextLoaderListener和ContextLoaderServlet提供两种方式将IoC容器集成到ServletContext缓存中。
从面向对象基本设计原则角度来看SpringIoC容器的设计:
最基本的两条设计原则--编程到接口、首选组合复用:
编程到接口,
在SpringIoC容器实现中,interface 关键字随处可见,但是有一点需要注意的就是:并不是使用了interface关键字,就能保证编程到接口,
但一般来说对编程到接口原则的遵守,inteface关键字的使用是必须的。编程到接口所描述的实质是要将组件的外部接口和内部实现分离
开来,这将带来一系列的好处:可扩展性,可重用性,可维护性,依赖性,内聚性,耦合性,清晰性,简洁性,可读性,可修改性,
抽象性,封装性,模块化,层次化,测试性,其它特性。
首选组合复用,
面向对象的复用方式主要分两种--组合复用、继承复用,继承复用可以细分为两种--接口复用、具体复用,
这条原则关注的组合复用与具体复用之间的区别,
事实上这条原则针对复用方式的选择上意义并不大,因为这三种复用方式所处理的是不同的复用问题,一旦能够从has-a、is-like-a、is-a的角度
区分开,问题就不大了。
这条原则真正有意义的在于它的教训意义,可以借此了解这条原则形成的原因,全面了解复用的方式,了解每一种复用方式的特点,了解不同
复用方式之间的差别。
SpringIoC容器的设计很好的体现了这两条原则,如ApplicationContext接口
这是一个基于接口的设计,并且是一个接口复用,
ApplicationContext接口继承了ListableBeanFactory,HierarchicalBeanFactory,MessageSource,ApplicationEventPublisher,ResourcePatternResolver
接口,那么就意味着 ApplicationContext可以提供这些接口中定义的所有功能,但是这些功能的实际实现并不是由ApplicationContext的实现类
提供的,而是以组合复用的方式委托给了各个接口的实际实现类来完成;
具体复用在接口的实现过程中所使用,以便将接口的设计层次与接口的实现层次分离开来,如:
更为全面的设计原则描述:
单一职责、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、组合复用原则、迪米特法则;
共同重用原则、共同封闭原则,无环依赖原则、稳定依赖原则、稳定抽象原则,
总结:
要全面理解IOC容器,回答下述问题是必须的。
1。IOC容器是什么,
2。IOC容器提供什么样的功能,
3。IOC容器的特征是什么,
4。IOC容器设计的理论依据是什么,
5。IOC容器的设计需要注意的问题是什么,
6。如何实现一个IOC容器,
7。不同容器、不同IOC容器之间的比较,
参考目录:
《Expert One-on-One J2EE Design and Development》
《Expert One-on-One J2EE Development without EJB》
《Professional Java Development with the Spring Framework》
《Effective Java》
《Refactoring-Improving the Design of Existing Code》
《Agile Software Development Principles,Patterns,and Practices》
《Code Complete II》
观察的角度:
从外部接口,内部实现,组成部分,执行过程四个方面来认识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的工厂类,
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组件,
- //将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;
- }
//将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; }
- //XmlBeanDefinitionParser组件处理配置文件中默认命名空间的元素解析,
- public interface XmlBeanDefinitionParser {
- //对Document文档的解析,将解析出的内容封装到BeanDefintion中。
- void registerBeanDefinitions(Document doc, ReaderContext readerContext)throws BeanDefinitionStoreException;
- }
//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>等其它实现。
- //对客户化命名空间的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);
- }
//对客户化命名空间的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");
- //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;
- }
//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; }
- //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 {
- }
//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组件提供对监听器的完整操作,包括新增监听器、移除单个或全部监听器、通知监听器。
- //容器事件发布器。
- 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 {
- }
//容器事件发布器。 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组件完成。
- //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();
- }
//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
- //提供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);
- }
//提供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); }
- //ContextLoader组件从ServletContext初始化配置参数中获取Spring的配置文件路径信息,并进行IoC容器的实例化、初始化、销毁操作。
- public class ContextLoader {
- public WebApplicationContext initWebApplicationContext(ServletContext servletContext){
- //code.
- }
- public void closeWebApplicationContext(ServletContext servletContext) {
- //code.
- }
- }
//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接口
- public interface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory,
- ssageSource, ApplicationEventPublisher, ResourcePatternResolver {
- }
public interface ApplicationContext extends ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver { }
这是一个基于接口的设计,并且是一个接口复用,
ApplicationContext接口继承了ListableBeanFactory,HierarchicalBeanFactory,MessageSource,ApplicationEventPublisher,ResourcePatternResolver
接口,那么就意味着 ApplicationContext可以提供这些接口中定义的所有功能,但是这些功能的实际实现并不是由ApplicationContext的实现类
提供的,而是以组合复用的方式委托给了各个接口的实际实现类来完成;
具体复用在接口的实现过程中所使用,以便将接口的设计层次与接口的实现层次分离开来,如:
- public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
- }
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { }
更为全面的设计原则描述:
单一职责、开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、组合复用原则、迪米特法则;
共同重用原则、共同封闭原则,无环依赖原则、稳定依赖原则、稳定抽象原则,
总结:
要全面理解IOC容器,回答下述问题是必须的。
1。IOC容器是什么,
2。IOC容器提供什么样的功能,
3。IOC容器的特征是什么,
4。IOC容器设计的理论依据是什么,
5。IOC容器的设计需要注意的问题是什么,
6。如何实现一个IOC容器,
7。不同容器、不同IOC容器之间的比较,
参考目录:
《Expert One-on-One J2EE Design and Development》
《Expert One-on-One J2EE Development without EJB》
《Professional Java Development with the Spring Framework》
《Effective Java》
《Refactoring-Improving the Design of Existing Code》
《Agile Software Development Principles,Patterns,and Practices》
《Code Complete II》
相关推荐
《Spring IOC容器实现分析》 在Java开发领域,Spring框架无疑是使用最为广泛的轻量级框架之一,其中的核心组件就是IOC(Inversion of Control)容器。本文将深入剖析Spring的IOC容器,理解其工作原理和重要功能,以...
Spring IoC容器是Spring框架的核心,它负责管理应用对象的生命周期和依赖关系。通过对IoC(Inversion of Control,控制反转)的实现,Spring容器将对象的创建和组装工作从应用代码中分离出来,使得应用更易于测试和...
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一,它提供了一个统一的依赖注入机制,使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
### Spring IOC容器实现分析 #### 一、Spring IOC容器概览 Spring框架作为一款轻量级的开源框架,其核心之一便是IOC(Inversion of Control)容器。该容器的主要功能在于管理和控制对象间的依赖关系,使得开发人员...
文档可能将深入探讨Spring IoC容器初始化、Bean生命周期管理、依赖注入等关键概念,并以2021年的开源版本为背景进行分析。 从提供的部分文档内容来看,我们可以提炼出以下几个知识点: 1. **BeanFactory与...
spring-context:上下文,即IOC容器 spring-context-support:对IOC的扩展,以及IOC子容器 spring-context-indexer:类管理组件和Classpath扫描 spring-expression:表达式语句 切面编程: spring-aop:面向切面编程,...
而Spring通过其IoC容器实现了对对象的创建、配置和管理过程的解耦,使得开发人员可以更加关注业务逻辑的实现。 - **控制反转**:控制反转是指将原本由程序控制的部分(如对象创建)交给外部容器(在这里是Spring...
通过对Spring IoC容器的理解和源码分析,我们可以深入了解到Spring框架是如何管理和控制应用对象的生命周期及依赖关系的。在实际开发中,了解Spring IoC容器的工作原理有助于更好地利用Spring框架,提高开发效率和...
IoC使得应用程序中的对象不再负责创建和管理它们的依赖对象,而是将这个责任交给了一个外部的容器,即Spring的IoC容器。这种设计模式使得代码更加灵活,易于测试和维护。 在Spring中,IoC容器负责管理对象,这些...
### Spring源码分析_Spring_IOC:深入理解Spring的IOC容器机制 #### 基本概念与核心作用 在探讨Spring框架的核心组件之一——IOC(Inversion of Control,控制反转)容器之前,首先需要理解它在Spring框架中的角色...
Spring框架的核心就是IOC容器,它负责管理对象的生命周期和对象间的依赖关系,使得开发者可以摆脱繁杂的依赖注入工作,专注于业务逻辑的实现。 首先,我们需要理解IOC的概念。IOC是控制反转,它的核心思想是将对象...
传统的程序设计中,通常是调用者主动去创建依赖对象或者调用依赖对象的方法,而在Spring框架中的IOC容器则负责将被依赖对象传入到调用者之中。这种模式使得组件之间的依赖关系由容器在运行期决定,即由容器动态地将...
标题中的“山寨spring_ioc容器”指的是一个非官方的、模仿Spring框架实现的IoC(Inversion of Control,控制反转)容器。这个容器可能是由个人开发者或者小团队创建的,目的是为了学习Spring的核心机制,或者在某些...
在mySpring框架中,我们可以按照上述思路,逐步实现IOC容器和MVC模型。首先,构建一个简单的配置解析器,然后实现bean的实例化和依赖注入。接着,设计Controller的注册和调用机制,以及视图解析过程。最后,将这些...
总的来说,这篇博客文章会涵盖Spring IoC容器的基本概念、配置方式、依赖注入以及可能深入到源码分析和实际开发中的应用。通过学习这些内容,开发者能够更有效地利用Spring框架,构建更加灵活、可维护的Java应用程序...
Spring框架中的IOC容器是实现DI的核心,它负责管理对象(称为Bean)的生命周期和依赖关系。 二、Spring IOC体系结构 Spring的IOC体系主要由BeanFactory和BeanDefinition组成。BeanFactory是Spring容器的基础接口,...
6. **自定义实现Spring IOC**:虽然Spring提供了强大的IOC容器,但理解其工作原理有助于我们自定义实现。我们可以创建一个类来加载Bean定义,解析XML配置,然后使用反射创建和初始化对象,最后根据依赖关系图进行...
在Spring框架中,IoC(Inversion of Control,控制反转)是一种设计模式,它通过将对象的创建和管理交给一个外部容器(也就是IoC容器)来实现,从而解耦了对象之间的依赖关系。Spring IoC容器是实现这一模式的核心...
Spring IoC容器通过配置文件或注解来定义对象及其依赖关系。这种依赖注入(Dependency Injection,DI)的方式允许我们声明性地配置组件,而不是硬编码依赖。在“Java进阶之SpringIoC应用共18页.pdf”文档中,可能会...