1. 优享JAVA首页
  2. Java
  3. Spring
  4. Spring源码分析

bean的加载 一

经过前面的分析我们结束了对XML配置文件的解析,接下来就是对bean加载的探索,bean加载的功能实现远比bean的解析要复杂得多。

下面的示例演示了bean加载的功能:

    MyTestBean bean = (MyTestBean) bf.getBean("myTestBean");

这里调用getBean方法时执行了哪些逻辑呢,我们可以先快速的体验一下Spring中的代码是如何实现的

  public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
  }
 
  protected <T> T doGetBean(
     final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
     throws BeansException {
    //提取对应的beanName
    final String beanName = transformedBeanName(name);
    Object bean;
 
    /**
     * 检查缓存中或者实例工厂中是否有对应的实例
     * 为什么首先会使用这段代码呢,
     * 因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,Spring创建bean的原则是不等bean创建完成就会将创建的bean的ObjectFactory提早曝光
     * 也就是将ObjectFactory加入到缓存中,一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory
     */
    //直接尝试从缓存中获取或者singletonFactories中的ObjectFactory中获取
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
     if (logger.isDebugEnabled()) {
       if (isSingletonCurrentlyInCreation(beanName)) {
         logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
            "' that is not fully initialized yet - a consequence of a circular reference");
       }
       else {
         logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
       }
     }
     //返回对应的实例,有时候存在诸如BeanFactory的情况并不是直接返回实例本身而是返回指定方法返回的实例
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
 
    else {
     //只有在单例的情况下才会尝试解决循环依赖,原型模式情况下,如果存在A中有B的属性,B中有A的属性,那么当依赖注入的时候,就会产生当A还未创建完成的时候因为对于B的创建在返回创建A,造成循环依赖,也就是下面的情况
     if (isPrototypeCurrentlyInCreation(beanName)) {
       throw new BeanCurrentlyInCreationException(beanName);
     }
 
     // Check if bean definition exists in this factory.
     BeanFactory parentBeanFactory = getParentBeanFactory();
     //如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
     if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
       // Not found -> check parent.
       String nameToLookup = originalBeanName(name);
       //递归到BeanFactory中寻找
       if (args != null) {
         // Delegation to parent with explicit args.
         return (T) parentBeanFactory.getBean(nameToLookup, args);
       }
       else {
         // No args -> delegate to standard getBean method.
         return parentBeanFactory.getBean(nameToLookup, requiredType);
       }
     }
     //如果不是仅仅做类型检查则是创建bean,这里要进行记录
     if (!typeCheckOnly) {
       markBeanAsCreated(beanName);
     }
 
     try {
       //将存储XMl配置文件的GernericBeanDefinition转换为RootBeanDefinition,如果指定BeanName是子Bean的话同时会合并父类的相关属性
       final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
       checkMergedBeanDefinition(mbd, beanName, args);
 
       // Guarantee initialization of beans that the current bean depends on.
       String[] dependsOn = mbd.getDependsOn();
       //若存在依赖则需要递归实例化依赖的bean
       if (dependsOn != null) {
         for (String dep : dependsOn) {
          if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
          }
          //缓存依赖调用
          registerDependentBean(dep, beanName);
          try {
            getBean(dep);
          }
          catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
          }
         }
       }
 
       // Create bean instance.
       //实例化依赖的bean后便可以实例化mbd本身了
       //singleton模式的创建
       if (mbd.isSingleton()) {
         sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
          @Override
          public Object getObject() throws BeansException {
            try {
              return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
              // Explicitly remove instance from singleton cache: It might have been put there
              // eagerly by the creation process, to allow for circular reference resolution.
              // Also remove any beans that received a temporary reference to the bean.
              destroySingleton(beanName);
              throw ex;
            }
          }
         });
         bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
       }
 
       else if (mbd.isPrototype()) {
         // It's a prototype -> create a new instance.
         //prototype模式的创建(new)
         Object prototypeInstance = null;
         try {
          beforePrototypeCreation(beanName);
          prototypeInstance = createBean(beanName, mbd, args);
         }
         finally {
          afterPrototypeCreation(beanName);
         }
         bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
       }
 
       else {
         //指定的scope上实例化bean
         String scopeName = mbd.getScope();
         final Scope scope = this.scopes.get(scopeName);
         if (scope == null) {
          throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
         }
         try {
          Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
              beforePrototypeCreation(beanName);
              try {
                return createBean(beanName, mbd, args);
              }
              finally {
                afterPrototypeCreation(beanName);
              }
            }
          });
          bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
         }
         catch (IllegalStateException ex) {
          throw new BeanCreationException(beanName,
              "Scope '" + scopeName + "' is not active for the current thread; consider " +
              "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
              ex);
         }
       }
     }
     catch (BeansException ex) {
       cleanupAfterBeanCreationFailure(beanName);
       throw ex;
     }
    }
 
    // Check if required type matches the type of the actual bean instance.
    //检查需要的类型是否符合bean的实际类型
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
     try {
       return getTypeConverter().convertIfNecessary(bean, requiredType);
     }
     catch (TypeMismatchException ex) {
       if (logger.isDebugEnabled()) {
         logger.debug("Failed to convert bean '" + name + "' to required type '" +
            ClassUtils.getQualifiedName(requiredType) + "'", ex);
       }
       throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
     }
    }
    return (T) bean;
  }

