Spring DI(依赖注入)之setter注入

Spring主要有两种注入方式：Setter注入和构造器注入。

使用Setter注入，可以注入很多类型。

(1) 注入基本类型：

可以使用Setter注入基本类型，如int、boolean等等，同时他们对应的封装类型，如Integer、Boolean等类型。

Company类定义如下：

package org.shirdrn.entity;

public class Company {
private int id;
private String name;
private Boolean chinese;
public Boolean getChinese() {
return chinese;
}
public void setChinese(Boolean chinese) {
this.chinese = chinese;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

对应的XML配置applicationContext.xml内容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="companyBean" class="org.shirdrn.entity.Company"
abstract="false" singleton="true" lazy-init="default"
autowire="default" dependency-check="default">
<property name="id">
<value>2008</value>
</property>
<property name="name">
<value>CNAET</value>
</property>
<property name="chinese">
<value>true</value>
</property>
</bean>
</beans>

测试的程序代码如下：

package org.shirdrn.main;

import org.shirdrn.entity.Company;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
Company c = (Company)ctx.getBean("companyBean");
System.out.println("id = "+c.getId());
System.out.println("name = "+c.getName());
System.out.println("isChinese = "+c.getChinese());

}
}

测试输出结果如下所示：

id = 2008
name = CNAET
isChinese = true

(2) 注入引用类型

在Company类中添加一个属性，公司的CEO：

private Person CEO;

并且添加它的Setter和Getter方法。

Person类如下所示：

package org.shirdrn.entity;

public class Person {
private Integer id;
private String name;
private Integer age;
private String email;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

对应的XML文件applicationContext.xml配置如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="person" class="org.shirdrn.entity.Person" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>1001</value>
</property>
<property name="name">
<value>Shirdrn</value>
</property>
<property name="age">
<value>26</value>
</property>
<property name="email">
<value>shirdrn@hotmail.com</value>
</property>
</bean>

<bean id="companyBean" class="org.shirdrn.entity.Company"
abstract="false" singleton="true" lazy-init="default"
autowire="default" dependency-check="default">
<property name="id">
<value>2008</value>
</property>
<property name="name">
<value>CNAET</value>
</property>
<property name="chinese">
<value>true</value>
</property>
<property name="CEO">
<ref bean="person" />
</property>
</bean>

</beans>

第一个bean元素配置person，第二个bean配置了companyBean，公司的详情，其中CEO引用了第一个bean，表示一个人的详细信息，关键的配置在于：

<property name="CEO">
<ref bean="person" />
</property>

ref元素指定了引用的bean的id。

测试的程序代码如下：

package org.shirdrn.main;

import org.shirdrn.entity.Company;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
Company c = (Company)ctx.getBean("companyBean");
System.out.println("company's id = "+c.getId());
System.out.println("company's name = "+c.getName());
System.out.println("company is Chinese = "+c.getChinese());
System.out.println("--- the following is CEO's detail ---");
System.out.println("CEO's id = "+c.getCEO().getId());
System.out.println("CEO's name = "+c.getCEO().getName());
System.out.println("CEO's age = "+c.getCEO().getAge());
System.out.println("CEO's Email = "+c.getCEO().getEmail());
}
}

测试输出结果如下所示：

company's id = 2008
company's name = CNAET
company is Chinese = true
--- the following is CEO's detail ---
CEO's id = 1001
CEO's name = Shirdrn
CEO's age = 26
CEO's Email = shirdrn@hotmail.com

(3) 注入Properties：

Properties类型也是键值对，而且它的键、值都只能是String类型。

新建一个PropertiesBean类，如下所示：

package org.shirdrn.entity;

import java.util.Properties;

public class PropertiesBean {
Properties hibernate;

public Properties getHibernate() {
return hibernate;
}

public void setHibernate(Properties hibernate) {
this.hibernate = hibernate;
}
}

XML中配置详情如下：

