概述
这个方法我们并不陌生，通常我们在程序中都会先获取到ApplicationContext，之后调用getBean()方法获取bean，那这个方法是如何获取的bean呢？下面就来分析一下
getBean()方法
public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); }
doGetBean()方法
这里我先说一下这个方法的调用流程
- 转换beanName的名称，因为Bean和FactoryBean不同，获取bean的方法不同，如果要想获取FactoryBean，需要在beanName前面加上&符号
- 从singletonObjects中获取，实例化好的bean都会放到这个容器中
- 如果singletonObjects不存在，就从bean的父bean中寻找
- 如果父bean中也不存，就要执行创建过程了，第一步合并beanDefiniton(因为bean可能继承了很多的父类，把所有的属性合并，以字类的属性优先)
- 判断bean有没有依赖的bean，如果有，先创建依赖的bean
- 判断bean是单例模式还是原型模式，还是以上两者都不是，不同的模式采用不同的创建方法
- 创建完成
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //1. 如果name不是以&开头，直接返回name，如果是以&开头，去掉&，有多少去掉多少，之后返回，并且把name，和去掉&之后的name作为key-value存入一个 //缓存map中 //2. 转换别名，获得bean的真名 final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons.//如果拿到单例bean直接返回 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 + "'"); } } // 为什么要调用 getObjectForBeanInstance 方法,判断当前Bean是不是FactoryBean,如果是,那么要调用getObject方法 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } //如果bean没有创建，从父容器查找beanName对应的bean，如果存在就直接返回 else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. //这里使用了一个threadlocal包裹这个一个对象，用来处理循环依赖，后面看一下这个是怎么解决循环依赖的 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. //这里的parentBeanFactory是在初始化的时候赋值的，但是这个初始化的过程中调用的是无参构造函数，并没有 //赋值，还有一个地方就是setParentBeanFactory，这个也可以赋值，但是没有找到是在哪里调用的 BeanFactory parentBeanFactory = getParentBeanFactory(); //判断当前类的父类是否为空和在之前从xml中加载bean的时候有没有把这个name放入到ioc的那个map中 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { //parentBeanFactory就是父容器，从父容器中获取 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) { //将当前的name放入alreadyCreated这个map中 markBeanAsCreated(beanName); } try { //这一步返回的实际上是MergeBeadDefinition，什么意思呢，就是一个bean可以设置parent属性， //但是这个parent并不是常说的继承来的parent，而是在定义bean的时候可以设置，那下面的方法其实就是 //把父类中的一些属性赋值给字类，如果字类中也存在该属性的值，优先使用字类的，如果字类不存在就是使用父类的 //这里科普个关于BeanDefinition的例子，这个就是AbstractBeanDefinition，这个是所有具体实现的beanDefinition //的抽象父类，然后有几个具体实现的字类RootBeanDefinition，GenericBeanDefinition,ChildBeanDefinition,有这三个 //实现类，其中第一个不能拥有parent //如果父容器中不存在，就合并beanDefinition final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //判断mbd是不是抽象的 checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. //这个可能来自于上面根据beanName得到的那个mbd //检查是否有依赖的bean，如果有，先实例化依赖的bean String[] dependsOn = mbd.getDependsOn(); //当前来看，我的例子这个为null //如果有依赖的bean，解决循环依赖的问题 if (dependsOn != null) { //通过for循环把依赖的map全部是实例化放入到容器中 for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //将依赖的map放入依赖map中 registerDependentBean(dep, beanName); try { //在这里获取依赖的bean，如果这里存在循环依赖就会有问题 getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. if (mbd.isSingleton()) { //有了beanDefinition，创建bean，这个getSingleton其实就是调用了ObjectFactory中的getObject方法 //这里最重要的是才createBean方法 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; } }); //这里是说看一下上面创建的那个shareInstance是是一个什么类型的bean，如果是factoryBean之类的需要调用 //一下getObject()获取真正的bean bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } //创建prototype类型的bean 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); } //创建其他类型的bean else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } 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 ScopeNotActiveException(beanName, scopeName, ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } }
以上方法调用的子方法很多，我分析一下createBean()，剩下的一些子方法大家自己看一下
createBean()方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } //这里的mbd就是合并之后的beanDefinition,这里搞了一个副本，之后的操作都是基于副本的 RootBeanDefinition mbdToUse = mbd; // Make sure bean class is actually resolved at this point, and // clone the bean definition in case of a dynamically resolved Class // which cannot be stored in the shared merged bean definition. //1.解析beanName对应的bean类型，比如com.test.IOCServiceImpl Class<?> resolvedClass = resolveBeanClass(mbd, beanName); // 如果resolvedClass存在，并且mdb的beanClass类型不是Class，并且mdb的beanClass不为空（则代表beanClass存的是Class的name）, if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { // 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性， // 该拷贝副本取代mdb用于后续的操作 mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { // 2.验证及准备覆盖的方法（对override属性进行标记及验证） //这里就是为了解决xml中配置的什么lookup-method，这里做的操作就是对于存在override的bean做一个标记 mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. // 3.实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，达到“短路”效果 //这个就是aop操作的，在切面前编程 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { // 4.如果bean不为空，则会跳过Spring默认的实例化过程， return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { // 5.创建Bean实例（真正创建Bean的方法） Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } }
这个里面有两个比较重要的方法
-
resolveBeforeInstantiation(beanName, mbdToUse);
-
doCreateBean(beanName, mbdToUse, args);
第一个方法和aop有关，下篇文章在分析，下面分析一下第二个方法
这个方法处理流程
- 实例化bean,但是这个bean是没有属性的
- 填充属性
- 解决循环依赖
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { //从这个缓存中移除并获取 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //创建bean，有三种方式 instanceWrapper = createBeanInstance(beanName, mbd, args); } //这里的bean是没有填充属性的，是一个空的bean final Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. // 这里又遇到后置处理了，此处的后置处理是用于处理已“合并的 BeanDefinition” synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. /** * earlySingletonExposure 是一个重要的变量，这里要说明一下。该变量用于表示是否提前暴露 * 单例 bean，用于解决循环依赖。earlySingletonExposure 由三个条件综合而成，如下： * 条件1：mbd.isSingleton() - 表示 bean 是否是单例类型 * 条件2：allowCircularReferences - 是否允许循环依赖 * 条件3：isSingletonCurrentlyInCreation(beanName) - 当前 bean 是否处于创建的状态中 * * earlySingletonExposure = 条件1 && 条件2 && 条件3 * = 单例 && 是否允许循环依赖 && 是否存于创建状态中。 */ boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 添加工厂对象到 singletonFactories 缓存中，在第一步中getSingleton，有从这个缓存singletonFactories获取 //工厂，之后创建bean addSingletonFactory(beanName, // 获取早期 bean 的引用，如果 bean 中的方法被 AOP 切点所匹配到，此时 AOP 相关逻辑会介入 () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 向 bean 实例中填充属性，populateBean 方法也是一个很重要的方法，后面会专门写文章分析 populateBean(beanName, mbd, instanceWrapper); /* * 进行余下的初始化工作，详细如下： * 1. 判断 bean 是否实现了 BeanNameAware、BeanFactoryAware、 * BeanClassLoaderAware 等接口，并执行接口方法 * 2. 应用 bean 初始化前置操作 * 3. 如果 bean 实现了 InitializingBean 接口，则执行 afterPropertiesSet * 方法。如果用户配置了 init-method，则调用相关方法执行自定义初始化逻辑 * 4. 应用 bean 初始化后置操作 * * 另外，AOP 相关逻辑也会在该方法中织入切面逻辑，此时的 exposedObject 就变成了 * 一个代理对象了 */ exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } //处理循环依赖 if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { //注册bean registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
进入createBeanInstance()方法
/** 在上面分注释中，factory method, constructor autowiring, or simple instantiation，这个写的很清楚 * 就是可以采用三种方式实例化一个bean * 创建 bean 实例，并将实例包裹在 BeanWrapper 实现类对象中返回。createBeanInstance * 中包含三种创建 bean 实例的方式： * 1. 通过工厂方法创建 bean 实例 * 2. 通过构造方法自动注入（autowire by constructor）的方式创建 bean 实例 * 3. 通过无参构造方法方法创建 bean 实例 * * 若 bean 的配置信息中配置了 lookup-method 和 replace-method，则会使用 CGLIB * 增强 bean 实例。关于这个方法，后面会专门写一篇文章介绍，这里先说这么多。 */ protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // Make sure bean class is actually resolved at this point. Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } /* * 当多次构建同一个 bean 时，可以使用此处的快捷路径，即无需再次推断应该使用哪种方式构造实例， * 以提高效率。比如在多次构建同一个 prototype 类型的 bean 时，就可以走此处的捷径。 * 这里的 resolved 和 mbd.constructorArgumentsResolved 将会在 bean 第一次实例 * 化的过程中被设置，在后面的源码中会分析到，先继续往下看。 */ //RootBeanDefinition，在这个玩意中有一个构造方法给这个玩意赋值，之后就可以使用这个函数式接口实例化 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } //这里使用的是工厂方法创建 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // Shortcut when re-creating the same bean... boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } //这里使用的是自动注入构造方法创建bean if (resolved) { // 通过“构造方法自动注入”的方式构造 bean 对象 if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { // 通过“默认构造方法”的方式构造 bean 对象 return instantiateBean(beanName, mbd); } } // Candidate constructors for autowiring? Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { //bean初始化 return autowireConstructor(beanName, mbd, ctors, args); } // Preferred constructors for default construction? ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); } // No special handling: simply use no-arg constructor. //使用无参构造函数初始化bean return instantiateBean(beanName, mbd); }
总结
总的来说创建bean的过程代码写的很清晰，逻辑的过程页很容易明白，这里其实有两个问题没有解决，一个就是在创建单例模式的bean的时候，循环依赖是如何解决的，第二个问题就是aop在这个里面是如何织入的，之后会写文章分析上面的两个问题
参考文章