从代码量上来看,bean的加载经历了一个很复杂的过程,粗略的了解Spring加载bean的过程,大致步骤如下:

1、转换对应beanName

这里的beanName传入的参数可能是别名,也可能是FactoryBean,所有要进行一系列的解析,解析的内容包括下面这些:
(1)、去除FactoryBean的修饰符,也就是如果name=“&aa”,那么会首先去除&,
(2)、取指定alias所表示的最终beanName,如别名A指向的名称为B则返回B,如果别名A指向B,别名B又指向C,则返回C。

2、尝试从缓存中加载单例

单例在Spring的同一个容器内只会被创建一次,后续获取Bean时就直接从缓存中获取。这里只是尝试加载,首先尝试从缓存中加载,如果加载不成功则再次从singletonFactories中加载,因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,在Spring中创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中,一旦下一个bean创建的时候需要依赖上一个bean则直接使用ObjectFactory

3、bean的实例化

如果从缓存中得到了bean的原始状态,则需要对bean进行实例化,缓存中记录的只是最原始的bean的状态,并不一定是我们最终想要的bean。如果要对工厂bean进行处理,那么这里得到的其实不是工厂bean的初始状态,但是我们真正需要的是工厂bena中定义的factory-method方法中返回的bean,而getObjectForBeanInstance就是完成这个工作的。

4、原型模式的依赖检查

只有在单例情况下才会尝试解决循环依赖,如果存在A中有B的属性,B中有A的属性,那么当依赖注入的时候,就会产生当A还未创建完成的时候因为对于B的创建再次返回创建A,造成循环依赖,也就是情况:isPrototypeCurrentlyInCreation(beanName)判断为true。

5、检测parentBeanFactory

如果缓存没有数据的话直接转到父类工厂上去加载。这里有一个很重要的判断条件,parentBeanFactory!=null&&!containsBeanDefinition(beanName),parentBeanFactory!=null。parentBeanFactory如果为空,则其他一切都是浮云,但是!containsBeanDefinition(beanBane)比较重要,它是检测如果当前加载的XML配置文件中不包含beanName所对应的配置,就只能到parentBeanFactory中去尝试,然后递归的调用getBean方法。

6、将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition

因为从XML配置文件中读取到的Bean信息时存储在GernericBeanDefinition中的,但是所有的bean后续处理都是针对于RootBeanDefinition的,所以这里需要进行一个转换,转换的同时如果父类bean不为空的话,则会一并合并父类的属性。

7、寻找依赖

因为bean的初始化过程中很可能会用到某些属性,而某些属性很可能是动态配置的,并且配置成依赖于其他的bean,那么这个时候就有必要加载依赖的bean,所以,在Spring的加载顺寻中,在初始化某一个bean的时候首先会初始化这个bean对应的依赖

8、针对不同的scope进行bean的创建

在Spring总存在着不同的scope,其中默认的是singleton,但是还有些其他的配置诸如prototype、request之类的,在这个步骤中Spring会根据不同的配置进行不同的初始化策略

9、类型的转换

程序到这里返回bean后,已经基本结束了,通常对该方法的调用参数requiredType是为空的。可能会存在这样的情况,返回的bean其实是一个String,但是requiredType却传入Integer类型,那么这个时候本步骤就会起作用了,它的功能是将返回的bean转换为requiredType所指定的类型。
经过上面的步骤后bean的加载就结束了,这个时候就可以返回我们需要的bean。

下面的图直观的反映了整个过程,其中最重要的是步骤8,针对不同的scope进行bean的创建。

