¿Cómo Autowire Bean de tipo genérico <T> en Spring?

Tengo un bean Item<T>que debe estar conectado automáticamente en una @Configurationclase.

@Configuration
public class AppConfig {

    @Bean
    public Item<String> stringItem() {
        return new StringItem();
    }

    @Bean
    public Item<Integer> integerItem() {
        return new IntegerItem();
    }

}

Pero cuando lo intento @Autowire Item<String>, obtengo la siguiente excepción.

"No qualifying bean of type [Item] is defined: expected single matching bean but found 2: stringItem, integerItem"

¿Cómo debo Autowire tipo genérico Item<T>en Spring?

La solución simple es actualizar a Spring 4.0, ya que considerará automáticamente los genéricos como una forma de @Qualifier, como se muestra a continuación:

@Autowired
private Item<String> strItem; // Injects the stringItem bean

@Autowired
private Item<Integer> intItem; // Injects the integerItem bean

De hecho, incluso puede conectar automáticamente los genéricos anidados al inyectar en una lista, como se muestra a continuación:

// Inject all Item beans as long as they have an <Integer> generic
// Item<String> beans will not appear in this list
@Autowired
private List<Item<Integer>> intItems;

¿Cómo funciona esto?

La nueva ResolvableTypeclase proporciona la lógica de trabajar realmente con tipos genéricos. Puede usarlo usted mismo para navegar y resolver fácilmente la información de tipo. La mayoría de los métodos en ResolvableTypeellos mismos devolverán un ResolvableType, por ejemplo:

// Assuming 'field' refers to 'intItems' above
ResolvableType t1 = ResolvableType.forField(field); // List<Item<Integer>> 
ResolvableType t2 = t1.getGeneric(); // Item<Integer>
ResolvableType t3 = t2.getGeneric(); // Integer
Class<?> c = t3.resolve(); // Integer.class

// or more succinctly
Class<?> c = ResolvableType.forField(field).resolveGeneric(0, 0);

Consulte los ejemplos y tutoriales en los siguientes enlaces.

• Spring Framework 4.0 y Java Generics
• Spring y Autowiring de tipos genéricos

Espero que esto te ayude.

Si no desea actualizar a Spring 4, debe realizar el autowire por nombre como se muestra a continuación:

@Autowired
@Qualifier("stringItem")
private Item<String> strItem; // Injects the stringItem bean

@Autowired
@Qualifier("integerItem")
private Item<Integer> intItem; // Injects the integerItem bean

A continuación se muestra una solución que hice para responder a esta pregunta:

        List<String> listItem= new ArrayList<>();

        ResolvableType resolvableType = ResolvableType.forClassWithGenerics(List.class, String.class);
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setTargetType(resolvableType);
        beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        beanDefinition.setAutowireCandidate(true);

        DefaultListableBeanFactory bf = (DefaultListableBeanFactory) configurableWebApplicationContext.getBeanFactory();

        bf.registerBeanDefinition("your bean name", beanDefinition);
        bf.registerSingleton("your bean name", listItem);

La estrategia Spring Autowired se define en su archivo de configuración (application.xml).

si no lo ha definido, el valor predeterminado es por Tipo, la inyección de resorte usa el mecanismo de reflexión JDK.

entonces List? String? y List? Item ?, el tipo es el mismo List.class, por lo que Spring confundió cómo inyectar.

y como la respuesta de las personas anteriores, debe apuntar a @Qualifier para decirle a Spring qué bean debe inyectarse.

Me gusta el archivo de configuración de primavera para definir el frijol en lugar de la Anotación.

<bean>
 <property name="stringItem">
        <list>
              <....>
        </list>
 </property>

Spring 4.0 es la respuesta con el uso de la anotación @Qualifier. Espero que esto ayude

Creo que no tiene nada que ver con los genéricos ... Si está inyectando dos beans diferentes del mismo tipo, debe proporcionar un calificador para ayudar a Spring a identificarlos;

... En otro lugar

@Configuration
@Bean
public Item stringItem() {
    return new StringItem();
}

@Bean
public Item integerItem() {
    return new IntegerItem();
}

Si tiene declaraciones no genéricas como estas, debe agregar un calificador para ayudar a Spring a identificarlas ...

@Autowired
**@Qualifier("stringItem")**
private Item item1;

@Autowired
**@Qualifier("integerItem")**
private Item item2;

Por supuesto, en las versiones 4 y superiores, Spring considera los tipos genéricos a través de los resolutores, lo cual es muy bueno ...