- 浏览: 755044 次
- 性别:
- 来自: 郑州
文章分类
- 全部博客 (396)
- JAVA (50)
- ORACLE (22)
- HIBERNATE (1)
- SPRING (26)
- STRUTS (4)
- OTHERS (0)
- MYSQL (11)
- Struts2 (16)
- JS (33)
- Tomcat (6)
- DWR (1)
- JQuery (26)
- JBoss (0)
- SQL SERVER (0)
- XML (10)
- 生活 (3)
- JSP (11)
- CSS (5)
- word (1)
- MyEclipse (7)
- JSTL (1)
- JEECMS (2)
- Freemarker (8)
- 页面特效 (1)
- EXT (2)
- Web前端 js库 (2)
- JSON http://www.json.org (3)
- 代码收集 (1)
- 电脑常识 (6)
- MD5加密 (0)
- Axis (0)
- Grails (1)
- 浏览器 (1)
- js调试工具 (1)
- WEB前端 (5)
- JDBC (2)
- PowerDesigner (1)
- OperaMasks (1)
- CMS (1)
- Java开源大全 (2)
- 分页 (28)
- Eclipse插件 (1)
- Proxool (1)
- Jad (1)
- Java反编译 (2)
- 报表 (6)
- JSON (14)
- FCKeditor (9)
- SVN (1)
- ACCESS (1)
- 正则表达式 (3)
- 数据库 (1)
- Flex (3)
- pinyin4j (2)
- IBATIS (3)
- probe (1)
- JSP & Servlet (1)
- 飞信 (0)
- AjaxSwing (0)
- AjaxSwing (0)
- Grid相关 (1)
- HTML (5)
- Guice (4)
- Warp framework (1)
- warp-persist (1)
- 服务器推送 (3)
- eclipse (1)
- JForum (5)
- 工具 (1)
- Python (1)
- Ruby (1)
- SVG (3)
- Joda-Time日期时间工具 (1)
- JDK (3)
- Pushlet (2)
- JSP & Servlet & FTP (1)
- FTP (6)
- 时间与效率 (4)
- 二维码 (1)
- 条码/二维码 (1)
最新评论
-
ctrlc:
你这是从web服务器上传到FTP服务器上的吧,能从用户电脑上上 ...
jsp 往 FTP 上传文件问题 -
annybz:
说的好抽象 为什么代码都有两遍。这个感觉没有第一篇 和第二篇 ...
Spring源代码解析(三):Spring JDBC -
annybz:
...
Spring源代码解析(一):IOC容器 -
jie_20:
你确定你有这样配置做过测试? 请不要转载一些自己没有测试的文档 ...
Spring2.0集成iReport报表技术概述 -
asd51731:
大哥,limit传-1时出错啊,怎么修改啊?
mysql limit 使用方法
在Spring中,IOC容器的重要地位我们就不多说了,对于Spring的使用者而言,IOC容器实际上是什么呢?我们可以说
BeanFactory就是我们看到的IoC容器,当然了Spring为我们准备了许多种IoC容器来使用,这样可以方便我们从不同的层面,不同的资源位
置,不同的形式的定义信息来建立我们需要的IoC容器。
在Spring中,最基本的IOC容器接口是BeanFactory -
这个接口为具体的IOC容器的实现作了最基本的功能规定 - 不管怎么着,作为IOC容器,这些接口你必须要满足应用程序的最基本要求:
- public interface BeanFactory {
- //这里是对FactoryBean的转义定义,因为如果使用 bean的名字检索FactoryBean得到的对象是工厂生成的对象,
- //如果需要得到工厂本身,需要转义
- String FACTORY_BEAN_PREFIX = "&" ;
- //这里根据bean的名字,在IOC容器中得到bean实 例,这个IOC容器就是一个大的抽象工厂。
- Object getBean(String name) throws BeansException;
- //这里根据bean的名字和Class类型来得到bean实 例,和上面的方法不同在于它会抛出异常:如果根据名字取得的bean实例的Class类型和需要的不同的话。
- Object getBean(String name, Class requiredType) throws BeansException;
- //这里提供对bean的检索,看看是否在IOC容器有这个名 字的bean
- boolean containsBean(String name);
- //这里根据bean名字得到bean实例,并同时判断这个 bean是不是单件
- boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
- //这里对得到bean实例的Class类型
- Class getType(String name) throws NoSuchBeanDefinitionException;
- //这里得到bean的别名,如果根据别名检索,那么其原名也 会被检索出来
- String[] getAliases(String name);
- }
public interface BeanFactory { //这里是对FactoryBean的转义定义,因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象, //如果需要得到工厂本身,需要转义 String FACTORY_BEAN_PREFIX = "&"; //这里根据bean的名字,在IOC容器中得到bean实例,这个IOC容器就是一个大的抽象工厂。 Object getBean(String name) throws BeansException; //这里根据bean的名字和Class类型来得到bean实例,和上面的方法不同在于它会抛出异常:如果根据名字取得的bean实例的Class类型和需要的不同的话。 Object getBean(String name, Class requiredType) throws BeansException; //这里提供对bean的检索,看看是否在IOC容器有这个名字的bean boolean containsBean(String name); //这里根据bean名字得到bean实例,并同时判断这个bean是不是单件 boolean isSingleton(String name) throws NoSuchBeanDefinitionException; //这里对得到bean实例的Class类型 Class getType(String name) throws NoSuchBeanDefinitionException; //这里得到bean的别名,如果根据别名检索,那么其原名也会被检索出来 String[] getAliases(String name); }
在BeanFactory里只对IOC容器的基本行为作了定义,根本不关心你的bean是怎样定义怎样加载的 -
就像我们只关心从这个工厂里我们得到到什么产品对象,至于工厂是怎么生产这些对象的,这个基本的接口不关心这些。如果要关心工厂是怎样产生对象的,应用程
序需要使用具体的IOC容器实现-
当然你可以自己根据这个BeanFactory来实现自己的IOC容器,但这个没有必要,因为Spring已经为我们准备好了一系列工厂来让我们使用。比
如XmlBeanFactory就是针对最基础的BeanFactory的IOC容器的实现 - 这个实现使用xml来定义IOC容器中的bean。
Spring
提供了一个BeanFactory的基本实现,XmlBeanFactory同样的通过使用模板模式来得到对IOC容器的抽象-
AbstractBeanFactory,DefaultListableBeanFactory这些抽象类为其提供模板服务。其中通过resource
接口来抽象bean定义数据,对Xml定义文件的解析通过委托给XmlBeanDefinitionReader来完成。下面我们根据书上的例子,简单的
演示IOC容器的创建过程:
- ClassPathResource res = new ClassPathResource( "beans.xml" );
- DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
- XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
- reader.loadBeanDefinitions(res);
ClassPathResource res = new ClassPathResource("beans.xml"); DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory); reader.loadBeanDefinitions(res);
这些代码演示了以下几个步骤:
1. 创建IOC配置文件的抽象资源
2.
创建一个BeanFactory
3.
把读取配置信息的BeanDefinitionReader,这里是XmlBeanDefinitionReader配置给BeanFactory
4.
从定义好的资源位置读入配置信息,具体的解析过程由XmlBeanDefinitionReader来完成,这样完成整个载入bean定义的过程。我们的
IoC容器就建立起来了。在BeanFactory的源代码中我们可以看到:
- public class XmlBeanFactory extends DefaultListableBeanFactory {
- //这里为容器定义了一个默认使用的bean定义读取器
- private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader( this );
- public XmlBeanFactory(Resource resource) throws BeansException {
- this (resource, null );
- }
- //在初始化函数中使用读取器来对资源进行读取,得到bean 定义信息。
- public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
- super (parentBeanFactory);
- this .reader.loadBeanDefinitions(resource);
- }
public class XmlBeanFactory extends DefaultListableBeanFactory { //这里为容器定义了一个默认使用的bean定义读取器 private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this); public XmlBeanFactory(Resource resource) throws BeansException { this(resource, null); } //在初始化函数中使用读取器来对资源进行读取,得到bean定义信息。 public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException { super(parentBeanFactory); this.reader.loadBeanDefinitions(resource); }
我们在后面会看到读取器读取资源和注册bean定义信息的整个过程,基本上是和上下文的处理是一样的,从这里我们可以看到上下文和
XmlBeanFactory这两种IOC容器的区别,BeanFactory往往不具备对资源定义的能力,而上下文可以自己完成资源定义,从这个角度上
看上下文更好用一些。
仔细分析Spring
BeanFactory的结构,我们来看看在BeanFactory基础上扩展出的ApplicationContext -
我们最常使用的上下文。除了具备BeanFactory的全部能力,上下文为应用程序又增添了许多便利:
*
可以支持不同的信息源,我们看到ApplicationContext扩展了MessageSource
* 访问资源 ,
体现在对ResourceLoader和Resource的支持上面,这样我们可以从不同地方得到bean定义资源
*
支持应用事件,继承了接口ApplicationEventPublisher,这样在上下文中引入了事件机制而BeanFactory是没有的。
ApplicationContext
允许上下文嵌套 - 通过保持父上下文可以维持一个上下文体系 -
这个体系我们在以后对Web容器中的上下文环境的分析中可以清楚地看到。对于bean的查找可以在这个上下文体系中发生,首先检查当前上下文,其次是父上
下文,逐级向上,这样为不同的Spring应用提供了一个共享的bean定义环境。这个我们在分析Web容器中的上下文环境时也能看到。
ApplicationContext
提供IoC容器的主要接口,在其体系中有许多抽象子类比如AbstractApplicationContext为具体的BeanFactory的实现,
比如FileSystemXmlApplicationContext和
ClassPathXmlApplicationContext提供上下文的模板,使得他们只需要关心具体的资源定位问题。当应用程序代码实例化
FileSystemXmlApplicationContext的时候,得到IoC容器的一种具体表现 -
ApplicationContext,从而应用程序通过ApplicationContext来管理对bean的操作。
BeanFactory
是一个接口,在实际应用中我们一般使用ApplicationContext来使用IOC容器,它们也是IOC容器展现给应用开发者的使用接口。对应用程
序开发者来说,可以认为BeanFactory和ApplicationFactory在不同的使用层面上代表了SPRING提供的IOC容器服务。
下
面我们具体看看通过FileSystemXmlApplicationContext是怎样建立起IOC容器的,
显而易见我们可以通过new来得到IoC容器:
ApplicationContext = new FileSystemXmlApplicationContext(xmlPath);
调用的是它初始化代码:
- public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
- throws BeansException {
- super (parent);
- this .configLocations = configLocations;
- if (refresh) {
- //这里是IoC容器的初始化过程,其初始化过程的大致 步骤由AbstractApplicationContext来定义
- refresh();
- }
- }
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException { super(parent); this.configLocations = configLocations; if (refresh) { //这里是IoC容器的初始化过程,其初始化过程的大致步骤由AbstractApplicationContext来定义 refresh(); } }
refresh的模板在AbstractApplicationContext:
- public void refresh() throws BeansException, IllegalStateException {
- synchronized ( this .startupShutdownMonitor) {
- synchronized ( this .activeMonitor) {
- this .active = true ;
- }
- // 这里需要子类来协助完成资源位置定义,bean 载入和向IOC容器注册的过程
- refreshBeanFactory();
- ............
- }
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { synchronized (this.activeMonitor) { this.active = true; } // 这里需要子类来协助完成资源位置定义,bean载入和向IOC容器注册的过程 refreshBeanFactory(); ............ }
这个方法包含了整个BeanFactory初始化的过程,对于特定的FileSystemXmlBeanFactory,我们看到定位资源
位置由refreshBeanFactory()来实现:
在AbstractXmlApplicationContext中定义了对资源的读取
过程,默认由XmlBeanDefinitionReader来读取:
- protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
- // 这里使用 XMLBeanDefinitionReader来载入bean定义信息的XML文件
- XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
- //这里配置reader的环境,其中 ResourceLoader是我们用来定位bean定义信息资源位置的
- ///因为上下文本身实现了ResourceLoader接 口,所以可以直接把上下文作为ResourceLoader传递给XmlBeanDefinitionReader
- beanDefinitionReader.setResourceLoader( this );
- beanDefinitionReader.setEntityResolver( new ResourceEntityResolver( this ));
- initBeanDefinitionReader(beanDefinitionReader);
- //这里转到定义好的 XmlBeanDefinitionReader中对载入bean信息进行处理
- loadBeanDefinitions(beanDefinitionReader);
- }
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException { // 这里使用XMLBeanDefinitionReader来载入bean定义信息的XML文件 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); //这里配置reader的环境,其中ResourceLoader是我们用来定位bean定义信息资源位置的 ///因为上下文本身实现了ResourceLoader接口,所以可以直接把上下文作为ResourceLoader传递给XmlBeanDefinitionReader beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); initBeanDefinitionReader(beanDefinitionReader); //这里转到定义好的XmlBeanDefinitionReader中对载入bean信息进行处理 loadBeanDefinitions(beanDefinitionReader); }
转到beanDefinitionReader中进行处理:
- protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
- Resource[] configResources = getConfigResources();
- if (configResources != null ) {
- //调用 XmlBeanDefinitionReader来载入bean定义信息。
- reader.loadBeanDefinitions(configResources);
- }
- String[] configLocations = getConfigLocations();
- if (configLocations != null ) {
- reader.loadBeanDefinitions(configLocations);
- }
- }
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException { Resource[] configResources = getConfigResources(); if (configResources != null) { //调用XmlBeanDefinitionReader来载入bean定义信息。 reader.loadBeanDefinitions(configResources); } String[] configLocations = getConfigLocations(); if (configLocations != null) { reader.loadBeanDefinitions(configLocations); } }
而在作为其抽象父类的AbstractBeanDefinitionReader中来定义载入过程:
- public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
- //这里得到当前定义的ResourceLoader,默认的我们使 用DefaultResourceLoader
- ResourceLoader resourceLoader = getResourceLoader();
- ......... //如果没有找到我们需要的 ResourceLoader,直接抛出异常
- if (resourceLoader instanceof ResourcePatternResolver) {
- // 这里处理我们在定义位置时使用的各种 pattern,需要ResourcePatternResolver来完成
- try {
- Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
- int loadCount = loadBeanDefinitions(resources);
- return loadCount;
- }
- ........
- }
- else {
- // 这里通过ResourceLoader来完成位 置定位
- Resource resource = resourceLoader.getResource(location);
- // 这里已经把一个位置定义转化为Resource 接口,可以供XmlBeanDefinitionReader来使用了
- int loadCount = loadBeanDefinitions(resource);
- return loadCount;
- }
- }
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException { //这里得到当前定义的ResourceLoader,默认的我们使用DefaultResourceLoader ResourceLoader resourceLoader = getResourceLoader(); .........//如果没有找到我们需要的ResourceLoader,直接抛出异常 if (resourceLoader instanceof ResourcePatternResolver) { // 这里处理我们在定义位置时使用的各种pattern,需要ResourcePatternResolver来完成 try { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); int loadCount = loadBeanDefinitions(resources); return loadCount; } ........ } else { // 这里通过ResourceLoader来完成位置定位 Resource resource = resourceLoader.getResource(location); // 这里已经把一个位置定义转化为Resource接口,可以供XmlBeanDefinitionReader来使用了 int loadCount = loadBeanDefinitions(resource); return loadCount; } }
当我们通过ResourceLoader来载入资源,别忘了了我们的GenericApplicationContext也实现了
ResourceLoader接口:
- public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
- public Resource getResource(String location) {
- //这里调用当前的loader也就是 DefaultResourceLoader来完成载入
- if ( this .resourceLoader != null ) {
- return this .resourceLoader.getResource(location);
- }
- return super .getResource(location);
- }
- .......
- }
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry { public Resource getResource(String location) { //这里调用当前的loader也就是DefaultResourceLoader来完成载入 if (this.resourceLoader != null) { return this.resourceLoader.getResource(location); } return super.getResource(location); } ....... }
而我们的FileSystemXmlApplicationContext就是一个DefaultResourceLoader -
GenericApplicationContext()通过DefaultResourceLoader:
- public Resource getResource(String location) {
- //如果是类路径的方式,那需要使用 ClassPathResource来得到bean文件的资源对象
- if (location.startsWith(CLASSPATH_URL_PREFIX)) {
- return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
- }
- else {
- try {
- // 如果是URL方式,使用 UrlResource作为bean文件的资源对象
- URL url = new URL(location);
- return new UrlResource(url);
- }
- catch (MalformedURLException ex) {
- // 如果都不是,那我们只能委托给子类由子 类来决定使用什么样的资源对象了
- return getResourceByPath(location);
- }
- }
- }
public Resource getResource(String location) { //如果是类路径的方式,那需要使用ClassPathResource来得到bean文件的资源对象 if (location.startsWith(CLASSPATH_URL_PREFIX)) { return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader()); } else { try { // 如果是URL方式,使用UrlResource作为bean文件的资源对象 URL url = new URL(location); return new UrlResource(url); } catch (MalformedURLException ex) { // 如果都不是,那我们只能委托给子类由子类来决定使用什么样的资源对象了 return getResourceByPath(location); } } }
我们的FileSystemXmlApplicationContext本身就是是DefaultResourceLoader的实现类,
他实现了以下的接口:
- protected Resource getResourceByPath(String path) {
- if (path != null && path.startsWith( "/" )) {
- path = path.substring( 1 );
- }
- //这里使用文件系统资源对象来定义bean文件
- return new FileSystemResource(path);
- }
protected Resource getResourceByPath(String path) { if (path != null && path.startsWith("/")) { path = path.substring(1); } //这里使用文件系统资源对象来定义bean文件 return new FileSystemResource(path); }
这样代码就回到了FileSystemXmlApplicationContext中来,他提供了FileSystemResource来
完成从文件系统得到配置文件的资源定义。这样,就可以从文件系统路径上对IOC配置文件进行加载 -
当然我们可以按照这个逻辑从任何地方加载,在Spring中我们看到它提供的各种资源抽象,比如ClassPathResource,
URLResource,FileSystemResource等来供我们使用。上面我们看到的是定位Resource的一个过程,而这只是加载过程的一
部分 -
我们回到AbstractBeanDefinitionReaderz中的loadDefinitions(resource)来看看得到代表bean文
件的资源定义以后的载入过程,默认的我们使用XmlBeanDefinitionReader:
- public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
- .......
- try {
- //这里通过Resource得到 InputStream的IO流
- InputStream inputStream = encodedResource.getResource().getInputStream();
- try {
- //从InputStream中得到XML的 解析源
- InputSource inputSource = new InputSource(inputStream);
- if (encodedResource.getEncoding() != null ) {
- inputSource.setEncoding(encodedResource.getEncoding());
- }
- //这里是具体的解析和注册过程
- return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
- }
- finally {
- //关闭从Resource中得到的IO流
- inputStream.close();
- }
- }
- .........
- }
- protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
- throws BeanDefinitionStoreException {
- try {
- int validationMode = getValidationModeForResource(resource);
- //通过解析得到DOM,然后完成bean在IOC容 器中的注册
- Document doc = this .documentLoader.loadDocument(
- inputSource, this .entityResolver, this .errorHandler, validationMode, this .namespaceAware);
- return registerBeanDefinitions(doc, resource);
- }
- .......
- }
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { ....... try { //这里通过Resource得到InputStream的IO流 InputStream inputStream = encodedResource.getResource().getInputStream(); try { //从InputStream中得到XML的解析源 InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } //这里是具体的解析和注册过程 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { //关闭从Resource中得到的IO流 inputStream.close(); } } ......... } protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { int validationMode = getValidationModeForResource(resource); //通过解析得到DOM,然后完成bean在IOC容器中的注册 Document doc = this.documentLoader.loadDocument( inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware); return registerBeanDefinitions(doc, resource); } ....... }
我们看到先把定义文件解析为DOM对象,然后进行具体的注册过程:
- public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
- // 这里定义解析器,使用 XmlBeanDefinitionParser来解析xml方式的bean定义文件 - 现在的版本不用这个解析器了,使用的是 XmlBeanDefinitionReader
- if ( this .parserClass != null ) {
- XmlBeanDefinitionParser parser =
- (XmlBeanDefinitionParser) BeanUtils.instantiateClass( this .parserClass);
- return parser.registerBeanDefinitions( this , doc, resource);
- }
- // 具体的注册过程,首先得到 XmlBeanDefinitionReader,来处理xml的bean定义文件
- BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
- int countBefore = getBeanFactory().getBeanDefinitionCount();
- documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
- return getBeanFactory().getBeanDefinitionCount() - countBefore;
- }
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 这里定义解析器,使用XmlBeanDefinitionParser来解析xml方式的bean定义文件 - 现在的版本不用这个解析器了,使用的是XmlBeanDefinitionReader if (this.parserClass != null) { XmlBeanDefinitionParser parser = (XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass); return parser.registerBeanDefinitions(this, doc, resource); } // 具体的注册过程,首先得到XmlBeanDefinitionReader,来处理xml的bean定义文件 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); int countBefore = getBeanFactory().getBeanDefinitionCount(); documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); return getBeanFactory().getBeanDefinitionCount() - countBefore; }
具体的在BeanDefinitionDocumentReader中完成对,下面是一个简要的注册过程来完成bean定义文件的解析和
IOC容器中bean的初始化
- public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
- this .readerContext = readerContext;
- logger.debug( "Loading bean definitions" );
- Element root = doc.getDocumentElement();
- BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
- preProcessXml(root);
- parseBeanDefinitions(root, delegate);
- postProcessXml(root);
- }
- protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
- if (delegate.isDefaultNamespace(root.getNamespaceURI())) {
- //这里得到xml文件的子节点,比如各个bean节 点
- NodeList nl = root.getChildNodes();
- //这里对每个节点进行分析处理
- for ( int i = 0 ; i < nl.getLength(); i++) {
- Node node = nl.item(i);
- if (node instanceof Element) {
- Element ele = (Element) node;
- String namespaceUri = ele.getNamespaceURI();
- if (delegate.isDefaultNamespace(namespaceUri)) {
- //这里是解析过程的调用, 对缺省的元素进行分析比如bean元素
- parseDefaultElement(ele, delegate);
- }
- else {
- delegate.parseCustomElement(ele);
- }
- }
- }
- } else {
- delegate.parseCustomElement(root);
- }
- }
- private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
- //这里对元素Import进行处理
- if (DomUtils.nodeNameEquals(ele, IMPORT_ELEMENT)) {
- importBeanDefinitionResource(ele);
- }
- else if (DomUtils.nodeNameEquals(ele, ALIAS_ELEMENT)) {
- String name = ele.getAttribute(NAME_ATTRIBUTE);
- String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
- getReaderContext().getReader().getBeanFactory().registerAlias(name, alias);
- getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
- }
- //这里对我们最熟悉的bean元素进行处理
- else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) {
- //委托给 BeanDefinitionParserDelegate来完成对bean元素的处理,这个类包含了具体的bean解析的过程。
- // 把解析bean文件得到的信息放到 BeanDefinition里,他是bean信息的主要载体,也是IOC容器的管理对象。
- BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
- if (bdHolder != null ) {
- bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
- // 这里是向IOC容器注册,实际上是放到 IOC容器的一个map里
- BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
- // 这里向IOC容器发送事件,表示解析和 注册完成。
- getReaderContext().fireComponentRegistered( new BeanComponentDefinition(bdHolder));
- }
- }
- }
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { this.readerContext = readerContext; logger.debug("Loading bean definitions"); Element root = doc.getDocumentElement(); BeanDefinitionParserDelegate delegate = createHelper(readerContext, root); preProcessXml(root); parseBeanDefinitions(root, delegate); postProcessXml(root); } protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root.getNamespaceURI())) { //这里得到xml文件的子节点,比如各个bean节点 NodeList nl = root.getChildNodes(); //这里对每个节点进行分析处理 for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; String namespaceUri = ele.getNamespaceURI(); if (delegate.isDefaultNamespace(namespaceUri)) { //这里是解析过程的调用,对缺省的元素进行分析比如bean元素 parseDefaultElement(ele, delegate); } else { delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } } private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //这里对元素Import进行处理 if (DomUtils.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } else if (DomUtils.nodeNameEquals(ele, ALIAS_ELEMENT)) { String name = ele.getAttribute(NAME_ATTRIBUTE); String alias = ele.getAttribute(ALIAS_ATTRIBUTE); getReaderContext().getReader().getBeanFactory().registerAlias(name, alias); getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); } //这里对我们最熟悉的bean元素进行处理 else if (DomUtils.nodeNameEquals(ele, BEAN_ELEMENT)) { //委托给BeanDefinitionParserDelegate来完成对bean元素的处理,这个类包含了具体的bean解析的过程。 // 把解析bean文件得到的信息放到BeanDefinition里,他是bean信息的主要载体,也是IOC容器的管理对象。 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 这里是向IOC容器注册,实际上是放到IOC容器的一个map里 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 这里向IOC容器发送事件,表示解析和注册完成。 getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } } }
我们看到在parseBeanDefinition中对具体bean元素的解析式交给
BeanDefinitionParserDelegate来完成的,下面我们看看解析完的bean是怎样在IOC容器中注册的:
在
BeanDefinitionReaderUtils调用的是:
- public static void registerBeanDefinition(
- BeanDefinitionHolder bdHolder, BeanDefinitionRegistry beanFactory) throws BeansException {
- // 这里得到需要注册bean的名字;
- String beanName = bdHolder.getBeanName();
- //这是调用IOC来注册的bean的过程,需要得到 BeanDefinition
- beanFactory.registerBeanDefinition(beanName, bdHolder.getBeanDefinition());
- // 别名也是可以通过IOC容器和bean联系起来的进行注 册
- String[] aliases = bdHolder.getAliases();
- if (aliases != null ) {
- for ( int i = 0 ; i < aliases.length; i++) {
- beanFactory.registerAlias(beanName, aliases[i]);
- }
- }
- }
public static void registerBeanDefinition( BeanDefinitionHolder bdHolder, BeanDefinitionRegistry beanFactory) throws BeansException { // 这里得到需要注册bean的名字; String beanName = bdHolder.getBeanName(); //这是调用IOC来注册的bean的过程,需要得到BeanDefinition beanFactory.registerBeanDefinition(beanName, bdHolder.getBeanDefinition()); // 别名也是可以通过IOC容器和bean联系起来的进行注册 String[] aliases = bdHolder.getAliases(); if (aliases != null) { for (int i = 0; i < aliases.length; i++) { beanFactory.registerAlias(beanName, aliases[i]); } } }
我们看看XmlBeanFactory中的注册实现:
- //---------------------------------------------------------------------
- // 这里是IOC容器对BeanDefinitionRegistry接口的实现
- //---------------------------------------------------------------------
- public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
- throws BeanDefinitionStoreException {
- ..... //这里省略了对BeanDefinition的验 证过程
- //先看看在容器里是不是已经有了同名的bean,如果有抛出 异常。
- Object oldBeanDefinition = this .beanDefinitionMap.get(beanName);
- if (oldBeanDefinition != null ) {
- if (! this .allowBeanDefinitionOverriding) {
- ...........
- }
- else {
- //把bean的名字加到IOC容器中去
- this .beanDefinitionNames.add(beanName);
- }
- //这里把bean的名字和Bean定义联系起来放到一个 HashMap中去,IOC容器通过这个Map来维护容器里的Bean定义信息。
- this .beanDefinitionMap.put(beanName, beanDefinition);
- removeSingleton(beanName);
- }
//--------------------------------------------------------------------- // 这里是IOC容器对BeanDefinitionRegistry接口的实现 //--------------------------------------------------------------------- public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { .....//这里省略了对BeanDefinition的验证过程 //先看看在容器里是不是已经有了同名的bean,如果有抛出异常。 Object oldBeanDefinition = this.beanDefinitionMap.get(beanName); if (oldBeanDefinition != null) { if (!this.allowBeanDefinitionOverriding) { ........... } else { //把bean的名字加到IOC容器中去 this.beanDefinitionNames.add(beanName); } //这里把bean的名字和Bean定义联系起来放到一个HashMap中去,IOC容器通过这个Map来维护容器里的Bean定义信息。 this.beanDefinitionMap.put(beanName, beanDefinition); removeSingleton(beanName); }
这样就完成了Bean定义在IOC容器中的注册,就可被IOC容器进行管理和使用了。
从上面的代码来看,我们总结一下IOC容器
初始化的基本步骤:
* 初始化的入口在容器实现中的refresh()调用来完成
* 对bean
定义载入IOC容器使用的方法是loadBeanDefinition,其中的大致过程如下:通过ResourceLoader来完成资源文件位置的定
位,DefaultResourceLoader是默认的实现,同时上下文本身就给出了ResourceLoader的实现,可以从类路径,文件系统,
URL等方式来定为资源位置。如果是XmlBeanFactory作为IOC容器,那么需要为它指定bean定义的资源,也就是说bean定义文件时通过
抽象成Resource来被IOC容器处理的,容器通过BeanDefinitionReader来完成定义信息的解析和Bean信息的注册,往往使用的
是XmlBeanDefinitionReader来解析bean的xml定义文件 -
实际
评论
发表评论
-
Spring--quartz中cronExpression配置说明
2011-12-02 18:28 0quartz中cronExpression配置说明 字段 ... -
使用Spring的jdbcTemplate进一步简化JDBC操作
2011-12-02 09:20 1265先看applicationContext.xml配置文件: ... -
Spring MVC:使用SimpleUrlHandlerMapping的一个简单例子
2011-12-01 11:26 966实现一个控制器ShirdrnCon ... -
最简单的Spring MVC入门示例
2010-05-19 14:29 1529应一位朋友的要求,写一个最简单的spring示例,使用s ... -
Spring源代码解析(十):Spring Acegi框架授权的实现
2010-03-18 12:48 1525我们从FilterSecurityIntercep ... -
Spring源代码解析(九):Spring Acegi框架鉴权的实现
2010-03-18 12:47 1507简单分析一下Spring Acegi的源代码实现: Ser ... -
Spring源代码解析(八):Spring驱动Hibernate的实现
2010-03-18 12:41 1446O/R工具出现之后,简化了许多复杂的信息持久化的开发。Spri ... -
Spring源代码解析(七):Spring AOP中对拦截器调用的实现
2010-03-18 12:40 1422前面我们分析了Spring AOP实现中得到Proxy对象的过 ... -
Spring源代码解析(六):Spring声明式事务处理
2010-03-18 12:37 1098我们看看Spring中的事务处理的代码,使用Spring管理事 ... -
Spring源代码解析(五):Spring AOP获取Proxy
2010-03-18 12:36 1324下面我们来看看Spring的AOP的一些相关代码是怎么得到Pr ... -
Spring源代码解析(四):Spring MVC
2010-03-18 12:35 7743下面我们对Spring MVC框架代码进行分析,对于web ... -
Spring源代码解析(三):Spring JDBC
2010-03-18 12:33 1697下面我们看看Spring JDBC相关的实现, 在Spri ... -
Spring源代码解析(二):IoC容器在Web容器中的启动
2010-03-18 12:32 1447上面我们分析了IOC容器本身的实现,下面我们看看在典型的web ... -
使用Spring的JdbcTemplate和BeanPropertyRowMapper完成的JDBC
2010-03-18 12:08 2248先道要加上两个包:Spring2.5下面的: spring. ... -
使用Spring的SimpleJdbcTemplate完成DAO操作
2010-03-18 12:06 1511l SimpleJdbcTemplate内部包含了 ... -
使用Spring的NamedParameterJdbcTemplate完成DAO操作
2010-03-18 12:05 1428NamedParameterJdbcTemplate内部包含了 ... -
Spring in Action 学习笔记—第四章 征服数据库(转)
2010-03-18 12:03 1255Spring2.0正式版(http://www.springf ... -
Spring管理JDBC连接
2010-03-18 11:59 1691在Spring中,JdbcTemplate是经常被使用的类来帮 ... -
Spring JDBC数据库操作类
2010-03-18 09:26 16451.JdbcTemplate 在Spring中, ... -
Spring JdbcTemplate 批量插入或更新操作
2010-03-18 09:19 5283用 JdbcTemplate 进行批量插入或更新操作 ...
相关推荐
在Spring源代码解析的第一部分,我们将聚焦于IOC容器,特别是BeanFactory接口,它是所有Spring容器的基础。 BeanFactory接口是Spring的基石,它定义了基本的容器操作,如获取Bean、检查Bean是否存在、确定Bean的...
Spring源代码解析(一):IOC容器 Spring源代码解析(二):IoC容器在Web容器中的启动 Spring源代码解析(三):Spring JDBC Spring源代码解析(四):Spring MVC Spring源代码解析(五):Spring AOP获取Proxy Spring源...
Spring源代码解析1:IOC容器.doc Spring源代码解析2:IoC容器在Web容器中的启动.doc Spring源代码解析3:Spring JDBC .doc Spring源代码解析4:Spring MVC .doc Spring源代码解析5:Spring AOP获取Proxy .doc Spring...
Spring源代码解析1:IOC容器;Spring源代码解析2:IoC容器在Web容器中的启动;Spring源代码解析3:Spring JDBC ; Spring源代码解析4:Spring MVC ;Spring源代码解析5:Spring AOP获取Proxy;Spring源代码解析6:...
当我们在Web环境中运行Spring应用时,IoC容器需要在Web容器(如Tomcat、Jetty等)中启动并运行。这个过程涉及到一系列的初始化步骤,确保Spring能够正确地与Web容器集成。 首先,`WebApplicationContext`是`...
Spring源代码解析2:IoC容器在Web容器中的启动;Spring源代码解析3:Spring JDBC ; Spring源代码解析4:Spring MVC ;Spring源代码解析5:Spring AOP获取Proxy;Spring源代码解析6:Spring声明式事务处理 ; ...
本文将通过分析Spring源代码来揭示其IoC容器的工作原理。 首先,我们要理解IoC的概念。IoC是一种设计模式,它将对象的创建和管理从应用逻辑中解耦出来,由一个中心组件(如Spring的ApplicationContext)负责。在...
在"spring源代码解析(一):IOC容器.doc"中,讲解了如何通过XML配置或注解方式定义bean,以及容器如何解析配置并构建对象的依赖关系。同时,也探讨了容器如何通过接口查找和管理bean。 2. **Web环境下的IOC容器...
Spring源代码解析(二):ioc容器在Web容器中的启动.doc Spring源代码分析(三):Spring JDBC.doc Spring源代码解析(四):Spring MVC.doc Spring源代码解析(五):Spring AOP获取Proxy.doc Spring源代码解析(六):...
《Spring源代码解析》 Spring框架作为Java领域最流行的开源框架之一,它的设计思想和实现方式一直是广大开发者关注的焦点。深入理解Spring的源代码,能够帮助我们更好地掌握其工作原理,提高我们的开发效率和代码...
Spring框架的源代码解析主要集中在它的核心特性——依赖注入(Dependency Injection,简称DI),这是通过Inversion of Control(IOC)容器实现的。IOC容器在Spring中扮演着至关重要的角色,负责管理对象(bean)的...
Spring框架是Java开发中最常用的轻...总的来说,"Spring源代码解析"将涵盖Spring的核心组件、设计理念、内部实现以及与其他技术的交互,对于希望提升技术水平、深入理解框架运作机制的开发者来说,这是一个宝贵的资源。
《Spring技术内幕:深入解析Spring架构与设计原理(第2版)》从源代码的角度对Spring的内核和各个主要功能模块的架构、设计和实现原理进行了深入剖析。你不仅能从本书中参透Spring框架的出色架构和设计思想,还能从...
在整个源代码分析中,我们可以看到 Spring 实现声明式事务管理有三个部分: 1. 对在上下文中配置的属性的处理,这里涉及的类是 TransactionAttributeSourceAdvisor,这是一个通知器,用它来对属性值进行处理,属性...
源代码分析有助于深入理解Spring的工作原理,提升编程技能,并且能够帮助开发者在遇到问题时进行调试和优化。 1. **Spring IoC容器**: Spring的核心是IoC容器,它负责管理对象的生命周期和依赖关系。通过XML配置...