Escreva na frente
O Spring nos ajuda a gerenciar objetos por meio do contêiner IOC, mas como obter esses objetos gerenciados quando precisamos de um ou mais deles? Isso está relacionado à injeção de objetos. Por meio da injeção, podemos obter do contêiner Spring. Aquisição passiva reversa de objetos, e então podemos usar os recursos desses objetos para completar nossas tarefas.
1: injeção de método setter
1.1: Definir a classe injetada
public class MyDao {
}
1.2: Definir a classe injetada
public class MyAction {
private MyDao myDao;
public MyDao getMyDao() {
return myDao;
}
public void setMyDao(MyDao myDao) {
this.myDao = myDao;
}
}
1.3: definir xml
<?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.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myDao" class="yudaosourcecode.spring.MyDao"/>
<bean id="myAction" class="yudaosourcecode.spring.MyAction">
<property name="myDao" ref="myDao"/>
</bean>
</beans>
1.4: Teste
@Test
public void testDiBySetter() {
ApplicationContext ac =
new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
MyAction myAction = ac.getBean("myAction", MyAction.class);
System.out.println("myAction.getMyDao(): ");
System.out.println(myAction.getMyDao());
}
corre:
myAction.getMyDao():
yudaosourcecode.spring.MyDao@75881071
2: injeção de construtor
2.1: Definir a classe injetada
public class DiPerson {
}
public class DiUser {
}
2.2: Definir a classe injetada
public class ConstructorDi {
public DiPerson diPerson;
public DiUser diUser;
public ConstructorDi(DiPerson diPerson, DiUser diUser) {
this.diPerson = diPerson;
this.diUser = diUser;
}
}
Observe-os private DiPerson diPersone private DiUser diUsernão definimos métodos de leitura e escrita.
2.3: Definir xml
<beanid="myPerson" class="yudaosourcecode.spring.DiPerson"/>
<bean id="myUser" class="yudaosourcecode.spring.DiUser"/>
<bean id="constructorDi" class="yudaosourcecode.spring.ConstructorDi">
<!--
public ConstructorDi(DiPerson diPerson, DiUser diUser) {
this.diPerson = diPerson;
this.diUser = diUser;
}
-->
<constructor-arg index="0" ref="myPerson"/>
<constructor-arg index="1" ref="myUser"/>
</bean>
2.4: Teste
@Test
public void diByConstructorTest() {
ClassPathXmlApplicationContext ac
= new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
ConstructorDi constructorDi = ac.getBean("constructorDi", ConstructorDi.class);
System.out.println("constructorDi.diPerson is: ");
System.out.println(constructorDi.diPerson);
System.out.println("constructorDi.diUser is: ");
System.out.println(constructorDi.diUser);
}
Resultado:
constructorDi.diPerson is:
yudaosourcecode.spring.DiPerson@7403c468
constructorDi.diUser is:
yudaosourcecode.spring.DiUser@43738a82
Process finished with exit code 0
3: injeção estática de método de fábrica
Na verdade, esse método está chamando um método estático de uma determinada classe para obter os objetos necessários para injeção.
3.1: Definir a classe injetada
public class DiPerson {
}
3.2: Definir uma classe de fábrica estática
A classe de fábrica estática fornece métodos estáticos para retornar DiPersonobjetos:
public class StaticFactoryCls {
public static final DiPerson generatePersonDi() {
return new DiPerson();
}
}
3.3: Definir a classe injetada
public class StaticFactoryMethodDi {
private DiPerson diPerson;
public DiPerson getDiPerson() {
return diPerson;
}
public void setDiPerson(DiPerson diPerson) {
this.diPerson = diPerson;
}
}
3.4: definir xml
<!-- 通过工厂方法定义bean -->
<bean id="staticFactoryDiPerson" class="yudaosourcecode.spring.StaticFactoryCls" factory-method="generatePersonDi"/>
<bean id="staticFactoryMethodDi" class="yudaosourcecode.spring.StaticFactoryMethodDi">
<property name="diPerson" ref="staticFactoryDiPerson"/>
</bean>
3.5: Teste
staticFactoryMethodDi.getDiPerson() is:
yudaosourcecode.spring.DiPerson@67b467e9
Process finished with exit code 0
4: Injeção de método de fábrica de instância
A única diferença entre este método e a injeção de método de fábrica estático é que o método de geração do objeto é um método de instância, não um método estático.
4.1: Definir a classe injetada
public class DiPerson {
}
4.2: Definir a classe de fábrica da instância
public class InstanceFactoryCls {
public DiPerson generatePersonDi() {
return new DiPerson();
}
}
Observe que o método aqui é um método de instância, não um método estático.
4.3: Definir a classe injetada
public class InstanceFactoryMethodDi {
private DiPerson diPerson;
public DiPerson getDiPerson() {
return diPerson;
}
public void setDiPerson(DiPerson diPerson) {
this.diPerson = diPerson;
}
}
4.4: definir xml
<!-- 定义实例工厂bean -->
<bean id="instanceFactoryCls" class="yudaosourcecode.spring.InstanceFactoryCls"/>
<!-- 通过实例工厂bean获取需要DI的bean -->
<bean id="instanceFactoryDiPerson"
factory-bean="instanceFactoryCls"
factory-method="generatePersonDi"/>
<bean id="instanceFactoryMethodDi" class="yudaosourcecode.spring.InstanceFactoryMethodDi">
<property name="diPerson" ref="instanceFactoryDiPerson"/>
</bean>
4.5: Teste
@Test
public void diByInstanceFactoryTest() {
ClassPathXmlApplicationContext ac
= new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
InstanceFactoryMethodDi instanceFactoryMethodDi = ac.getBean("instanceFactoryMethodDi", InstanceFactoryMethodDi.class);
System.out.println("instanceFactoryMethodDi.getDiPerson() is: ");
System.out.println(instanceFactoryMethodDi.getDiPerson());
}
corre:
instanceFactoryMethodDi.getDiPerson() is:
yudaosourcecode.spring.DiPerson@5c072e3f
Process finished with exit code 0