Spring IOC(七)类型推断

Spring IOC(七)类型推断

Spring 系列目录(https://www.cnblogs.com/binarylei/p/10198698.html)

Spring 容器中可以根据 beanName 查找其类型,其推断方式和 bean 的创建方式密切相关,并且 Spring 中有一个原则是尽可能的不要通过创建 bean 来获取其类型,除了 FactoryBean 只有通过创建对象调用其 getObjectType 方法,但也只是部分的创建该 FactoryBean(所谓的部分创建是指只实例化对象,而不进行属性注入和初始化过程):

  1. 对于缓存中存在单例的 bean,则直接根据对象获取其类型。
  2. 对于 FactoryBean 创建的 bean,Spring 会部分实例化,调用 FactoryBean#getObjectType() 方法。
  3. 对于工厂方法,Spring 不会实例化这个对象,而是用该方法的返回值类型来进行推断。如果该方法定义了泛型且返回值的类型恰好和泛型有关,则要通过传递的参数来进一步推断,但在 @Spring 5.1.3 似乎有 BUG。
  4. 工厂方法也有可能返回一个 FactoryBean 类型,静态工厂和实例工厂方法处理方法有些不一样。都有两种方式推断类型:一是根据方法的返回值类型进行推断;二是实例化这个 FactoryBean 后调用 getObjectType 方法。对于实例工厂,如果这个工厂还没有实例话就只执行第一种推断方式。

一、Spring 类型推断测试

(1) 环境准备

public class User {
}

// 如果 FactoryBean 没有指定 User 类型则要部分实例化对象
public class UserFactoryBean implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User();
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

public class UserFactory {
    // 1. 实例工厂
    public User getObject1() {
        return new User();
    }

    // 2. 静态工厂
    public static User getObject2() {
        return new User();
    }

    // 3.1 带参的工厂方法
    public User getObject3(String username, String password) {
        return new User();
    }

    // 3.2 带泛型的工厂方法,但返回值类型和泛型无关
    public <T, K, V> User getObject4(T t, String username) {
        return new User();
    }

    // 3.3 带泛型的工厂方法,但返回值类型由参数决定
    public <T, K, V> T getObject5(T t) {
        return t;
    }

    // 4.1 静态工厂方法返回类型为 FactoryBean
    public static FactoryBean<User> getObject6() {
        return new UserFactoryBean();
    }

    // 4.2 实例工厂方法返回类型为 FactoryBean
    public FactoryBean<User> getObject7() {
        return new UserFactoryBean();
    }
}

(2) xcml 配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1. 直接定义 className-->
    <bean id="bean1" class="com.github.binarylei.spring.beans.factory.test.BeanFactoryTypeInferenceTest.User"/>

    <!--2. FactoryBean-->
    <bean id="bean2" class="com.github.binarylei.spring.beans.factory.test.BeanFactoryTypeInferenceTest.UserFactoryBean"/>

    <!--3. 实例工厂-->
    <bean id="userFactory" class="com.github.binarylei.spring.beans.factory.test.BeanFactoryTypeInferenceTest.UserFactory"/>
    <bean id="bean3" factory-bean="userFactory" factory-method="getObject1"/>

    <!--4. 静态工厂-->
    <bean id="bean4" class="com.github.binarylei.spring.beans.factory.test.BeanFactoryTypeInferenceTest.UserFactory" factory-method="getObject2"/>

    <!--5. 带参的工厂方法,和构造器注入类似-->
    <!--5.1 工厂方法没有定义泛型-->
    <bean id="bean5.1" factory-bean="userFactory" factory-method="getObject3">
        <constructor-arg index="0" value="0"/>
        <constructor-arg index="1" value="1"/>
    </bean>

    <!--5.2 工厂方法定义泛型,但返回值类型与泛型无关-->
    <bean id="bean5.2" factory-bean="userFactory" factory-method="getObject4">
        <constructor-arg index="0" value="0"/>
        <constructor-arg index="1" value="1"/>
    </bean>

    <!--5.3 工厂方法定义泛型,返回值类型与参数类型决定-->
    <bean id="bean5.3" factory-bean="userFactory" factory-method="getObject5">
        <constructor-arg index="0" value="0"/>
    </bean>

    <!--6 静态工厂方法的返回值为一个 FactoryBean 类型-->
    <bean id="bean6.1" class="com.github.binarylei.spring.beans.factory.test.BeanFactoryTypeInferenceTest.UserFactory" factory-method="getObject6"/>

    <!--7 实例工厂方法的返回值为一个 FactoryBean 类型-->
    <bean id="bean6.2" factory-bean="userFactory" factory-method="getObject7"/>
</beans>

(3) 测试一把

@Test
public void test() {
    DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(lbf);
    reader.loadBeanDefinitions(new ClassPathResource("spring-context-factory.xml"));

     // 1. 直接定义 className
    Assert.assertTrue(lbf.isTypeMatch("bean1", User.class));
    // 2. FactoryBean
    Assert.assertTrue(lbf.isTypeMatch("bean2", User.class));
    // 3. 实例工厂
    Assert.assertTrue(lbf.isTypeMatch("bean3", User.class));
    // 4. 静态工厂
    Assert.assertTrue(lbf.isTypeMatch("bean4", User.class));
    // 5.1 工厂方法没有定义泛型
    Assert.assertTrue(lbf.isTypeMatch("bean5.1", User.class));
    // 5.2 工厂方法定义泛型,但返回值类型与泛型无关
    Assert.assertTrue(lbf.isTypeMatch("bean5.2", User.class));
    // 5.3 工厂方法定义泛型,返回值类型与参数类型决定,无法获取 @Spring 5.1.3
    Assert.assertFalse(lbf.isTypeMatch("bean5.3", User.class));
    // 6.1 静态工厂方法返回类型为 FactoryBean
    Assert.assertTrue(lbf.isTypeMatch("bean6.1", User.class));

    // 6.2 实例工厂方法返回类型为 FactoryBean,如果实例化这个工厂后可以获取其类型
    Assert.assertFalse(lbf.isTypeMatch("bean6.2", User.class));
    lbf.getBean("userFactory");
    Assert.assertTrue(lbf.isTypeMatch("bean6.2", User.class));
}

可以看到工厂方法带有泛型且返回值类型和泛型有关后 Spring 不能正确处理了,另外实例工厂的工厂方法返回 FactoryBean 也不能正确处理。

二、Spring 类型推断源码分析

2.1 类型匹配的入口 - isTypeMatch

@Override
public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
    return isTypeMatch(name, ResolvableType.forRawClass(typeToMatch));
}

