`
samsongbest
  • 浏览: 171426 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Spring2.5.6源代码分析(一):IOC容器

 
阅读更多

1. BeanFactory是最顶层的类,从它下手最合适不过。

 

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;

public interface BeanFactory {

     //假如有个bean名字叫myJndiObject是个FactoryBean,用&myJndiObject返回factory, 
     //不然返回factory的实例     
     String FACTORY_BEAN_PREFIX = "&";    

    //根据名字返回bean
    Object getBean(String name) throws BeansException;

    //返回的bean要符合类的类型
    Object getBean(String name, Class requiredType) throws BeansException;

    //带构造函数参数返回bean
    Object getBean(String name, Object[] args) throws BeansException;

    //是否含有某个bean
    boolean containsBean(String name);

    //某个bean是不是单例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    //某个bean是不是原型,就是有多个实例
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    //检查bean是否是某个类的类型
    boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException;

    //返回某个bean的类的类型
    Class getType(String name) throws NoSuchBeanDefinitionException;

    //得到bean的别名
    String[] getAliases(String name);

}

 

2. FileSystemXmlApplicationContext

从本地读取配置

	public FileSystemXmlApplicationContext(String[] configLocations,
			boolean refresh, ApplicationContext parent) throws BeansException {
		// 交给父类
		super(parent);

		// 调用爷爷类AbstractRefreshableConfigApplicationContext的方法,
		// 父类AbstractXmlApplicationContext里是一些beanFactory的reader方法,
		// 用ApplicationContext直接进爷爷类
		setConfigLocations(configLocations);

		if (refresh) {

			// AbstractApplicationContext的刷新方法是重头戏,里面调用N个方法
			refresh();
		}
	}

 

3. AbstractRefreshableConfigApplicationContext

这个类没多大用,主要把配置文件的路径赋给自身的configLocations字段

	public void setConfigLocations(String[] locations) {
		if (locations != null) {

			// 断言没有null值,否则报所带msg的异常,这个断言我也可以用用
			Assert.noNullElements(locations,
					"Config locations must not be null");

			this.configLocations = new String[locations.length];
			for (int i = 0; i < locations.length; i++) {

				// 路径如果是${...}这样的,就需要处理成系统路径
				this.configLocations[i] = resolvePath(locations[i]).trim();
			}
		} else {
			this.configLocations = null;
		}
	}

 

4. AbstractApplicationContext

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//记录启动时间,active标识变为true,输出个日志到控制台
                        prepareRefresh();

			// 在这一步里,所有的xml信息都设置到beandefinition中了
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				// Destroy already created singletons to avoid dangling resources.
				beanFactory.destroySingletons();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}
		}
	}
 

4.开始读文档里的Element子节点

    org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;

		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
                
                //设置default值
		BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
                
                //对预定义的节点做预处理,暂时为空方法 
		preProcessXml(root);
		parseBeanDefinitions(root, delegate);
		postProcessXml(root);
	}
 

 

5. 文档里面的节点设置成类的字段

    org.springframework.beans.factory.xml.BeanDefinitionParserDelegate一个一个解析文档中的节点,属性

	public void initDefaults(Element root) {
		DocumentDefaultsDefinition defaults = new DocumentDefaultsDefinition();
		defaults.setLazyInit(root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE));
		defaults.setMerge(root.getAttribute(DEFAULT_MERGE_ATTRIBUTE));
		defaults.setAutowire(root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE));
		defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));
		if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
			defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
		}
		if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
			defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
		}
		if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
			defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
		}
		defaults.setSource(this.readerContext.extractSource(root));

		this.defaults = defaults;
		this.readerContext.fireDefaultsRegistered(defaults);
	}

 

6. 一开始初始化所有单例的bean

    org.springframework.beans.BeanUtils

	public static Object instantiateClass(Constructor ctor, Object[] args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
                        
                        //在这一行真正实例化
                        return ctor.newInstance(args);
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor.getDeclaringClass(),
					"Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor.getDeclaringClass(),
					"Has the class definition changed? Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor.getDeclaringClass(),
					"Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor.getDeclaringClass(),
					"Constructor threw exception", ex.getTargetException());
		}
	}
 

zz

分享到:
评论

相关推荐

    Spring2.5.6源代码和JAR文件

    对于开发者来说,Spring 2.5.6的源代码提供了深入理解框架工作原理的机会。通过阅读源代码,可以学习到如何实现DI、AOP,以及Spring是如何管理bean的生命周期和装配的。这对于提升个人技能、解决实际问题和定制化...

    hibernate3 + spring 2.5.6源代码

    本篇文章将详细探讨Hibernate3与Spring2.5.6的源代码,帮助开发者深入理解这两个框架的核心机制及其整合方式。 一、Hibernate3:持久层的革命者 Hibernate3是一款优秀的对象关系映射(ORM)框架,它极大地简化了...

    spring2.5.6jar包

    2. **IoC容器(Inversion of Control Container)**:IoC容器负责创建、配置和管理对象,是DI的实现方式。在Spring 2.5.6中,用户可以使用XML配置文件来定义bean及其依赖,或者利用注解如`@Component`、`@Service`、...

    spring2.5.6所有包.rar

    - **IoC容器**:Spring的核心是IoC容器,它负责创建、配置和管理对象。2.5.6版本的容器引入了基于注解的配置,简化了XML配置,提升了开发效率。 2. **主要模块** - **Spring Core Container**:包括Bean工厂和...

    spring-2.5.6api文档

    一、IoC(Inversion of Control)容器 Spring的核心特性是依赖注入(Dependency Injection,简称DI),它是IoC的一个实现。IoC容器负责管理对象的生命周期和对象间的依赖关系,通过反转控制权,使得代码更加灵活和可...

    spring2.5.6_参考文档

    Spring的核心特性之一是IOC,它使得组件间的依赖关系由容器来管理,而不是由组件自己管理。这使得代码更易于测试和维护,因为对象的创建和组装都在容器中进行,程序员可以专注于业务逻辑而不必关心对象的生命周期。...

    struts2.1.8+spring2.5.6

    开发者可以通过解压这个文件,然后在自己的项目中引用这些类库,结合Spring2.5.6来搭建一个基于Struts2的MVC架构,并利用Spring进行服务层管理和依赖注入。 总之,Struts2.1.8和Spring2.5.6是J2EE开发的重要组成...

    spring-framework-2.5.6.rar

    Spring 2.5.6是该框架的一个较早版本,尽管现在已经有更新的版本发布,但理解这个版本仍然对学习Spring的基本原理和历史发展有重要意义。 Spring的主要组件包括: 1. **IoC(Inversion of Control)容器**:它是...

    spring 2.5.6和hibernate3.2.2集成(1)

    - 核心特性:包括Bean工厂,IoC容器,以及AOP代理,这些都是Spring的基础,用于管理对象生命周期和提供面向切面的扩展。 2. Hibernate框架: - 版本3.2.2:同样是一个成熟且广泛使用的版本,提供了强大的ORM功能...

    Struts2.1.6与Spring2.5.6框架整合开发

    接下来是Spring2.5.6,这是一个全面的企业级应用框架,它支持IoC(Inversion of Control,控制反转)和AOP(Aspect-Oriented Programming,面向切面编程)。IoC通过容器管理对象及其依赖关系,降低了组件间的耦合度...

    java web spring-framework-2.5.6.jar.zip

    在提供的压缩包 "spring-framework-2.5.6" 中,包含了 Spring 框架的源代码和类库,开发者可以查阅这些资料以深入了解 Spring 的实现细节,或者对特定版本的问题进行调试。随着技术的发展,更现代的版本如 Spring ...

    Struts2.1.8+Spring2.5.6+hibernate3.2.3整合

    Spring 2.5.6作为一个轻量级的IOC(Inversion of Control)和AOP(Aspect Oriented Programming)容器,负责管理对象的生命周期和依赖关系。在与Struts2整合时,Spring可以作为Action的工厂,创建并注入Action实例。...

    ssh2(spring2.5.6+struts2.2.3+hibenate3.2)

    Spring的核心特性包括IoC容器、数据访问/集成、Web、AOP、工具类、消息和测试支持。 1. **依赖注入**:Spring通过DI管理对象之间的关系,使代码更松耦合,易于测试和维护。 2. **AOP**:Spring的AOP模块允许开发者...

    WEB项目-集成Flex3+BlazeDS3.2+Spring2.5.6+iBatis2.3.4

    本讲主要讲解如何将Flex3前端、BlazeDS3.2后端数据传输服务、Spring2.5.6依赖注入框架以及iBatis2.3.4持久层框架集成到一个项目中,以实现更高效的业务逻辑处理。 1. **Flex3** 是Adobe推出的一种富互联网应用程序...

    SSH2框架整合(Struts2.1.6+hibernate3.3.2+spring2.5.6)

    在这个例子中,使用的版本分别是Struts2.1.6、Hibernate3.3.2和Spring2.5.6。 首先,让我们详细了解一下这三个框架的核心功能: 1. **Struts2**:这是一个基于MVC(Model-View-Controller)设计模式的Web应用框架...

    spring源代码

    Spring 2.5.6版本是该框架的一个历史版本,虽然较新版本(如5.x或6.x)已发布,但了解其源代码有助于我们理解Spring的基本原理和早期设计思想。 1. **IoC容器**:Spring的核心是IoC容器,它负责管理对象的生命周期...

    sping配置jar包

    2. **spring-context-2.5.6.jar**:Spring 上下文模块提供了一个更高级别的应用上下文,它允许开发者访问系统服务,如消息源、事务管理器等。此外,它还引入了事件发布机制,支持 AOP(面向切面编程)以及集成其他...

Global site tag (gtag.js) - Google Analytics