从源代码解读spring IOC容器

最新推荐文章于 2023-09-06 10:24:17 发布

天天向上999

最新推荐文章于 2023-09-06 10:24:17 发布

阅读量262

点赞数

出处：http://cuishen.iteye.com/blog/243963

从源代码解读spring IOC容器

博客分类：
j2ee

IOC Spring Bean 配置管理 Cache

spring IOC容器(Inversion of Control container)做项目的时候经常要用到，但是好像感觉不到它的存在，因为代码里面很少用到spring，主要是写配置。但是我不得不说：spring做的确实很巧妙，这种和代码的松耦合很大的提高了代码的灵活性和可扩展性。最近手头的开发任务比较少，于是抽空看了看spring1.2.9的源代码，现在把心得贴出来和网友共享，欢迎大家批评指正。

1. spring IOC容器接口定义

org.springframework.beans.factory 这里是定义spring IOC容器接口的包，在这个包里有我们熟悉的BeanFactory

Java代码

package org.springframework.beans.factory;
public interface BeanFactory {
/**
*这里是对FactoryBean的转义定义，如果使用bean的名字检索FactoryBean，得到的是工厂生成的对象，
*如果需要得到工厂本身，需要转义。For example, if the bean named
* <code>myJndiObject</code> is a FactoryBean, getting <code>&myJndiObject</code>
* will return the factory
*/
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容器实现

spring已经为我们准备了丰富的IOC容器的具体实现(当然，有兴趣的朋友也可以尝试实现自己的一套IOC容器来证明自己的实力也未尝不可)，现在先让我们看看spring是怎样实现的：

2. spring IOC容器接口的实现

Java代码

package org.springframework.beans.factory.support;
public abstract class AbstractBeanFactory implements ConfigurableBeanFactory {
/**
* 放置单例bean实例的缓存(IOC容器)
* Cache of singletons: bean name --> bean instance
*/
private final Map singletonCache = CollectionFactory.createLinkedMapIfPossible(16);
/**
* 根据bean名称从缓存(IOC容器)中获得bean实例，如果缓存中没有，则根据bean的定义
* 信息造bean的实例，如果是单例，就放进缓存(IOC容器)
*/
public Object getBean(String name, Class requiredType, Object[] args) throws BeansException {
String beanName = transformedBeanName(name);
Object bean = null;
// 在缓存中根据名字查找bean实例.
Object sharedInstance = null;
synchronized (this.singletonCache) {
sharedInstance = this.singletonCache.get(beanName);
}
if (sharedInstance != null) {
...
// 如果容器里找的到，则从缓存返回bean
bean = getObjectForSharedInstance(name, sharedInstance);
} else {
...
// Check if bean definition exists in this factory.
// 如果当前BeanFactory里没有bean定义信息，则去ParentBeanFactory
// 里查找
if (getParentBeanFactory() != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
if (getParentBeanFactory() instanceof AbstractBeanFactory) {
// Delegation to parent with args only possible for AbstractBeanFactory.
return ((AbstractBeanFactory) getParentBeanFactory()).getBean(name, requiredType,
args);
}
else if (args == null) {
// No args -> delegate to standard getBean method.
return getParentBeanFactory().getBean(name, requiredType);
}
else {
...
}
}
// 获得bean定义信息
RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
checkMergedBeanDefinition(mergedBeanDefinition, beanName, requiredType, args);
// Create bean instance.
if (mergedBeanDefinition.isSingleton()) {
synchronized (this.singletonCache) {
// Re-check singleton cache within synchronized block.
sharedInstance = this.singletonCache.get(beanName);
if (sharedInstance == null) {
...
this.currentlyInCreation.add(beanName);
try {
// 根据bean定义信息造bean的实例
sharedInstance = createBean(beanName, mergedBeanDefinition, args);
// 将bean实例放入缓存(IOC容器)
addSingleton(beanName, sharedInstance);
}
catch (BeansException ex) {
...
}
finally {
this.currentlyInCreation.remove(beanName);
}
}
}
bean = getObjectForSharedInstance(name, sharedInstance);
}
else {
// 如果不是单例模式 just create a new instance.
bean = createBean(beanName, mergedBeanDefinition, args);
}
}
...
return bean;
}
/**
* 抽象方法，在子类中实现
*/
protected abstract Object createBean(
String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args) throws
BeanCreationException;
/**
* 在缓存中注册bean实例
*/
public void registerSingleton(String beanName, Object singletonObject) throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(singletonObject, "Singleton object must not be null");
synchronized (this.singletonCache) {
Object oldObject = this.singletonCache.get(beanName);
if (oldObject != null) {
...
}
addSingleton(beanName, singletonObject);
}
}
/**
* 在缓存中注册bean实例
*/
protected void addSingleton(String beanName, Object singletonObject) {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(singletonObject, "Singleton object must not be null");
synchronized (this.singletonCache) {
this.singletonCache.put(beanName, singletonObject);
}
}
}

