问题？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的四大模块详解了.
