在SpringBoot框架下，接口有读个实现类，在不改变任何源码的情况下，SpringBoot怎么知道给接口注入哪个实现类的依赖呢？

在Spring Boot框架下，当一个接口有多个实现类时，Spring Boot 默认情况下不知道要注入哪个实现类的依赖。因此，你需要使用一些方法来明确告诉Spring Boot应该注入哪个实现类的依赖。

以下是一些常用的方法：

1.使用@Qualifier注解： 你可以在依赖注入点上使用@Qualifier注解来指定要注入的具体实现类的名称。首先，在实现类上使用@Component或@Service等注解进行标记，然后在依赖注入点使用@Qualifier注解来指定要注入的实现类的名称。例如：

@Service
public class MyServiceImpl1 implements MyService {
    // 实现1的逻辑
}

@Service
public class MyServiceImpl2 implements MyService {
    // 实现2的逻辑
}
1
2
3
4
5
6
7
8
9

在需要注入的地方：

@Autowired
@Qualifier("myServiceImpl1")
private MyService myService;
1
2
3

这样，Spring Boot 将知道要注入MyServiceImpl1实现类的依赖。

2.使用@Primary注解： 你可以在其中一个实现类上使用@Primary注解，以指定一个默认的首选实现类。如果没有使用@Qualifier来明确指定实现类，Spring Boot 将注入使用@Primary注解的实现类的依赖。例如：

@Service
@Primary
public class MyServiceImpl1 implements MyService {
    // 实现1的逻辑
}
@Service
public class MyServiceImpl2 implements MyService {
    // 实现2的逻辑
}
1
2
3
4
5
6
7
8
9

在需要注入的地方，不需要额外的注解：

@Autowired
private MyService myService; // 将注入MyServiceImpl1
1
2

3.使用条件注解： 你可以使用条件注解（例如@ConditionalOnProperty）来根据应用程序的配置动态选择要注入的实现类

1.使用条件注解（如@ConditionalOnProperty）来根据应用程序的配置动态选择要注入的实现类是一种非常灵活的方法，它允许你根据配置文件中的属性值来决定要使用的实现类。下面是一个示例，演示如何使用@ConditionalOnProperty来实现这一目标。

假设你有一个接口MyService，有两个不同的实现类：MyServiceImpl1和MyServiceImpl2。你想根据配置文件中的属性值来决定要注入哪个实现类。

1.创建接口和实现类：

public interface MyService {
    void doSomething();
}

@Service
public class MyServiceImpl1 implements MyService {
    @Override
    public void doSomething() {
        // 实现1的逻辑
    }
}

@Service
public class MyServiceImpl2 implements MyService {
    @Override
    public void doSomething() {
        // 实现2的逻辑
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.在配置文件（例如application.properties或application.yml）中定义一个属性来指示要使用哪个实现类。例如，将属性名设置为my.service.impl：

my.service.impl=1
1

1.创建一个配置类，并在该类中使用@ConditionalOnProperty来根据属性值选择要注入的实现类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyServiceConfig {

    @Autowired
    private Environment environment;

    @Bean
    @ConditionalOnProperty(name = "my.service.impl", havingValue = "1")
    public MyService myService1() {
        return new MyServiceImpl1();
    }

    @Bean
    @ConditionalOnProperty(name = "my.service.impl", havingValue = "2")
    public MyService myService2() {
        return new MyServiceImpl2();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个配置类中，我们使用了@ConditionalOnProperty注解，并指定了要检查的属性名（my.service.impl）和属性值（1和2）。根据配置文件中的属性值，Spring Boot 将选择注入相应的实现类。

1.在需要使用MyService的地方，通过自动注入来获取具体的实现类：

@Service
public class MyServiceConsumer {
    private final MyService myService;

    @Autowired
    public MyServiceConsumer(MyService myService) {
        this.myService = myService;
    }

    public void useMyService() {
        myService.doSomething();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，MyServiceConsumer通过自动注入MyService来获取实现类，根据配置中的属性值，将注入MyServiceImpl1或MyServiceImpl2。