AbstractBeanFactory实现了BeanFactory接口里的getBean()方法，做为抽象的父类为所有继承它的子类提供getBean()的模板服务，getBean()方法是根据bean的名称在缓存--AbstractBeanFactory#singletonCache(IOC容器)里查找其实例，如果找不到则根据用户的配置文件里的bean定义信息(spring背后有一套功能十分强大的xml文件解析工具来完成bean定义文件的解析，有兴趣的朋友可以看看org.springframework.beans.factory.xml.XmlBeanDefinitionReader和org.springframework.beans.factory.xml.DefaultXmlBeanDefinitionParser，解析好后会将bean定义信息放入缓存，限于篇幅这里不再赘述)造bean实例，如果该bean是单例模式，则同时放进缓存---AbstractBeanFactory#singletonCache。getBean()是IOC容器的核心方法。在getBean()里用到了createBean()方法，顾名思义--造bean实例的方法，该方法在子类中得到了实现，现在我们看看子类中到底是怎样createBean的。

Java代码

package org.springframework.beans.factory.support;
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
/**
* 造bean对象
*/
protected Object createBean(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args)
throws BeanCreationException {
// 实例化并初始化当前bean所依赖的所有bean.
if (mergedBeanDefinition.getDependsOn() != null) {
for (int i = 0; i < mergedBeanDefinition.getDependsOn().length; i++) {
getBean(mergedBeanDefinition.getDependsOn()[i]);
}
}
...
Object bean = null;
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
if (mergedBeanDefinition.hasBeanClass()) {
bean = applyBeanPostProcessorsBeforeInstantiation(mergedBeanDefinition.getBeanClass(), beanName);
if (bean != null) {
return bean;
}
}
BeanWrapper instanceWrapper = null;
Object originalBean = null;
...
try {
...
if (mergedBeanDefinition.getFactoryMethodName() != null) {
//反射factoryBean的工厂方法
instanceWrapper = instantiateUsingFactoryMethod(beanName, mergedBeanDefinition, args);
}
else if (mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR
|| mergedBeanDefinition.hasConstructorArgumentValues() ) {
//实例化bean的方法
instanceWrapper = autowireConstructor(beanName, mergedBeanDefinition);
}
else {
//实例化bean的方法
// No special handling: simply use no-arg constructor.
instanceWrapper = instantiateBean(beanName, mergedBeanDefinition);
}
bean = instanceWrapper.getWrappedInstance();
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
if (isAllowCircularReferences() && isSingletonCurrentlyInCreation(beanName)) {
...
addSingleton(beanName, bean);
}
...
originalBean = bean;
bean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 调用bean实例里的init方法
invokeInitMethods(beanName, bean, mergedBeanDefinition);
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
catch (BeanCreationException ex) {
...
}
// Register bean as disposable, and also as dependent on specified "dependsOn" beans.
registerDisposableBeanIfNecessary(beanName, originalBean, mergedBeanDefinition);
return bean;
}
/**
* 反射factoryBean里的工厂方法，实现依赖注入
*/
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs) throws
BeansException {
...
BeanWrapperImpl bw = new BeanWrapperImpl();
initBeanWrapper(bw);
...
Object beanInstance = this.instantiationStrategy.instantiate(
mergedBeanDefinition, beanName, this, factoryBean, factoryMethodToUse, argsToUse);
...
bw.setWrappedInstance(beanInstance);
return bw;
}
/**
* 匹配bean构造方法来实例化bean
*/
protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mergedBeanDefinition)
throws BeansException {
...
BeanWrapperImpl bw = new BeanWrapperImpl();
initBeanWrapper(bw);
...
Object beanInstance = this.instantiationStrategy.instantiate(
mergedBeanDefinition, beanName, this, constructorToUse, argsToUse);
bw.setWrappedInstance(beanInstance);
...
return bw;
}
/**
* 用bean的默认构造方法造bean实例
*/
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mergedBeanDefinition)
throws BeansException {
Object beanInstance = getInstantiationStrategy().instantiate(mergedBeanDefinition, beanName, this);
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
}

