spring IOC源码分析（3）

时间：2023-03-10 01:12:47
spring IOC源码分析（3）

1.IOC容器的依赖注入

Spring中，依赖注入是在用户第一次向IOC容器索要Bean时触发的（通过getBean方法）。

spring IOC源码分析（3）

在BeanFactory中我们看到getBean（String…）函数，它的具体实现在AbstractBeanFactory中：

  1. public Object getBean(String name) throws BeansException {
  2. return doGetBean(name, null, null, false);
  3. }

可以看到具体的注入过程转移到doGetBean（String…）中，在这个方法中，它首先从缓存中取，如果单件模式的bean已经被创建，则这种bean请求不需要重复的创建，调用

  1. bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

跟踪进入getObjectForBeanInstance（…,null）,可以知道因为最后的RootBeanDefinition参数是null，所以执行的是：

  1. if (mbd == null) {
  2. object = getCachedObjectForFactoryBean(beanName);
  3. }

而getCachedObjectForFactoryBean(beanName)中实现，其实现很简单，就是在缓存的bean map中查找bean返回。

继续回到doGetBean（String…）方法中：

  1. //取当前bean的所有依赖bean，这样就会触发getBean的递归调用，直至取到一个没有任何依赖的bean为止
  2. String[] dependsOn = mbd.getDependsOn();
  3. if (dependsOn != null) {
  4. for (String dependsOnBean : dependsOn) {
  5. getBean(dependsOnBean);
  6. //注册依赖的bean实例，具体实现过程在DefaultSingletonBeanRegistry中实现，其实就是将依赖的bean添加到依赖的hashmap中
  7. registerDependentBean(dependsOnBean, beanName);
  8. }
  9. }
  10. //通过调用createBean来，创建单例bean的实例
  11. if (mbd.isSingleton()) {
  12. sharedInstance = getSingleton(beanName, new ObjectFactory() {
  13. public Object getObject() throws BeansException {
  14. try {
  15. return createBean(beanName, mbd, args);
  16. }
  17. catch (BeansException ex) {
  18. destroySingleton(beanName);
  19. throw ex;
  20. }
  21. }
  22. });
  23. bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  24. }
  25. //同样调用createBean创建prototype的bean实例
  26. else if (mbd.isPrototype()) {
  27. // It's a prototype -> create a new instance.
  28. Object prototypeInstance = null;
  29. try {
  30. beforePrototypeCreation(beanName);
  31. prototypeInstance = createBean(beanName, mbd, args);
  32. }
  33. finally {
  34. afterPrototypeCreation(beanName);
  35. }
  36. bean=getObjectForBeanInstance(prototypeInstance,name, beanName, mbd);
  37. }

继续看createBean（…），可以看到在AbstractBeanFactory中它只是个抽象类，具体的实现交给其子类（又见模板模式），进入子类AbstractAutowireCapableBeanFactory中看createBean的具体实现：

  1. Object beanInstance = doCreateBean(beanName, mbd, args);

其具体的实现转到doCreateBean（String…）,这里我们看到与依赖注入关系比较密切的方法有createBeanInstance和populateBean。

  1. BeanWrapper instanceWrapper = null;
  2. if (mbd.isSingleton()) {
  3. instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  4. }
  5. if (instanceWrapper == null) {
  6. instanceWrapper = createBeanInstance(beanName, mbd, args);
  7. }
  1. // Initialize the bean instance.
  2. Object exposedObject = bean;
  3. try {
  4. populateBean(beanName, mbd, instanceWrapper);
  5. if (exposedObject != null) {
  6. exposedObject = initializeBean(beanName, exposedObject, mbd);
  7. }
  8. }

在createBeanInstance中生成了Bean所包含的Java对象，这个对象的生成有很多不同的方式，可以通过工厂方法生成，也可以通过容器的autowire特性生成，生成的方式由相关联的BeanDefinition来指定，进入createBeanInstance方法，有：

  1. return instantiateUsingFactoryMethod(beanName, mbd, args);
  1. return instantiateBean(beanName, mbd);

上面是其中的两个实例化方法，上面的是在BeanDefinition的FactoryMethod存在的情况下，使用工厂方法对bean进行实例化。下面一个是使用默认的构造函数对bean进行实例化。我们进入instantiateBean(beanName,mbd)，可以看到有：

  1. return getInstantiationStrategy().instantiate(mbd, beanName, parent);

