sostituire <constructor-arg> con Spring Annotation

Question

c'è un modo per sostituire il costruttore-arg con Annotation?

ho questo costruttore:

public GenericDAOImpl(Class<T> type) { 
    this.type = type; 
} 

e ho bisogno di iniettare che nel mio Facciata:

@Inject 
private GenericDAO<Auto, Long> autoDao; 

Il problema è che non so come passare il valore del parametro in costructor.

Grazie in anticipo

[Altre informazioni] cerco di spiegare il mio problema.

<bean id="personDao" class="genericdao.impl.GenericDaoHibernateImpl"> 
     <constructor-arg> 
      <value>genericdaotest.domain.Person</value> 
     </constructor-arg> 
</bean> 

Voglio convertire quel codice usando solo annotazioni. Qualcuno può spiegare come?

Answer 1

Aggiornamento: Ho paura che non sia possibile fare ciò che si sta tentando di fare. Non è possibile ottenere argomenti del costruttore dai parametri del punto di iniezione. A FactoryBean sarebbe il primo posto da cercare, ma non viene fornito il metadata del punto di iniezione. (Da notare: questo caso è facilmente coperto da CDI)

risposta originale: (che può ancora funzionare se si configurano le tipologie esternamente)

Basta utilizzare @Inject sul costruttore. Ma nota che la primavera aggrotta le sopracciglia sull'iniezione del costruttore. Prendi in considerazione setter/field injection.

Nel tuo caso, tuttavia, è probabile che tu abbia più di un bean di tipo Class. Se questo è il caso, è possibile utilizzare @Resource(name="beanName").

Dalla documentazione di javax.inject.Inject:

costruttori iniettabili sono annotati con @Inject e di accettare zero o più dipendenze come argomenti. @Inject può essere applicato a un massimo di un costruttore per classe.

@Inject ConstructorModifiersopt SimpleTypeName(FormalParameterListopt) 
    Throwsopt ConstructorBody 

Answer 2

penso @Inject solo non aiuta, si dovrà utilizzare un'annotazione @Qualifier anche.

Ecco la sezione dedicata del Primavera Riferimento:
3.9.3 Fine-tuning annotation-based autowiring with qualifiers

Se ho capito bene, si dovrà utilizzare il meccanismo @Qualifier.

Se si utilizza Spring's @Qualifier annotation, probabilmente si può farlo in linea, qualcosa di simile:

@Repository 
public class DaoImpl implements Dao{ 

    private final Class<?> type; 

    public DaoImpl(@Qualifier("type") final Class<?> type){ 
     this.type = type; 
    } 

} 

Ma se si utilizza il JSR-330 @Qualifier annotation, credo che si dovrà creare il proprio annotazioni personalizzate che è contrassegnato con @Qualifier .

---

Un'altra possibilità potrebbe essere l'annotazione @Value. Con esso puoi usare Expression Language, ad es. in questo modo:

public DaoImpl(
    @Value("#{ systemProperties['dao.type'] }") 
    final Class<?> type){ 
    this.type = type; 
} 

Answer 3

un'opzione per avere il tipo nel costruttore è:

public abstract class GenericDAO<T> { 
    private Class<T> persistentClass; 

    public GenericDAO() { 
     this.persistentClass = (Class<T>) ((ParameterizedType) getClass() 
      .getGenericSuperclass()).getActualTypeArguments()[0]; 
    } 
... 
} 

ma deve avere specifiche implementazioni diverse per ogni T.

vantaggio è che non è necessario per passare il tipo T come parametro.

Answer 4

Spring Java Configuration potrebbe essere di aiuto qui. Se si crea una classe Java che definisce semplicemente i vostri fagioli utilizzando le annotazioni @Configuration e @Bean che potrebbe essere simile a questa:

@Configuration 
public class DaoConfiguration { 
    @Bean 
    public GenericDAO<Person> personDao() { 
     return new GenericDaoHibernateImpl(Person.class); 
    } 
} 

Assicurarsi che la classe DaoConfiguration viene sottoposto a scansione (in genere tramite @ComponentScan) e una corretta DAO-oggetto sarà creato per te nel contesto Spring. Il fagiolo avrà il nome del metodo, che in questo caso è personDao in modo da poter iniettare per nome utilizzando il nome personDao o per tipo se il tipo è GenericDAO<Person>.