关于java:Spring-中三种-BeanName-生成器

无论咱们是通过 XML 文件，还是 Java 代码，亦或是包扫描的形式去注册 Bean，都能够不设置 BeanName，而 Spring 均会为之提供默认的 beanName，明天咱们就来看看 Spring 中三种解决不同状况的 beanName 生成器。

Spring 中提供了一个名为 BeanNameGenerator 的接口，这个接口就只有一个须要实现的办法就是 generateBeanName，从名字就能看进去，这就是专门用来生成 beanName 的办法。

public interface BeanNameGenerator {String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry);
}

这个办法有两个参数：

definition：这个是要生成的 Bean 定义。
registry：这个是未来 BeanDefinition 的注册器。

BeanNameGenerator 有三个不同的实现类，对应不同的解决场景：

AnnotationBeanNameGenerator：这个专门用来解决包扫描的时候扫到的 Bean，对于这些 Bean，其 name 属性该如何解决，由这个类来解决，当然，小伙伴们都晓得，通过 @Component/@Service/@Repository/@Controller 这些注解定义的 Bean，默认状况下，beanName 就是类名首字母小写。
FullyQualifiedAnnotationBeanNameGenerator：这个继承自 AnnotationBeanNameGenerator，并重写了 AnnotationBeanNameGenerator#buildDefaultBeanName 办法，这个是应用类的全门路来作为 Bean 的默认名称。
DefaultBeanNameGenerator：这个是专门用来解决 XML 文件中定义的 Bean 如果没有设置 beanName，那么就通过 DefaultBeanNameGenerator 来为其生成 beanName。

看了下面三个场景之后，可能有小伙伴发现一个 BUG，那么 @Bean 注解定义的 Bean，其 beanName 属性是在哪里解决的呢？这个其实比拟非凡，是当场解决的，没用到 BeanNameGenerator，松哥前面独自说。

接下来咱们具体看下下面这三个实现类。

咱们间接来看最要害的 generateBeanName 办法吧：

@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {if (definition instanceof AnnotatedBeanDefinition) {String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
        if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            return beanName;
        }
    }
    // Fallback: generate a unique default bean name.
    return buildDefaultBeanName(definition, registry);
}

这个办法首先判断 definition 是否为 AnnotatedBeanDefinition 类型，依据咱们后面文章对 BeanDefinition 的介绍（七种 BeanDefinition，各显其能！），大家晓得，AnnotatedBeanDefinition 的实现类次要是针对三种状况：@Bean 注解定义的 Bean、@Service/@Controller/@Component/@Repository 等注解标记的 Bean 以及零碎的启动配置类，如果是这三种状况，那么就去调用 determineBeanNameFromAnnotation 办法，这个办法会尝试从注解中提取进去 beanName，如果不是下面三种状况，那么就调用 buildDefaultBeanName 办法去生成 beanName。

那咱们先来看 determineBeanNameFromAnnotation 办法：

@Nullable
protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {AnnotationMetadata amd = annotatedDef.getMetadata();
    Set<String> types = amd.getAnnotationTypes();
    String beanName = null;
    for (String type : types) {AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
        if (attributes != null) {
            Set<String> metaTypes = this.metaAnnotationTypesCache.computeIfAbsent(type, key -> {Set<String> result = amd.getMetaAnnotationTypes(key);
                return (result.isEmpty() ? Collections.emptySet() : result);
            });
            if (isStereotypeWithNameValue(type, metaTypes, attributes)) {Object value = attributes.get("value");
                if (value instanceof String strVal) {if (StringUtils.hasLength(strVal)) {if (beanName != null && !strVal.equals(beanName)) {
                            throw new IllegalStateException("Stereotype annotations suggest inconsistent" +
                                    "component names:'" + beanName + "'versus'" + strVal + "'");
                        }
                        beanName = strVal;
                    }
                }
            }
        }
    }
    return beanName;
}

这个办法首先会去获取类上的注解信息，拿到 amd 之后，获取到所有的注解类型，而后进行遍历。

遍历的时候，首先获取到注解上的所有属性 attributes，当 attributes 不为空的时候，持续去读取以后注解的元注解，并将读取到的后果存入到 metaAnnotationTypesCache 汇合中。这个是干嘛呢？大家晓得，Spring 中用来标记 Bean 的注解大部分衍生自 @Component，甚至咱们也能够自定义注解，那么如果自定义注解了，这个中央就没法判断了，因为每个人自定义进去的注解都不一样。所以，万变不离其宗，这里就去找各个注解的元注解。例如如果咱们在类上增加的是 @Configuration，那么 @Configuration 的元注解有两个，别离是 @Component 和 @Indexed。

接下来的 isStereotypeWithNameValue 办法就是判断 type 是不是 @Component 或者 Jakarta 中自带的 @ManagedBean、@Named，亦或者 metaTypes 里是否蕴含 @Component。如果确定是 @Component 衍生进去的注解，亦或者是 @ManagedBean、@Named 注解标记的 Bean，那么就将其 value 属性读取进去，作为 beanName，如果蕴含多个无效注解，且各自配置的 beanName 不统一，就会抛出异样。

例如上面这种状况：

@Configuration("j")
@Component("a")
public class JavaConfig {}

这两个 beanName 不统一，运行时就会出错。

同时，通过下面的剖析，小伙伴也看到了，咱们其实能够通过自定义注解为 Bean 设置名称，例如我有如下注解：

@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface MyBeanName {String value() default "";
}

这个注解衍生自 @Component，那么它的用法如下：

@MyBeanName("f")
public class JavaConfig {}

那么 f 就是以后类生成的 beanName。

以上是从注解中去提取 beanName，然而注解中可能没有提供 beanName，那么就得调用 buildDefaultBeanName 办法去主动生成了，如下：

protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {return buildDefaultBeanName(definition);
}
protected String buildDefaultBeanName(BeanDefinition definition) {String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    String shortClassName = ClassUtils.getShortName(beanClassName);
    return StringUtils.uncapitalizeAsProperty(shortClassName);
}

这个就很好懂了，先拿到 bean 的残缺类名，而后提取进去 shortName，也就是去除包名之后的名字，而后首字母小写之后返回。

这就是 @Component 注解体系下的 beanName 生成流程。

FullyQualifiedAnnotationBeanNameGenerator 类只是重写了 AnnotationBeanNameGenerator 的 buildDefaultBeanName 办法，如下：

@Override
protected String buildDefaultBeanName(BeanDefinition definition) {String beanClassName = definition.getBeanClassName();
    Assert.state(beanClassName != null, "No bean class name set");
    return beanClassName;
}

重写后的办法就是获取类的残缺门路返回。

FullyQualifiedAnnotationBeanNameGenerator 默认状况下并不会间接应用，须要本人手动配置，像上面这样：

@Configuration
@ComponentScan(nameGenerator = FullyQualifiedAnnotationBeanNameGenerator.class)
public class JavaConfig {}

此时，生成的 Bean 的默认名称就是类的全门路了。

这个是专门用来解决 XML 中默认的 beanName 的。这个在最近录制的 Spring 源码视频中曾经具体介绍过了，这里就不再啰嗦了，感兴趣的小伙伴戳这里：Spring 源码应该怎么学？。

如果类是被 @Bean 注解标记的，那么解决状况就非凡一些，间接现场解决，办法在 org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod 地位：

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
    // Consider name and any aliases
    List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
    String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

    // Register aliases even when overridden
    for (String alias : names) {this.registry.registerAlias(beanName, alias);
    }
}

从这里能够看到，如果一开始配置了 name 属性，那么就把 names 汇合中的第一个值拿进去作为 beanName，汇合中的其余值则当作别名来解决，如果没有配置 name 属性值，那么就应用办法名作为 beanName。

好啦，这就是松哥和大家讲的 Spring 中默认的 beanName 生成策略，感兴趣的小伙伴能够试试哦

关于java:Spring-中三种-BeanName-生成器

1. BeanNameGenerator

2. AnnotationBeanNameGenerator

3. FullyQualifiedAnnotationBeanNameGenerator

4. DefaultBeanNameGenerator

5. @Bean 解决非凡状况

6. 小结