其实create bean的过程就是通过bean的定义信息反射bean实例的过程。真正用反射造对象的代码这里没有体现出来，我们注意到了BeanWrapper仅仅是bean实例的包装类，不涉及到造对象的代码；instantiateUsingFactoryMethod()、autowireConstructor()和instantiateBean()方法里都用到了实例化策略类里面的方法--instantiate()，毫无疑问反射对象的代码就应该在instantiate()里面，现在就让我们来揭开实例化策略类的神秘面纱。

Java代码

package org.springframework.beans.factory.support;
public class SimpleInstantiationStrategy implements InstantiationStrategy {
public Object instantiate(
RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (beanDefinition.getMethodOverrides().isEmpty()) {
// 调用BeanUtils的静态方法实例化bean
return BeanUtils.instantiateClass(beanDefinition.getBeanClass());
}
else {
// Must generate CGLIB subclass.
// 抛异常"Method Injection not supported in SimpleInstantiationStrategy"
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}
public Object instantiate(
RootBeanDefinition beanDefinition, String beanName, BeanFactory owner,
Constructor ctor, Object[] args) {
if (beanDefinition.getMethodOverrides().isEmpty()) {
// 调用BeanUtils的静态方法实例化bean
return BeanUtils.instantiateClass(ctor, args);
}
else {
return instantiateWithMethodInjection(beanDefinition, beanName, owner, ctor, args);
}
}
public Object instantiate(
RootBeanDefinition beanDefinition, String beanName, BeanFactory owner,
Object factoryBean, Method factoryMethod, Object[] args) {
try {
// It's a static method if the target is null.
if (!Modifier.isPublic(factoryMethod.getModifiers()) ||
!Modifier.isPublic(factoryMethod.getDeclaringClass().getModifiers())) {
// 如果方法不是公有方法，则修改它的访问权限
factoryMethod.setAccessible(true);
}
// 用反射调用factoryBean实例中的方法
return factoryMethod.invoke(factoryBean, args);
}
catch (IllegalArgumentException ex) {
...
}
}
}

原来一部分实例化bean的代码放到BeanUtils.instantiateClass()方法里了，我们现在来看看BeanUtils类

Java代码

package org.springframework.beans;
public abstract class BeanUtils {
/**
* 实例化带默认构造方法的bean
*/
public static Object instantiateClass(Class clazz) throws BeanInstantiationException {
...
try {
return instantiateClass(clazz.getDeclaredConstructor((Class[]) null), null);
}
...
}
/**
* 根据构造方法实例化bean
*/
public static Object instantiateClass(Constructor ctor, Object[] args) throws BeanInstantiationException {
...
try {
if (!Modifier.isPublic(ctor.getModifiers()) ||
!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) {
//如果是私有构造方法则修改访问权限
ctor.setAccessible(true);
}
// 反射实例
return ctor.newInstance(args);
}
...
}
}

从以上代码我们不难看出，spring如果遇到bean的构造方法是私有的，那么它会去修改bean的访问权限，同样可以反射出bean的对象

3. spring依赖注入(dependence injection)的实现

所谓依赖，举个例子说明，一个类Person，另一个类Car，如果Person的某个方法比如说drive，需要引用Car，则称Person类依赖于Car类，延伸到对象，这种依赖关系依然成立。这其中的依赖关系，就导致了对象Person需要负责对象Car的创建，甚至是整个生命周期的管理，而这样显然会带来耦合度高，不易维护等缺点。spring框架的依赖注入为我们提供了很好的解决方案，将Person依赖的对象Car造好，然后注入到Person中去，而无需Person自己去引用Car，这个注入的过程，由spring IOC容器来完成，无需对象去关心。

Spring提供了3种类型的依赖注入：构造函数注入（constructor injection）、setter注入（setter injection）和方法注入（method injection）。说白了就是反射factoryBean里的方法，把所依赖的对象做为参数传进去完成注入。这里提到了factoryBean的概念，这个factoryBean其实就是IOC容器管理的bean，说白了就是有依赖关系的bean，例如我们上面举的例子里面的Person类，Person需要依赖Car对象，在IOC容器中Person的实例就是一个factoryBean，Car的对象将被注入这个factoryBean

spring究竟是怎样实现依赖注入的，其实上面已经有所提到，我们现在再来仔细看看AbstractAutowireCapableBeanFactory类的instantiateUsingFactoryMethod方法

Java代码

package org.springframework.beans.factory.support;
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs) throws
BeansException {
ConstructorArgumentValues cargs = mergedBeanDefinition.getConstructorArgumentValues();
ConstructorArgumentValues resolvedValues = null;
int minNrOfArgs = 0;
if (explicitArgs == null) {
// 如果没有工厂方法的参数直接传入，我们将从bean definition中得到
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mergedBeanDefinition, cargs, resolvedValues);
}
else {
minNrOfArgs = explicitArgs.length;
}
boolean isStatic = true;
Class factoryClass = null;
Object factoryBean = null;
if (mergedBeanDefinition.getFactoryBeanName() != null) {
// 获得factoryBean的实例
factoryBean = getBean(mergedBeanDefinition.getFactoryBeanName());
factoryClass = factoryBean.getClass();
isStatic = false;
}
else {
// It's a static factory method on the bean class.
factoryClass = mergedBeanDefinition.getBeanClass();
}
BeanWrapperImpl bw = new BeanWrapperImpl();
initBeanWrapper(bw);
// 尝试调用factoryBean里的方法，如果这个工厂方法里的参数和得到的参数匹配
Method[] candidates = factoryClass.getMethods();
Method factoryMethodToUse = null;
Object[] argsToUse = null;
int minTypeDiffWeight = Integer.MAX_VALUE;
// 对工厂方法和参数做个遍历，挑出合适的方法和参数
for (int i = 0; i < candidates.length; i++) {
Method factoryMethod = candidates[i];
if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
factoryMethod.getName().equals(mergedBeanDefinition.getFactoryMethodName()) &&
factoryMethod.getParameterTypes().length >= minNrOfArgs) {
Class[] argTypes = factoryMethod.getParameterTypes();
ArgumentsHolder args = null;
if (resolvedValues != null) {
// Resolved contructor arguments: type conversion and/or autowiring necessary.
try {
args = createArgumentArray(
beanName, mergedBeanDefinition, resolvedValues, bw,
argTypes, "factory method");
}
catch (UnsatisfiedDependencyException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Ignoring factory method [" + factoryMethod + "] of
bean '" + beanName +
"': " + ex.getMessage());
}
if (i == candidates.length - 1 && factoryMethodToUse == null) {
throw ex;
}
else {
// Swallow and try next overloaded factory method.
continue;
}
}
}
else {
// Explicit arguments given -> arguments length must match exactly.
if (argTypes.length != explicitArgs.length) {
continue;
}
args = new ArgumentsHolder(explicitArgs);
}
int typeDiffWeight = args.getTypeDifferenceWeight(argTypes);
// Choose this constructor if it represents the closest match.
if (typeDiffWeight < minTypeDiffWeight) {
factoryMethodToUse = factoryMethod;
argsToUse = args.arguments;
minTypeDiffWeight = typeDiffWeight;
}
}
}
if (factoryMethodToUse == null) {
throw new BeanCreationException(
mergedBeanDefinition.getResourceDescription(), beanName,
"Cannot find matching factory method '" + mergedBeanDefinition.getFactoryMethodName
() +
"' on class [" + factoryClass.getName() + "]");
}
// 反射factoryBean的factory method，把依赖的bean对象做为参数传入，完成注入.
Object beanInstance = this.instantiationStrategy.instantiate(
mergedBeanDefinition, beanName, this, factoryBean, factoryMethodToUse, argsToUse);
...
bw.setWrappedInstance(beanInstance);
...
return bw;
}
}

现在总结下：

spring的IOC容器的功能就是把实例化对象和代码解耦，现在造对象的活完全交给spring IOC容器来做了，如果有需要，spring容器还可以把bean注入到依赖它的其它bean中，方便程序使用。我们要做的仅仅是配置好bean定义文件，并告诉spring定义文件在哪，然后在代码里getBean()就行啦！

IOC容器的载体说白了就是Map，即我们常说的缓存。在spring中IOC缓存主要分bean实例的缓存(单例)和bean定义信息的缓存

spring通过定位资源-->解析bean定义文件并缓存bean定义信息-->根据bean定义造bean实例-->如果是单例模式则把这个bean放进缓存管理，否则直接造对象-->如果有依赖关系，则反射目标bean的方法(setter方法/构造方法/普通方法)并将其依赖的bean做为参数传入，完成注入-->至此，IOC容器就建立起来了。