阅读量:0
preInstantiateSingletons
v1.0 preInstantiateSingletons
tips：最终调用getBean使用的是RootBeanDefinition进行构建的
public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } //获取所有beanDefinition的名字 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); //循环 for (String beanName : beanNames) { // 获取合并后的BeanDefinition，看代码V1.1 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //如果RootBeanDefinition不是抽象BeanDefinition，是单例bean，非懒加载，则创建bean对象 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { // 获取FactoryBean对象 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { // 创建真正的Bean对象(getObject()返回的对象) getBean(beanName); } } } else { // 创建Bean对象 getBean(beanName); } } } // 所有的非懒加载单例Bean都创建完了后 //找出实现了SmartInitializingSingleton接口的单例bean，并执行afterSingletonsInstantiated（）方法 for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize") .tag("beanName", beanName); SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } smartInitialize.end(); } } }什么是抽象BeanDefinition？
V1.1 getMergedLocalBeanDefinition
合并BeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { // 先从RootBeanDefinitionMap中获取当前beanName对应的RootBeanDefinition对象 RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName); //如果已经存在，则直接返回 if (mbd != null && !mbd.stale) { return mbd; } //如果不存在，则继续向下判断 return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); } ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException { synchronized (this.mergedBeanDefinitions) { RootBeanDefinition mbd = null; RootBeanDefinition previous = null; // Check with full lock now in order to enforce the same merged instance. if (containingBd == null) { mbd = this.mergedBeanDefinitions.get(beanName); } if (mbd == null || mbd.stale) { previous = mbd; //如果当前BeanDefinition没有父类 if (bd.getParentName() == null) { //判断bd是否是RootBeanDefinition的实例，如果是，则克隆一个新的RootBeanDifinition对象 if (bd instanceof RootBeanDefinition) { mbd = ((RootBeanDefinition) bd).cloneBeanDefinition(); } else { //直接创建一个RootBeanDefionition对象，并赋值 mbd = new RootBeanDefinition(bd); } } else { //当bd存在父类的时候 // pbd表示parentBeanDefinition BeanDefinition pbd; try { //获取父BeanDefinition的名称 String parentBeanName = transformedBeanName(bd.getParentName()); //如果 当前bean的名称与父类名称不相同，表示父类还存在父类，则需要继续递归调用 //最终的效果是每一个父类都已经合并完了，当前beanDefinition在和父类进行合并 if (!beanName.equals(parentBeanName)) { pbd = getMergedBeanDefinition(parentBeanName); } else { BeanFactory parent = getParentBeanFactory(); if (parent instanceof ConfigurableBeanFactory) { pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName); } else { throw new NoSuchBeanDefinitionException(parentBeanName, "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName + "': cannot be resolved without a ConfigurableBeanFactory parent"); } } } catch (NoSuchBeanDefinitionException ex) { throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex); } // 子BeanDefinition的属性覆盖父BeanDefinition的属性，这就是合并 //先用父类的BeanDefinition创建一个新的RootBeanDefinition mbd = new RootBeanDefinition(pbd); //在使用子类 的BeanDefinition覆盖RootBeanDefinition的属性 mbd.overrideFrom(bd); } // 如果未设置bean的作用域，则默认设置未单例 if (!StringUtils.hasLength(mbd.getScope())) { mbd.setScope(SCOPE_SINGLETON); } // A bean contained in a non-singleton bean cannot be a singleton itself. // Let's correct this on the fly here, since this might be the result of // parent-child merging for the outer bean, in which case the original inner bean // definition will not have inherited the merged outer bean's singleton status. if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { mbd.setScope(containingBd.getScope()); } if (containingBd == null && isCacheBeanMetadata()) { this.mergedBeanDefinitions.put(beanName, mbd); } } if (previous != null) { copyRelevantMergedBeanDefinitionCaches(previous, mbd); } return mbd; }doGetBean
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // name有可能是 &xxx 或者 xxx，如果name是&xxx，那么beanName就是xxx // name有可能传入进来的是别名，那么beanName就是id //具体看v1.1 String beanName = transformedBeanName(name); Object beanInstance; // 优先从单例池中获取beanDefinition Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { 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 + "'"); } } // 如果sharedInstance是FactoryBean，那么就调用getObject()返回对象 beanInstance = 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)) { //如果beanDefinitionMap的keys中不包含beanName，则调用父类的bean工厂创建创建对象 String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { //此处是递归处理，直至找到beanDefginition 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); } StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate") .tag("beanName", name); try { if (requiredType != null) { beanCreation.tag("beanType", requiredType::toString); } //拿到beanName对应的RootBeanDefinition RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检查BeanDefinition是不是Abstract的 checkMergedBeanDefinition(mbd, beanName, args); // 找出这个对象所依赖的所有bean的集合，该字段于构建rootBeandefinition的时候赋值 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { // dependsOn表示当前beanName所依赖的，当前Bean创建之前dependsOn所依赖的Bean必须已经创建好了 for (String dep : dependsOn) { // beanName是不是被dep依赖了，如果是则出现了循环依赖 //看代码v1.3 if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // dep被beanName依赖了，存入dependentBeanMap中，dep为key，beanName为value registerDependentBean(dep, beanName); // 创建所依赖的bean try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // bean是单例的情况 if (mbd.isSingleton()) { //此处第二个参数lambda并不会马上执行，此处是相当于传入了一个对象， //该对象是getSingleton()方法中第二个参数接口的实例化，重写了该接口中唯一一个方法 //具体看代码v1.2 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; } }); beanInstance = 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); } beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { // session.getAttriute(beaName) setAttri Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new ScopeNotActiveException(beanName, scopeName, ex); } } } catch (BeansException ex) { beanCreation.tag("exception", ex.getClass().toString()); beanCreation.tag("message", String.valueOf(ex.getMessage())); cleanupAfterBeanCreationFailure(beanName); throw ex; } finally { beanCreation.end(); } } // 检查通过name所获得到的beanInstance的类型是否是requiredType //看代码v1.5 return adaptBeanInstance(name, beanInstance, requiredType); }v1.1 transformedBeanName
根据传入的名字获取bean真正的名字（有可能传入的是别名或者工厂类别名，以&开头的），特别需要说明的是，spring针对于别名专门使用一个map（aliasMap）进行存储，key为别名，而value则是bean真正的名字。所以在创建bena第一步就需要先根据名字获取到bean真正的名字
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; }); } ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ public String canonicalName(String name) { String canonicalName = name; // Handle aliasing... String resolvedName; do { //从别名map中获取bean的真实名字 resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }v1.2 getSingleton
获取单例对象
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } //创建bean之前的一些准备 //1 判断beanName是否是被过滤的，如果是需要过滤的，则抛出异常 //2 将beanName添加到singletonsCurrentlyInCreation集合中，表示bean正在创建 //上面条件其中一个失败都会抛出异常 beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { //开始创建单例对象，调用外部的lambda表达式 singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } //结束创建过程 //1 判断beanName是否是被过滤的，如果是需要过滤的，则抛出异常 //2 将beanName移除singletonsCurrentlyInCreation集合，表示bean不在创建过程中（已经创建结束了） //上面条件其中一个失败都会抛出异常 afterSingletonCreation(beanName); } // 添加到单例池 if (newSingleton) { addSingleton(beanName, singletonObject); } } return singletonObject; } }v1.3 isDependent
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) { if (alreadySeen != null && alreadySeen.contains(beanName)) { return false; } String canonicalName = canonicalName(beanName); //dependentBeanMapbeanName为key 以被key依赖的所有bean名字的集合为value Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName); if (dependentBeans == null) { return false; } if (dependentBeans.contains(dependentBeanName)) { return true; } for (String transitiveDependency : dependentBeans) { if (alreadySeen == null) { alreadySeen = new HashSet<>(); } alreadySeen.add(beanName); if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { return true; } } return false; }v1.4 adaptBeanInstance
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) { // Check if required type matches the type of the actual bean instance. if (requiredType != null && !requiredType.isInstance(bean)) { try { // SimpleTypeConverter Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return (T) 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; } 