How is this interface working? -- Is it Spring magic or am I missing something?

[Hans Hovan]

I'm working on a large application that uses Spring Boot. In it, an interface is used in a way that I don't understand.
I've stripped down the code to the only parts that I think are relevant to the question. There are four files that I have put in order of application flow.

A controller object is created.
It is told to process some stuff.
The controller tells an interface processor to do the work.
There is a processor that implements the interface processor.

It was my understanding that when using an interface you'd do something like:

IProcessor iProcessor = new Processor();

In other words, assigning the interface an implementation. But in this sample program it seems the processor implementation is implicitly assigned, not in the code as far as I can tell. I'm trying to figure out if this is some Spring wizardry or if I'm just understanding interfaces wrong:

@Component
public class DoStuff {
    private ProcessorController PROCESSOR_CONTROLLER;
    private OtherLayer OTHER_LAYER;

    @Autowired
    public DoStuff(ProcessorController processorController, OtherLayer otherLayer) {
        this.PROCESSOR_CONTROLLER = processorController;
        this.OTHER_LAYER = otherLayer;
    }

    public void execute() {
        List<String> stuffToProcess = OTHER_LAYER.getStuffToProcess();
        PsROCESSOR_CONTROLLER.process(tuffToProcess);
    }
}

@Component
public class ProcessorController {
    private final IProcessor IPROCESSOR;

    @Autowired
    public ProcessorController(IProcessor iProcessor) {
        this.IPROCESSOR = iProcessor;
    }

    public void process(List<String> stuffToProcess) {
        stuffToProcess.forEach(t -> IPROCESSOR.process(t))
    }
}

public interface IProcessor {
    void process(String stuff);
}

@Component
public class Processor implements IProcessor {

    @Override
    public void process(String stuff) {
        System.out.println(stuff);
    }
}

If the ProcessorController class contained something like this:

private final IProcessor IPROCESSOR;

@Autowired
public ProcessorController(Processor Processor) {
    this.IPROCESSOR = processor;
}

I think it would make sense since we've linked the interface with its implementation. But it isn't that way. So what is going on here? Any help is appreciated!

[Junilu Lacar]

Hans Hovan wrote:
If the ProcessorController class contained something like this:
So part of the ProcessorController class would look like this instead:

private final IProcessor IPROCESSOR;

@Autowired
public ProcessorController(Processor Processor) {
    this.IPROCESSOR = processor;
}

I think it would make sense since we've linked the interface with its implementation. But it isn't that way. So what is going on here? Any help is appreciated!

If you do that, you've negated the usefulness of programming to an interface instead of an implementation. This design would be far inferior to the other since it's programmed to a specific implementation. What you're seeing is Spring's @Autowire magic in action where it will find a class marked with @Component and inject it into something marked as @Autowired that takes an IProcessor implementation. It can be any IProcessor implementation and not a particular one. This creates a "seam" in your program where you can switch out the implementation with a different one, say for testing purposes, and the program should still work as expected.

[Junilu Lacar]

I suspect your confusion stems from an incorrect assumption of how @Autowired works in Spring. Look up assignment compatibility in Java. That's basically what Spring uses to determine what can be autowired to what. Essentially, when you have a variable or parameter declared as an interface type, any object that implements that interface is assignment-compatible with it.

[Rob Spoor]

And you either need to have just one such implementation, or mark one with @Primary. Otherwise Spring can't decide which one to use and will just fail instead.

[Hans Hovan]

Junilu Lacar wrote:

Hans Hovan wrote:
If the ProcessorController class contained something like this:
So part of the ProcessorController class would look like this instead:

private final IProcessor IPROCESSOR;

@Autowired
public ProcessorController(Processor Processor) {
    this.IPROCESSOR = processor;
}

I think it would make sense since we've linked the interface with its implementation. But it isn't that way. So what is going on here? Any help is appreciated!

If you do that, you've negated the usefulness of programming to an interface instead of an implementation. This design would be far inferior to the other since it's programmed to a specific implementation. What you're seeing is Spring's @Autowire magic in action where it will find a class marked with @Component and inject it into something marked as @Autowired that takes an IProcessor implementation. It can be any IProcessor implementation and not a particular one. This creates a "seam" in your program where you can switch out the implementation with a different one, say for testing purposes, and the program should still work as expected.

Thanks much for the explanation. Really appreciate it. Follow-up question: What if there were two classes that implemented IProcessor though? How would Spring know which one to use?

Edit: It looks like this was already answered in Rob's post. Makes sense. Thanks.

[Dave Tolls]

If you have multiple  Components implementing the same interface just give them a name.
Spring uses the bean name to try and disambiguate.
Failing that you can use the @Qualifier annotation.

@Component("firstComponent")
public class FirstClass implements MyInterface {
}

@Component("secondComponent")
public class SecondClass implements MyInterface {
}


public MyService {

  @Autowired
  @Qualifier("firstClass")
  private MyInterface myInterface;
}

Without the @Qualifier annotation Spring would not know what to inject, however if the attribute in the service was called firstClass rather than myInterface then Spring would inject the bean that was called firstClass.