Injecting service class by interface?

Question

So I have 2 Service classes that implement the same interface:

@Service
public class ServiceOne implements InterfaceOne {

}

@Service
public class ServiceTwo implements InterfaceOne {

}

I was wondering how I can inject particular instance inside the controller ?

@RestController
@RequestMapping("/test")
public class MyController {
    @Inject
    public MyController(InterfaceOne service) {

    }
}

I'm not sure how DI is supposed to work with service classes. Basically those two services classes have the same interface and I was hoping to avoid nessesary if's if I could just inject the right one into the controller. An example would be much appreciated.

Edit: Sorry guys, I wasn't clear. What I also need to figure out is, which service class needs to be injected in the controller without specifying concrete implementation at that point. So, I was hoping there is a way to do some kind of if statement and check which implementation of the service should be plugged in.

Hello, in this case, I think you should use `@Qualifier` on your services. — Mickael, Nov 14 '18 at 10:22
You can give them names: https://stackoverflow.com/questions/48941960/qualify-bean-based-on-the-bean-name-in-spring — Thilo, Nov 14 '18 at 10:22
I think that either you will use @Qualifier as suggested by Mickael or you will `@Autowire` the specific service instead of autowiring the interface. — Christos Karapapas, Nov 14 '18 at 10:26
Sorry guys, I wasn't clear at first. I have updated the description — Zed, Nov 14 '18 at 10:27

Peter Walser · Answer 1 · 2018-11-15T11:10:35.863

Two approaches when dealing with multiple implementations:

Use a specific flavour, identified by a @Qualifier

Annotate each implementation with a specific @Qualifier (such as @Qualifier("One") and @Qualifier("Two")), and inject the specific flavour:

@Autowired
@Qualifier("One")
InterfaceOne implementation;

Use all implementations (or evaluate most appropriate with code)

The second approach is useful when you have a strategy interface, and want to have all implementations injected. You can then use all or any of them, and also query them for additional details.

In that case (when expecting 1..n implementations), use:

@Autowired
List<InterfaceOne> implementations;

If the implementations are optional (0..n), use:

@Autowired
Optional<List<InterfaceOne>> implementations;

EDIT: example on how to use a strategy interface with multiple implementations:

Interface:

public interface HelloWorldService {
    String sayHello();
    String getLanguage();
}

Implementations:

@Service
public class HelloWorldServiceEN implements HelloWorldService {
    public String sayHello() { return "Hi there!"; }
    public String getLanguage() { return "en"; }
}

@Service
public class HelloWorldServiceDE implements HelloWorldService {
    public String sayHello() { return "Hallo!"; }
    public String getLanguage() { return "de"; }
}

@Service
public class HelloWorldServiceFR implements HelloWorldService {
    public String sayHello() { return "Salut!"; }
    public String getLanguage() { return "fr"; }
}

Usage:

@Autowired
private List<HelloWorldService> helloWorldServices;

public void sayHelloInAllLanguages() {
    for (HelloWorldService helloWorldService : helloWorldServices) {
        System.out.println(helloWorldService.sayHello());
    }
}

public void sayHelloInUserLanguage() {
    String userLanguage = Locale.getDefault().getLanguage();
    HelloWorldService helloWorldService = find(userLanguage);
    System.out.println(helloWorldService.sayHello());

}

private HelloWorldService find(String language) {

    // find service in specific language
    Optional<HelloWorldService> service = helloWorldServices.stream().filter(s -> language.equals(s.getLanguage())).findFirst();
    if (service.isPresent()) {
        return service.get();
    }

    // fallback to english, if available
    service = helloWorldServices.stream().filter(s -> language.equals("en")).findFirst();
    if (service.isPresent()) {
        return service.get();
    }

    // fallback to any language
    return helloWorldServices.stream().findFirst().orElseThrow(IllegalStateException::new);
}

hi, it would be great if you give an example for the use case of **Use all implementations**. How can a method from `ServiceOne` implementation be called? — Erfan Ahmed, Nov 15 '18 at 07:10

Injecting service class by interface?

1 Answers1