spring源码研究之路_IOC
来源:互联网 发布:sim卡apdu数据 编辑:程序博客网 时间:2024/06/05 15:13
目前在企业级项目开发中几乎都会使用spring。Spring是基于IOC和AOP的一套编程框架,提供了JAVAEE各层的解决方案,可以称为框架粘合剂。
首先我们来说一下IOC,IOC是spring最核心的理念,包括AOP也要屈居第二,那么IOC到底是什么呢,四个字,控制反转。详细点说是通过引入工厂,将对象创建的权利,交给工厂来管理。利用这种思想可以很好实现模块间的解耦。
public class Person { public void work(){ System.out.println("I am working"); }}
上面这个是Person类,如果我们还有一个Company公司类,公司要开张需要人来工作,所以我们可能需要这样。
public class Company { public Person person; public Company(Person person){ this.person = person; } public void open(){ person.work(); System.out.println("I am opening"); }}
好了,这样可以了,虽说和现实有些区别,毕竟没有一个人的公司,但是就是这么个意思。必须要有人在公司里,公司才能开张。
有了spring上述情况我们是怎么写的呢?Person类不变,Company就可以简单些了。
public class Company { @Autowired public Person person; public void open(){ person.work(); System.out.println("I am opening"); }}
OK了,使用注解后,spring里的写法是这样的,是不是简单很多?或许你可能会说,这才减少了多少代码,但是事实上是,真正的项目中,不可能有这么简单的依赖关系,或许是2层,3层甚至N层。
当然,可能我们有时候用的XML,XML和注解的区别就在于这里,注解可以快速的完成依赖的注入,但是缺点也很明显,那就是比如我公司里不需要人了,我需要的是机器,那么我还要手动改代码,将Person换成machine,而如果是XML配置,那么我们只需要改下配置文件就可以。维护起来会方便很多,当然XML的缺点也很明显,那就是依赖关系复杂的时候,XML文件会比较臃肿,所以我们一般的做法是将XML分离开来。
说到这里,有些扯远了,但是我觉得以上可以足够说明IOC的好处,知道了IOC的好处,我们自然就要知道怎么来实现IOC了。
或许看了spring的源码,第一感觉是很蒙,包太多,我也很蒙,但是研究东西就是得沉下心来,先来关注一下这个接口,BeanFactory,附上代码。
package org.springframework.beans.factory;import org.springframework.beans.BeansException;/* * @author Rod Johnson * @author Juergen Hoeller * @since 13 April 2001 */public interface BeanFactory { String FACTORY_BEAN_PREFIX = "&"; Object getBean(String name) throws BeansException; <T> T getBean(String name, Class<T> requiredType) throws BeansException; <T> T getBean(Class<T> requiredType) throws BeansException; Object getBean(String name, Object... args) throws BeansException; boolean containsBean(String name); boolean isSingleton(String name) throws NoSuchBeanDefinitionException; boolean isPrototype(String name) throws NoSuchBeanDefinitionException; boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException; Class<?> getType(String name) throws NoSuchBeanDefinitionException; String[] getAliases(String name);}
这个便是spring核心的Bean工厂定义,上面的author说是2001年写的,已经历史久远了,这个类是spring中所有bean工厂,也就是俗称的IOC容器的祖宗,各种IOC容器都只是它的实现或者为了满足特别需求的扩展实现,包括我们平时用的最多的ApplicationContext。从上面的方法就可以看出,这些工厂的实现最大的作用就是根据bean的名称亦或类型等等,来返回一个bean的实例。
一个工厂如果想拥有这样的功能,那么它一定需要以下几个因素:
1.需要持有各种bean的定义,否则无法正确的完成bean的实例化。
2.需要持有bean之间的依赖关系,否则在bean实例化的过程中也会出现问题。例如上例,如果我们只是各自持有Person和Company,却不知道他们的依赖关系,那么在Company初始化以后,调用open方法时,就会报空指针。这是因为Company其实并没有真正的被正确初始化。
3.以上两种都要依赖于我们所写的依赖关系的定义,暂且认为是XML文件(其实可以是各种各样的),那么我们需要一个工具来完成XML文件的读取。
我目前想到的,只需要满足以上三种条件,便可以创建一个bean工厂,来生产各种bean。当然,spring有更高级的做法,以上只是我们直观的去想如何实现IOC。
其实在上述过程中仍旧有一些问题,比如第一步,我们需要持有bean的定义,如何持有?这是一个问题。我们知道spring的XML配置文件中,有一个属性是lazy-init,这就说明,bean在何时实例化我们是可以控制的。这个属性默认是false,但是我们可以将这个属性设置为true,也就是说spring容器初始化以后,配置了延迟加载的各种bean都还未产生,它们只在需要的时候出现。
所以我们无法直接的创建一个Map<String,Object>来持有这些bean的实例,在这里要注意,我们要储存的是bean的定义,而非实例。
那么接下来,又是一个祖宗级别的接口要出现了,来看BeanDefinition。
package org.springframework.beans.factory.config;import org.springframework.beans.BeanMetadataElement;import org.springframework.beans.MutablePropertyValues;import org.springframework.core.AttributeAccessor;public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; int ROLE_APPLICATION = 0; int ROLE_SUPPORT = 1; int ROLE_INFRASTRUCTURE = 2; String getParentName(); void setParentName(String parentName); String getBeanClassName(); void setBeanClassName(String beanClassName); String getFactoryBeanName(); void setFactoryBeanName(String factoryBeanName); String getFactoryMethodName(); void setFactoryMethodName(String factoryMethodName); String getScope(); void setScope(String scope); boolean isLazyInit(); void setLazyInit(boolean lazyInit); String[] getDependsOn(); void setDependsOn(String[] dependsOn); boolean isAutowireCandidate(); void setAutowireCandidate(boolean autowireCandidate); boolean isPrimary(); void setPrimary(boolean primary); ConstructorArgumentValues getConstructorArgumentValues(); MutablePropertyValues getPropertyValues(); boolean isSingleton(); boolean isPrototype(); boolean isAbstract(); int getRole(); String getDescription(); String getResourceDescription(); BeanDefinition getOriginatingBeanDefinition();}
顾名思义,这个便是spring中的bean定义接口,所以其实我们工厂里持有的bean定义,就是一堆这个玩意,或者是他的实现类和子接口。这个接口并非直接的祖宗接口,他所继承的两个接口一个是core下面的AttributeAccessor,继承这个接口就以为这我们的bean定义接口同样具有处理属性的能力,而另外一个是beans下面的BeanMetadataElement,字面翻译这个接口就是bean的元数据元素,它可以获得bean的配置定义的一个元素。在XML文件中来说,就是会持有一个bean标签。
仔细观看,能发现beanDefinition中有两个方法分别是String[] getDependsOn()和void setDependsOn(String[] dependsOn),这两个方法就是获取依赖的beanName和设置依赖的beanName,这样就好办了,只要我们有一个BeanDefinition,就可以完全的产生一个完整的bean实例。
BeanFactory和BeanDefinition,一个是IOC的核心工厂接口,一个是IOC的bean定义接口,我们无法让BeanFactory持有一个Map<String,Object>来完成bean工厂的功能,是因为spring的初始化是可以控制的,可以到用的时候才将bean实例化供开发者使用,除非我们将bean的lazy-init属性设置为true,初始化bean工厂时采用延迟加载。
那么知道了上述两个接口,我相信不少人甚至不看源码都已经猜到spring是如何做的了。没错,就是让bean工厂持有一个Map<String,BeanDefinition>,这样就可以在任何时候我们想用哪个bean,取到它的bean定义,我们就可以创造出一个新鲜的实例。
接口当然不可能持有这样一个对象,那么这个对象一定是在BeanFactory的某个实现类或者抽象实现类当中所持有的,我经过跋山涉水,终于把它给找出来了,来看DefaultListableBeanFactory。
package org.springframework.beans.factory.support;import java.io.NotSerializableException;import java.io.ObjectStreamException;import java.io.Serializable;import java.lang.annotation.Annotation;import java.lang.ref.Reference;import java.lang.ref.WeakReference;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.security.AccessController;import java.security.PrivilegedAction;import java.util.ArrayList;import java.util.Arrays;import java.util.Collection;import java.util.HashMap;import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;import javax.inject.Provider;import org.springframework.beans.BeansException;import org.springframework.beans.FatalBeanException;import org.springframework.beans.TypeConverter;import org.springframework.beans.factory.BeanCreationException;import org.springframework.beans.factory.BeanCurrentlyInCreationException;import org.springframework.beans.factory.BeanDefinitionStoreException;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.BeanFactoryAware;import org.springframework.beans.factory.BeanFactoryUtils;import org.springframework.beans.factory.CannotLoadBeanClassException;import org.springframework.beans.factory.FactoryBean;import org.springframework.beans.factory.NoSuchBeanDefinitionException;import org.springframework.beans.factory.ObjectFactory;import org.springframework.beans.factory.SmartFactoryBean;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.beans.factory.config.BeanDefinitionHolder;import org.springframework.beans.factory.config.ConfigurableBeanFactory;import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;import org.springframework.beans.factory.config.DependencyDescriptor;import org.springframework.core.annotation.AnnotationUtils;import org.springframework.util.Assert;import org.springframework.util.ObjectUtils;import org.springframework.util.StringUtils;/** * @author Rod Johnson * @author Juergen Hoeller * @author Sam Brannen * @author Costin Leau * @since 16 April 2001 */public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable { private static Class javaxInjectProviderClass = null; static { ClassLoader cl = DefaultListableBeanFactory.class.getClassLoader(); try { javaxInjectProviderClass = cl.loadClass("javax.inject.Provider"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - Provider interface simply not supported then. } } /** Map from serialized id to factory instance */ private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories = new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(); /** Optional id for this factory, for serialization purposes */ private String serializationId; /** Whether to allow re-registration of a different definition with the same name */ private boolean allowBeanDefinitionOverriding = true; /** Whether to allow eager class loading even for lazy-init beans */ private boolean allowEagerClassLoading = true; /** Resolver to use for checking if a bean definition is an autowire candidate */ private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver(); /** Map from dependency type to corresponding autowired value */ private final Map<Class, Object> resolvableDependencies = new HashMap<Class, Object>(); /** Map of bean definition objects, keyed by bean name */ private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(); /** List of bean definition names, in registration order */ private final List<String> beanDefinitionNames = new ArrayList<String>(); /** Whether bean definition metadata may be cached for all beans */ private boolean configurationFrozen = false; /** Cached array of bean definition names in case of frozen configuration */ private String[] frozenBeanDefinitionNames;}
注明下,这里我省略了下面N多行源码,源码太长,而且太多的话容易混乱,切勿认为此类就这么多了。
看它名字就知道,这是一个默认的bean工厂实现类,也就是说,如果你需要的功能非常单一,这个实现类已经足够可以满足你了,而以后如果你想要对spring的容器扩展,那么只需要扩展或者持有这个对象即可。
/** Map of bean definition objects, keyed by bean name */ private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();
看到这一行,其实已经证明了我们的猜测,即使英文不太好,也能看懂它所注释的意思是bean定义的MAP对象,采用beanName作为key值。
走到这里,思路已经很明确了,bean工厂的初始化其实就是往这个Map里填充东西。只要把我们XML文件中定义的bean都填充到这里,其实这个工厂就已经可以工作了。
那么从现在来看,我们需要什么才能把Map填充呢?也就是初始化bean工厂呢,或者说建立IOC容器。我首先列出来以下几步。
1.需要一个File指向我们的XML文件(本文的配置文件都已XML为例,因为这是我们最熟悉的),专业点可以叫资源定位,简单点可以说我们需要一些工具来完成找到XML文件的所在位置。
2.需要一个Reader来读取我们的XML文件,专业点叫DOM解析,简单点说,就是把XML文件的各种定义都给拿出来。
3.需要将读出来的数据都设置到Map当中。
这三部总结起来就是定位、解析、注册。我们首先按照这个思路来试一下。
直接上代码,我们还使用原来的Person类作为一个Bean。
package com.springframework.beans.test;public class Person { public void work(){ System.out.println("I am working"); }}
我们还需要写一个简单的XML文件,beans.xml。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id="person" class="com.springframework.beans.test.Person"></bean></beans>
下面是我们根据上述的思路写一段程序,来看看会发生什么情况。
package com.springframework.beans.test;import org.springframework.beans.factory.support.DefaultListableBeanFactory;import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;import org.springframework.core.io.ClassPathResource;public class TestDefaultListableBeanFactory { public static void main(String[] args) { ClassPathResource classPathResource = new ClassPathResource("beans.xml"); DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory(); XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(defaultListableBeanFactory); xmlBeanDefinitionReader.loadBeanDefinitions(classPathResource); System.out.println("numbers: " + defaultListableBeanFactory.getBeanDefinitionCount()); ((Person)defaultListableBeanFactory.getBean("person")).work(); }}
成功的解析XML文件,并注册了一个bean定义,而且我们使用getBean方法也成功得到了Person的实例。
上述这段程序当中可以看出,bean工厂的初始化一共使用了四行程序。
第一行完成了我们的第一步,即资源定位,采用classpath定位,因为我的beans.xml文件是放在src下面的。
第二行创建了一个默认的bean工厂。
第三行创建了一个reader,从名字就不难看出,这个reader是用来读取XML文件的。这一步要多说一句,其中将我们创建的defaultListableBeanFactory作为参数传给了reader的构造函数,这里是为了第四步读取XML文件做准备。
第四行使用reader解析XML文件,并将读取的bean定义回调设置到defaultListableBeanFactory当中。其实回调这一步就相当于我们上述的注册这一步。
这个时候defaultListableBeanFactory已经被正确初始化了,我们已经可以使用它的一些方法了,比如上面所使用的获取bean个数,以及获得一个bean实例的方法。
但是我相信真正的开发当中,没有人会采用这样的方式去创造一个bean工厂,我们可以有更简单的方式。上面的四步,我们肯定希望一步就可以完成它。是的,这不是在做梦,就像下面这样。
package com.springframework.beans.test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.FileSystemXmlApplicationContext;public class TestApplicationContext { public static void main(String[] args) { ApplicationContext applicationContext = new FileSystemXmlApplicationContext("classpath:beans.xml"); System.out.println("numbers: " + applicationContext.getBeanDefinitionCount()); ((Person)applicationContext.getBean("person")).work(); }}
具体我们在new一个FileSystemXmlApplicationContext对象的时候,spring到底做了哪些事情呢,这个自然要去跟随源码去看个究竟。
- spring源码研究之路_IOC
- spring原理_IOC详解
- Spring源码研究之@Configuration
- Spring-Session源码研究之Start
- Spring-Session源码研究之processRequest
- Spring-Session源码研究之Start_Servlet3.0
- Spring学习文档_IOC配置与应用
- Spring初探01_IOC简单实例
- spring源码研究(0)
- Spring源码研究之注解扫描<context:component-scan/>
- Mybatis与Spring集成源码研究之MapperScannerConfigurer
- Spring AOP源码研究笔记
- 研究spring源码有所得
- linux 驱动学习之ioctl 命令_IOC _ 相关宏
- java _IOC
- 【Hadoop源码研究】之Configuration
- elasticsearch源码研究之启动
- MyBatis源码研究之$和#
- #pragma pack(n)和__attribute__((aligned(m)))的区别
- iOS开发之基类BaseViewController和BaseTableViewController应该做哪些事情
- 机型适配
- 读thinking in java笔记(五):访问权限控制
- android 内存管理概要
- spring源码研究之路_IOC
- Struts2工作流程
- Kafka深度解析
- B-spline【贝塞尔曲线】
- ci制作登陆+验证码
- http长连接
- 如何理解js中的call及apply
- 平衡二叉树
- 性能测试与压力测试