Spring IoC 容器

Spring IoC(Inversion of Control)容器所管理的对象称为bean，因此bean需要被初始化。

Spring IoC容器的实例化有很多种方式，灵活、简单、易用，这里有几种方式。

新建一个j2EE Web Project，工程名称为Spring，而且POJO已经存在，为Person.java，代码如下：

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配置bean。这里使用Spring 1.2版本，DTD验证，配置文件同Spring 2.0版本有很大的不同，Spring 2.0版本使用Schema验证，稍微复杂一点。

其中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>
</beans>

Spring IoC容器的实例化，这里有几种方式，写一个Main类作为测试用的主函数。

第一种初始化bean的方式：

使用ApplicationContext，通过构造一个FileSystemXmlApplicationContext对象，读取配置文件，测试代码如下所示：

package org.shirdrn.main;

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");
Person p = (Person)ctx.getBean("person");
System.out.println("id = "+p.getId());
System.out.println("name = "+p.getName());
System.out.println("age = "+p.getAge());
System.out.println("Email = "+p.getEmail());
}
}

测试结果输出如下：

id = 1001
name = Shirdrn
age = 26
Email = shirdrn@hotmail.com

因为使用FileSystemXmlApplicationContext对象加载配置文件，它首先会从相对于工程的根目录Spring下面查找，所以配置文件指定在src/目录之下。

第二种初始化bean的方式：

通过创建一个Resource对象，根据Resource对象，实例化一个XmlBeanFactory对象，然后从从BeanFactory中获取实例bean。测试代码如下所示：

package org.shirdrn.main;

import org.shirdrn.entity.Person;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;


public class Main {
public static void main(String[] args){
Resource resource = new FileSystemResource("src/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
Person p = (Person)factory.getBean("person");
System.out.println("id = "+p.getId());
System.out.println("name = "+p.getName());
System.out.println("age = "+p.getAge());
System.out.println("Email = "+p.getEmail());
}
}


测试结果输出如下：

id = 1001
name = Shirdrn
age = 26
Email = shirdrn@hotmail.com

因为使用FileSystemResource对象加载配置文件，它首先会从相对于工程的根目录Spring下面查找，所以配置文件指定在src/目录之下。

第三种初始化bean的方式：

使用ClassPathResource创建一个资源，读取配置文件的时候，会从当前工程的classpath中读取，因此使用ClassPathResource创建一个对象的时候，就不需要指定路径了。然后根据构造的ClassPathResource对象，创建一个XmlBeanFactory，然后从从BeanFactory中获取实例bean。测试代码如下所示：

package org.shirdrn.main;

import org.shirdrn.entity.Person;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;


public class Main {
public static void main(String[] args){
ClassPathResource resource = new ClassPathResource("applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
Person p = (Person)factory.getBean("person");
System.out.println("id = "+p.getId());
System.out.println("name = "+p.getName());
System.out.println("age = "+p.getAge());
System.out.println("Email = "+p.getEmail());
}
}

测试结果输出如下：

id = 1001
name = Shirdrn
age = 26
Email = shirdrn@hotmail.com

第四种初始化bean的方式：

假如存在多个bean的XML配置文件，想通过一次加载所有的配置文件，可以使用ClassPathXmlApplicationContext对象，根据构造函数指定的多个参数(及配置文件)，来实现批量初始化。

已经存在一个applicationContext.xml的配置文件了，指定bean的id为person。再新建一个名称为myApplicationContext.xml的配置文件，这里也是，只配置一个bean，它的id为personx，如下所示：

<?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="personx" class="org.shirdrn.entity.Person" abstract="false"
singleton="true" lazy-init="default" autowire="default"
dependency-check="default">
<property name="id">
<value>9999</value>
</property>
<property name="name">
<value>Linda</value>
</property>
<property name="age">
<value>24</value>
</property>
<property name="email">
<value>linda@hotmail.com</value>
</property>
</bean>
</beans>

测试代码如下所示：

package org.shirdrn.main;

import org.shirdrn.entity.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Main {
public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext(
new String[]{
"applicationContext.xml",
"myApplicationContext.xml"
});
Person p = (Person)ctx.getBean("person");
System.out.println("pid = "+p.getId());
System.out.println("pname = "+p.getName());
System.out.println("page = "+p.getAge());
System.out.println("pEmail = "+p.getEmail());

Person px = (Person)ctx.getBean("personx");
System.out.println("pxid = "+px.getId());
System.out.println("pxname = "+px.getName());
System.out.println("pxage = "+px.getAge());
System.out.println("pxEmail = "+px.getEmail());
}
}

测试结果输出如下：

pid = 1001
pname = Shirdrn
page = 26
pEmail = shirdrn@hotmail.com
pxid = 9999
pxname = Linda
pxage = 24
pxEmail = linda@hotmail.com

这里，其实主要还是根据bean的id取得需要加载的实例，只不过一次就可以初始化两个配置bean的文件。相当于在beans元素里面配置了两个bean，bean的id分别为person和personx。

还可以使用ApplicationContext的getBeansOfType()来获取指定类型的bean，返回一个Map，然后通过从Map中取出key，这里key为person和personx，示例代码如下所示：

package org.shirdrn.main;

import java.util.HashMap;
import java.util.Map;

import org.shirdrn.entity.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Main {
public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext(
new String[]{
"applicationContext.xml",
"myApplicationContext.xml"
});
Map map = new HashMap();
map = ctx.getBeansOfType(Person.class);
Person mp = (Person)map.get("person");
System.out.println("pid = "+mp.getId());
System.out.println("pname = "+mp.getName());
System.out.println("page = "+mp.getAge());
System.out.println("pEmail = "+mp.getEmail());

Person mpx = (Person)map.get("personx");
System.out.println("pxid = "+mpx.getId());
System.out.println("pxname = "+mpx.getName());
System.out.println("pxage = "+mpx.getAge());
System.out.println("pxEmail = "+mpx.getEmail());
}
}

测试结果输出如下：

pid = 1001
pname = Shirdrn
page = 26
pEmail = shirdrn@hotmail.com
pxid = 9999
pxname = Linda
pxage = 24
pxEmail = linda@hotmail.com

使用Spring IoC容器去管理对象，可以提高程序的独立性。如果某个对象的细节发生了变化，只需要去修改配置文件，配置文件又是基于XML的，是格式化的数据，非常方便，而我们的程序根本就不需要修改，减轻了维护程序的负担