Explication détaillée de plusieurs méthodes d'injection de dépendances dans Java Spring

Cet article présente principalement en détail plusieurs méthodes d'injection de dépendances Spring. L'éditeur pense que c'est assez bon, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur pour y jeter un œil

Introduction à IoC

Dans le développement Java ordinaire, les programmeurs doivent s'appuyer sur les méthodes d'autres classes d'une certaine classe.

Habituellement, new est une méthode consistant à s'appuyer sur une classe puis à appeler une instance de classe. Le problème avec ce type de développement est que les nouvelles instances de classe ne sont pas faciles à gérer de manière uniforme.

Spring a proposé l'idée de l'injection de dépendances, c'est-à-dire que les classes dépendantes ne sont pas instanciées par les programmeurs, mais le conteneur Spring nous aide à spécifier de nouvelles instances et à injecter les instances dans les classes qui nécessitent l'objet.

Un autre terme pour l'injection de dépendances est « inversion de contrôle ». L'interprétation populaire est la suivante : nous créons généralement une nouvelle instance et le contrôle de cette instance est notre programmeur.

L'inversion de contrôle signifie que le travail sur la nouvelle instance n'est pas effectué par nos programmeurs mais est confié au conteneur Spring.

Spring propose de nombreuses formes d'injection de dépendances. Cet article présente uniquement comment Spring effectue la configuration IOC via XML.

1.Set injection

Il s'agit de la méthode d'injection la plus simple. Supposons qu'il existe un SpringAction et qu'un objet SpringDao doit être instancié dans la classe, vous pouvez alors le définir. une variable membre SpringDao privée, puis créez la méthode set SpringDao (c'est l'entrée d'injection d'ioc) :

Ensuite, écrivez le fichier Spring XML, l'attribut name dans et l'attribut class Fait référence au nom complet de la classe. Comme il existe une propriété publique Springdao dans SpringAction, une balise doit être créée dans la balise Le nom dans la balise est le nom de la propriété SpringDao dans la classe SpringAction, et la référence fait référence au suivant. De cette façon, spring instancie réellement l'objet SpringDaoImpl. et appelle la méthode setSpringDao de SpringAction à l'injection SpringDao :

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(1)依赖注入,配置当前类中相应的属性--> 
<property name="springDao" ref="springDao"></property> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

2. Injection de constructeur

Cette méthode de moyens d'injection avec injection de paramètres par le constructeur, voir l'exemple ci-dessous. J'ai créé deux variables membres SpringDao et User, mais je n'ai pas défini la méthode set de l'objet, donc la première méthode d'injection ne peut pas être prise en charge. Constructeur SpringAction. Injection dans la fonction, c'est-à-dire que lors de la création d'un objet SpringAction, les deux valeurs des paramètres​​de SpringDao et User doivent être transmises :

public class SpringAction { 
//注入对象springDao 
private SpringDao springDao; 
private User user; 

public SpringAction(SpringDao springDao,User user){ 
this.springDao = springDao; 
this.user = user; 
System.out.println("构造方法调用springDao和user"); 
} 

public void save(){ 
user.setName("卡卡"); 
springDao.save(user); 
} 
}

Idem dans le fichier XML Au lieu d'utiliser le formulaire , utilisez la balise L'attribut ref pointe également vers l'attribut name d'autres balises 🎜>

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置--> 
<constructor-arg ref="springDao"></constructor-arg> 
<constructor-arg ref="user"></constructor-arg> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean> 
<bean name="user" class="com.bless.springdemo.vo.User"></bean>

Pour résoudre l'incertitude des paramètres du constructeur, vous constaterez peut-être que les deux paramètres transmis par le constructeur sont du même type afin de distinguer. auquel on doit attribuer la valeur correspondante, vous devez effectuer un petit traitement :

Ce qui suit consiste à définir l'index, qui est la position du paramètre :

<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<constructor-arg index="0" ref="springDao"></constructor-arg> 
<constructor-arg index="1" ref="user"></constructor-arg> 
</bean>

L'autre consiste à définir le type de paramètre :

<constructor-arg type="java.lang.String" ref=""/>

3.

Comme son nom l'indique, la fabrique statique consiste à obtenir les objets dont vous avez besoin en appelant la méthode de la fabrique statique, pour que Spring puisse gérer tous les objets, nous ne pouvons pas obtenir les objets directement via la "classe d'ingénierie". . Méthode statique ()", mais obtenez-les toujours par injection de ressort :

package com.bless.springdemo.factory; 

import com.bless.springdemo.dao.FactoryDao; 
import com.bless.springdemo.dao.impl.FactoryDaoImpl; 
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl; 

public class DaoFactory { 
//静态工厂 
public static final FactoryDao getStaticFactoryDaoImpl(){ 
return new StaticFacotryDaoImpl(); 
} 
}

Regardez également la classe clé. Ici, je dois injecter un Objet FactoryDao. Il ressemble exactement à la première injection, mais si vous regardez le XML suivant, vous trouverez une grande différence :

public class SpringAction { 
//注入对象 
private FactoryDao staticFactoryDao; 

public void staticFactoryOk(){ 
staticFactoryDao.saveFactory(); 
} 
//注入对象的set方法 
public void setStaticFactoryDao(FactoryDao staticFactoryDao) { 
this.staticFactoryDao = staticFactoryDao; 
} 
}

Le fichier de configuration IOC de Spring, faites attention à la classe pointée par n'est pas la classe d'implémentation de FactoryDao, mais pointe vers la fabrique statique DaoFactory et configurez la fabrique -method="getStaticFactoryDaoImpl" spécifie laquelle méthode d'usine à appeler :

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction" > 
<!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)--> 
<property name="staticFactoryDao" ref="staticFactoryDao"></property> 
</property> 
</bean> 
<!--(3)此处获取对象的方式是从工厂类中获取静态方法--> 
<bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>

4. Injection de méthode d'usine d'instance

Usine d'instance signifie que l'usine d'instance signifie que La méthode d'obtention d'une instance d'objet n'est pas statique, vous devez donc d'abord créer une nouvelle classe d'usine, puis appeler la méthode d'instance ordinaire :

public class DaoFactory { 
//实例工厂 
public FactoryDao getFactoryDaoImpl(){ 
return new FactoryDaoImpl(); 
} 
}

Ensuite il n'y a rien à dire sur la classe suivante, qui est très similaire à la précédente, mais il faut créer des objets FactoryDao via la classe instance factory :

public class SpringAction { 
//注入对象 
private FactoryDao factoryDao; 

public void factoryOk(){ 
factoryDao.saveFactory(); 
} 

public void setFactoryDao(FactoryDao factoryDao) { 
this.factoryDao = factoryDao; 
} 
}

Dernier fichier de configuration Spring :

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)--> 
<property name="factoryDao" ref="factoryDao"></property> 
</bean> 

<!--(4)此处获取对象的方式是从工厂类中获取实例方法--> 
<bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean> 
<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>

Résumé

Spring La méthode d'injection IOC est la plus utilisée. C'est (1)(2). Si vous écrivez davantage et pratiquez davantage, vous deviendrez très compétent.

Notez également : les objets créés via Spring sont des singletons par défaut. Si vous devez créer plusieurs objets d'instance, vous pouvez ajouter un attribut après la balise  :

<. 🎜>

<bean name="..." class="..." scope="prototype">

Ce qui précède est une explication détaillée de plusieurs méthodes d'injection de dépendances Java Spring. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !