引言
在一次产品发布前夕，测试同学发现某一个接口异常，后来发现是因为在导出dubbo服务时，对同一个接口的两个版本使用了相同的服务引用导致，当时的dubbo导出配置如下：
在dubbo服务导出时，并没有限制ref的唯一性，因此编译时没有暴露该问题。由此也随之引出了我们的思考，在Spring的配置文件中，是否允许bean的id/name重复呢？通过查阅一些资料，得到的结论大致如下，这里先把结论给出来，后面再来进一步分析源码。结论如下：
- 同一个配置文件，id和name都不允许重复；
- 不同的配置文件，由变量allowBeanDefinitionOverriding进行控制，默认值为true，即id和name允许重复，后加载的会覆盖前面加载的；
- 同一个配置文件，在不配置id和name的情况下，class允许重复。
举个栗子，配置文件中同时存在这样两个bean定义是合法的，且不会存在覆盖的情况。本文将尝试解答在这种场景下的两个问题：
1.加载bean定义时，两个bean名称分别是什么样的？
2.通过getBean获取bean对象时，bean名称又该怎么传？
1.加载bean定义
加载配置文件时，对于bean标签，解析入口在这里：
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 解析bean定义，这里面会根据条件生成bean名称
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 注册bean实例，这里会将bean别名与bean名称的映射关系
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
parseBeanDefinitionElement跟进去看一下：
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 首先获取id和name属性
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
// name属性同时作为bean的别名保存起来
List aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
// 如果只配置了name，没有配置id，则用第一个name作为id
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
// 走到这里，说明id和name都为空，此时需要自动生成一个bean名称
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
在id和name都为空的条件下，最后会调用BeanDefinitionReaderUtils#generateBeanName方法生成一个bean名称，这里的逻辑跟进去是这样子的：
public static String generateBeanName(
BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean)
throws BeanDefinitionStoreException {
...
if (isInnerBean) {
// 对于内部bean，根据bean信息生成一个hash码作为后缀追加到bean名称当中
id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
}
else {
// 否则，名称重复时，使用计数器向上递增，追加到全路径名后作为bean名称
int counter = -1;
while (counter == -1 || registry.containsBeanDefinition(id)) {
counter++;
id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
}
}
return id;
}
至此，bean名称已经生成了，在我们的例子中，得到的两个bean名称分别为com.youzan.shys.advisor.NaiveWaiter#0、com.youzan.shys.advisor.NaiveWaiter#1.
2.获取bean对象
接下来看一下注册bean时做了什么，registerBeanDefinition跟一下：
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 如果bean别名不为空，注册别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
注册别名的逻辑就比较简单了：
public void registerAlias(String name, String alias) {
Assert.hasText(name, "'name' must not be empty");
Assert.hasText(alias, "'alias' must not be empty");
if (alias.equals(name)) {
this.aliasMap.remove(alias);
}
else {
String registeredName = this.aliasMap.get(alias);
if (registeredName != null) {
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
if (!allowAliasOverriding()) {
throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
checkForAliasCircle(name, alias);
// 保存bean别名与bean名称之间的映射关系
this.aliasMap.put(alias, name);
}
}
这里执行完之后，aliasMap中将保存如下一对映射关系：
"com.youzan.shys.advisor.NaiveWaiter" -> "com.youzan.shys.advisor.NaiveWaiter#0"
接下来，调用getBean方法时，会根据这个映射关系获取bean对象，最终会在doGetBean方法中调用一个用于转换bean名称的方法：
protected T doGetBean(final String name, @Nullable final Class requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
...
}
在这个方法里面，又会调用下面这个方法，从之前保存的别名映射关系里面获取真实的bean名称
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
所以在获取bean对象时，beanName可以有如下三种选择，效果是一样的：
com.youzan.shys.advisor.NaiveWaiter
com.youzan.shys.advisor.NaiveWaiter#0
com.youzan.shys.advisor.NaiveWaiter#1