提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  .Net

当前栏目

注解@Bean解析

2023-02-18 16:35:17 时间

注解@Bean 介绍

　　1）@Bean：Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中；

　　2）SpringIOC 容器管理一个或者多个bean，这些bean都需要在@Configuration注解下进行创建，在一个方法上使用@Bean注解就表明这个方法需要交给Spring进行管理；

　　3）@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。添加的bean的id为方法名；

　　4）使用Bean时，即是把已经在xml文件中配置好的Bean拿来用，完成属性、方法的组装；比如@Autowired , @Resource，可以通过byTYPE（@Autowired）、byNAME（@Resource）的方式获取Bean；

　　5）注册Bean时，@Component , @Repository , @ Controller , @Service , @Configration这些注解都是把你要实例化的对象转化成一个Bean，放在IoC容器中，等你要用的时候，它会和上面的@Autowired , @Resource配合到一起，把对象、属性、方法完美组装；

　　6）@Configuration与@Bean结合使用：@Configuration可理解为用spring的时候xml里面的标签，@Bean可理解为用spring的时候xml里面的标签；

 

注解@Bean 基本构成

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {

    name属性的别名，在不需要其他属性时使用，也就是说value 就是默认值。
    @AliasFor("name")
    String[] value() default {};

    //此bean 的名称，或多个名称，主要的bean的名称加别名。如果未指定，则bean的名称是带注解方法的名称。如果指定了，方法的名称就会忽略，如果没有其他属性声明的话，bean的名称和别名可能通过value属性配置
    @AliasFor("value")
    String[] name() default {};

    //等同于xml中bean的autowire熟悉，不推荐使用此属性。
    @Deprecated
    Autowire autowire() default Autowire.NO;

    //等同于xml中bean标签的autowire-candidate属性。
    boolean autowireCandidate() default true;

    //在初始化期间对bean实例调用的方法的可选名称。不常用，因为该方法可以直接在Bean注释方法的主体中以编程方式调用。等同于xml bean标签中的init-method属性。
    String initMethod() default "";

    //等同于xml bean中的destory方法。
    String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;

}

 

注解@Bean的情况说明

　　0.示例展示

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }

}

 

　　1.首先，Spring会把@Bean修饰的方法解析成BeanDefinition：

　　　　1）如果方法不是static的，那么解析出来的BeanDefinition中：

　　　　　　（1）factoryBeanName为AppConfig所对应的beanName，比如"appConfig"

　　　　　　（2）factoryMethodName为对应的方法名，比如"aService"

　　　　　　（3）factoryClass为AppConfig.class

　　　　2）如果方法是static的，那么解析出来的BeanDefinition中：

　　　　　　（1）factoryBeanName为null

　　　　　　（2）factoryMethodName为对应的方法名，比如"aService"

　　　　　　（3）factoryClass也为AppConfig.class

 

　　2.在由@Bean生成的BeanDefinition中，有一个重要的属性isFactoryMethodUnique，表示 factoryMethod是不是唯一的，在普通情况下@Bean生成的BeanDefinition的 isFactoryMethodUnique为true，但是如果出现了方法重载，那么就是特殊的情况，比如

@Bean
public static AService aService(){
    return new AService();
}

@Bean
public AService aService(BService bService){
    return new AService();
}

 

　　3.虽然有两个@Bean，但是肯定只会生成一个aService的Bean，那么Spring在处理@Bean时，也只会生成一个aService的BeanDefinition，比如Spring先解析到第一个@Bean，会生成一个BeanDefinition，此时isFactoryMethodUnique为true，但是解析到第二个@Bean时，会判断出来beanDefinitionMap中已经存在一个aService的BeanDefinition了，那么会把之前的这个BeanDefinition的isFactoryMethodUnique修改为false，并且不会生成新的BeanDefinition了。

　　4.并且后续在根据BeanDefinition创建Bean时，会根据isFactoryMethodUnique来操作，如果为true，那就表示当前BeanDefinition只对应了一个方法，那也就是只能用这个方法来创建Bean了，但是如果isFactoryMethodUnique为false，那就表示当前BeanDefition对应了多个方法，需要和推断构造方法的逻辑一样，去选择用哪个方法来创建Bean。

 

注解@Bean 在哪里产生作用

　　1.它是在哪里被设置的【包括一些其他属性其实都会在扫描流程中填充好】：在AbstractApplicationContext类#refresh方法#invokeBeanFactoryPostProcessors(beanFactory);流程中，展示：

　　　　ConfigurationClassParser类#doProcessConfigurationClass方法

// 解析配置类中的@Bean，但并没有真正处理@Bean，只是暂时找出来
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
    configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}

// 解析配置类所实现的接口中的@Bean，但并没有真正处理@Bean，只是暂时找出来
processInterfaces(configClass, sourceClass);

 

 

 

　　2.产生作用的地方位于实例化步骤【doCreateBean方法的createBeanInstance(beanName, mbd, args)，进入createBeanInstance】：

// @Bean对应的BeanDefinition
if (mbd.getFactoryMethodName() != null) {
    return instantiateUsingFactoryMethod(beanName, mbd, args);
}

 

　　3.分析instantiateUsingFactoryMethod方法

protected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
    // 使用factoryBean来实例化对象
    return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

