Préface
Dans le développement normal de Java, les programmeurs doivent s'appuyer sur d'autres classes dans une certaine classe, donc ils utilisent généralement des instances de classe new à une nouvelle classe, puis d'appeler les classes. Le problème avec ce développement est que new instances de classe ne sont pas faciles à gérer. Spring propose l'idée de l'injection de dépendance, c'est-à-dire que les classes de dépendance ne sont pas instanciées par les programmeurs, mais nous aident new des instances via des conteneurs de printemps et injecter des instances dans la classe qui a besoin de l'objet. Un autre terme pour l'injection de dépendance est «l'inversion de contrôle». La compréhension commune est la suivante: Habituellement, nous new une instance, et le contrôle de cette instance est notre programmeur, et l'inversion de contrôle signifie que le travail de la new instance n'est pas effectué par les programmeurs américains mais est remis au conteneur à ressort.
Il y a quatre façons d'injecter la dépendance au printemps
1. Définir l'injection (généralement également appelée injection d'attribut)
2. Injection de constructeur
3. Injection d'interface (ce n'est pas utilisé maintenant)
4. Injection d'annotation (@Autowire)
Vous trouverez ci-dessous un exemple de l'utilisation de l'injection de méthode définie, de l'injection de constructeur et de l'injection d'annotation.
1. Définir l'injection de méthode (injection d'attribut)
Userdao.java
classe publique UserDao {public void insertuser (utilisateur utilisateur) {// logique spécifique omise}}Userservice.java
Interface publique UserService {void Insertuger (utilisateur utilisateur);}UserServiceImpl.java
public class userServiceIMPl implémente userService {private userDao UserDao; public void SetUserDao (userdao userdao) {this.userdao = userdao; } public void insertUser (utilisateur utilisateur) {userdao.insert (utilisateur); }}Fichier de configuration de ressort
<? 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/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/wwwww. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd "> <! - omettez une configuration non liée à l'écriture de configuration -> <userdao"> </EAN> </pan Id = "uservice"> <propider) " ref = "userdao"> </bEAN> </bans>
Ce qui précède peut injecter UserDao dans UserServiceIMPl
2. Injection de constructeur
User.java
classe publique User {// pour simplicité, écrivez deux attributs de nom de chaîne privée; Âge entier privé; // omettez la méthode Getter / Setter sur le nom, l'âge public public (nom de chaîne, int age) {this.name = name; this.age = âge; }}Utilisez maintenant le fichier de configuration Spring pour injecter l'objet utilisateur
<? 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/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/wwwww. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd "> <! - omettez une écriture de configuration non liée -> <Bean Id =" User "> <! Paramètres) -> <constructor-arg type = "java.lang.string" index = "0" value = "zhangsan" /> <constructor-arg type = "java.lang.integer" index = "1" value = "20> </ beeb> </ beeans>
Ce qui précède peut injecter les valeurs de propriété dans l'objet utilisateur. Bien sûr, si vous souhaitez injecter l'exemple à l'aide de la méthode SET, c'est en fait la même chose. Il est nécessaire d'avoir un constructeur dans UserServiceImpl , et les paramètres formels sont userdao, il n'y a donc pas besoin d' setter .
Ensuite, l'écriture du fichier de configuration de ressort doit être modifiée pour cela
<? 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/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/wwwww. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd "> <! - omettez une écriture de configuration non liée -> <! Commence à partir de 0 (éviter plusieurs constructeurs ayant le même nombre de paramètres) -> <Constructor-arg index = "0" ref = "userdao"> </ank> </bans>
Cela peut également réaliser l'effet obtenu par l'injection de méthode d'ensemble ci-dessus
3. Injection d'annotation
Je n'ai jamais essayé s'il peut être @Autowire avec succès sans ajouter @Component,@Service,@Controller , etc. à ces classes. Cependant, il est recommandé d'ajouter des annotations correspondantes au niveau correspondant. Dans l'exemple suivant, UserDAO appartient à la couche modul. Au printemps, vous pouvez utiliser @Component Annotation.
Userdao.java
@ComponentPublic class userDao {public void insertuser (utilisateur utilisateur) {// logique spécifique omise}}Userservice.java
Interface publique UserService {void Insertuger (utilisateur utilisateur);}UserServiceImpl.java
// Présentation du package Spring correspondant @ServicePublic Class UserserServiceIMPL implémente UserService {@Autowire Private UserDao UserDao; public void insertuser (utilisateur utilisateur) {userdao.insert (utilisateur); }}Fichier de configuration correspondant de Spring
<? 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/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/www.springframe.org/schemama/Beans/wwwww. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd "> <! - omettez une écriture de configuration non liée -> <! - * signifie analyser tous les packages. Dans le développement réel, vous pouvez scanner en fonction des packages impliquant des composants d'annotation -> <contexte: Component-Scan Base-Package = "*"> <! - Allumez la numérisation des composants -> </ Context: Component-Scan> <Context: Annotation-Config> <Eband Id = "Userdao"> </ Beand> <ankE-Config> <Bean Id = "userdao"> </ Bean> <ank id = "userService" /> </ beans>
Cependant, au cours du processus de développement, l'injection de méthode de la méthode est activée et l'injection d'annotation est activée, Spring choisira d'abord l'injection de set, de sorte qu'il n'oublie pas de fournir la méthode d'ensemble correspondante, sinon elle échouera.
Grâce à la comparaison, l'injection d'annotation est beaucoup plus pratique que les autres injections, et moins de fichiers de code et de configuration sont écrits. Il est recommandé d'utiliser l'injection d'annotation pendant le processus de développement.
Résumer
Ce qui précède est une introduction complète à plusieurs méthodes d'injection de dépendance au printemps. J'espère que cela peut vous aider dans votre étude ou votre travail. Si vous avez des questions, vous pouvez également laisser un message à communiquer. Merci pour votre soutien à wulin.com.