【死磕 Spring】—– IOC 之 Factory 实例化 bean

   protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {        // 解析 bean，将 bean 类名解析为 class 引用        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 回调，则使用给定的回调方法初始化策略        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();        if (instanceSupplier != null) {            return obtainFromSupplier(instanceSupplier, beanName);        }        // 如果工厂方法不为空，则使用工厂方法初始化策略        if (mbd.getFactoryMethodName() != null)  {            return instantiateUsingFactoryMethod(beanName, mbd, args);        }        boolean resolved = false;        boolean autowireNecessary = false;        if (args == null) {            // constructorArgumentLock 构造函数的常用锁            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);            }        }        // 确定解析的构造函数        // 主要是检查已经注册的 SmartInstantiationAwareBeanPostProcessor        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);        if (ctors != null ||                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {            // 构造函数自动注入            return autowireConstructor(beanName, mbd, ctors, args);        }        //使用默认构造函数注入        return instantiateBean(beanName, mbd);    }

Supplier<?> instanceSupplier = mbd.getInstanceSupplier();if (instanceSupplier != null) {    return obtainFromSupplier(instanceSupplier, beanName);}

public interface Supplier<T> {    T get();}

    public void setInstanceSupplier(@Nullable Supplier<?> instanceSupplier) {        this.instanceSupplier = instanceSupplier;    }

    public <T> RootBeanDefinition(@Nullable Class<T> beanClass, String scope, @Nullable Supplier<T> instanceSupplier) {        super();        setBeanClass(beanClass);        setScope(scope);        setInstanceSupplier(instanceSupplier);    }

    protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {        String outerBean = this.currentlyCreatedBean.get();        this.currentlyCreatedBean.set(beanName);        Object instance;        try {          // 调用 Supplier 的 get()，返回一个对象            instance = instanceSupplier.get();        }        finally {            if (outerBean != null) {                this.currentlyCreatedBean.set(outerBean);            }            else {                this.currentlyCreatedBean.remove();            }        }        // 根据对象构造 BeanWrapper 对象        BeanWrapper bw = new BeanWrapperImpl(instance);        // 初始化 BeanWrapper        initBeanWrapper(bw);        return bw;    }

    protected BeanWrapper instantiateUsingFactoryMethod(            String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);    }

/*
* 提示：该行代码过长，系统自动注释不进行高亮。一键复制会移除系统注释 
* public BeanWrapper instantiateUsingFactoryMethod(            final String beanName, final RootBeanDefinition mbd, @Nullable final Object[] explicitArgs) {        // 构造 BeanWrapperImpl 对象        BeanWrapperImpl bw = new BeanWrapperImpl();        // 初始化 BeanWrapperImpl        // 向BeanWrapper对象中添加 ConversionService 对象和属性编辑器 PropertyEditor 对象        //        this.beanFactory.initBeanWrapper(bw);        Object factoryBean;        Class<?> factoryClass;        boolean isStatic;        // 工厂名不为空        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 = this.beanFactory.getBean(factoryBeanName);            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {                throw new ImplicitlyAppearedSingletonException();            }            factoryClass = factoryBean.getClass();            isStatic = false;        }        else {            // 工厂名为空，则其可能是一个静态工厂            // 静态工厂创建bean，必须要提供工厂的全类名            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;        ConstructorResolver.ArgumentsHolder argsHolderToUse = null;        // 参数        Object[] argsToUse = null;        // 工厂方法的参数        // 如果指定了构造参数则直接使用        // 在调用 getBean 方法的时候指定了方法参数        if (explicitArgs != null) {            argsToUse = explicitArgs;        }        else {            // 没有指定，则尝试从配置文件中解析            Object[] argsToResolve = null;            // 首先尝试从缓存中获取            synchronized (mbd.constructorArgumentLock) {                // 获取缓存中的构造函数或者工厂方法                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {                    // 获取缓存中的构造参数                    argsToUse = mbd.resolvedConstructorArguments;                    if (argsToUse == null) {                        // 获取缓存中的构造函数参数的包可见字段                        argsToResolve = mbd.preparedConstructorArguments;                    }                }            }            // 缓存中存在,则解析存储在 BeanDefinition 中的参数            // 如给定方法的构造函数 A(int ,int )，则通过此方法后就会把配置文件中的("1","1")转换为 (1,1)            // 缓存中的值可能是原始值也有可能是最终值            if (argsToResolve != null) {                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);            }        }        //        if (factoryMethodToUse == null || argsToUse == null) {            // 获取工厂方法的类全名称            factoryClass = ClassUtils.getUserClass(factoryClass);            // 获取所有待定方法            Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);            // 检索所有方法，这里是对方法进行过滤            List<Method> candidateSet = new ArrayList<>();            for (Method candidate : rawCandidates) {                // 如果有static 且为工厂方法，则添加到 candidateSet 中                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {                    candidateSet.add(candidate);                }            }            Method[] candidates = candidateSet.toArray(new Method[0]);            // 排序构造函数            // public 构造函数优先参数数量降序，非public 构造函数参数数量降序            AutowireUtils.sortFactoryMethods(candidates);            // 用于承载解析后的构造函数参数的值            ConstructorArgumentValues resolvedValues = null;            boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);            int minTypeDiffWeight = Integer.MAX_VALUE;            Set<Method> ambiguousFactoryMethods = null;            int minNrOfArgs;            if (explicitArgs != null) {                minNrOfArgs = explicitArgs.length;            }            else {                // getBean() 没有传递参数，则需要解析保存在 BeanDefinition 构造函数中指定的参数                if (mbd.hasConstructorArgumentValues()) {                    // 构造函数的参数                    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();                    resolvedValues = new ConstructorArgumentValues();                    // 解析构造函数的参数                    // 将该 bean 的构造函数参数解析为 resolvedValues 对象，其中会涉及到其他 bean                    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);                }                else {                    minNrOfArgs = 0;                }            }            LinkedList<UnsatisfiedDependencyException> causes = null;            for (Method candidate : candidates) {                // 方法体的参数                Class<?>[] paramTypes = candidate.getParameterTypes();                if (paramTypes.length >= minNrOfArgs) {                    // 保存参数的对象                    ArgumentsHolder argsHolder;                    // getBean()传递了参数                    if (explicitArgs != null){                        // 显示给定参数，参数长度必须完全匹配                        if (paramTypes.length != explicitArgs.length) {                            continue;                        }                        // 根据参数创建参数持有者                        argsHolder = new ArgumentsHolder(explicitArgs);                    }                    else {                        // 为提供参数，解析构造参数                        try {                            String[] paramNames = null;                            // 获取 ParameterNameDiscoverer 对象                            // ParameterNameDiscoverer 是用于解析方法和构造函数的参数名称的接口，为参数名称探测器                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();                            if (pnd != null) {                                // 获取指定构造函数的参数名称                                paramNames = pnd.getParameterNames(candidate);                            }                            // 在已经解析的构造函数参数值的情况下，创建一个参数持有者对象                            argsHolder = createArgumentArray(                                    beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);                        }                        catch (UnsatisfiedDependencyException ex) {                            if (this.beanFactory.logger.isTraceEnabled()) {                                this.beanFactory.logger.trace("Ignoring factory method [" + candidate +                                        "] of bean '" + beanName + "': " + ex);                            }                            if (causes == null) {                                causes = new LinkedList<>();                            }                            causes.add(ex);                            continue;                        }                    }                    // isLenientConstructorResolution 判断解析构造函数的时候是否以宽松模式还是严格模式                    // 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常                    // 宽松模式：使用具有"最接近的模式"进行匹配                    // typeDiffWeight：类型差异权重                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));                    // 代表最接近的类型匹配，则选择作为构造函数                    if (typeDiffWeight < minTypeDiffWeight) {                        factoryMethodToUse = candidate;                        argsHolderToUse = argsHolder;                        argsToUse = argsHolder.arguments;                        minTypeDiffWeight = typeDiffWeight;                        ambiguousFactoryMethods = null;                    }                    // 如果具有相同参数数量的方法具有相同的类型差异权重，则收集此类型选项                    // 但是，仅在非宽松构造函数解析模式下执行该检查，并显式忽略重写方法（具有相同的参数签名）                    else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&                            !mbd.isLenientConstructorResolution() &&                            paramTypes.length == factoryMethodToUse.getParameterCount() &&                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {                        // 查找到多个可匹配的方法                        if (ambiguousFactoryMethods == null) {                            ambiguousFactoryMethods = new LinkedHashSet<>();                            ambiguousFactoryMethods.add(factoryMethodToUse);                        }                        ambiguousFactoryMethods.add(candidate);                    }                }            }            // 没有可执行的工厂方法，抛出异常            if (factoryMethodToUse == null) {                if (causes != null) {                    UnsatisfiedDependencyException ex = causes.removeLast();                    for (Exception cause : causes) {                        this.beanFactory.onSuppressedException(cause);                    }                    throw ex;                }                List<String> argTypes = new ArrayList<>(minNrOfArgs);                if (explicitArgs != null) {                    for (Object arg : explicitArgs) {                        argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");                    }                }                else if (resolvedValues != null){                    Set<ConstructorArgumentValues.ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());                    valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());                    valueHolders.addAll(resolvedValues.getGenericArgumentValues());                    for (ConstructorArgumentValues.ValueHolder value : valueHolders) {                        String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :                                (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));                        argTypes.add(argType);                    }                }                String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);                throw new BeanCreationException(mbd.getResourceDescription(), beanName,                        "No matching factory method found: " +                                (mbd.getFactoryBeanName() != null ?                                        "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +                                "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +                                "Check that a method with the specified name " +                                (minNrOfArgs > 0 ? "and arguments " : "") +                                "exists and that it is " +                                (isStatic ? "static" : "non-static") + ".");            }            else if (void.class == factoryMethodToUse.getReturnType()) {                throw new BeanCreationException(mbd.getResourceDescription(), beanName,                        "Invalid factory method '" + mbd.getFactoryMethodName() +                                "': needs to have a non-void return type!");            }            else if (ambiguousFactoryMethods != null) {                throw new BeanCreationException(mbd.getResourceDescription(), beanName,                        "Ambiguous factory method matches found in bean '" + beanName + "' " +                                "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +                                ambiguousFactoryMethods);            }            if (explicitArgs == null && argsHolderToUse != null) {                // 将解析的构造函数加入缓存                argsHolderToUse.storeCache(mbd, factoryMethodToUse);            }        }        try {            // 实例化 bean            Object beanInstance;            if (System.getSecurityManager() != null) {                final Object fb = factoryBean;                final Method factoryMethod = factoryMethodToUse;                final Object[] args = argsToUse;                // 通过执行工厂方法来创建bean示例                beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->                                beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),                        beanFactory.getAccessControlContext());            }            else {                // 通过执行工厂方法来创建bean示例                beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(                        mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);            }            // 包装为 BeanWraper 对象            bw.setBeanInstance(beanInstance);            return bw;        }        catch (Throwable ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                    "Bean instantiation via factory method failed", ex);        }    }
*/

        public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {            synchronized (mbd.constructorArgumentLock) {                mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;                mbd.constructorArgumentsResolved = true;                if (this.resolveNecessary) {                    mbd.preparedConstructorArguments = this.preparedArguments;                }                else {                    mbd.resolvedConstructorArguments = this.arguments;                }            }        }

            synchronized (mbd.constructorArgumentLock) {                // 获取缓存中的构造函数或者工厂方法                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {                    // 获取缓存中的构造参数                    argsToUse = mbd.resolvedConstructorArguments;                    if (argsToUse == null) {                        // 获取缓存中的构造函数参数的包可见字段                        argsToResolve = mbd.preparedConstructorArguments;                    }                }            }

if (mbd.hasConstructorArgumentValues()) {    // 构造函数的参数    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();    resolvedValues = new ConstructorArgumentValues();    // 解析构造函数的参数    // 将该 bean 的构造函数参数解析为 resolvedValues 对象，其中会涉及到其他 bean    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,            @Nullable Object factoryBean, final Method factoryMethod, @Nullable 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    }

Object result = factoryMethod.invoke(factoryBean, args);