java同名不同包文件_spring框架对于不同包下同名类的查找问题

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 beanDefinitionMap = new ConcurrentHashMap(256);

现在的报错原因，就是因为在注册bean之前，对beanName做了唯一性验证，而这个验证正好失败。

从报错的日志来看，注册TestSpring这个类的时候，使用的beanName是testSrping，而不是com.test.mybatis.context.package1.TestSpring。

我们继续看spring的源码

//扫码获取bean的主要函数

protected Set doScan(String... basePackages) {

Assert.notEmpty(basePackages, "At least one base package must be specified");

Set beanDefinitions = new LinkedHashSet();

for (String basePackage : basePackages) {

Set 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.

*

The default implementation simply builds a decapitalized version

* of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".

*

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

...

这样beanName就为类的完全名(packageName+类名)。