Sping bean 的默认名称

先来看一个例子，我定义一个Service , IDataService 它有2个实现类：OracleService 和 SQLService 。
代码如下：

public interface IDataService {
    void showMsg(String msg) ;
}

@Repository
public class OracleService implements IDataService{
    @Override
    public void showMsg(String msg) {
        System.out.println("oracle >>> " + msg);
    }
}

@Repository
public class SQLService implements IDataService{
    @Override
    public void showMsg(String msg) {
        System.out.println("SQL >>>> " +msg);
    }
}

测试调用代码如下：

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("classpath:demo_sacn.xml")
public class TestService {

    @Autowired
    IDataService dataService;

    @Test
    public void dd() {
        dataService.showMsg("oracle service");
    }

}

运行，结果报错了，如下：

No qualifying bean of type 'com.example.demo.service.IDataService' available: expected single matching bean but found 2: oracleService,sqlService

为啥会报错，原因很简单，我这里有2个IDataService的实现类。那么如何解决呢？
通用的解法是加上限定符的注解 @Qualifier，如下：

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("classpath:demo_sacn.xml")
public class TestService {

    @Qualifier("oracleService")
    @Autowired
    IDataService dataService;

    @Test
    public void dd() {
        dataService.showMsg("oracle service");
    }

}

这样就能正常执行。@Qualifier("oracleService") 中的 oracleService 就是 Bean 的默认名称。

这里我们很容易得出一个结论：对于 Bean 的名字，如果没有显式指明，就应该是类名，不过首字母应该小写。但是这个轻松得出的结论成立么？

我们进行一个测试，修改@Qualifier("oracleService")中的值为 @Qualifier("sQLService")，结果发现报错了。

No qualifying bean of type 'com.example.demo.service.IDataService' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Qualifier(value=sQLService), @org.springframework.beans.factory.annotation.Autowired(required=true)}

满怀信心运行完上面的程序，依然会出现之前的错误，而如果改成 SQLiteDataService，则运行通过了。这和之前的结论又矛盾了。所以，显式引用 Bean 时，首字母到底是大写还是小写呢？

看案例的话，当我们启动基于 Spring Boot 的应用程序时，会自动扫描我们的 Package，以找出直接或间接标记了 @Component 的 Bean 的定义（即 BeanDefinition）。例如 OracleService、SQLService 都被标记了 @Repository，而 Repository 本身被 @Component 标记，所以它们都是间接标记了 @Component。

一旦找出这些 Bean 的信息，就可以生成这些 Bean 的名字，然后组合成一个个 BeanDefinitionHolder 返回给上层。

基本匹配我们前面描述的过程，其中方法调用 BeanNameGenerator#generateBeanName 即用来产生 Bean 的名字，它有两种实现方式。因为 DataService 的实现都是使用注解标记的，所以 Bean 名称的生成逻辑最终调用的其实是 AnnotationBeanNameGenerator#generateBeanName 这种实现方式，我们可以看下它的具体实现，代码如下：

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

大体流程只有两步：看 Bean 有没有显式指明名称，如果有则用显式名称，如果没有则产生一个默认名称。很明显，在我们的案例中，是没有给 Bean 指定名字的，所以产生的 Bean 的名称就是生成的默认名称，查看默认名的产生方法 buildDefaultBeanName，其实现如下：

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

首先，获取一个简短的 ClassName，然后调用 Introspector#decapitalize 方法，设置首字母大写或小写，具体参考下面的代码实现：

    public static String decapitalize(String name) {
        if (name == null || name.length() == 0) {
            return name;
        }
        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) && Character.isUpperCase(name.charAt(0))) {
            return name;
        }
        char chars[] = name.toCharArray();
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }

到这，我们很轻松地明白了前面两个问题出现的原因：如果一个类名是以两个大写字母开头的，那么这个Bean的默认名称就是类名，其它情况下默认就是类名的首字母变成小写。结合我们之前的案例，SQLService 的 Bean，其名称应该就是类名本身，而 OracleService 的 Bean 名称则变成了首字母小写（oracleService）。

知道了 Bean 默认名称的规则是不是就意味着我们能搞定所有 Bean 的显式引用，不再犯错了呢？天真了。我们可以沿用上面的案例，稍微再添加点别的需求，例如我们需要定义一个内部类来实现一种新的 IDataService，我在之前的测试类里面添加了内部类，代码如下：

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("classpath:demo_sacn.xml")
public class TestService {

    @Qualifier("oracleService") 
    @Autowired
    IDataService dataService;

    @Test
    public void dd() {
        dataService.showMsg("oracle service");
    }


    @Repository
    public static class InnerDataService implements IDataService {

        @Override
        public void showMsg(String msg) {
            System.out.println("我是内部类的service >> " + msg);
        }
    }
}

然后我修改引用的地方，类名首字母小写，@Qualifier("innerDataService")，结果已运行还是报错。
上面贴出了如何产生默认 Bean 名的方法（即 AnnotationBeanNameGenerator#buildDefaultBeanName），当时我们只关注了首字母是否小写的代码片段，而在最后变换首字母之前，有一行语句是对 class 名字的处理，代码如下：

String shortClassName = ClassUtils.getShortName(beanClassName);

public static String getShortName(String className) {
        Assert.hasLength(className, "Class name must not be empty");
        int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
        int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR);
        if (nameEndIndex == -1) {
            nameEndIndex = className.length();
        }
        String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
        shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR);
        return shortName;
    }

假如，我们上面的内部类的 className 是 com.example.demo.service.TestService.InnerDataService，那么调用 getShortName 方法后，得出的 Bean 名称就是 TestService.InnerDataService，我们所以我们在案例程序中，直接使用 innerDataService自然找不到想要的 Bean的，改成 **@Qualifier(“testService.InnerDataService”)**就可以了。
所以源码的理解和解读还是蛮重要的。

其实，如果不想这么麻烦还是可以在定义 InnerDataService 的时候加上显式的名称@Repository("innerService")，如下：

    @Repository("innerService")
    public static class InnerDataService implements IDataService {

        @Override
        public void showMsg(String msg) {
            System.out.println("我是内部类的service >> " + msg);
        }
    }

这样，引用地方的限定符就可以这样改了 @Qualifier("innerService")。所以，如果搞不清楚 Bean 默认的名称，就可以在定义的时候加上显式的 Bean 名称。