//ConstructorResolver类#instantiateUsingFactoryMethod方法
//省略日志与异常
public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

    BeanWrapperImpl bw = new BeanWrapperImpl();
    this.beanFactory.initBeanWrapper(bw);

    Object factoryBean;
    Class<?> factoryClass;
    boolean isStatic;

    //通过beanDefinition获取到factoryBeanName ，实际就是@Bean注解的方法所在的configuration类
    String factoryBeanName = mbd.getFactoryBeanName();
    //表示非静态方法
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(...);
        }
        factoryBean = this.beanFactory.getBean(factoryBeanName);

        // 该mbd已经创建过了【代表这个逻辑已经走过了】
        if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
            throw new ImplicitlyAppearedSingletonException();
        }
        factoryClass = factoryBean.getClass();
        isStatic = false;
    }
    else {//表示静态方法
        // It's a static factory method on the bean class.
        if (!mbd.hasBeanClass()) {
            throw new BeanDefinitionStoreException(...);
        }
        factoryBean = null;
        factoryClass = mbd.getBeanClass();
        isStatic = true;
    }

    Method factoryMethodToUse = null;
    ArgumentsHolder argsHolderToUse = null;
    Object[] argsToUse = null;

    //如果在调用getBean方法时有传参，那就用传的参作为@Bean注解的方法（工厂方法）的参数， 一般懒加载的bean才会传参，启动过程就实例化的实际上都没有传参
    if (explicitArgs != null) {
        argsToUse = explicitArgs;
    }
    else {
        Object[] argsToResolve = null;
        synchronized (mbd.constructorArgumentLock) {
            factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
            //不为空表示已经使用过工厂方法，现在是再次使用工厂方法， 一般原型模式和Scope模式采用的上，直接使用该工厂方法和缓存的参数
            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);
        }
    }

    // 调用getBean方法没有传参，同时也是第一次使用工厂方法
    if (factoryMethodToUse == null || argsToUse == null) {
        
        factoryClass = ClassUtils.getUserClass(factoryClass);

        // 获取configuration类的所有候选方法
        Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
        List<Method> candidateList = new ArrayList<>();
        for (Method candidate : rawCandidates) {
            // 查找到与工厂方法同名的候选方法,即有@Bean的同名方法
            if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                candidateList.add(candidate);
            }
        }

        //当与工厂方法同名的候选方法只有一个，且调用getBean方法时没有传参，且没有缓存过参数，直接通过调用实例化方法执行该候选方法
        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]);
        // 有多个与工厂方法同名的候选方法时，进行排序。public的方法会往前排，然后参数个数多的方法往前排
        AutowireUtils.sortFactoryMethods(candidates);

        ConstructorArgumentValues resolvedValues = null;
        boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
        int minTypeDiffWeight = Integer.MAX_VALUE;
        Set<Method> ambiguousFactoryMethods = null;

        int minNrOfArgs;
        // 如果调用getBean方法时有传参，那么工厂方法最少参数个数要等于传参个数
        if (explicitArgs != null) {
            minNrOfArgs = explicitArgs.length;
        }
        else {
            //如果getBean的时候没有传参，如果BeanDefinition中有设置，则从BeanDefinition中获取
            if (mbd.hasConstructorArgumentValues()) {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                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;

                if (explicitArgs != null) {
                    // Explicit arguments given -> arguments length must match exactly.
                    if (paramTypes.length != explicitArgs.length) {
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                }
                else {
                    // Resolved constructor arguments: type conversion and/or autowiring necessary.
                    try {
                        String[] paramNames = null;
                        ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                        if (pnd != null) {
                            paramNames = pnd.getParameterNames(candidate);
                        }
                        //当传入的参数为空，需要根据工厂方法的参数类型注入相应的bean
                        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
                                paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
                    }
                    catch (UnsatisfiedDependencyException ex) {
                        if (logger.isTraceEnabled()) {
                            logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
                        }
                        // Swallow and try next overloaded factory method.
                        if (causes == null) {
                            causes = new LinkedList<>();
                        }
                        causes.add(ex);
                        continue;
                    }
                }

                //计算工厂方法的权重
                int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                        argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                // Choose this factory method if it represents the closest match.
                if (typeDiffWeight < minTypeDiffWeight) {
                    /*
                    * 当权重小时，重新设置factoryMethodToUse 和argsHolderToUse ，argsToUse ，
                    * 并把当前权重值设置为最小权重值，等待遍历的下一个候选工厂方法比对，
                    * 并且将ambiguousFactoryMethods （表示有含糊同样权重的候选方法）设置为空
                    * */
                    factoryMethodToUse = candidate;
                    argsHolderToUse = argsHolder;
                    argsToUse = argsHolder.arguments;
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousFactoryMethods = null;
                }

                /*
                * 当遍历到下一个候选方法的时候，已经设置了factoryMethodToUse 且权重值与上一次的最小权重值相等时，
                * ambiguousFactoryMethods填值，这个ambiguousFactoryMethods不为空表示有两个候选方法的最小权重相等，
                * spring无法匹配出最适合的工厂方法，如果再继续往下遍历候选器，有更小的权重值，
                * 那ambiguousFactoryMethods会再次被设置为空
                * */
                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<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                for (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(...);
        }
        //返回类型不能为void
        else if (void.class == factoryMethodToUse.getReturnType()) {
            throw new BeanCreationException(...);
        }
        //存在含糊的两个工厂方法，不知选哪个
        else if (ambiguousFactoryMethods != null) {
            throw new BeanCreationException(...);
        }

        if (explicitArgs == null && argsHolderToUse != null) {
            mbd.factoryMethodToIntrospect = factoryMethodToUse;
            argsHolderToUse.storeCache(mbd, factoryMethodToUse);
        }
    }

    //去实例化
    bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
    return bw;
}

 

 

 

 

相关文章