SpringloC容器的依赖注入源码解析(2)—— doGetBean之从缓存获取Bean

本文阅读 8 分钟
首页 代码,Java 正文

img 直接打开AbstractBeanFactory的doGetBean方法:

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 

   // 先将方法传入的name转换成容器真实的beanName
   // 之前可以通过三种形式获取beanName
   // 一个是原始的beanName,一个是加了&的,一个是别名
   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   Object sharedInstance = getSingleton(beanName);
   // 加果先前已经创建过单例Bean的实例,并且调用的getBean方法传入的参数为空,则执行理面的逻辑
   // args之所以要求为空是因为如果有args,则需要做进一步赋值,因此无法直接返回
   if (sharedInstance != null && args == null) { 
      if (logger.isTraceEnabled()) { 
         // 如果Bean还在创建中,则说明是循环引用
         if (isSingletonCurrentlyInCreation(beanName)) { 
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else { 
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      // 如果是普通bean,直接返回,如果是FactoryBean,则返回他的getObject
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else { 
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      if (isPrototypeCurrentlyInCreation(beanName)) { 
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (parentBeanFactory instanceof AbstractBeanFactory) { 
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) { 
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else if (requiredType != null) { 
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
         else { 
            return (T) parentBeanFactory.getBean(nameToLookup);
         }
      }

      if (!typeCheckOnly) { 
         markBeanAsCreated(beanName);
      }

      try { 
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
         String[] dependsOn = mbd.getDependsOn();
         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.
         // 如果BeanDefinition为单例
         if (mbd.isSingleton()) { 
            // 这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象
            sharedInstance = getSingleton(beanName, () -> { 
               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.
            Object prototypeInstance = null;
            try { 
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally { 
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

         else { 
            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, () -> { 
                  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.
   if (requiredType != null && !requiredType.isInstance(bean)) { 
      try { 
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         if (convertedBean == null) { 
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
         return convertedBean;
      }
      catch (TypeMismatchException ex) { 
         if (logger.isTraceEnabled()) { 
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                  ClassUtils.getQualifiedName(requiredType) + "'", ex);
         }
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
   }
   return (T) bean;
}

第一行先将方法传入的name转换成容器真实的beanName,回顾之前,可以通过三种形式获取beanName,一个是原始的beanName,一个是加了&的,一个是别名

final String beanName = transformedBeanName(name);
Object bean;

进入到transformedBeanName方法里面

protected String transformedBeanName(String name) { 
   return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
public static String transformedBeanName(String name) { 
   Assert.notNull(name, "'name' must not be null");
   if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { 
      return name;
   }
   return transformedBeanNameCache.computeIfAbsent(name, beanName -> { 
      do { 
         beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
      }
      while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
      return beanName;
   });
}

先看看是否是以&前缀开始的,不是的话直接返回name,是的话将&全部去掉。

再进入到canonicalName方法里:

public String canonicalName(String name) { 
   String canonicalName = name;
   // Handle aliasing...
   String resolvedName;
   do { 
       // 根据别名获取真正的beanName,传入beanName就啥都获取不到
      resolvedName = this.aliasMap.get(canonicalName);
      if (resolvedName != null) { 
         canonicalName = resolvedName;
      }
   }
   while (resolvedName != null);
   return canonicalName;
}

如果能在map里找到真名,则证明传入的是别名,为了防止是别名的别名,这里有一个递归操作直到找不到,此时为真名

回到doGetBean,获取到beanName之后就尝试去缓存获得Bean实例

Object sharedInstance = getSingleton(beanName);

进入方法里

public Object getSingleton(String beanName) { 
   return getSingleton(beanName, true);
}

第二个参数控制是否允许非延迟加载,true表示允许立即加载

protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
   // 尝试从一级缓存里面获取完备的Bean
   Object singletonObject = this.singletonObjects.get(beanName);
   // 如果完备的单例还没有创建出来,创建中的Bean的名字会被保存在singletonsCurrentlyInCreation中
   // 因此看看是否正在创建
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
      // 尝试给一级缓存对象加锁,因为接下来就要对缓存对象操作了
      synchronized (this.singletonObjects) { 
          // 尝试从二级缓存earlySingletonObjects这个存储还没进行属性添加操作的Bean实例缓存中获取
         singletonObject = this.earlySingletonObjects.get(beanName);
         // 如果还没有获取到并且第二个参数为true,为true则表示bean允许被循环引用
         if (singletonObject == null && allowEarlyReference) { 
            // 从三级缓存singletonFactories这个ObjectFactory实例的缓存里尝试获取创建此Bean的单例工厂实例 
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            // 如果获取到工厂实例
            if (singletonFactory != null) { 
               // 调用单例工厂的getObject方法返回对象实例 
               singletonObject = singletonFactory.getObject();
               // 将实例放入二级缓存里
               this.earlySingletonObjects.put(beanName, singletonObject);
               // 从三级缓存里移除
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

该方法在DefaultSingletonBeanRegistry类里,负责对容器创建出来的单例进行注册,从一个map (singletonObjects)中尝试获取key为beanName的单例实例,其中singletonObjects就是一级缓存。

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName))

保证从一级缓存里没有获取到相关实例,并且该实例一定是当前正在创建的实例

public boolean isSingletonCurrentlyInCreation(String beanName) { 
   return this.singletonsCurrentlyInCreation.contains(beanName);
}

isSingletonCurrentlyInCreation方法会去查询一个set,看看正在创建的单例bean名单里是否有beanName,如果此时bean是单例的且正在创建,则会给一级缓存加一个同步锁,之后再操作另外两层缓存。

为了提高性能,二级缓存earlySingletonObjects和三级缓存singletonFactories都是HashMap,因为前面已经对一级缓存加了锁,所以是安全的。

首先尝试从二级缓存里获取Bean实例

singletonObject = this.earlySingletonObjects.get(beanName);

二级缓存里存的是还没有实例化的Bean(没执行populate)

之后又可能从三级缓存singletonFactories里尝试获取,这里存储的是Bean对应的ObjectFactory实例(工厂),后续可以通过getObject()来创建Bean的实例,由于Bean实例的属性可能还没有注入,所以先将其放入二级缓存里,然后从三级缓存里清除(保证三级缓存里只有一级保存Bean实例,避免重复创建Bean实例打破单例),之所以没有注入的Bean也要返回的原因是为了打破循环依赖问题。

回到doGetBean, img 如果先前已经创建过单例Bean的实例,并且调用的getBean方法传入的参数为空,则执行理面的逻辑,args之所以要求为空是因为,如果有args,则需要做进一步赋值,因此无法直接返回。

无论是否有循环引用,最终都是要调用getObjectForBeanInstance返回Bean实例,但由于我们可能获取到的是工厂而非实例,所以还可能要多一步由工厂创建bean实例的步骤。

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

   // Don't let calling code try to dereference the factory if the bean isn't a factory.
   if (BeanFactoryUtils.isFactoryDereference(name)) { 
      if (beanInstance instanceof NullBean) { 
         return beanInstance;
      }
      // 如果name是以&开头的但是不是FactoryBean,则直接抛出异常
      if (!(beanInstance instanceof FactoryBean)) { 
         throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
      }
      if (mbd != null) { 
         mbd.isFactoryBean = true;
      }
      return beanInstance;
   }

   // Now we have the bean instance, which may be a normal bean or a FactoryBean.
   // If it's a FactoryBean, we use it to create a bean instance, unless the
   // caller actually wants a reference to the factory.
   // 如果是一个普通的Bean,则直接返回
   if (!(beanInstance instanceof FactoryBean)) { 
      return beanInstance;
   }

   // FactoryBean创建出bean实例返回
   Object object = null;
   if (mbd != null) { 
      mbd.isFactoryBean = true;
   }
   else { 
      // 单例模式下,FactoryBean仅会创建一个Bean实例
      // 因此需要优先从缓存获取,这里的缓存不是前面的三级缓存,这个是缓存工厂创建出来的bean的
      object = getCachedObjectForFactoryBean(beanName);
   }

   if (object == null) { 
      // /若缓存没有则尝试创建
      // Return bean instance from factory.
      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
      // Caches object obtained from FactoryBean if it is a singleton.
      if (mbd == null && containsBeanDefinition(beanName)) { 
         mbd = getMergedLocalBeanDefinition(beanName);
      }
      boolean synthetic = (mbd != null && mbd.isSynthetic());
      object = getObjectFromFactoryBean(factory, beanName, !synthetic);
   }
   return object;
}

jvm里面通过Synthetic来标识是由自己的机制生成的类,用在这里标识这是Spring内部生成的Bean实例,不允许第三方改动。

进入到getObjectFromFactoryBean方法:

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { 
   // 加果需要在工厂模式下维持单例的话
   if (factory.isSingleton() && containsSingleton(beanName)) { 
      synchronized (getSingletonMutex()) { 
         // 又见双重检查锁机制,尝试再从缓存中获取,防止多线程下可能有别的线程已完成该单例Bean的创建
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) { 
            // 调用工厂方法,创建Bean实例
            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)
            // 看看此时是否有别的线程先人一步创建好了Bean实例,如果是,则使用最先创建出来的以保证单例
            // 之所以这样做是因为factoryBean是用户自定义的,就有可能是异步模式的,即getObject可能是异步的
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) { 
               object = alreadyThere;
            }
            else { 
               // 如果是 Synthetic 的就不能使用后置处理器服务了
               if (shouldPostProcess) { 
                  // 该Bean实例是否已经有别的线程在尝试创建,但是还没有进行后置处理
                  if (isSingletonCurrentlyInCreation(beanName)) { 
                     // Temporarily return non-post-processed object, not storing it yet..
                     return object;
                  }
                  // 后置处理完成前,先加入缓存里锁定起来
                  beforeSingletonCreation(beanName);
                  try { 
                     // 触发BeanPostProcessor,第三方框架可以在此用AOP来包装Bean实例
                     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);
               }
            }
         }
         return object;
      }
   }
   else { 
      // 如果不是单例,则直接创建并返回
      Object object = doGetObjectFromFactoryBean(factory, beanName);
      if (shouldPostProcess) { 
         try { 
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) { 
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}

先确保factory创建出来的是单例,如果是就先上锁,这里用到了双重锁检查机制,尝试再去factoryBeanObjectCache缓存里获取一遍,防止多线程下可能有别的线程已完成该单例Bean的创建

回到doGetBean,if块里的代码执行完了之后就会跳过else的代码块,然后再经过一系列检查之后就返回bean实例了

本文为互联网自动采集或经作者授权后发布,本文观点不代表立场,若侵权下架请联系我们删帖处理!文章出自:https://wangjiawei.blog.csdn.net/article/details/121324423
-- 展开阅读全文 --
安全面试之XSS(跨站脚本攻击)
« 上一篇 07-24

发表评论

成为第一个评论的人

热门文章

标签TAG

最近回复