Explication détaillée de la façon de mettre en œuvre le cadre d'injection de dépendance pour 200 lignes de code Java

Introduction de l'injection de dépendance

Prenons d'abord le concept d'injection de dépendance:

L'injection de dépendance et l'inversion du contrôle, que nous mentionnons souvent sont le même concept. La signification spécifique est: lorsqu'un rôle (peut-être une instance Java, appelant) a besoin de l'aide d'un autre rôle (une autre instance Java, appelant), dans le processus de programmation traditionnel, l'appelant est généralement créé par l'appelant. Mais au printemps, le travail de création de la Callee n'est plus effectué par l'appelant, il est donc appelé l'inversion de contrôle; Le travail de création de l'instance Callee est généralement effectué par le conteneur à ressort puis injecté dans l'appelant, il est donc également appelé injection de dépendance.

En fait, en termes simples, le rôle de l'injection de dépendance est de découpler les dépendances entre les objets du code d'origine et d'ajouter le traitement du framework Spring pour nous permettre de gérer les dépendances de manière flexible et centrale.

Cadre d'injection de dépendance

Le cadre d'injection de dépendance n'est pas mystérieux, c'est en fait une chose très simple. Ne regardez pas le code source d'injection de dépendance du printemps, car tant que vous allez, cela signifie que vous n'écrirez plus jamais et que vous n'oserez pas commencer par vous-même. Sa fonction est trop puissante, donc la conception est trop compliquée. Les programmeurs ordinaires ne peuvent que soupirer à la vue.

Je n'ai pas lu attentivement le code source Spring. Malgré cela, il n'a fallu qu'une demi-journée pour appliquer un petit cadre Iockids qui répond essentiellement à la norme d'injection de dépendance standard "JSR-330". Ce petit cadre n'a qu'un seul injecteur de classe principale, avec environ 200 lignes de code, et il a les fonctions suivantes.

1. Injection singleton / non-singleton
2. Injection de constructeur
3. Injection de terrain
4. Injection de dépendance circulaire
5. Injection de qualification

Regardons un exemple légèrement plus compliqué d'utilisation

 import javax.inject.inject; import javax.inject.named; import javax.inject.singleton; import iockids.injector; @singletonclass root {@inject @named ("a") nœud a; @Inject @Named ("B") Node B; @Override public String toString () {return String.format ("root (% s,% s)", a.name (), b.name ()); }} Interface Node {String Name ();} @ Singleton @ NAGME ("A") La classe NODEA implémente Node {@Inject Leaf Leaf; @Inject @Named ("B") Node B; @Override public String name () {if (b == null) return string.format ("nodea (% s)", leaf); else return String.format ("NodeAwithB (% s)", leaf); }} @ Singleton @ nommé ("B") La classe NodeB implémente le nœud {Leaf Leaf; @Inject @Named ("A") Node A; @Inject Public NodeB (feuille de feuille) {this.leaf = leaf; } @Override public String name () {if (a == null) return String.format ("nodeB (% s)", leaf); else return string.format ("nodeBWitha (% s)", leaf); }} classade leaf {@inject root root; INT INDEX; séquence int statique; Public Leaf () {index = Sequence ++; } public String toString () {if (root == null) return "leaf" + index; else return "leafwithroot" + index; }} public class Demo {public static void main (String [] args) {var injector = new Injector (); inject inject var root = injecteur.getInstance (root.class); System.out.println (root); }}

Le code ci-dessus utilise toutes les fonctions fournies par Iockids.

1. La classe root / novea / nodeb est une classe singleton
2. La classe de feuilles est une classe non singlear
3. Ils utilisent tous l'injection de champ
4. Nodeb utilise l'injection de constructeur
5. Nodea et NodeB utilisent également l'injection de nom de qualification
6. Il y a des champs de type racine dans la classe des feuilles, qui est une dépendance circulaire
7. Il y a un champ NodeB dans Nodea et Nodea Field dans NodeB, qui est également une dépendance circulaire

Pour faciliter la compréhension du code ci-dessus, j'ai dessiné un diagramme de dépendance

La sortie de code ci-dessus est la suivante

 Root (NodeAwithB (Leafwithroot0), NodeBWitha (Leafwithroot1))

De cette sortie, nous pouvons également imaginer à peu près la structure de dépendance.

Iockids fournit des rapports d'exception d'erreur d'injection riche pour empêcher les erreurs de configuration d'injection des utilisateurs.

Par exemple, si nous configurons les noms de Nodea et NodeB ci-dessus au même A, la pile d'erreur ci-dessous sera exposée.

 iockids.injectException: Javax.inject.inject.in à la duplication avec la même classe iockids.demo.node à iockids.injector.registerqualifiedClass (injector.java:87) à iockids.injector.registerqualifiedClass (injector.java:70) at à attitude iockids.demo.demo.main (Demo.java:106)

Si nous ajoutons un paramètre au constructeur de nodeb à volonté

 @Inject Public NodeB (feuille de feuille, int k) {this.leaf = leaf; }

L'erreur suivante sera lancée lors de l'exécution

 iockids.injectexception: pas de constructeur accessible pour la classe d'injection int à iockids.injector.createew (inject iockids.injector.createfromConstructor (inject iockids.injector.injectmembers (injector.java:233) sur iockids.injector.createnew (inject iockids.injector.injectmembers (injector.java:233) sur iockids.injector.createnew (injector.java:136) sur iockids.injector.createw (inject.java:94) sur iockids.injector.gerenew (injecteur iockids.demo.demo.main (Demo.java:107)

Adresse open source du projet: https://github.com/pyloque/iockids (téléchargement local)

Résumer

Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.