<bean id="propertiesBean" class="org.shirdrn.entity.PropertiesBean"
abstract="false" singleton="true" lazy-init="default"
autowire="default" dependency-check="default">
<property name="hibernate">
<props>
<prop key="connection.url">
jdbc:microsoft:sqlserver://localhost:1433;databasename=person
</prop>
<prop key="dialect">
org.hibernate.dialect.SQLServerDialect
</prop>
<prop key="connection.username">sa</prop>
<prop key="connection.password">111111</prop>
<prop key="show_sql">true</prop>
</props>
</property>
</bean>

测试程序代码如下：

package org.shirdrn.main;

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

import org.shirdrn.entity.PropertiesBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;


public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
PropertiesBean propertiesBean = (PropertiesBean)ctx.getBean("propertiesBean");
Properties hibernate = propertiesBean.getHibernate();
Set keySet = hibernate.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()){
String propKey = (String)it.next();
String value = (String)hibernate.get(propKey);
System.out.println(propKey+" : "+value);
}
}
}

测试输出结果如下：

connection.url : jdbc:microsoft:sqlserver://localhost:1433;databasename=person
connection.username : sa
dialect : org.hibernate.dialect.SQLServerDialect
show_sql : true
connection.password : 111111
(4) 注入集合类型：

集合类型主要包括：List、Set、Map。

<1> 注入List

在Company类中再增加一个属性：

private List employees;

同时添加对应的Setter和Getter方法。

添加两个bean，他们的id分别为person1Bean和person2Bean：

<bean id="person1Bean" class="org.shirdrn.entity.Person" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>2001</value>
</property>
<property name="name">
<value>张飞</value>
</property>
<property name="age">
<value>26</value>
</property>
<property name="email">
<value>zhangfei@live.cn</value>
</property>
</bean>

<bean id="person2Bean" class="org.shirdrn.entity.Person" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>2002</value>
</property>
<property name="name">
<value>John Allen Green</value>
</property>
<property name="age">
<value>28</value>
</property>
<property name="email">
<value>john@baidu.com</value>
</property>
</bean>

在applicationContext.xml中的id为companyBean的bean中添加属性employees，使用list元素，并且list中是引用类型，分别指向person1Bean和person2Bean：

<property name="employees">
<list>
<ref bean="person1Bean" />
<ref bean="person2Bean" />
</list>
</property>

测试的程序代码如下：

package org.shirdrn.main;

import java.util.List;

import org.shirdrn.entity.Company;
import org.shirdrn.entity.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
Company c = (Company)ctx.getBean("companyBean");
List employees = (List)c.getEmployees();
Person employee1 = (Person)employees.get(0);
Person employee2 = (Person)employees.get(1);
System.out.println("--- the following is Employee1's detail---");
System.out.println("employee1's id = "+employee1.getId());
System.out.println("employee1's name = "+employee1.getName());
System.out.println("employee1's age = "+employee1.getAge());
System.out.println("employee1's Email = "+employee1.getEmail());
System.out.println("\n--- the following is Employee2's detail---");
System.out.println("employee2's id = "+employee2.getId());
System.out.println("employee2's name = "+employee2.getName());
System.out.println("employee2's age = "+employee2.getAge());
System.out.println("employee2's Email = "+employee2.getEmail());
}
}

测试输出结果如下所示：

--- the following is Employee1's detail---
employee1's id = 2001
employee1's name = 张飞
employee1's age = 26
employee1's Email = zhangfei@live.cn

--- the following is Employee2's detail---
employee2's id = 2002
employee2's name = John Allen Green
employee2's age = 28
employee2's Email = john@baidu.com

<2> 注入Set

和注入List很相似，但是有细微的差别：

在配置bean元素的时候，在property元素内部使用set元素，同时set元素中可以使用value或ref节点；

Set集合中不允许存在重复的元素；

<3> 注入Map

由于Map存在键-值映射，所以配置不同于List和Set。

