Plusieurs méthodes d'injection de dépendance Spring

Introduction à IoC

Dans le développement Java normal, les programmeurs doivent s'appuyer sur les méthodes d'autres classes d'une 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>

<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>

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

3.

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(); 
} 
}

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

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

<!--配置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>

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

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

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

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

<!--配置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>

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