@Override
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
    String beanName = transformedBeanName(name);

    // 1. 根据实例化后的对象获取 bean 的类型,注意 FactoryBean 的处理即可
    Object beanInstance = getSingleton(beanName, false);
    if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
        // 1.1 如果是 FactoryBean 类型,此时需要判断是否要查找的就是这个工厂对象,判断 beanName 是否是以 & 开头
        //     如果是其创建的类型,则需要调用 getTypeForFactoryBean 从这个 FactoryBean 实例中获取真实类型
        if (beanInstance instanceof FactoryBean) {
            if (!BeanFactoryUtils.isFactoryDereference(name)) {
                Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
                return (type != null && typeToMatch.isAssignableFrom(type));
            } else {
                return typeToMatch.isInstance(beanInstance);
            }
        // 1.2 如果是普通 bean 则可直接判断类型,当然 Spring 还考虑的泛型的情况
        } else if (!BeanFactoryUtils.isFactoryDereference(name)) {
            if (typeToMatch.isInstance(beanInstance)) {
                return true;
            } else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {
                // AOP 有关 ????
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                Class<?> targetType = mbd.getTargetType();
                if (targetType != null && targetType != ClassUtils.getUserClass(beanInstance) &&
                        typeToMatch.isAssignableFrom(targetType)) {
                    Class<?> classToMatch = typeToMatch.resolve();
                    return (classToMatch == null || classToMatch.isInstance(beanInstance));
                }
            }
        }
        return false;
    } else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
        // null instance registered
        return false;
    }

    // 2. 父工厂,没什么好说的
    BeanFactory parentBeanFactory = getParentBeanFactory();
    if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
        return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch);
    }

    // 3. 下面就要从 bean 的定义中获取该 bean 的类型了
    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

    Class<?> classToMatch = typeToMatch.resolve();
    if (classToMatch == null) {
        classToMatch = FactoryBean.class;
    }
    Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ?
            new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch});

    // 3.1 AOP 代理时会将原始的 BeanDefinition 存放到 decoratedDefinition 属性中,可以行忽略这部分
    BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
    if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {
        RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
        Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
        if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {
            return typeToMatch.isAssignableFrom(targetClass);
        }
    }

    // 3.2 predictBeanType 推断 beanName 的类型,主要的逻辑
    Class<?> beanType = predictBeanType(beanName, mbd, typesToMatch);
    if (beanType == null) {
        return false;
    }

    // 3.3 处理 FactoryBean 类型
    if (FactoryBean.class.isAssignableFrom(beanType)) {
        if (!BeanFactoryUtils.isFactoryDereference(name) && beanInstance == null) {
            // 此时需要从 FactoryBean 中推断出真实类型
            beanType = getTypeForFactoryBean(beanName, mbd);
            if (beanType == null) {
                return false;
            }
        }
    // 3.4 beanType 不是 FactoryBean 类型,但是又要获取 FactoryBean 的类型???
    } else if (BeanFactoryUtils.isFactoryDereference(name)) {
        // Special case: A SmartInstantiationAwareBeanPostProcessor returned a non-FactoryBean
        // type but we nevertheless are being asked to dereference a FactoryBean...
        // Let's check the original bean class and proceed with it if it is a FactoryBean.
        beanType = predictBeanType(beanName, mbd, FactoryBean.class);
        if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) {
            return false;
        }
    }

    // 3.5 优先从缓存中判断,可以比较泛型
    ResolvableType resolvableType = mbd.targetType;
    if (resolvableType == null) {
        resolvableType = mbd.factoryMethodReturnType;
    }
    if (resolvableType != null && resolvableType.resolve() == beanType) {
        return typeToMatch.isAssignableFrom(resolvableType);
    }
    return typeToMatch.isAssignableFrom(beanType);
}

