1 问题背景
由于厌倦了java里面冗长的命名方式，因此最近开始将文件名尽量的缩短。信息尽量通过包名来一层层描述。
这样使用了一段时间，都没有什么问题，而且idea面板也清爽了很多。
近日按这种简略的类名的方式重构一份历史代码，编译没有问题，启动了时候报了这样一个错误：
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanDefinitionStoreException:
Failed to parse configuration class [com.test.mybatis.DemoApplication];
nested exception is org.springframework.context.annotation.ConflictingBeanDefinitionException:
Annotation-specified bean name 'testSpring' for bean class [com.test.mybatis.context.package2.TestSpring]
conflicts with existing, non-compatible bean definition of same name and class [com.test.mybatis.context.package1.TestSpring]
简单说，就是有不同包下的类重名了。
2 问题复现
首先是模拟这种场景，我们启动一个springboot项目。在不同的包下，建立两个名字一样的类，如图：
然后注入这两个类，并启动，代码如下：
@Service
public class Context {
@Autowired
private TestSpring testSpring1;
@Autowired
private com.test.mybatis.context.package2.TestSpring testSpring2;
public void test() {
testSpring1.fun();
testSpring2.fun();
}
}
启动中报错，和1里描述的一样。
3 问题分析
java描述一个类(相同加载器，相同虚拟机)，确实是依赖类的完整名(包名+类名)，也就是说，不同包下的同名类，互相完全没有关系，是两个完全不同的类。但spring对这种类的处理却和这种方式不同。很有趣的问题，因此决定把它搞清楚。
是spring中，被它所管理的类是通过BeanDefinition来描述的，而注册一个bean，是通过这个函数registerBeanDefinition(String beanName, BeanDefinition beanDefinition)进行的。
最终bean会被存储在这样一个map里：private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);
现在的报错原因，就是因为在注册bean之前，对beanName做了唯一性验证，而这个验证正好失败。
从报错的日志来看，注册TestSpring这个类的时候，使用的beanName是testSrping，而不是com.test.mybatis.context.package1.TestSpring。
我们继续看spring的源码
//扫码获取bean的主要函数
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
for (String basePackage : basePackages) {
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); //获取beanName
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) { //该步报错,conflicts
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
现在问题变成了为什么beanNameGenerator.generateBeanName(candidate, this.registry);会返回类名，而不是package+类名。
我们继续看generateBeanName的实现，有两个实现
DefaultBeanNameGenerator
AnnotationBeanNameGenerator
先看DefaultBeanNameGenerator的实现，它的实现相对简单，核心代码是这句String generatedBeanName = definition.getBeanClassName();而它的实现如下
@Override
public String getBeanClassName() {
Object beanClassObject = this.beanClass;
if (beanClassObject instanceof Class) {
return ((Class<?>) beanClassObject).getName(); //返回类的完整名，packageName + className
}
else {
return (String) beanClassObject;
}
}
也就是说，DefaultBeanNameGenerator返回的beanName是packageName+beanName。
在我们的代码中，对TestSpring使用的是@Service修饰，因此，我们使用的是AnnotationBeanNameGenerator的实现。
我们来看它的实现，如下：
@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
if (definition instanceof AnnotatedBeanDefinition) {
String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition); //如果用户指定了@Service("value")使用value作为beanName
if (StringUtils.hasText(beanName)) {
// Explicit bean name found.
return beanName;
}
}
// Fallback: generate a unique default bean name.
return buildDefaultBeanName(definition, registry);
}
如果用户指定了@Service("testBean")，则使用testBean作为beanName，如果没有指定，我们继续往下看buildDefaultBeanName的实现：
/**
* Derive a default bean name from the given bean definition.
* <p>The default implementation simply builds a decapitalized version
* of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".
* <p>Note that inner classes will thus have names of the form
* "outerClassName.InnerClassName", which because of the period in the
* name may be an issue if you are autowiring by name.
* @param definition the bean definition to build a bean name for
* @return the default bean name (never {@code null})
*/
protected String buildDefaultBeanName(BeanDefinition definition) {
String shortClassName = ClassUtils.getShortName(definition.getBeanClassName());
return Introspector.decapitalize(shortClassName);
}
这里已经解释的比较清楚了，如果使用的是
@Service
class TestSpring
则beanName为testSpring。
鉴于此，我们不同包下的同名类会造成beanName重复，从而报错。
4 总结
spring并不支持不同的包下类名相同的设定。这是因为默认的spring检索bean的唯一id(@Service,@Component等)为bean的name，并不包含package name信息。想要规避这种问题有两种方式
a 对bean显式命名，@Service("yourName")
b 使用xml的方式声明bean
<bean class="com.context.SpringTest">
...
</bean>
这样beanName就为类的完全名(packageName+类名)。
