remplacer <constructor-arg> avec le Printemps Annotation

il y a un moyen de remplacer constructor-arg avec l'Annotation?

J'ai ce constructeur:

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

et j'ai besoin d'injecter dans mon Façade:

@Inject
private GenericDAO<Auto, Long> autoDao;

Le problème est que je ne sais pas comment faire pour transmettre la valeur du paramètre dans costructor.

Je vous remercie à l'avance

[Plus D'Info]
J'essaie d'expliquer mon problème.

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

Je veux convertir ce code en utilisant uniquement de l'annotation.
Quelqu'un peut expliquer comment?

OriginalL'auteur Roberto de Santis | 2011-01-06

4

Je pense que @Inject seul n'aide pas, vous devrez utiliser un @Qualifier annotation également.

Voici la Section pertinente du Printemps de Référence:

3.9.3 Fine-tuning annotation de base permettra à l'autowiring avec des qualificatifs

Si je comprends bien, vous aurez à utiliser la @Qualifier mécanisme.

Si vous utilisez Le printemps est @Qualificatif annotation, vous pouvez probablement le faire en ligne, quelque chose comme ceci:
```
@Repository
public class DaoImpl implements Dao{

    private final Class<?> type;

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

}
```
Mais si vous utilisez la JSR 330 @Qualificatif annotation, je suppose que vous aurez à créer vos propres annotations personnalisées qui est marqué avec @Qualifier.

Une autre possibilité serait la @ annotation. Avec elle, vous pouvez utiliser l'Expression de la Langue, par exemple comme ceci:
```
public DaoImpl(
    @Value("#{ systemProperties['dao.type'] }")
    final Class<?> type){
    this.type = type;
}
```
OriginalL'auteur Sean Patrick Floyd
2

Mise à jour: j'ai peur que cela n'est pas possible de faire ce que vous voulez. Vous ne pouvez pas obtenir des arguments du constructeur à partir des paramètres du point d'injection. Un FactoryBean serait le premier endroit à regarder, mais il n'est pas donné le point d'injection de métadonnées. (À noter: ce cas est facilement couvert par CDI)

Réponse originale à cette question: (qui peuvent encore fonctionner si vous configurez vos types de l'extérieur)

Simplement utiliser @Inject sur le constructeur. Mais notez que le printemps fronce les sourcils sur le constructeur d'injection. Envisager setter/champ d'injection.

Dans votre cas, cependant, vous êtes susceptible d'avoir plus d'un fèves de type Class. Si c'est le cas, vous pouvez utiliser @Resource(name="beanName").

À partir de la documentation de javax.injecter.Injecter:
Injectable constructeurs sont annotées avec @Inject et accepter zéro, une ou plusieurs dépendances comme arguments. @Inject peut s'appliquer à plus d'un constructeur pour la classe.
```
   @Inject ConstructorModifiersopt SimpleTypeName(FormalParameterListopt)  
   Throwsopt ConstructorBody
```
J'ai déjà utiliser @Inject, mais j'ai besoin de passer la valeur de la Classe<T> type de trop. Il y a un moyen de le faire? ou je dois utiliser une approche xml?
quelle est cette valeur? Où obtenez-vous?
privé GenericDAO<Auto, Long> autoDao; lorsque le GenericDAO était istantiated j'ai besoin de passer la valeur de la Classe<T> type de

OriginalL'auteur Bozho

Une option pour avoir le type de votre constructeur est:

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

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

mais DOIVENT posséder certaines implémentations différentes pour chaque T.

Avantage est que vous n'avez pas besoin de passer en T type de paramètre.

OriginalL'auteur danidacila

0

Du printemps Java Configuration peut-être ici d'une grande aide. Si vous créez une classe Java qui définit simplement vos haricots en utilisant les annotations @Configuration et @Bean il pourrait ressembler à quelque chose comme ceci:
```
@Configuration
public class DaoConfiguration {
    @Bean
    public GenericDAO<Person> personDao() {
        return new GenericDaoHibernateImpl(Person.class);
    }
}
```
Assurez-vous que le DaoConfiguration classe est numérisée (généralement par l'intermédiaire de @ComponentScan) et une bonne DAO-objet sera créé pour vous dans le Ressort du contexte. Le haricot aura le nom de la méthode qui dans ce cas est personDao de sorte que vous pouvez injecter par nom en utilisant le nom personDao ou par type si le type est GenericDAO<Person>.

OriginalL'auteur wassgren

Vous devez vous connecter pour publier un commentaire.