Spring Boot自动装配具有多个实现的接口

Question

在普通的 Spring 中，当我们想要自动装配一个接口时，我们在 Spring 上下文文件中定义它的实现。

1. Spring Boot 呢？
2. 我们怎样才能做到这一点？

目前我们只自动装配非接口类。

这个问题的另一部分是关于在 Spring Boot 项目中使用 Junit 类中的类。

例如，如果我们想使用 CalendarUtil，如果我们自动装配 CalendarUtil，它将抛出空指针异常。在这种情况下我们能做什么？我现在只是使用“new”初始化...

Answer 1

使用@Qualifier注解用于区分同一接口的bean
看看 Spring Boot documentation
此外，要注入同一接口的所有 bean，只需 autowire List of interface
（在 Spring/Spring Boot/SpringBootTest 中的方法相同）
示例如下：

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
    SpringApplication.run(DemoApplication.class, args);
}

public interface MyService {

    void doWork();

}

@Service
@Qualifier("firstService")
public static class FirstServiceImpl implements MyService {

    @Override
    public void doWork() {
        System.out.println("firstService work");
    }

}

@Service
@Qualifier("secondService")
public static class SecondServiceImpl implements MyService {

    @Override
    public void doWork() {
        System.out.println("secondService work");
    }

}

@Component
public static class FirstManager {

    private final MyService myService;

    @Autowired // inject FirstServiceImpl
    public FirstManager(@Qualifier("firstService") MyService myService) {
        this.myService = myService;
    }

    @PostConstruct
    public void startWork() {
        System.out.println("firstManager start work");
        myService.doWork();
    }

}

@Component
public static class SecondManager {

    private final List<MyService> myServices;

    @Autowired // inject MyService all implementations
    public SecondManager(List<MyService> myServices) {
        this.myServices = myServices;
    }

    @PostConstruct
    public void startWork() {
        System.out.println("secondManager start work");
        myServices.forEach(MyService::doWork);
    }

}

}

对于你问题的第二部分，看看这个有用的答案first / second

Answer 2

您也可以通过给它提供实现的名称来使其工作。

例如：

@Autowired
MyService firstService;

@Autowired
MyService secondService;

Answer 3

如 cmets 中所述，通过使用 @Qualifier 注解，您可以区分 docs 中描述的不同实现。

对于测试，您也可以使用同样的方法。例如：

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class MyClassTests {

        @Autowired
        private MyClass testClass;
        @MockBean
        @Qualifier("default")
        private MyImplementation defaultImpl;

        @Test
        public void givenMultipleImpl_whenAutowiring_thenReturnDefaultImpl() {
    // your test here....
    }
}

Answer 4

如果我们有同一个接口的多个实现，Spring 需要知道应该将哪一个自动装配到一个类中。这是一个员工手机号码和电子邮件地址验证器的简单示例：-

员工等级：

公共类员工{

 private String mobileNumber;
 private String emailAddress;
 
 ...
 
 /** Getters & Setters omitted **/

}

接口 EmployeeValidator：

public interface EmployeeValidator {
    public Employee validate(Employee employee);
}

手机号码验证器的第一个实现类：

@Component(value="EmployeeMobileValidator")
public class EmployeeMobileValidator implements EmployeeValidator {
    @Override
    public Employee validate(Employee employee) {
        //Mobile number Validation logic goes here.
    }
}

电子邮件地址验证器的第二个实现类：

@Component(value="EmployeeEmailValidator")
public class EmployeeEmailValidator implements EmployeeValidator {
    @Override
    public Employee validate(Employee employee) {
        //Email address validation logic goes here.
    }
}

我们现在可以将上面的这些验证器单独自动装配到一个类中。

员工服务接口：

public interface EmployeeService {
    public void handleEmployee(Employee employee);
}

员工服务实现类

@Service
public class EmployeeServiceImpl implements EmployeeService {
    
    /** Autowire validators individually **/
    
    @Autowired
    @Qualifier("EmployeeMobileValidator")    // Autowired using qualifier for mobile validator
    private EmployeeValidator mobileValidator;

    @Autowired
    @Qualifier("EmployeeEmailValidator")    // Autowired using qualifier for email valodator
    private EmployeeValidator emailValidator;

    @Override
    public void handleEmployee(Employee employee) {
    
        /**You can use just one instance if you need**/
        
        employee = mobileValidator.validate(employee);        
        
        
    }   
}

Answer 5

当我们对具有多个实现的接口进行自动装配时，有两种方法：

1. Spring @Primary annotation

简而言之，每当我们尝试自动装配接口以使用标有@Primary 注释的特定实现时，它都会告诉我们的 Spring 应用程序。它就像一个默认的自动装配设置。每个接口的实现集群只能使用一次。 →@Primary Docs

1. Spring @Qualifier annotation

这个 Spring 注解让我们可以更好地控制选择确切的实现，只要我们定义对接口的引用，就可以在其选项中进行选择。 →@Qualifier Docs

有关更多详细信息，请访问其文档的链接。

Answer 6

public interface SomeInterfaces {

    void send(String message);

    String getType();
}

• kafka 服务

@Component
public class SomeInterfacesKafkaImpl implements SomeInterfaces {

    private final String type = "kafka";

    @Override
    public void send(String message) {
        System.out.println(message + "through Kafka");
    }

    @Override
    public String getType() {
        return this.type;
    }
}

• redis 服务

@Component
public class SomeInterfacesRedisImpl implements SomeInterfaces {

    private final String type = "redis";

    @Override
    public void send(String message) {
        System.out.println(message + "through Redis");
    }

    @Override
    public String getType() {
        return this.type;
    }
}

• 主人

@Component
public class SomeInterfacesMaster {

    private final Set<SomeInterfaces> someInterfaces;


    public SomeInterfacesMaster(Set<SomeInterfaces> someInterfaces) {
        this.someInterfaces = someInterfaces;
    }

    public void sendMaster(String type){

        Optional<SomeInterfaces> service =
                someInterfaces
                        .stream()
                        .filter(service ->
                                service.getType().equals(type)
                        )
                        .findFirst();
        SomeInterfaces someService =
                service
                        .orElseThrow(() -> new RuntimeException("There is not such way for sending messages."));

        someService .send(" Hello. It is a letter to ....");

    }
}

• 测试

@SpringBootTest
public class MultiImplementation {
}

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class SomeInterfacesMasterTest extends MultiImplementation {

    @Autowired
    private SomeInterfacesMaster someInterfacesMaster;

    @Test
    void sendMaster() {
        someInterfacesMaster.sendMaster("kafka");
    }
}

因此，根据Open/Closed原则，我们只需要添加一个实现而不破坏现有代码。

@Component
public class SomeInterfacesRabbitImpl implements SomeInterfaces {

   private final String type = "rabbit";

    @Override
    public void send(String message) {
        System.out.println(message + "through Rabbit");
    }

    @Override
    public String getType() {
        return this.type;
    }
}

• 测试-v2

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class SomeInterfacesMasterTestV2 extends MultiImplementation {

    @Autowired
    private SomeInterfacesMaster someInterfacesMaster;


    @Test
    void sendMasterV2() {
        someInterfacesMaster.sendMaster("rabbit");
    }
}