Tout d'abord, pour apprendre à injecter des haricots au printemps, vous devez d'abord comprendre ce qu'est l'injection de dépendance. L'injection de dépendance fait référence à: Laissez la classe d'appel injecter la dépendance de la classe d'implémentation de la classe d'implémentation d'une certaine interface être injectée par un tiers pour éliminer la dépendance de la classe d'appel à la classe d'implémentation d'une certaine interface.
Les méthodes d'injection de dépendance soutenues dans les conteneurs à ressort incluent principalement l'injection de propriété, l'injection de constructeur et l'injection de méthode d'usine. Ensuite, nous présenterons ces trois méthodes d'injection de dépendance et leurs méthodes de configuration spécifiques en détail.
1. Injection d'attribut
Injection d'attribut signifie injecter la valeur d'attribut ou l'objet dépendant du bean via la méthode setxxx (). Étant donné que la méthode d'injection d'attribut est sélective et flexible, elle est également la méthode d'injection la plus couramment utilisée dans le développement réel.
Spring appellera d'abord le constructeur par défaut du bean pour instancier l'objet bean, puis appellera la méthode définie via la méthode réfléchie pour injecter la valeur de la propriété.
L'injection de propriété nécessite que le bean fournisse un constructeur par défaut et doit fournir une méthode définie pour les propriétés qui doivent être injectées.
Conseils: le constructeur soi-disant par défaut, c'est-à-dire un constructeur sans paramètres. S'il n'y a pas de constructeur personnalisé dans la classe, le système (JVM) générera automatiquement un constructeur par défaut sans paramètres. Si le constructeur avec paramètres est explicitement personnalisé dans la classe, le système ne générera pas automatiquement le constructeur par défaut et vous devez ajouter manuellement un constructeur sans paramètres.
Ce qui suit est un exemple pour démontrer la méthode d'injection de propriété des haricots au printemps:
Écrivez une classe d'utilisateurs:
package com.kevin.bean; / ** * Créer une méthode d'injection de propriété de bean de test de classe * @author kevin * * / public class utilisateur {private String username; public String getUserName () {return username; } public void setUsername (String username) {this.userName = username; }}Fichier de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! </fans>
Parmi eux, chaque valeur de propriété correspond à une balise de propriété et la valeur de propriété du nom est le nom de la propriété dans la classe. Dans la classe d'implémentation Bean, il a la méthode d'implémentation correspondante setUserName ().
Conseils: Spring ne vérifiera que si le haricot contient une méthode de setter et ne fait pas d'exigences spécifiques pour savoir s'il existe des variables d'attribut correspondantes. Cependant, selon les règles conventionnelles, nous devons définir les variables d'attribut correspondantes pour elle.
Spécifications de dénomination pour les balises <propriété> au printemps:
De manière générale, les noms de variables d'attribut Java commencent par des lettres minuscules, mais compte tenu de certaines abréviations anglaises avec des significations spéciales, les haricots Java permettent également aux noms de variables à partir de lettres majuscules. Mais les deux points suivants doivent être remplis:
Pour les méthodes d'injection d'attribut, les garanties ne peuvent être fournies que dans le fichier de configuration artificiellement, mais les garanties ne peuvent pas être fournies au niveau de la syntaxe. Pour le moment, vous devez utiliser l'injection de constructeur pour mieux répondre aux exigences.
2. Injection de constructeur
L'injection de constructeur est une autre méthode d'injection couramment utilisée en plus de l'injection d'attribut. Il peut garantir que certaines propriétés nécessaires sont définies lorsque les haricots sont instanciés et peuvent être utilisés après l'instanciation.
La condition préalable à l'utilisation d'injection de constructeur est que le haricot doit fournir un constructeur avec des arguments.
Pour l'injection de constructeur, les fichiers de configuration peuvent être utilisés de la manière suivante:
【Correspond à la méthode d'entrée des paramètres par type】
Écrivez le code du bean:
package com.kevin.bean; / ** * Écrivez le test de bean pour correspondre aux paramètres par type * @author kevin * * / public class Person {private String Name; Âge entier privé; public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public Integer Getage () {Return Age; } public void Setage (entier Âge) {this.age = age; }}Écrire des fichiers de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! - Constructeur de bean -> <! - CONFIGURATION Object -> <bean id =" Person "> <Constructor-arg Type =" String "> <Value> </ Constructor-arg> <constructor-arg type = "Integer"> <value> 20 </value> </ constructor-arg> </bans>
Les fichiers de configuration de Spring adoptent des stratégies de configuration indépendantes de l'ordre des étiquettes des éléments, de sorte que la certitude des informations de configuration peut être garantie dans une certaine mesure.
Ensuite, lorsque les paramètres de type multiple du constructeur dans un bean sont les mêmes, il est facile de provoquer la confusion en correspondant aux paramètres selon le type. À l'heure actuelle, une autre méthode est nécessaire: correspondant aux paramètres en fonction de l'index.
【Correspondant aux paramètres en fonction de l'index】
Écrivez le code du bean:
package com.kevin.bean; / ** * Écrivez des tests et des paramètres de bean dans la méthode d'index * @author kevin * * / classe publique Student {Nom de chaîne privée; Gender de chaîne privée; double score privé; Étudiant public (nom de chaîne, genre de chaîne, double score) {super (); this.name = name; this.gender = genre; this.score = score; }}Le fichier de configuration est écrit comme suit:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! Value = "Kevin"> </ Constructor-Arg> <Constructor-Arg index = "1" value = "male"> </ constructor-arg> <constructor-arg index = "2" value = "66"> </ constructor-arg> </ank> </bans>
CONSEILS: Pendant l'injection de propriété, Spring détermine l'attribut de configuration et la méthode du secteur correspondant en fonction des spécifications du bean Java et utilise le mécanisme de réflexion Java pour appeler la méthode du secteur de l'attribut pour compléter l'injection de propriété. Cependant, le mécanisme de réflexion Java ne se souvient pas du nom du paramètre du constructeur, nous ne pouvons donc pas configurer le constructeur en formulant le nom du paramètre du constructeur, afin que nous ne puissions qu'indirectement l'injection de propriété du constructeur via le type de paramètre et l'index.
【Paramètres combinés de type d'utilisation et d'index】
Dans certains fichiers de configuration complexes, le type et l'index doivent être utilisés simultanément pour terminer l'injection de paramètre du constructeur. Voici un exemple à démontrer.
Écrivez des haricots:
package com.kevin.bean; / ** * Écrivez des tests de bean pour utiliser les paramètres de type et indexer les paramètres * @author kevin * * / classe publique professeur {nom de chaîne privé; adresse de chaîne privée; Salaire double privé; Âge privé; professeur public (nom de chaîne, adresse de chaîne, double salaire) {super (); this.name = name; this.address = adresse; this.salary = salaire; } Public Teacher (nom de chaîne, adresse de chaîne, int age) {super (); this.name = name; this.address = adresse; this.age = âge; }}Dans cette classe, il y a deux constructeurs surchargés et ils ont tous trois paramètres. Dans ce cas, l'utilisation des méthodes de type et d'index ne peut pas compléter les exigences. À l'heure actuelle, leurs deux propriétés doivent être utilisées en même temps.
Fichier de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! - Constructor-arg index =" 0 "Type =" STRING "> <value> kevin </value> </ constructor-arg> <constructor-arg index = "1" type = "string"> <value> China </value> </ constructor-arg> <constructor-arg index = "2" type = "int"> <value> 20 </value> </ Constructor-arg> </ean> </bEANS>
Vous pouvez voir que l'accent est réellement mis sur le type du troisième paramètre, nous spécifions donc l'index et le type dans le fichier de configuration, afin que Spring puisse savoir quel constructeur injecter le paramètre.
Conseils: Ajouter à notre fichier de configuration, il y a un problème d'ambiguïté. Le conteneur à ressort peut être démarré normalement et ne rapportera pas d'erreur. Il utilisera au hasard un constructeur assorti pour instancier le haricot. Le constructeur sélectionné au hasard peut ne pas être nécessaire par l'utilisateur, nous devons donc veiller à éviter cette ambiguïté lors de la programmation.
【Correspond aux paramètres via sa propre réflexion de type】
Si le type de paramètre de constructeur de bean est discernable, car le mécanisme de réflexion Java peut obtenir le type de paramètre du constructeur, même si l'injection du constructeur ne fournit pas d'informations de type et d'index, le ressort peut toujours compléter l'injection d'informations du constructeur. Par exemple, dans l'exemple suivant, le type de paramètre du constructeur de la classe Manager peut être distingué.
Écrivez la classe Manager:
package com.kevin.bean; / ** * Écrivez un test de bean pour faire correspondre les arguments via sa propre réflexion de type * @author kevin * * / gestionnaire de classe publique {nom de chaîne privé; Salaire double privé; personne privée; Gestionnaire public (nom de chaîne, double salaire, personne personne) {super (); this.name = name; this.salary = salaire; this.person = personne; }}Écrire des fichiers de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/Context/spring-context.xsd "> <! <constructor-arg> <ref bean = "user" /> </ constructor-arg> <constructor-arg> <ref bean = "personne" /> </ constructor-arg> </bans>
Les méthodes ci-dessus peuvent implémenter l'injection de paramètres du constructeur, mais afin d'éviter la survenue de problèmes, il est recommandé d'utiliser un index et un type explicites pour configurer les informations de saisie des paramètres du constructeur.
3. Injection de méthode d'usine
La méthode d'usine est un modèle de conception qui est souvent utilisé dans les applications et qui est également la principale méthode d'implémentation de l'idée d'inversion de contrôle et de conception à instance unique. La classe d'usine est chargée de créer une ou plusieurs instances de classe d'usine. La méthode de classe d'usine renvoie généralement l'instance de classe cible sous la forme d'une interface ou d'une variable de classe abstraite.
La classe d'usine bloque les étapes d'instanciation de la classe cible à l'extérieur, et l'appelant n'a même pas à spécifier la classe cible spécifique. Parce que les conteneurs de printemps fournissent la fonctionnalité des méthodes d'usine dans les méthodes de cadre et sont ouvertes aux développeurs de manière transparente. Par conséquent, il est rarement nécessaire d'écrire des méthodes d'ingénierie manuellement. Cependant, les méthodes d'ingénierie seront toujours rencontrées dans certains systèmes hérités ou bibliothèque tiers. À l'heure actuelle, la méthode d'injection d'usine de printemps peut être utilisée pour injecter le ressort.
Les méthodes d'injection d'usine de printemps peuvent être divisées en statique et non statique.
【Méthode d'usine non statique】
Certaines méthodes d'usine sont non statiques et doivent être instanciées avant que les méthodes d'usine puissent être appelées. Ce qui suit est un exemple à démontrer.
Écrivez une classe d'usine:
package com.kevin.factoryBean; / ** * Écrire des tests de classe d'usine Injection de méthode d'usine non statique * @Author Kevin * * / classe publique BookFactory {public book bachebook () {book book = new book (); book.setName ("Think in Java"); livre de retour; }}Écriture de fichiers de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/Contex Factory-Method = "Buybook"> </bEAN> </EANS>
Étant donné que la méthode d'usine de BookFactory n'est pas statique, vous devez d'abord définir un haricot de la classe d'usine, puis vous référer à l'instance de haricot d'usine via la propriété en usine. Ensuite, la méthode d'usine correspondante est utilisée pour spécifier la méthode d'usine correspondante.
【Méthode d'usine statique】
De nombreuses méthodes de classe d'usine sont statiques, ce qui signifie que les méthodes de classe d'usine peuvent être appelées sans créer des instances de classe d'usine. Par conséquent, les méthodes d'ingénierie statique sont plus pratiques et concises que les méthodes d'usine non statiques. Ce qui suit est un exemple pour démontrer la méthode d'usine statique.
Écrivez une classe d'usine:
package com.kevin.factoryBean; / ** * Écriture de la classe d'usine Test de méthode d'usine statique injection * @author kevin * * / public class carfactory {public static car createCar () {Car Car = new Car (); car.setbrand ("Lamborghini"); voiture de retour; }}Écrire des fichiers de configuration:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! - Définitions bean ici -> <! - Objet de configuration -> <bean id =" car "factory-method =" CreateCar "> </ beebr
Résumer
Spring fournit trois méthodes d'injection facultatives, mais dans les applications réelles, il n'y a pas de norme unifiée pour laquelle nous devons choisir. Voici quelques raisons de se référer à:
Raison de l'injection de constructeur:
Propriétés Raison d'injection:
En fait, le printemps nous fournit autant de méthodes pour injecter des paramètres, ces méthodes doivent donc avoir leurs propres raisons. Chaque méthode présente des avantages uniques dans un certain numéro. Nous n'avons qu'à choisir la méthode appropriée en fonction de nos besoins d'utilisation spécifiques, mais l'injection de méthode d'usine n'est généralement pas recommandée.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.