spring容器IOC创建对象<二>

问题？spring是如何创建对象的？什么时候创建对象？有几种创建方式？测试对象是单例的还是多例的 ？对象的初始化和销毁？

下面的四大模块IOC的内容了！需要深刻理解

SpringIOC定义：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器控制对象的生命周期。

先拷入核心jar包：点击打开下载链接

一、spring是如何创建对象的，有几种创建方式

spring容器创建对象的方式

1、默认是调用默认的构造函数

2、利用静态工厂方法创建

spring调用工厂方法产生对象，但是真正创建对象还是由程序员来完成的

3、实例工厂方法

例子：

简单的测试类：

package cn.itcast.sh.spring.ioc;

public class HelloWord {
	public HelloWord(){
		System.out.println("构造方法实现了");
	}
	public void hello(){
		System.out.println("I'm a Ioc");
	}
}

package cn.itcast.sh.spring.ioc;

public class HelloWordFactory {
	public static HelloWord getInstance(){
		return new HelloWord();
	}
}

package cn.itcast.sh.spring.ioc;

public class HelloWordLocator {
	public static HelloWordLocator getInstance(){
		return new HelloWordLocator();
	}
}

spring配置文件applicationContext.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-2.5.xsd">

        <!-- id:标识符
        	 class:相应的对象类，放入容器中
        	 alias:别名，可写可不写，就是另外取一个名字
         -->   

        <!-- 这是第一种创建对象的方式：利用构造方法 ，一般都是采用这种方式来创建对象-->
       <bean id="hello" class="cn.itcast.sh.spring.ioc.HelloWord"></bean>
       <alias name="hello" alias="王三"/>

       <!-- 这是第二种创建对象的方式：利用factory-method，静态工厂方法 -->
       <bean id="helloFactory" class="cn.itcast.sh.spring.ioc.HelloWordFactory" factory-method="getInstance"></bean>

       <!-- 这是第三种创建对象的方式：使用实例工厂方法实例化 -->
        <bean id="heillLocator" class="cn.itcast.sh.spring.ioc.HelloWordLocator" factory-bean="heillLocator" factory-method="getInstance"></bean>

</beans>

测试对象的产生(注意：这里涉及到一个别名，但是用得不多，只是区别于不同的客户端去使用它来取名字，以不至于弄混)：

package cn.itcast.sh.spring.ioc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.sh.spring.ioc.HelloWord;
import cn.itcast.sh.spring.ioc.HelloWordFactory;

public class IocTest {

	/**
	 *  spring创建对象的两种方式
	 *
	 */

	//第一种：调用默认的构造方法进行创建
	@Test
	public void IocT1(){
		/**
		 * 1.启动spring容器
		 * 2.从容器中拿出对象
		 * 3.然后由对象执行相应的操作
		 *
		 */
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWord helloWord = (HelloWord) context.getBean("王三");//取的是别名
		helloWord.hello();
	}

	//利用静态工厂来创建对象
	@Test
	public void IocT2(){
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWord factory = (HelloWord) context.getBean("helloFactory");
		factory.hello();
	}

	//利用实例工厂来创建对象
		@Test
		public void IocT3(){
			ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
			HelloWordFactory factory = (HelloWordFactory) context.getBean("heillLocator");
			factory.getInstance();
		}
}

结果如何来测一测

二、什么时候创建对象

时间：这个又两个时间，一个是默认的在spring容器启动的时候，另外一个在getbean的时候创建对象(就是拿到配置文件中的标识符的时候创建对象)

两者有什么区别呢？

1、在默认的情况下，启动spring容器创建对象

2、在spring的配置文件bean中有一个属性lazy-init="default/true/false"

(1)、如果lazy-init为"default/false"在启动spring容器时创建对象

(2)、如果lazy-init为"true",在context.getBean时才要创建对象

意义：

在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat,

如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了

内存中，如果有数据，则对内存来是一个消耗，但是可以过早发现错误。

在第二种情况下，可以减少内存的消耗，但是不容易发现错误

在多例的情况下

就是一种情况：在context.getBean时才创建对象

案例：

applicationContext.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-2.5.xsd">

        <!--
        1、在默认的情况下是，启动容器的时候，创建对象(这种方式可以及时发现错误)
        2、 加上lazy-init="default"：在getbean的时候创建对象(可以减少内存的浪费)
         -->
       <bean id="helloWhen" class="cn.itcast.sh.spring.when.HelloWord" lazy-init="true"></bean>
</beans>

测试类：

package cn.itcast.sh.spring.ioc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.sh.spring.when.HelloWord;

public class IocWhen {

