Autowire Generic Type Spring 4.1.7

Question

I'm working in Spring version greater than 4. I've got beans with the same super-class configured using @Configuration

@Configuration
public Class ConfigClass{

  @Bean
  public Apple apple(){stuff to return apple bean}

  @Bean
  public Orange orange(){stuff to return orange bean}

}

I've got an bean which maybe composed of either one of those two beans

@Component
public Class FruitEater<ReturnType extends Fruit>{

  @Bean
  ReturnType fruit;

}

And I get this beautiful ambiguity error message:

No qualifying bean of type [fruit] is defined: expected single matching bean but found 2: appleInjection,orangeInjection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: fruiteater.bean; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [fruit] is defined: expected single matching bean but found 2: apple,orange

My thinking is that since the ReturnType should be resolved at compile-time, spring should be able to Autowire based on the Generic Type. I've heard of the Spring's ResolvableType but I'm not sure how I can leverage that as I'm still pretty new to Spring. Is there a way to resolve this and keep my FruitEater a generic FruitEater?

Thanks, in advance.

Answer 1

You've declared a singleton (default) FruitEater bean. Singleton beans are (YMMV) eagerly initialized.

In your case, Spring sees a bean definition for the type FruitEater, but that's it. There's no parameterization (argument for ReturnType), there's no hint for what should be injected into fruit. There's no way for it to pick between the two Apple and Orange beans.

Presumably, if, instead of a singleton, you had declared FruitEater with a prototype scope (or something similar) and had injection targets like

@Autowired
private FruitEater<Apple> fruitEater;

the bean to be injected would be created at injection time and there would be enough type information to create it and inject its field, ie. an Apple bean in this example.

This isn't currently supported.

One solution is to remove the FruitEater bean declaration (the @Component) and instead provide appropriate parameterized subtypes

@Component
class OrangeEater extends FruitEater<Orange> {
}

class FruitEater<ReturnType extends Fruit> {
    @Autowired
    protected ReturnType fruit;
}

Spring is now smart enough, with the type information provided in the extends clause, to create the OrangeEater bean and inject an Orange in its fruit field.

Complete example

public class Sample {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigClass.class);
        System.out.println(ctx.getBean(Injected.class).orangerEater);
        System.out.println(ctx.getBean(Injected.class).appleEater);
    }

    @Component
    static class Injected {
        @Autowired
        FruitEater<Orange> orangerEater;

        @Autowired
        FruitEater<Apple> appleEater;
    }
}

@Configuration
@ComponentScan
class ConfigClass {

    @Bean
    public Apple apple() {
        return new Apple();
    }

    @Bean
    public Orange orange() {
        return new Orange();
    }
}

class Fruit {
}

class Apple extends Fruit {
}

class Orange extends Fruit {
}

@Component
class AppleEater extends FruitEater<Apple> {
}

@Component
class OrangeEater extends FruitEater<Orange> {
}

class FruitEater<ReturnType extends Fruit> {
    @Autowired
    protected ReturnType fruit;
}

Alternatively, ditch the component scanning. Use constructor injection.

public FruitEater(ReturnType fruit) {
    this.fruit = fruit;
}

then declare the beans explicitly

@Bean
public FruitEater<Apple> appleEater() {
    return new FruitEater(apple());
}