手把手搭建spring开发环境(一)

      写在前面：本文主要讲配置xml文件方式搭建spring开发环境，及springIOC容器创建对象的一些细节，注解方式见后续文章。

     传统的开发过程中，对象的创建是由调用者写死的，spring框架中，对象的创建不再有调用创建，改为容器创建这就是IOC（Inversion on Control）控制反转。在对象由容器创建成功后，对象关系的处理，就是依赖注入（ dependency injection）。

开发步骤：

1）准备核心jar包（这里用的是spring3.2.5的版本）：

   commons-logging-1.1.3.jar                      日志

   spring-beans-3.2.5.RELEASE.jar           bean节点

   spring-context-3.2.5.RELEASE.jar          spring上下文节点

   spring-core-3.2.5.RELEASE.jar               spring核心功能

   spring-expression-3.2.5.RELEASE.jar    spring表达式相关

 2）配置spring核心配置文件： applicationContext.xml

      加入头文件：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
</beans>

   3）调用api

     创建java项目，i）创建实体类User；

public class User {
	int id;
	String name;
	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;
	}

	public User(){
		System.out.println("user对象创建。");
	}
}

ii)创建调用类App

public class App {
	
	@Test
	public void testApp() {
		//加载资源文件
		Resource resource = new ClassPathResource("applicationContext.xml");
		//创建容器对象，即bean工厂  IOC容器=工厂类+applicaitonContext.xml
		BeanFactory bf = new XmlBeanFactory(resource);
		User user = (User)bf.getBean("user");
		System.out.println(user);
		
		}
}

iii）在applicationContext.xml配置bean标签，IOC容器通过加载bean标签来创建对象。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
        <bean id="user" class="a.User"></bean>
</beans>

运行App中testApp方法

可以看出对象创建成功。至此，已经完成了第一个springdemo。

调用api获取对象还可以用另一种方式：

@Test
	public void testApp02() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("a/applicationContext.xml");
		User user = (User)ac.getBean(User.class);
		System.out.println(user);
	}

运行结果同testApp()方法。

下面来看springIOC容器创建对象的细节。

1）spring对象的创建默认是单例模式

scope="singleton" 单例    service/dao/工具类

scope="prototype" 多例   action

2）对象什么时候创建？

scope="singleton"在启动（容器初始化完成）之前就已经创建了bean，整个应用有且仅有一个；

scope="prototype"在用到对象的时候才创建对象。

3）是否延迟创建（只对单例模式有效）

lazy-init="false"默认为false，不延迟创建，即在启动时创建对象。

lazy-init="true" 延迟初始化，在用到对象的时候创建

4）创建对象后，初始化/销毁

init-method="init_user"  初始化方法，对应对象的init_user方法，在对象创建之后，容器初始化完成之前执行；

destroy-method="destroy_user"销毁方法，对应对象的destroy_user方法，调用容器对象的destroy方法的时候执行，用ApplicationCont的实现类，ClassPathXmlApplicationContext调用。

配置文件如下：

<bean id="user" name="user1" class="a.User"  scope="singleton" lazy-init="default" init-method="init_user" destroy-method="destory_user" ></bean>

User类中增加如下代码：

    public void init_user(){
		System.out.println("user对象初始化");
	}
	
	public void destory_user(){
		System.out.println("user对象被销毁");
	}

App类中测试方法：

@Test
	public void testApp() {

//		ApplicationContext ac = new ClassPathXmlApplicationContext("a/applicationContext.xml");
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("a/applicationContext.xml");
		System.out.println("容器创建成功。");
		User user1 = (User)ac.getBean("user");
		User user2 = (User)ac.getBean("user");
		System.out.println(user1);
		System.out.println(user2);
		ac.destroy();
	}

运行结果如下：

根据运行结果可以验证以上结论。