因为getInstantiationStrategy()返回的默认的实例化策略，而默认的实例化策略是CglibSubclassingInstantiationStrategy，也即用cglib来对bean进行实例化。CGLIB是一个常用的字节码生成器的类库，它提供了一系列的API来提供Java的字节码生成和转换功能。

我们再次回到doCreateBean（）中的populateBean方法，看看在实例化Bean对象生成的基础上，spring怎样把这些bean对象的依赖关系设置好，完成整个依赖注入过程。在populateBean中，先是取得在BeanDefinition中设置的property值，这些property来自对BeanDefinition的解析，接着便开始进行依赖注入过程：

  1. //开始进行依赖注入过程，先处理autowire的注入
  2. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
  3. MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  4. //根据bean的名字进行autowire过程
  5. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
  6. autowireByName(beanName, mbd, bw, newPvs);
  7. }
  8. //根据类型type进行autowire的过程
  9. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
  10. autowireByType(beanName, mbd, bw, newPvs);
  11. }
  12. pvs = newPvs;
  13. }

最后在通过applyPropertyValues对属性进行注入：

  1. applyPropertyValues(beanName, mbd, bw, pvs);

接着我们到applyPropertyValues中去看具体的对属性进行解析然后注入的过程，在其中会调用BeanDefinitionValueResolver对BeanDefinition进行解析，

  1. BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

接着为解析值创建一个拷贝，拷贝的数据将会被注入到bean中，它会先对PropertyValue判断，如果其没有经过转换则会调用resolveValueIfNecessary进行解析，然后注入到property中。下面到BeanDefinitionValueResolver中去看一下解析过程的实现，在函数resolveValueIfNecessary中包含了所有对注入类型的处理，以RuntimeBeanReference（其是在对BeanDefinition进行解析时生成的数据对象）为例：

  1. if (value instanceof RuntimeBeanReference) {
  2. RuntimeBeanReference ref = (RuntimeBeanReference) value;
  3. return resolveReference(argName, ref);
  4. }
  5. //当注入类型为RuntimeBeanReference时，进入resolveReference（…）：
  6. private Object resolveReference(Object argName, RuntimeBeanReference ref) {
  7. try {
  8. //从RuntimeBeanReference取得reference的名字
  9. String refName = ref.getBeanName();
  10. refName = String.valueOf(evaluate(refName));
  11. //如果ref是在双亲的IOC容器中，那就到双亲IOC容器中去取
  12. if (ref.isToParent()) {
  13. if (this.beanFactory.getParentBeanFactory() == null) {
  14. //抛出异常BeanCreationException
  15. ……
  16. }
  17. return this.beanFactory.getParentBeanFactory().
  18. getBean(refName);
  19. }
  20. else {
  21. //在当前IOC容器中去取bean
  22. Object bean = this.beanFactory.getBean(refName);
  23. this.beanFactory.registerDependentBean(refName, this.beanName);
  24. return bean;
  25. }
  26. }

在上面的实现中，无论是到双亲的IOC容器中去取，还是在当前IOC容器中取，都会触发一个getBean的过程，这就触发了相应的依赖注入的发生。

这就完成了resolve的过程，为依赖注入准备好了条件。但真正的把Bean对象设置到它所依赖的另一个Bean的属性中去的地方是在BeanWrapper的setPropertyValues中（在分析populateBean的时候有提到），其中处理的属性是各种各样的。setPropertyValues的具体实现是在BeanWrapper的子类BeanWrapperImpl中：

在doCreateBean中执行完populateBean，完成Bean的生成和依赖注入以后，开始对Bean进行初始化，这个初始化过程包含了对后置处理器的postProcessBeforeInitializtion回调，具体实现在initializeBean方法中：

  1. Object wrappedBean = bean;
  2. if (mbd == null || !mbd.isSynthetic()) {
  3. wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  4. }
  5. try {
  6. invokeInitMethods(beanName, wrappedBean, mbd);
  7. }
  8. catch (Throwable ex) {
  9. //抛出异常BeanCreationException
  10. }
  11. if (mbd == null || !mbd.isSynthetic()) {
  12. wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  13. }
  14. return wrappedBean;

相关文章