HelloWord.java
package cn.itcast.spring;
public class HelloWord {
public HelloWord(){
System.out.println("helloword空参构造函数");
}
public HelloWord(String msg){
System.out.println(msg);
}
public void sayHello(){
System.out.println("sayHello");
}
public void init(){
System.out.println("init");
}
public void destroy(){
System.out.println("destroy");
}
}
HelloWordFactory.java
package cn.itcast.spring;
public class HelloWordFactory {
public HelloWordFactory(){
System.out.println("hellowrldfactory");
}
public static HelloWord getInstance(){
return new HelloWord("static-factory-hellword-newInstance");
}
public HelloWord getIns(){
return new HelloWord("factory-helloword-instance");
}
}
在src目录下建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">
<import resource="/cn/itcast/spring/aplicationContext-hello.xml"/>
</beans>
根据模块的spring文件 applicationContext-helloword.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">
<bean id="hello_1" class="cn.itcast.spring.HelloWord" init-method="init" destroy-method="destroy" scope="prototype"></bean>
<alias name="hello_1" alias="你好"/>
<bean id="hello_staic_factory" class="cn.itcast.spring.HelloWordFactory" factory-method="getInstance" ></bean>
<bean id="hello_factory" class="cn.itcast.spring.HelloWordFactory" ></bean>
<bean id="aa" factory-bean="hello_factory" factory-method="getIns" ></bean>
</beans>
控制反转：把对象的创建交给spring容器来做
一、spring容器创建对象的方式
1、默认是调用默认的构造函数
<bean id="hello_1" class="cn.itcast.spring.HelloWord"></bean>
2、利用静态工厂方法创建
spring调用工厂方法产生对象，但是真正创建对象还是由程序员来完成的
<bean id="hello_static_factory" class="cn.itcast.spring.HelloWordFactory" factory-method="getInstance"></bean>
3、实例工厂方法
<bean id="hello_factory" class="cn.itcast.spring.HelloWordFactory" ></bean>
<bean id="aa" factory-bean="hello_factory" factory-method="getIns"></bean>
说明：spring配置文件中，只要是一个bean就会为该bean创建对象
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");
HelloWord helloWord1 = (HelloWord) context.getBean("hello_1");//默认构造方法
HelloWord helloWord2 = (HelloWord) context.getBean("hello_staic_factory");//静态工厂方法
HelloWord helloWord3 = (HelloWord) context.getBean("aa");//实例工厂方法
二、spring容器创建对象的时机
在单例的情况下
1、在默认的情况下，启动spring容器创建对象
2、在spring的配置文件bean中有一个属性lazy-init="default/true/false"
1、如果lazy-init为"default/false"在启动spring容器时创建对象
2、如果lazy-init为"true",在context.getBean时才要创建对象
意义：
(1)在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat，如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了内存中，如果有数据，则对内存来是一个消耗
(2)在第二种情况下，可以减少内存的消耗，但是不容易发现错误
在多例的情况下 scope=”prototype”
就是一种情况：在context.getBean时才创建对象
疑问：1.实例工厂为原型，对象类不为原型，则在启动spring容器创建对象
2.实例工厂不为原型，对象类为原型，启动时spring创建工厂实例，在getBean创建对象实例
3.实例工厂，对象类都以为原型，在getBean时创建工厂和对象类实例
<bean id="hello_factory" class="cn.itcast.spring.HelloWordFactory"
scope="prototype"></bean>
<bean id="aa" factory-bean="hello_factory" factory-method="getIns" ></bean>
三、spring的bean中的scope
1、由spring产生的bean默认是单例的
2、可以在spring的配置文件中，scope的值进行修改="singleton/prototype/request
/session/global session"
3、如果spring的配置文件的scope为"prototype"，则在得到该bean时才创建对象
四、spring容器对象的生命周期：
<bean id="hello_1" class="cn.itcast.spring.HelloWord"
init-method="init" destroy-method="destroy"></bean>
1、spring容器创建对象
2、执行init方法
3、调用自己的方法
4、当spring容器关闭的时候执行destroy方法
当scope为"prototype"时，spring容器是否调用destroy方法？不会。