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>[e-mail]</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   = [e-mail]

(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>[e-mail]</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>[e-mail]</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   = [e-mail]

--- the following is Employee2's detail---
employee2's id      = 2002
employee2's name    = John Allen Green
employee2's age     = 28
employee2's Email   = [e-mail]

<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的键，是一个对象，获取此键对应的值，就能够获取一个对象的相信信息。