Discussion :

[verbose]

Bonjour,

J'ai récemment eu l'occasion d'utiliser l'injection de dépendance, je trouve cela pratique et ça permet d'écrire un code propre avec séparation des couches.

Mais un détail m'a chiffonné. Il peut arriver des cas de figure où on a besoin d'effectuer des opérations dans le constructeur. Or, dans l'état actuel de l'api standard, il n'est pas possible d'injecter les dépendances avant l'appel du constructeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
public class Exemple {
    @Inject
    private Dependance dependance;
 
    public Exemple() {
        // Ici la dépendance n'est pas encore injectée
    }
}

Pour contourner cette limitation, il est possible d'annoter un constructeur avec @Inject, et ce sont les paramètres du constructeur qui sont injectés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
public class Exemple {
    private Dependance dependance;
 
    @Inject
    public Exemple(Dependance dependance) {
        this.dependance = dependance;
        // Ici la dépendance est injectée
    }
}

C'est peut-être une question de goût, mais je trouve que cette pirouette n'est pas très élégante. En plus, j'ai déjà eu l'occasion de tomber sur des cas de figures où une classe possède de nombreuses dépendances, et on se retrouve avec un constructeur avec quatre ou cinq arguments, ça commence à faire beaucoup.

L'idée que je souhaite soumettre à discussion est celle-ci :

Serait-il possible que la classe java.lang.Class soit modifiée (dans le cadre d'une JSR) pour fournir un meta-objet, c'est-à-dire un objet non encore initialisé ?

Ce que je souhaiterais, c'est que les frameworks d'injection de dépendance puissent utiliser l'api standard pour injecter les dépendances avant l'appel du constructeur. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
MetaObject<Exemple> meta = java.lang.Class.getMetaObject(Exemple.class);
meta.set("dependance", new Dependance()); // Injecte la dépendance
Exemple object = meta.init(); // Appel le constructeur

Je ne connais pas bien le mécanisme de construction des objets. Je sais seulement qu'il se déroule en plusieurs étapes, et que, en théorie, rien n'empêche de décomposer ces étapes. Je voudrais votre avis là-dessus. Pour ceux qui sont motivés, peut-être pourrions-nous même collaborer pour soumettre une requête au JCP. Je ne connais pas bien non plus les procédures du JCP ni comment il est possible d'y participer. Je suis ouvert à toutes les bonnes volontés.

[tchize_]

Spring propose deux solutions propres à ta questions (en plus de l'injection par paramètres)

1) utiliser une méthode de post-init. Ce qui me semble être le plus propre:
a) on instancie l'objet
b) on l'injecte
c) on l'initialise
d) il est prêt à servir

2) injecter dans le parent. Cela consiste à injecter entre le retour de l'appel à super() et la fin du constructeur fils. Ca nécessite que toutes les propriétés injectées soient définies dans le parent. Je trouve cette deuxième solution beaucoup plus pirouettesque et je trouve que la 1 est la plus propre en termes de POO.
a) on appelle super()
b) on injecte
c) on termine le constructeur
d) il est prêt à servir


Pour moi ce que vous proposez est une mauvaise idée car les étapes que vous suggérez vont à l'encontre de la manière dont sont construits les objets par la JVM. Les différentes étapes sont
1) reservation de l'espace mémoire
2) constructeur Objet
2* on descend dans tous les constructeurs
Si vous vous insérer entre 1 et 2, le constructeur java aura vite fait d'effacer toute injections que vous faites (tous les champs sont systématiquement initialisés à leur valeur par défaut par le constructeur).


edit: la JSR299 utilise @PostConstruct pour votre problème.

[verbose]

Je ne connaissais pas @PostConstruct, mais c'est une bonne solution à mes yeux