上面的代码一大堆,逻辑也比较复杂,我们现在只需要明白三点:

  1. Spring 先直接从缓存中获取这个 bean 实例,再根据对象推断其类型。如果 bean 还没有创建或者干脆就不是单例,则只能根据定义这个 bean 的 BeanDefinition 获取了。
  2. 先根据 BeanDefinition 获取其当前 bean 的类型,Spring 全部委托给了 predictBeanType(beanName, mbd, typesToMatch) 方法。
  3. 如果当前 bean 是 FactoryBean,则还需要进一步获取其真实类型。这个过程由 getTypeForFactoryBean 方法完成,这个方法有两个重载的方法,即可以直接通过实例对象获取,也可以通过定义的 BeanDefinition 获取对象类型。

下面我们就分别介绍一下这两个方法。

2.2 从 BeanDefinition 推断类型 - predictBeanType

我们先从简单的看起,AbstractBeanFactory#predictBeanType 实现了这个方法,其子类又重载了这个方法 AbstractAutowireCapableBeanFactory#predictBeanType。

(1) AbstractBeanFactory#predictBeanType

protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
    // 1. 直接从缓存中获取
    Class<?> targetType = mbd.getTargetType();
    if (targetType != null) {
        return targetType;
    }
    // 2. 工厂方法一律返回 null,子类会重载后解析对应的 getFactoryMethodName
    if (mbd.getFactoryMethodName() != null) {
        return null;
    }
    // 3. 解析 BeanDefinition 的 className,如果已经加载则直接从缓存中获取
    return resolveBeanClass(mbd, beanName, typesToMatch);
}

可以看到最终是从 BeanDefinition 中解析配置的 className 属性,将其加载到 JVM 中。它有三个参数,毫无疑问的是 mbd 是必须的,beanName 记录异常时使用,那 typesToMatch 是干嘛的呢?带着这个疑问我们看一下源码。

protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, 
        final Class<?>... typesToMatch) throws CannotLoadBeanClassException {
    if (mbd.hasBeanClass()) {
        return mbd.getBeanClass();
    }
    return doResolveBeanClass(mbd, typesToMatch);       
}
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
        throws ClassNotFoundException {

    ClassLoader beanClassLoader = getBeanClassLoader();
    ClassLoader classLoaderToUse = beanClassLoader;
    // 1. Spring 自定义的类型器 DecoratingClassLoader 修改了 JDK 的类加载规则,自己先加载一把,没有再特派给父加载器
    //    这就产生了一个问题,每个临时的类加载器可能加载同一个类可能出现多个
    //    所以可以将其加入到 excludeClass 仍采用双亲委派
    if (!ObjectUtils.isEmpty(typesToMatch)) {
        ClassLoader tempClassLoader = getTempClassLoader();
        if (tempClassLoader != null) {
            classLoaderToUse = tempClassLoader;
            if (tempClassLoader instanceof DecoratingClassLoader) {
                DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
                for (Class<?> typeToMatch : typesToMatch) {
                    dcl.excludeClass(typeToMatch.getName());
                }
            }
        }
    }
    // 2. 如果 className 含有点位符,解析后发生了变化,则不用缓存,以后每次都解析一次
    String className = mbd.getBeanClassName();
    if (className != null) {
        Object evaluated = evaluateBeanDefinitionString(className, mbd);
        if (!className.equals(evaluated)) {
            if (evaluated instanceof Class) {
                return (Class<?>) evaluated;
            } else if (evaluated instanceof String) {
                return ClassUtils.forName((String) evaluated, classLoaderToUse);
            } else {
                throw new IllegalStateException("Invalid class name expression result: " + evaluated);
            }
        }
        if (classLoaderToUse != beanClassLoader) {
            return ClassUtils.forName(className, classLoaderToUse);
        }
    }
    // 3. 解析 className 后缓存起来
    return mbd.resolveBeanClass(beanClassLoader);
}

至此,根据 BeanDefinition 解析 bean 的类型就完成了,最终还是回到了我们在 xml 文件中配置的 class 上来了,只是 Spring 的解析考虑了很多情况,一下子就复杂起来了。 想必现在对 typesToMatch 也有一定的了解了,就是为了保证要匹配的类型是同一个类加载器加载的,这里也就是 JDK 的系统类加载器 - AppClassLoader,这样调用 typeToMatch.isAssignableFrom(type) 方法才有意义。

(2) AbstractAutowireCapableBeanFactory#predictBeanType

AbstractAutowireCapableBeanFactory 又对 predictBeanType 进行了重载,增加了对工厂方法 factoryMethodName 的解析。

@Override
protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
    // 1. 增加了对工厂 factoryMethod 的解析
    Class<?> targetType = determineTargetType(beanName, mbd, typesToMatch);

    // 2. 后置处理器 SmartInstantiationAwareBeanPostProcessors 
    if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                Class<?> predicted = ibp.predictBeanType(targetType, beanName);
                if (predicted != null && (typesToMatch.length != 1 || FactoryBean.class != typesToMatch[0] ||
                        FactoryBean.class.isAssignableFrom(predicted))) {
                    return predicted;
                }
            }
        }
    }
    return targetType;
}

// 怎么样,逻辑还是之前的一样,只是增加对 factoryMethodName 的处理
protected Class<?> determineTargetType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
    Class<?> targetType = mbd.getTargetType();
    if (targetType == null) {
        targetType = (mbd.getFactoryMethodName() != null ?
                getTypeForFactoryMethod(beanName, mbd, typesToMatch) :
                resolveBeanClass(mbd, beanName, typesToMatch));
        if (ObjectUtils.isEmpty(typesToMatch) || getTempClassLoader() == null) {
            mbd.resolvedTargetType = targetType;
        }
    }
    return targetType;
}