beanpng

1、FactoryBean的使用

Spring通过反射机制利用bean的class属性指定实现类来实例化bean。在一些情况下,实例化bean的过程比较复杂,如果按照传统的方式需要在中提供大量的配置信息,配置的方式的灵活性是受限的,这个时候采用编码的方式可能会得到一个简单的方案,Spring提供BeanFactory的工厂类接口,我们可以通过实现该接口定制实例化逻辑。
FactoryBean接口对于Spring框架来说占有重要地位,Spring自身就提供70多个FactoryBean的实现,从Spring 3.0开始FactoryBean支持泛型:

package org.springframework.beans.factory;
public interface FactoryBean<T> {
  //返回由FactoryBean创建的bean实例,如果isSingleton()返回true,则该实例会放到Spring容器的单实例缓冲池中
  T getObject() throws Exception;
  //返回FactoryBean创建的bean类型
  Class<?> getObjectType();
  //返回由FactoryBean创建的bean实例的作用域是singleton还是prototype
  boolean isSingleton();
}

当配置文件中的class属性配置的实现类是FactoryBean时,通过getBean()方法返回的不是FactoryBean本身,而是FactoryBean#getObject()方法所返回的对象,相当于FactoryBean#getObject()代理了getBean()方法。

package test.factorybean;
public class Car {
  private int maxSpeed;
  private String brand;
  private double price;
  //省略get,set方法
}
package test.factorybean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean<Car> {
  private String carInfo;
  @Override
  public Car getObject() throws Exception {
    Car car = new Car();
    String[] infos = carInfo.split(",");
    car.setBrand(infos[0]);
    car.setMaxSpeed(Integer.parseInt(infos[1]));
    car.setPrice(Double.parseDouble(infos[2]));
    return car;
  }
  @Override
  public Class<?> getObjectType() {
    return Car.class;
  }
  @Override
  public boolean isSingleton() {
    return false;
  }
  public String getCarInfo() {
    return carInfo;
  }
  public void setCarInfo(String carInfo) {
    this.carInfo = carInfo;
  }
}

有了这个CarFactoryBean之后,就可以在配置文件中使用这种自定义的配置方式配置Car这个类

<?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.xsd">
  <bean id="car" class="test.factorybean.CarFactoryBean">
    <property name="carInfo" value="超级跑车,400,2000000"/>
  </bean>
</beans>

当调用getBean(“car”)时,Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口,这时Spring容器就调用接口方法CarFactoryBean#getObject()方法返回,如果希望获取的是CarFactoryBean的实例,则需要在使用geiBean(beanName)方法时在beanName前显式的加上”&”前缀。

package test.factorybean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
  public static void main(String[] args) throws Exception {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
       "test/factorybean/FactoryBeanTest.xml");
    // 如果要获取CarFactoryBean的实例,加上&前缀.否则报错java.lang.ClassCastException:
    // test.factorybean.Car cannot be cast to test.factorybean.CarFactoryBean
    CarFactoryBean cfb = (CarFactoryBean) applicationContext.getBean("&car");
    Car car = (Car) applicationContext.getBean("car");
    System.out.println(car.getBrand());
    String carInfo = cfb.getCarInfo();
    System.out.println(carInfo);
  }
}

2、缓存中获取单例bean

单例在Spring的同一个容器内只会被创建一次,后续再获取bean直接从单例缓存中获取,首先是尝试从缓存中加载,然后再次尝试从singletonFactories中加载,因为在创建单例bean的时候会存在依赖注入的情况,而在创建依赖的时候为了避免循环依赖,Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中,一旦下一个bean创建时需要依赖上个bean,则直接使用ObjectFactory。

  public Object getSingleton(String beanName) {
    //参数true设置标识允许早期依赖
    return getSingleton(beanName, true);
  }
 
  protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
     //如果为空,则锁定全局变量并进行处理
     synchronized (this.singletonObjects) {
       //如果此bean正在加载则不处理
       singletonObject = this.earlySingletonObjects.get(beanName);
       if (singletonObject == null && allowEarlyReference) {
         //当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactories
         ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
         if (singletonFactory != null) {
          //调用预先设定的getObject()方法
          singletonObject = singletonFactory.getObject();
          //记录在缓存中,earlySingletonObjects和singletonFactories互斥
          this.earlySingletonObjects.put(beanName, singletonObject);
          this.singletonFactories.remove(beanName);
         }
       }
     }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
  }

