Spring Ioc-Introduction détaillée à plusieurs méthodes d'injection de dépendances

Une méthode setter est injectée dans le fichier de configuration

comme suit :

<bean id="helloAction" class="org.yoo.action.SpringSetterHelloAction">
<!-- setter injection using the nested <ref/> element -->
<property name="helloservice"><ref bean="helloService"/></property>
<!--可以不设置类型 -->
<property name="name" value="yoo"></property>
</bean>

Code dans la classe d'implémentation d'action :

private IHelloService helloservice;private String name ;
public void sayHello(){helloservice.sayHello();
System.out.println(this.name);}
public void setHelloservice(IHelloService helloservice) {this.helloservice = helloservice;}
public void setName(String name) {this.name = name;}

Le nom et le helloservice ici sont injectés à l'aide de la méthode de définition d'attributs. Autrement dit, définissez une propriété globale dans la classe et disposez d'une méthode de définition pour la propriété pour l'injection de conteneur.

2 Injection de constructeur

spring prend également en charge l'injection de constructeur, c'est-à-dire l'injection de constructeur ou de constructeur dans certains matériaux.

Regardez d'abord le fichier de configuration :

<!--普通构造器注入-->
<bean id="helloAction" class="org.yoo.action.ConstructorHelloAction">
<!--type 必须为Java.lang.String 因为是按类型匹配的，不是按顺序匹配-->
<constructor-arg type="java.lang.String" value="yoo"/>
<!-- 也可以使用index来匹配-->
<!--<constructor-arg index="1" value="42"/>-->
<constructor-arg><ref bean="helloService"/>
</constructor-arg>
</bean>

Le code dans la classe d'implémentation d'action :

private HelloServiceImpl helloservice;
private String name ;
public SpringConstructorHelloAction(HelloServiceImpl helloservice,String name){this.helloservice = helloservice;
this.name = name ;}
@Overridepublic void sayHello() {helloservice.sayHello();
System.out.println(this.name);}

Définissez les 2 mêmes attributs, puis injectez-les dans le constructeur.

Trois injections d'usine statiques

Le fichier de configuration est le suivant :

<!--静态工厂构造注入-->
<!--注意这里的class 带factory-method参数-->
<!--factory-method的值是FactoryHelloAction中的工厂方法名createInstance-->
<bean id="helloAction" class="org.yoo.di.FactoryHelloAction" factory-method="createInstance">
<constructor-arg type="java.lang.String" value="yoo"/>
<constructor-arg>
<ref bean="helloService"/>
</constructor-arg>
</bean>

classe d'implémentation d'action :

private HelloServiceImpl helloservice;
private String name = null;
private SpringFactoryHelloAction(String name ,HelloServiceImpl helloservice){this.helloservice = helloservice ;
this.name = name ;}
public static SpringFactoryHelloAction createInstance(String name ,HelloServiceImpl helloservice) 
{SpringFactoryHelloAction fha = new SpringFactoryHelloAction (name,helloservice);
// some other operationsreturn fha;}
@Overridepublic void sayHello() 
{helloservice.sayHello();
System.out.println(this.name);}

Quatre Aucune injection de fichier de configuration (injection automatique)

Les trois méthodes ci-dessus doivent toutes écrire des fichiers de configuration Dans spring2.5, une implémentation ioc sans écrire de fichiers de configuration est également. fourni. Il convient de noter qu'aucun fichier de configuration ne fait référence aux dépendances entre les beans et n'est pas basé sur des fichiers de configuration, mais cela ne signifie pas qu'il n'y a pas de fichier de configuration Spring.

Le fichier de configuration est le suivant :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.php.cn/">
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean id="helloService" class="org.yoo.service.HelloServiceImpl">
</bean>
<bean id="helloAction" class="org.yoo.action.AutowiredHelloAction">
</bean>
</beans>

On peut voir que ce qui précède définit uniquement les deux beans helloService et helloAction, et ne définit pas la dépendance de helloAction sur helloService.

De plus,

Classe d'implémentation d'action :

/*
* 属性自动装载
*/
/*
@Autowired
private HelloService helloservice;
@Override
public void sayHello() {
helloservice.sayHello();
。

Le code ci-dessus est très simple. Ajoutez l'annotation @Autowired à l'attribut et Spring injectera automatiquement HelloService.

prend également en charge l'injection de constructeurs et de méthodes setter, comme suit :

Injection automatique de constructeurs :

/*
* 还可以使用构造函数设置
*/
@Autowired
public SpringAutowiredHelloAction(HelloServiceImpl helloservice){
this.helloservice = helloservice;
}

Injection automatique de méthodes setter :

/*
* 也可以使用set方法设置
*/
/*
@Autowired
public void setHelloservice(HelloService helloservice) {
this.helloservice = helloservice;
}

Enfin, il est mentionné dans le document de référence du printemps que si vous n'utilisez pas l'injection automatique, essayez d'utiliser la méthode setter. Généralement, la méthode setter est également utilisée.

Que ce soit pour utiliser l'injection automatique ou la méthode du fichier de configuration, si jdk est inférieur à 1,5 ou que spring n'est pas 2,5, vous ne pouvez utiliser que la méthode du fichier de configuration. Le reste dépend de la sélection réelle du projet.

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