在这里,我们重点关注 getTypeForFactoryMethod 方法,Spring 是如何从一个工厂方法中获取其类型的。

protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
    // 1. 缓存中直接取
    ResolvableType cachedReturnType = mbd.factoryMethodReturnType;
    if (cachedReturnType != null) {
        return cachedReturnType.resolve();
    }

    Class<?> factoryClass;
    boolean isStatic = true;

    // 2. 在 Spring 中有静态工厂和实例工厂之分,如果是实例工厂名称不能是当前的 beanName
    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");
        }
        // 2.1 获取实例工厂的类型
        factoryClass = getType(factoryBeanName);
        isStatic = false;
    } else {
        // 2.2 静态工厂只能是静态方法,解析自己的 BeanDefinition 就可以了
        factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
    }

    if (factoryClass == null) {
        return null;
    }
    // 2.3 如果是 CGLIB 代理,获取其真实类型
    factoryClass = ClassUtils.getUserClass(factoryClass);

    // 3.1 如果有多个方法同名,则取其返回傎的公有类型,除非为 null
    Class<?> commonType = null;
    // 3.2 缓存这个工厂方法
    Method uniqueCandidate = null;
    // 3.3 如果方法含有泛型,则需要根据传递的参数进一步判断返回值类型
    int minNrOfArgs =
            (mbd.hasConstructorArgumentValues() ? mbd.getConstructorArgumentValues().getArgumentCount() : 0);
    Method[] candidates = this.factoryMethodCandidateCache.computeIfAbsent(
            factoryClass, ReflectionUtils::getUniqueDeclaredMethods);

    // 4. 遍历所有的名称为工厂方法的
    for (Method candidate : candidates) {
        if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate) &&
                candidate.getParameterCount() >= minNrOfArgs) {
            // 4.1 方法中定义了泛型,则需要将配置的构造参数进行比较了,但似乎有问题
            // 4.1.1 getTypeParameters 获取定义的泛型个数
            if (candidate.getTypeParameters().length > 0) {
                // 4.1.2 getParameterTypes 获取该方法的参数列表
                Class<?>[] paramTypes = candidate.getParameterTypes();
                String[] paramNames = null;
                ParameterNameDiscoverer pnd = getParameterNameDiscoverer();
                if (pnd != null) {
                    paramNames = pnd.getParameterNames(candidate);
                }
                ConstructorArgumentValues cav = mbd.getConstructorArgumentValues();
                Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
                Object[] args = new Object[paramTypes.length];
                // 4.1.3 根据类型和参数名匹配真实的参数
                for (int i = 0; i < args.length; i++) {
                    ConstructorArgumentValues.ValueHolder valueHolder = cav.getArgumentValue(
                            i, paramTypes[i], (paramNames != null ? paramNames[i] : null), usedValueHolders);
                    if (valueHolder == null) {
                        valueHolder = cav.getGenericArgumentValue(null, null, usedValueHolders);
                    }
                    if (valueHolder != null) {
                        args[i] = valueHolder.getValue();
                        usedValueHolders.add(valueHolder);
                    }
                }
                // 4.1.4 解析返回值对应的泛型类型
                Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod(
                        candidate, args, getBeanClassLoader());
                uniqueCandidate = (commonType == null && returnType == candidate.getReturnType() ?
                        candidate : null);
                commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
                if (commonType == null) {
                    return null;
                }
            // 4.2 直接获取方法的返回值类型,如果有多个同名方法取其公共的祖先即可,没有就直接返回 null
            } else {
                // 第一次匹配上会缓存这个方法,但再次匹配上了,不好意思有重名的方法,直接清空
                uniqueCandidate = (commonType == null ? candidate : null);
                commonType = ClassUtils.determineCommonAncestor(candidate.getReturnType(), commonType);
                if (commonType == null) {
                    return null;
                }
            }
        }
    }

    // 5.1 如果同名的方法只有一个,那么将这个工厂方法直接缓存起来
    mbd.factoryMethodToIntrospect = uniqueCandidate;
    if (commonType == null) {
        return null;
    }
    // 5.2 如果只有唯一的工厂方法,那么尽可能缓存完型的类型,包括泛型。所以再解析一次用于缓存
    cachedReturnType = (uniqueCandidate != null ?
            ResolvableType.forMethodReturnType(uniqueCandidate) : ResolvableType.forClass(commonType));
    mbd.factoryMethodReturnType = cachedReturnType;
    return cachedReturnType.resolve();
}

根据工厂方法推断 bean 的类型看起来很复杂,但逻辑还是很清晰的:

  1. 直接从缓存中获取这个工厂方法的返回值类型。
  2. 解析工厂方法的类型,这里分为静态工厂和实例工厂,静态工厂即为自己本身,实例工厂为配置的 factory-bean
  3. 遍历这个工厂类的每个和 factory-method 同名的工厂方法,包括其父类。Spring 增加了对泛型返回值方法的支持,但我在测试的时候失败了,不知道是不是使用不对。总之,就是遍历这些方法的返回值类型,如果有多个就取其公共的类型。
  4. 如果只有唯一的一个工厂方法,缓存起来,同时缓存解析后的类型,尽可能保存完整的类型,包括泛型。

对于泛型返回值类型再多说一句,Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod( candidate, args, getBeanClassLoader()); 在测试时确实没有问题,后来发现是 Spring 在解析 xml 文件时对构造参数做了一个封装,也就是 valueHolder.getValue() 不是配置的类型,而是 TypedStringValue 类型,导致解析出现问题。

2.3 根据 FactoryBean 获取真实类型 - getTypeForFactoryBean

getTypeForFactoryBean 相对来说比较简单,我们先说这个方法。AbstractBeanFactory#getTypeForFactoryBean 实现了这个方法,其子类又重载了这个方法 AbstractAutowireCapableBeanFactory#getTypeForFactoryBean

(1) AbstractBeanFactory#getTypeForFactoryBean

protected Class<?> getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) {
    if (!mbd.isSingleton()) {
        return null;
    }
    FactoryBean<?> factoryBean = doGetBean(FACTORY_BEAN_PREFIX + beanName, FactoryBean.class, null, true);
    return getTypeForFactoryBean(factoryBean);
}

protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
    return factoryBean.getObjectType(); 
}

怎么样是不是很简单,先创建这个 FactoryBean 的实例,然后调用其 getObjectType 方法获取真实类型。但问题又来了,我们仅仅需要获取这个 bean 的类型,却要实例化与之相关的一系列对象,是不是代价太昂贵了,怎么规避这个问题呢?在其子类 AbstractAutowireCapableBeanFactory 中对这个方法做了进一步的增强,一起看一下。

(2) AbstractAutowireCapableBeanFactory#getTypeForFactoryBean

