美文网首页java mybatisJava
源码分析:Spring是如何获取容器中的Bean?

源码分析:Spring是如何获取容器中的Bean?

作者: 废柴程序员 | 来源:发表于2021-11-29 17:08 被阅读0次

    之前分析了Bean是如何注册到容器中的,既然我们把Bean交给Spring来管理,在我们需要对象的时候Spring会自动帮我们注入,那Spring肯定会有一个从容器中获取Bean的过程,只不过这个过程是Spring框架来帮我们完成的,对于我们使用者来说没有感知

    下面我们就通过源码来看一下Spring是如何从容器中获取Bean的

    image

    简单的例子

    首先还是从一个简单的例子来入手,XML配置方式我们一般这样获取Bean

    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
    User user = (User) applicationContext.getBean("userBean");
    System.out.println(user.getUserName());
    

    从上面的例子我们看到,Bean主要是applicationContext.getBean()方法来获取的,我们就从ClassPathXmlApplicationContext的getBean方法来入手

    public Object getBean(String name) throws BeansException {
            assertBeanFactoryActive();
            return getBeanFactory().getBean(name);
        }
    

    AbstractBeanFactory

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

    AbstractBeanFactory

    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    
            final String beanName = transformedBeanName(name);
            Object 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 + "'");
                    }
                }
                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 {
                    //这里通过beanName获取相关信息来组装RootBeanDefinition
                    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    checkMergedBeanDefinition(mbd, beanName, args);
    
                    // 当前Bean的依赖项
                    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);
                            }
                        }
                    }
    
                    // 此处开始创建实例对象
                    //单例的对象创建
                    if (mbd.isSingleton()) {
                        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;
        }
    

    doGetBean()方法基本上概括了整个Bean的获取过程

    • 首先通过BeanName从容器中获取Bean相关的信息,并组装成RootBeanDefinition
    • 通过RootBeanDefinition来创建实例对象,这里需要根据单例、多例来分别进行创建
    • 将创建或者获取到的对象返回

    组装RootBeanDefinition

    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
            // 先看看mergedBeanDefinitions中是否存在,实际上相当于缓存的作用
            RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
            if (mbd != null) {
                return mbd;
            }
            //请注意此处的第二个参数,传入的是一个BeanDefinition
            return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
        }
    

    getBeanDefinition(beanName)方法返回的是一个BeanDefinition对象,我们来看一下

    public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
            //这里通过beanName从beanDefinitionMap中获取BeanDefination
            BeanDefinition bd = this.beanDefinitionMap.get(beanName);
            if (bd == null) {
                if (logger.isTraceEnabled()) {
                    logger.trace("No bean named '" + beanName + "' found in " + this);
                }
                throw new NoSuchBeanDefinitionException(beanName);
            }
            return bd;
        }
    

    getBeanDefinition()方法的作用就是从beanDefinitionMap中获取BeanDefinition,这里有没有很熟悉的感觉?Bean在注册到容器中的时候,就是存入到beanDefinitionMap中,这里来进行获取,两边相当于对上了。

    我们继续来看一下getMergedBeanDefinition()方法

    protected RootBeanDefinition getMergedBeanDefinition(
                String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
                throws BeanDefinitionStoreException {
    
            synchronized (this.mergedBeanDefinitions) {
                RootBeanDefinition mbd = null;
    
                // Check with full lock now in order to enforce the same merged instance.
                if (containingBd == null) {
                    //从缓存中获取RootBeanDefinition
                    mbd = this.mergedBeanDefinitions.get(beanName);
                }
    
                if (mbd == null) {
                    if (bd.getParentName() == null) {
                        // Use copy of given root bean definition.
                        if (bd instanceof RootBeanDefinition) {
                            mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                        }
                        else {
                           //这里通过BeanDefinition来创建一个RootBeanDefinition
                            mbd = new RootBeanDefinition(bd);
                        }
                    }
                    else {
                        // Child bean definition: needs to be merged with parent.
                        BeanDefinition pbd;
                        try {
                            String parentBeanName = transformedBeanName(bd.getParentName());
                            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 an AbstractBeanFactory parent");
                                }
                            }
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                    "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                        }
                        // Deep copy with overridden values.
                        mbd = new RootBeanDefinition(pbd);
                        mbd.overrideFrom(bd);
                    }
    
                    // 设置默认为单例
                    if (!StringUtils.hasLength(mbd.getScope())) {
                        mbd.setScope(RootBeanDefinition.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());
                    }
    
                    //将构建好的RootBeanDefinition进行缓存
                    if (containingBd == null && isCacheBeanMetadata()) {
                        this.mergedBeanDefinitions.put(beanName, mbd);
                    }
                }
    
                return mbd;
            }
        }
    

    创建对象实例

    上面构造好了RootBeanDefinition,下面来创建对象

    //单例对象的创建
    if (mbd.isSingleton()) {
                        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);
                    }
    
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
                throws BeanCreationException {
    
            if (logger.isTraceEnabled()) {
                logger.trace("Creating instance of bean '" + beanName + "'");
            }
            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.
            Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }
    
            // Prepare method overrides.
            try {
                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.
                Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
                if (bean != null) {
                    return bean;
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                        "BeanPostProcessor before instantiation of bean failed", ex);
            }
    
            try {
                //根据beanName创建对象
                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);
            }
        }
    
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
                throws BeanCreationException {
    
            // 初始化Bean
            BeanWrapper instanceWrapper = null;
            if (mbd.isSingleton()) {
                instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
            }
            if (instanceWrapper == null) {
                //创建Bean实例
                instanceWrapper = createBeanInstance(beanName, mbd, args);
            }
            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.
            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.
            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");
                }
                addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
            }
    
            // Initialize the bean instance.
            Object exposedObject = bean;
            try {
                populateBean(beanName, mbd, instanceWrapper);
                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 " +
                                    "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                        }
                    }
                }
            }
    
            // Register bean as disposable.
            try {
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
            }
    
            return exposedObject;
        }
    
    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());
            }
    
            Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
            if (instanceSupplier != null) {
                return obtainFromSupplier(instanceSupplier, beanName);
            }
    
            if (mbd.getFactoryMethodName() != null) {
                //使用FactotyMethod实例化Bean
                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;
                    }
                }
            }
            if (resolved) {
                if (autowireNecessary) {
                    return autowireConstructor(beanName, mbd, null, null);
                }
                else {
                    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)) {
                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.
            return instantiateBean(beanName, mbd);
        }
    

    上面可以看到,通过不同的方法进行Bean的实例化,有FactoryMethod、autowireConstructor、还有无参构造器,这里看一下通过FactoryMethod的实例化

    protected BeanWrapper instantiateUsingFactoryMethod(
                String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    
            return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
        }
    
    public BeanWrapper instantiateUsingFactoryMethod(
                String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    
            BeanWrapperImpl bw = new BeanWrapperImpl();
            this.beanFactory.initBeanWrapper(bw);
    
            Object factoryBean;
            Class<?> factoryClass;
            boolean isStatic;
            //获取FactoryBeanName
            String factoryBeanName = mbd.getFactoryBeanName();
            if (factoryBeanName != null) {
                if (factoryBeanName.equals(beanName)) {
                    throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                            "factory-bean reference points back to the same bean definition");
                }
                //从容器中获取factoryBean
                factoryBean = this.beanFactory.getBean(factoryBeanName);
                if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                    throw new ImplicitlyAppearedSingletonException();
                }
                //实例化factoryClass
                factoryClass = factoryBean.getClass();
                isStatic = false;
            }
            else {
                // It's a static factory method on the bean class.
                if (!mbd.hasBeanClass()) {
                    throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                            "bean definition declares neither a bean class nor a factory-bean reference");
                }
                factoryBean = null;
                factoryClass = mbd.getBeanClass();
                isStatic = true;
            }
    
            Method factoryMethodToUse = null;
            ArgumentsHolder argsHolderToUse = null;
            Object[] argsToUse = null;
    
            if (explicitArgs != null) {
                argsToUse = explicitArgs;
            }
            else {
                Object[] argsToResolve = null;
                synchronized (mbd.constructorArgumentLock) {
                    factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
                    if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                        // Found a cached factory method...
                        argsToUse = mbd.resolvedConstructorArguments;
                        if (argsToUse == null) {
                            argsToResolve = mbd.preparedConstructorArguments;
                        }
                    }
                }
                if (argsToResolve != null) {
                    argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
                }
            }
    
            if (factoryMethodToUse == null || argsToUse == null) {
                // Need to determine the factory method...
                // Try all methods with this name to see if they match the given arguments.
                factoryClass = ClassUtils.getUserClass(factoryClass);
    
                Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
                List<Method> candidateList = new ArrayList<>();
                //过滤出工厂方法
                for (Method candidate : rawCandidates) {
                    if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                        candidateList.add(candidate);
                    }
                }
    
                if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                    Method uniqueCandidate = candidateList.get(0);
                    if (uniqueCandidate.getParameterCount() == 0) {
                        mbd.factoryMethodToIntrospect = uniqueCandidate;
                        synchronized (mbd.constructorArgumentLock) {
                            mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                            mbd.constructorArgumentsResolved = true;
                            mbd.resolvedConstructorArguments = EMPTY_ARGS;
                        }
                        //使用工厂方法创建实例对象
                        bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
                        return bw;
                    }
                }
    
                Method[] candidates = candidateList.toArray(new Method[0]);
                AutowireUtils.sortFactoryMethods(candidates);
    
                ConstructorArgumentValues resolvedValues = null;
                boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
                int minTypeDiffWeight = Integer.MAX_VALUE;
                Set<Method> ambiguousFactoryMethods = null;
    
                int minNrOfArgs;
                if (explicitArgs != null) {
                    minNrOfArgs = explicitArgs.length;
                }
                else {
                    // We don't have arguments passed in programmatically, so we need to resolve the
                    // arguments specified in the constructor arguments held in the bean definition.
                    if (mbd.hasConstructorArgumentValues()) {
                        ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                        resolvedValues = new ConstructorArgumentValues();
                        minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
                    }
                    else {
                        minNrOfArgs = 0;
                    }
                }
    
                /************因代码太长,略过很多代码*******************************
    
        }
    
    
    private Object instantiate(String beanName, RootBeanDefinition mbd,
                @Nullable Object factoryBean, Method factoryMethod, Object[] args) {
    
            try {
                if (System.getSecurityManager() != null) {
                    return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
                            this.beanFactory.getInstantiationStrategy().instantiate(
                                    mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
                            this.beanFactory.getAccessControlContext());
                }
                else {
                    //创建实例对象
                    return this.beanFactory.getInstantiationStrategy().instantiate(
                            mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Bean instantiation via factory method failed", ex);
            }
        }
    
    
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
                @Nullable Object factoryBean, final Method factoryMethod, Object... args) {
    
            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        ReflectionUtils.makeAccessible(factoryMethod);
                        return null;
                    });
                }
                else {
                    ReflectionUtils.makeAccessible(factoryMethod);
                }
    
                Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
                try {
                    currentlyInvokedFactoryMethod.set(factoryMethod);
                    //这里使用反射调用工厂方法,生成对象并返回
                    Object result = factoryMethod.invoke(factoryBean, args);
                    if (result == null) {
                        result = new NullBean();
                    }
                    return result;
                }
                finally {
                    if (priorInvokedFactoryMethod != null) {
                        currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                    }
                    else {
                        currentlyInvokedFactoryMethod.remove();
                    }
                }
            }
            catch (IllegalArgumentException ex) {
                throw new BeanInstantiationException(factoryMethod,
                        "Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
                        "args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
            }
            catch (IllegalAccessException ex) {
                throw new BeanInstantiationException(factoryMethod,
                        "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
            }
            catch (InvocationTargetException ex) {
                String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
                if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
                        ((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
                    msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
                            "declaring the factory method as static for independence from its containing instance. " + msg;
                }
                throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
            }
        }
    
    

    使用反射调用工厂方法,生成对象并返回,返回对象就表示从容器中根据注册的Bean信息拿到了具体的对象,到此整个调用链路都完成了。

    我原本以为是在调用getBean()时才去进行Bean的实例化,但是在断点跟踪的过程中,发现单例对象实际上是在容器启动的时候就会去实例化,getBean()的时候直接拿,不用再实例化。代码如下:

    public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // Prepare this context for refreshing.
                prepareRefresh();
    
                // Tell the subclass to refresh the internal bean factory.
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // Prepare the bean factory for use in this context.
                prepareBeanFactory(beanFactory);
    
                try {
                    // Allows post-processing of the bean factory in context subclasses.
                    postProcessBeanFactory(beanFactory);
    
                    // Invoke factory processors registered as beans in the context.
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    // Register bean processors that intercept bean creation.
                    registerBeanPostProcessors(beanFactory);
    
                    // Initialize message source for this context.
                    initMessageSource();
    
                    // Initialize event multicaster for this context.
                    initApplicationEventMulticaster();
    
                    // Initialize other special beans in specific context subclasses.
                    onRefresh();
    
                    // Check for listener beans and register them.
                    registerListeners();
    
                    // Instantiate all remaining (non-lazy-init) singletons.
                    finishBeanFactoryInitialization(beanFactory);
    
                    // Last step: publish corresponding event.
                    finishRefresh();
                }
    
                catch (BeansException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("Exception encountered during context initialization - " +
                                "cancelling refresh attempt: " + ex);
                    }
    
                    // Destroy already created singletons to avoid dangling resources.
                    destroyBeans();
    
                    // Reset 'active' flag.
                    cancelRefresh(ex);
    
                    // Propagate exception to caller.
                    throw ex;
                }
    
                finally {
                    // Reset common introspection caches in Spring's core, since we
                    // might not ever need metadata for singleton beans anymore...
                    resetCommonCaches();
                }
            }
        }
    

    在refresh()方法中有专门进行单例初始化的方法,就是finishBeanFactoryInitialization(beanFactory),从注释可以看出来就是用来做单例的实例化的

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
            // Initialize conversion service for this context.
            if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
                beanFactory.setConversionService(
                        beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
            }
    
            // Register a default embedded value resolver if no bean post-processor
            // (such as a PropertyPlaceholderConfigurer bean) registered any before:
            // at this point, primarily for resolution in annotation attribute values.
            if (!beanFactory.hasEmbeddedValueResolver()) {
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
            }
    
            // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
            String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
            for (String weaverAwareName : weaverAwareNames) {
                getBean(weaverAwareName);
            }
    
            // Stop using the temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(null);
    
            // Allow for caching all bean definition metadata, not expecting further changes.
            beanFactory.freezeConfiguration();
    
            // 实例化单例对象
            beanFactory.preInstantiateSingletons();
        }
    
    
    public void preInstantiateSingletons() throws BeansException {
            if (logger.isTraceEnabled()) {
                logger.trace("Pre-instantiating singletons in " + this);
            }
    
            // Iterate over a copy to allow for init methods which in turn register new bean definitions.
            // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
            List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
            // Trigger initialization of all non-lazy singleton beans...
            for (String beanName : beanNames) {
                RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    if (isFactoryBean(beanName)) {
                        Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                        if (bean instanceof FactoryBean) {
                            final 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) {
                                getBean(beanName);
                            }
                        }
                    }
                    else {
                        //从这里可以看出来,单例的实例化是通过调用getBean方法来实现的
                        getBean(beanName);
                    }
                }
            }
    
            // Trigger post-initialization callback for all applicable beans...
            for (String beanName : beanNames) {
                Object singletonInstance = getSingleton(beanName);
                if (singletonInstance instanceof SmartInitializingSingleton) {
                    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                    if (System.getSecurityManager() != null) {
                        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }, getAccessControlContext());
                    }
                    else {
                        smartSingleton.afterSingletonsInstantiated();
                    }
                }
            }
        }
    
    

    从上面的代码可以看出来,容器在启动的时候就会实例化单例对象,并且还是调用的getBean()方法做的实例化,当你从容器中获取Bean的时候,就直接取现成的对象了

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
            //从singletonObjects中获取已经实例化好的对象
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
                synchronized (this.singletonObjects) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null && allowEarlyReference) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
            return singletonObject;
        }
    
    

    以上就是从容器中获取单例Bean的过程,多例也是差不多的过程,就不再赘述,有兴趣可以自己研究一下

    总结一下

    Spring从容器中获取Bean的过程如下:

    首先通过BeanName从容器中获取Bean相关的信息,并组装成RootBeanDefinition

    通过RootBeanDefinition来创建实例对象,这里需要根据单例、多例来分别进行创建

    单例对象是容器启动的时候就已经实例化好了,可以直接拿来用,当然你也可以设置延迟加载

    作者:果子爸聊技术
    原文链接:https://blog.csdn.net/pzjtian/article/details/109171548

    相关文章

      网友评论

        本文标题:源码分析:Spring是如何获取容器中的Bean?

        本文链接:https://www.haomeiwen.com/subject/teelxrtx.html