Springboot将含有多个构造器的类注入到bean容器，并实现区分对同一个类不同bean名称的 bean的区分的四种方法

service类有两个构造函数，一个不带参，一个带参

public class BlockChainService {
   

    public BlockChainService() {
        System.out.println("不带参的构造器");
    }

    public BlockChainService(int i) {
        System.out.println("带参的构造器");
    }

}

在config同时注入service类两个不同构造函数的bean

@Configuration
public class BlockChainServiceConfig {
    @Bean
    BlockChainService blockChainService1(){
        return new BlockChainService();
    }
    @Bean
    BlockChainService blockChainService(){
        return new BlockChainService(1);
    }
}

当启动项目后BlockChainService类创建了 bean名为blockChainService和blockChainService1的两个bean（名称与BlockChainServiceConfig类使用@Bean注解的方法名一致），各种内存独立，相当于new了同一个类的 两个不同声明的对象。

那门在使用时如何区分不同bean呢？

第一种

@Autowired
private BlockChainService blockChainService;

@Autowired
private BlockChainService blockChainService1;

当一个类只有一个bean时，BlockChainService后的声明可以随便写，但是有两个以上的bean时，BlockChainService后的声明必须与bean名称一致，否则会报错，比方使用blockChainService2 就会出现如下错误：、

第二种@Autowired+@Qualifier

@Autowired
@Qualifier("blockChainService")
private BlockChainService blockChainService;
@Autowired
@Qualifier("blockChainService1")
private BlockChainService blockChainService1;

@Qualifier里是正确的beanming ，这时BlockChainService 后声明可以随便写；

第三种@Resource注解

@Resource(name = "blockChainService")
private BlockChainService blockChainService;

@Resource(name = "blockChainService1")
private BlockChainService blockChainService1;

@Resource正确的beanming ，这时BlockChainService 后的声明可以随便写

第四种，通过bean名称到备案容器中直接找到对应的bean

BlockChainService blockChainService=(BlockChainService)SpringUtil.getBean("blockChainService");
BlockChainService blockChainService1=(BlockChainService)SpringUtil.getBean("blockChainService1");

SpringUtil类：

@Component
public class SpringUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext = null;

    public SpringUtil() {
    }

    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        if (applicationContext == null) {
            applicationContext = arg0;
        }

    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static void setAppCtx(ApplicationContext webAppCtx) {
        if (webAppCtx != null) {
            applicationContext = webAppCtx;
        }
    }

    /**
     * 拿到ApplicationContext对象实例后就可以手动获取Bean的注入实例对象
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name, Class<T> clazz) throws ClassNotFoundException {
        return getApplicationContext().getBean(name, clazz);
    }

    public static final Object getBean(String beanName) {
        return getApplicationContext().getBean(beanName);
    }

    public static final Object getBean(String beanName, String className) throws ClassNotFoundException {
        Class clz = Class.forName(className);
        return getApplicationContext().getBean(beanName, clz.getClass());
    }

    public static boolean containsBean(String name) {
        return getApplicationContext().containsBean(name);
    }

    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return getApplicationContext().isSingleton(name);
    }

    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return getApplicationContext().getType(name);
    }

    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return getApplicationContext().getAliases(name);
    }
}