	/**
	 * 检测对像是在什么时候创建的
	 * 1、是在启动spring容器
	 * 2、在调用方法的时候
	 */
	@Test
	public void test(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		System.out.println("先启动了spring容器");
		HelloWord helloWord = (HelloWord)applicationContext.getBean("helloWhen");
		helloWord.hello();
	}
}

结果：

(1)如果是没有lazy-init="true"，启动容器的时候创建对象

(2)如果有lazy-init="true"

三、对象是单例的还是多例的

定义:意思就是，当多用户并发使用该对象的时候，创建该对象的时候，该对象是同一个吗？

spring的bean中的scope

1、由spring产生的bean默认是单例的

2、可以在spring的配置文件中，scope的值进行修改="singleton/prototype/request/session/globalsession"

3、如果spring的配置文件的scope为"prototype"，则产生的多例，并且是在getBean时才创建对象

案例：

类

package cn.itcast.sh.spring.scope;

import java.util.ArrayList;
import java.util.List;

public class HelloWord {
	/**
	 * 若产生的是默认单例的话，该list将会共享数据
	 *
	 */
	private List<String> strings = new  ArrayList<String>();

	public List<String> getStrings() {
		return strings;
	}
	public void setStrings(List<String> strings) {
		this.strings = strings;
	}
	public HelloWord(){
		System.out.println("构造方法实现了-----");
	}
	public void hello(){
		System.out.println("I'm a Ioc");
	}
}

applicationContext.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-2.5.xsd">
        <!-- 对象产生是默认(singleton)的单例，若要变成多例，需要配置属性scope='prototype':会使得产生对象的时间为getbean的时候，而不是spring容器启动的时候 -->
       <bean id="helloScope" class="cn.itcast.sh.spring.scope.HelloWord" scope="prototype"></bean>

</beans>

测试类：

package cn.itcast.sh.spring.ioc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.sh.spring.scope.HelloWord;

public class ScopeTest {
	@Test
	public void A(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		System.out.println("ssssssssssss");
		HelloWord helloWord = (HelloWord)applicationContext.getBean("helloScope");

		helloWord.getStrings().add("aaaa");
		HelloWord helloWord1 = (HelloWord)applicationContext.getBean("helloScope");

		helloWord1.getStrings().add("aaaa");
		System.out.println(helloWord.getStrings().size());
		System.out.println(helloWord);
		System.out.println(helloWord1);
		//结果显示是相同的对象
		//在这里可以说明产生的是单例对象(默认)，单例有一个特点就是所属属性是一个共享的，不是很安全的问题，要注意这个问题。

	}
}

结果:

(1)没有scope="prototype"，那就是单例

(2)有scope="prototype"

若是单例的话，其对象类的资源会被共享，而多例就不一样了，只用各种对象。

四、对象的初始化和销毁

首先我们要明白，对象创建了，会放在内存当中，只有关闭了spring或者关闭了该系统，对象才销毁，不占用内存，所以就要涉及到spring容器对象的生命周期：步骤为

1、spring容器创建对象

2、执行init方法(初始化对象)

3、调用自己的方法(对象的相应操作)

4、当spring容器关闭的时候执行destroy方法(对象用完了，销毁)

当scope为"prototype"时，spring容器是否调用destroy方法？

案例：

对象类：

package cn.itcast.sh.spring.initdestory;

import java.util.ArrayList;
import java.util.List;

public class HelloWord {
	public void init(){
		System.out.println("对象初始化了");
	}
	public void destroy(){
		System.out.println("对象销毁了");
	}

	public HelloWord(){
		System.out.println("构造方法实现了-----");
	}
	public void hello(){
		System.out.println("I'm a Ioc");
	}
}

applicationContext.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-2.5.xsd">

        <!-- 构造方法先创建对象(spring容器来做)，
       		 init方法初始化对象(spring容器来做)
       		    对象进行操作(客户端来做)
                                    最后才是销毁，如果需要手动销毁，手动close
             (spring容器来做，默认关闭容器才销毁对象，
             	销毁只针对单例，当scope为propert的时候，是不能销毁的)
          -->
       <bean id="helloInit" class="cn.itcast.sh.spring.initdestory.HelloWord"
       init-method="init" destroy-method="destroy"></bean><!-- 这里填的方法是在对象类中填写的方法,一般是默认不填，自动执行 -->
</beans>

测试类：

package cn.itcast.sh.spring.ioc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.sh.spring.initdestory.HelloWord;

public class InitDestoryTest {
	@Test
	public void A(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloWord helloWord = (HelloWord)applicationContext.getBean("helloInit");
		helloWord.hello();

		//手动销毁对象
//		ClassPathXmlApplicationContext classPathXmlApplicationContext = (ClassPathXmlApplicationContext)context;
//		classPathXmlApplicationContext.close();
		}
}

结果：

以上就是spring的IOC的四大模块详解了