@Override
protected Class<?> getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) {
    // 1. 处理 mbd.getInstanceSupplier(),另外一种创建 bean 的方式,@Sping 5.0 提供,我们先忽略...
    // if (mbd.getInstanceSupplier() != null) ...

    // 2. 这个 FactoryBean 也可能是其他的工厂的工厂方法创建的
    String factoryBeanName = mbd.getFactoryBeanName();
    String factoryMethodName = mbd.getFactoryMethodName();

    // 3. 实例工厂创建 FactoryBean<User>
    if (factoryBeanName != null) {
        // 3.1 如果实例工厂的 className 已经解析过了,就直接从其工厂方法的返回值类型进行推断
        if (factoryMethodName != null) {
            BeanDefinition fbDef = getBeanDefinition(factoryBeanName);
            if (fbDef instanceof AbstractBeanDefinition) {
                AbstractBeanDefinition afbDef = (AbstractBeanDefinition) fbDef;
                if (afbDef.hasBeanClass()) {
                    Class<?> result = getTypeForFactoryBeanFromMethod(afbDef.getBeanClass(), factoryMethodName);
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
        // 3.2 判断这个实例工厂有没有实例化,如果没有则直接 Game Over
        //     因为下面我们要调用 FactoryBean#getObjectType(),不能就是要部分实例化这个 FactoryBean 对象
        //     如果连创建这个 FactoryBean 的工厂都未实例化,那么更谈不上创建 FactoryBean 了
        //     Spring 不会为了获取一个 bean 的类型去循环创建 bean
        if (!isBeanEligibleForMetadataCaching(factoryBeanName)) {
            return null;
        }
    }

    // 4. 现在我们要先部分实例化这个 FactoryBean,调用其 getObjectType() 来获取对象类型
    FactoryBean<?> fb = (mbd.isSingleton() ?
            getSingletonFactoryBeanForTypeCheck(beanName, mbd) :
            getNonSingletonFactoryBeanForTypeCheck(beanName, mbd));
    if (fb != null) {
        // 4.1 调用 FactoryBean#getObjectType() 获取类型
        Class<?> result = getTypeForFactoryBean(fb);
        if (result != null) {
            return result;
        // 4.2 如果部分实例化还是获取不到,没办法了只有将这个 FactoryBean 全部实例化出来了
        } else {
            return super.getTypeForFactoryBean(beanName, mbd);
        }
    }

    // 5. 静态工厂创建 FactoryBean,这种情况下 fb=null,我们可以解析该方法的返回值类型
    if (factoryBeanName == null && mbd.hasBeanClass()) {
        // 5.1 解析方法的返回值的泛型类型,FactoryBean<User>
        if (factoryMethodName != null) {
            return getTypeForFactoryBeanFromMethod(mbd.getBeanClass(), factoryMethodName);
        // 5.2 该类就是一个 FactoryBean,则直接解析其泛型就好 FactoryBean<User>
        } else {
            return GenericTypeResolver.resolveTypeArgument(mbd.getBeanClass(), FactoryBean.class);
        }
    }
    return null;
}

这个方法思路很清晰,就是在尽可能不去实例化对象的情况下,拿到这个 FactoryBean 的真实创建的类型。重点关注下面三个方法:

  1. getTypeForFactoryBeanFromMethod 工厂方法创建 FactoryBean<...>,直接解析其中的泛型
  2. getSingletonFactoryBeanForTypeCheckgetNonSingletonFactoryBeanForTypeCheck 都先尝试部分实例化这个 FactoryBean,如果任然无法获取,则需要完整的实例化这个对象。
private Class<?> getTypeForFactoryBeanFromMethod(Class<?> beanClass, final String factoryMethodName) {
    class Holder {
        Class<?> value = null;
    }
    final Holder objectType = new Holder();
    Class<?> fbClass = ClassUtils.getUserClass(beanClass);

    // 解析工厂方法的返回值 FactoryBean<User> 类型,如果有多个同名的方法则取公共的类型
    ReflectionUtils.doWithMethods(fbClass, method -> {
        if (method.getName().equals(factoryMethodName) &&
                FactoryBean.class.isAssignableFrom(method.getReturnType())) {
            // 解析 FactoryBean<User> 中的泛型类型
            Class<?> currentType = GenericTypeResolver.resolveReturnTypeArgument(method, FactoryBean.class);
            if (currentType != null) {
                objectType.value = ClassUtils.determineCommonAncestor(currentType, objectType.value);
            }
        }
    });
    return (objectType.value != null && Object.class != objectType.value ? objectType.value : null);
}

getTypeForFactoryBeanFromMethod 实际上是在解析方法返回值 FactoryBean 中定义的范型。如下场景所示。

public class UserFactory {
    public static FactoryBean<User> getObject6() {
        return new UserFactoryBean();
    }
}

至于 getSingletonFactoryBeanForTypeCheck 和 getNonSingletonFactoryBeanForTypeCheck 两个方法也只是实例化了这个 bean。调用了 createBeanInstance 方法。

private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
        BeanWrapper bw = createBeanInstance(beanName, mbd, null);
        instance = bw.getWrappedInstance();      
        return fb;
    }
}

参考:

1 . 《》:<>


每天用心记录一点点。内容也许不重要,但习惯很重要!

posted on 2019-01-28 22:36  binarylei  阅读(783)  评论(0编辑  收藏  举报

导航