首先尝试从singletonObjects中获取实例,如果获取不到再从earlySingletonObjects中获取,如果还获取不到,再尝试从singletonFactories里面获取beanName对应的ObjectFactory,然后调用这个ObjectFactory的getObject来创建bean,并放到earlySingletonObjects里面去,并且从singletonFactories里面remove掉这个ObjectFactory,而对于后续的所有内存操作都只是为了循环依赖检测的时候使用,也就是在allowEarlyReference为true的情况下才会使用
这里用到的存储bean的map,它们的作用如下:

  //用于保存BeanName和创建bena实例之间的关系,bean name --> bean instance
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
 
  // 用于保存BeanName和创建bean的工厂之间的关系,bean name --> ObjectFactory
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
 
  //也是用于保存BeanName和创建bean实例之间的关系,与singletonObjects的不同之处在于,当一个单例bean被放到这里面后,那么当bean还在创建过程中,就可以通过getBean方法获取到了,其目的是用来检测循环引用。
  private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
 
  //用来保存当前所有已注册的bean
  private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);

3、从bean的实例中获取对象

在getBean方法中,getObjectForBeanInstance是个高频率使用的方法,无论是从缓存中获得bean还是根据不同的scope策略加载bean。得到bean的实例要做的第一件事就是调用这个方法来检测它的正确性,其实就是检测当前bean是否是FactoryBean类型的bean,如果是的话,那么需要调用该bean对应的FactoryBean实例中的getObject()作为返回值。

	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

		// 如果bean不是工厂,不要让调用代码试图解除对工厂的引用
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		// 现在有了bean的实例,这个实例可能是正常的bean或者是FactoryBean,如果是FactoryBean我们使用它创建实例,但是如果用户想要获取的是工厂实例而不是工厂的getObject方法对应的实例,那么传入的name应该加前缀&
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}
		// 加载FactoryBean
		Object object = null;
		if (mbd == null) {
			// 尝试从缓存中加载bean
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// 这里已经明确beanInstance一定是FactoryBean类型
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// containsBeanDefinition检测beanDefinitionMap中也就是在所有已经加载的bean中检测是否定义beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
				// 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition,如果指定BeanName是子Bean的话同时会合并父类的相关属性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			// 是否是用户定义的而不是程序本身定义的
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

上面代码大多数是一些辅助代码以及一些功能性的判断,而真正的核心代码却委托给了getObjectFromFactoryBean,下面看看getObjectForBeanInstance中所作的工作。

  • 1、对FactoryBean正确性的验证
  • 2、对非FactoryBean不做任何处理
  • 3、对bean进行转换
  • 4、将从Factory中解析bean的工作委托给getObjectFromFactoryBean
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		// 如果是单例模式
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (object != null && shouldPostProcess) {
							if (isSingletonCurrentlyInCreation(beanName)) {
								// Temporarily return non-post-processed object, not storing it yet..
								return object;
							}
							beforeSingletonCreation(beanName);
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
							finally {
								afterSingletonCreation(beanName);
							}
						}
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
						}
					}
				}
				return (object != NULL_OBJECT ? object : null);
			}
		}
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (object != null && shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

上面这段代码中做了一件事情就是返回的bean如果是单例,那就要必须保证全局唯一。同时不需重复创建,使用缓存来提高性能。

在doGetObjectFromFactoryBean方法中看到object = factory.getObject(),这句代码是最内部的代码实现。

	private Object doGetObjectFromFactoryBean(
			final FactoryBean<?> factory, final String beanName, final boolean shouldPostProcess)
			throws BeanCreationException {

		Object object;
		try {
			// // 需要权限验证
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
						@Override
						public Object run() throws Exception {
								return factory.getObject();
							}
						}, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				// 直接调用getObject()方法 
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}


		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null && isSingletonCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(
					beanName, "FactoryBean which is currently in creation returned null from getObject");
		}

		if (object != null && shouldPostProcess) {
			try {
				// 调用ObjectFactory的后处理器
				object = postProcessObjectFromFactoryBean(object, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);
			}
		}

		return object;
	}

上面讲述了FactoryBean的调用方法,如果bean声明为FactoryBean类型,则当前提取的bean并不是FactoryBean,而是FactoryBean中对应的getObject方法返回的bean类型,doGetObjectForFactoryBean正是实现这个功能的。

原创文章,作者:Craig,如若转载,请注明出处:https://www.goodlymoon.com/archives/960.html

发表评论

电子邮件地址不会被公开。 必填项已用*标注

QR code