假设有一个Car类，两个属性为id和name，如下所示：

package org.shirdrn.entity;

public class Car {
private String id;
private String name;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

一个公司Company有多辆公用Car，而且是用Map定义的，键为Car对象，值为String类型，描述Car的用途。在Company类中添加属性：

private Map cars = new HashMap(0);

同时添加对应的Setter和Getter方法。

配置文件applicationContext.xml中，增加两个bean分别为car1Bean和car2Bean：

<bean id="car1Bean" class="org.shirdrn.entity.Car" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>JL001</value>
</property>
<property name="name">
<value>宝马7系</value>
</property>
</bean>


<bean id="car2Bean" class="org.shirdrn.entity.Car" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>BJ007</value>
</property>
<property name="name">
<value>劳斯莱斯</value>
</property>
</bean>

同时在id为company的bean中增加如下属性配置，使用map元素：

<property name="cars">
<map>
<entry>
<key>
<ref bean="car1Bean" />
</key>
<value>出差专用</value>
</entry>

<entry>
<key>
<ref bean="car2Bean" />
</key>
<value>旅行专用</value>
</entry>
</map>
</property>

map元素的子元素entry表示一个键值对，其中entry的子元素key表示键，value表示值。

一共有4中组合方式：

键为value类型，值为value类型；

键为ref类型，值为value类型；

键为value类型，值为ref类型；

键为ref类型，值为ref类型。

如果想要获取公司的公用车辆对象，同时获取它的用途，可以编写如下测试程序，代码如下：

package org.shirdrn.main;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.shirdrn.entity.Car;
import org.shirdrn.entity.Company;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
Company c = (Company)ctx.getBean("companyBean");
Map cars = c.getCars();
Set keySet = cars.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()){
Car car = (Car)it.next();
String value = (String)cars.get(car);
System.out.println("the car "+car.getName()+"'s value is: "+value);
}
}
}

测试输出结果如下所示：

the car 宝马7系's value is: 出差专用
the car 劳斯莱斯's value is: 旅行专用

注意：

如果使用entry元素的属性配置，则注入Map的配置更加简洁，上面的Map注入只需要使用如下两行：

<entry key-ref="car1Bean" value="出差专用" />

<entry key-ref="car2Bean" value="旅行专用" />

让键使用ref类型，而值使用refref，配置bean如下：

<bean id="companyBean" class="org.shirdrn.entity.Company"
abstract="false" singleton="true" lazy-init="default"
autowire="default" dependency-check="default">
<property name="cars">
<map>
<entry>
<key>
<ref bean="car1Bean" />
</key>
<ref bean="car1Bean" />
</entry>
<entry>
<key>
<ref bean="car2Bean" />
</key>
<ref bean="car2Bean" />
</entry>
</map>
</property>
</bean>

测试程序代码如下：

package org.shirdrn.main;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.shirdrn.entity.Car;
import org.shirdrn.entity.Company;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;


public class Main {
public static void main(String[] args){
ApplicationContext ctx = new FileSystemXmlApplicationContext("src/applicationContext.xml");
Company c = (Company)ctx.getBean("companyBean");
Map cars = c.getCars();
Set keySet = cars.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()){
Car car = (Car)it.next();
Car value = (Car)cars.get(car);
System.out.println("the "+car+" car's value(id) is: "+value.getId());
System.out.println("the "+car+" car's value(name) is: "+value.getName());
}
}
}

测试结果输入如下：

the org.shirdrn.entity.Car@fa7e74 car's value(id) is: JL001
the org.shirdrn.entity.Car@fa7e74 car's value(name) is: 宝马7系
the org.shirdrn.entity.Car@183f74d car's value(id) is: BJ007
the org.shirdrn.entity.Car@183f74d car's value(name) is: 劳斯莱斯

只不过，此时Map的值是一个对象，根据Map的键，是一个对象，获取此键对应的值，就能够获取一个对象的相信信息。