IOC的概念
- IOC Inversion of Controller 控制反转。
- IOC 就是将对象的创建、初始化及销毁交给 spring 容器来处理。
ApplicationContext 与 BeanFactory 的关系
- ApplicationContext 是 BeanFactory 的子接口。
- BeanFactory 采用延迟加载的方案，在getBean时才会实例化Bean。
public void test4() {
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
beanFactory.getBean("helloWorld");
}
// 经过测试，BeanFactory在getBean时才实例化Bean。
- ApplicationContext 在配置文件加载时，就会初始化Bean，并且提供不同应用层的实现。在开发中我们一般使用 ApplicationContext 的实现类：
- FileSystemXmlApplicationContext 根据文件路径读取xml文件
public void test5() {
// 根据系统文件路径读取xml文件
ApplicationContext context = new FileSystemXmlApplicationContext("src/applicationContext.xml");
context.getBean("helloWorld");
}
- ClassPathXmlApplicationContext 根据classpath路径读取xml文件
public void test5() {
// 根据classpath路径读取xml文件
ApplicationContext context = new FileSystemXmlApplicationContext("applicationContext.xml");
context.getBean("helloWorld");
}
- WebApplicationContext web开发中常用
Bean的实例化方式
- 无参构造方法
- 编写配置文件
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.xsd">
<bean id="helloWorld" class="com.zhangquanli.spring.helloworld.HelloWorld"/>
</beans>
public void test1() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
helloWorld.show();
}
- 静态工厂方法
- 编写工厂类，在工厂类中提供一个静态方法，返回Bean对象
public class HelloWorldFactory {
public static HelloWorld getInstance() {
return new HelloWorld();
}
}
- 编写配置文件
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.xsd">
<bean id="helloWorld2" class="com.zhangquanli.spring.helloworld.HelloWorldFactory" factory-method="getInstance"/>
</beans>
public void test2() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld2");
helloWorld.show();
}
- 实例工厂方法
- 编写工厂类，在工厂类中提供一个非静态方法，返回Bean对象
public class HelloWorldFactory2 {
public HelloWorld getInstance() {
return new HelloWorld();
}
}
- 编写配置文件
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.xsd">
<bean id="helloWorldFactory2" class="com.zhangquanli.spring.helloworld.HelloWorldFactory2"/>
<bean id="helloWorld3" factory-bean="helloWorldFactory2" factory-method="getInstance"/>
</beans>
public void test3() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld3");
helloWorld.show();
}
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"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="helloWorld" class="com.zhangquanli.spring.helloworld.HelloWorld"/>
<alias name="helloWorld" alias="a"/>
<alias name="helloWorld" alias="b"/>
<alias name="helloWorld" alias="c"/>
</beans>
- 编写测试方法
public void testAlias() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld a = (HelloWorld) context.getBean("a");
a.show();
HelloWorld b = (HelloWorld) context.getBean("b");
b.show();
HelloWorld c = (HelloWorld) context.getBean("c");
c.show();
}
Bean的创建时机
- 在 bean 标签中有 lazy-init 属性
- default，相当于 false，在 spring 容器启动的时候创建对象。
- true，在 context.getBean 时创建对象。
- false，在 spring 容器启动的时候创建对象。
- lazy-init 属性的意义
- 如果把 lazy-init 设置为 true ，则当 spring 容器启动的时候，检测不到任何错误，这样会存在很大的安全性隐患。所以一般情况应该设置 lazy-init 为 false/default 。
- 但是如果一个bean中有一个属性，该属性含有大量的数据，这个时候不希望该bean过早的停留在内存中，这个时候需要用到 lazy-int 为 true 。
Bean的作用域
- 在 bean 标签中有 scope 属性，用于描述 bean 的作用域。
- singleton，单例模式，代表在 spring ioc 容器中只有一个 bean 实例。（默认的scope）
- prototype，多例模式，每一次从 spring ioc 容器中获取，都会返回一个新实例。
- request，用在web开发中，通过 request.setAttribute() 将 bean 对象存储到request域中。
- session，用在web开发中，通过 session.setAttribute() 将 Bean 对象存储到session域中。
- 默认情况下，放入spring容器中的bean是单例的。
- 将来service层和dao层所有的类将放入到spring容器中，所以默认情况下这两个层的类的实例都是单例的，所以不能把数据声明到属性中。如果声明到属性中，将会成为共享的，涉及到线程安全问题。
创建时机和作用域的结合
- <font color="red">
scope="prototype" lazy-init="true"</font> 在 context.getBean 时创建对象
- <font color="red">
scope="prototype" lazy-init="false"</font> 在 context.getBean 时创建对象，lazy-init为false失效。即在 scope 为 prototype 时，始终在 context.getBean 时创建对象
- scope为singleton时，是默认情况。
Bean的生命周期
- Bean的生命周期方法
- instantiate bean 实例化 Bean 对象
- populate properties 给 Bean 对象注入属性
- 如果 Bean 实现 BeanNameAware 执行 setBeanName
- 如果 Bean 实现 BeanFactoryAware 或 ApplicationContextAware 执行 setBeanFactory 或 setApplicationContext
- 如果存在类实现 BeanPostProcessor 执行postProcessBeforeInitialization
- 如果 Bean 实现 InitializingBean 执行 afterPropertiesSet
- 调用 Bean 中自定义的 init-method 方法
- 如果存在类实现 BeanPostProcessor 执行postProcessorAfterInitialization
- 执行业务逻辑代码
- 如果 Bean 实现 DisposableBean 执行 destroy
- 调用 Bean 中自定义的 destroy-method 方法
- Bean的生命周期测试代码
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class HelloWorld implements BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean {
private String info;
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
public HelloWorld() {
System.out.println("第一步：instantiate bean 实例化Bean对象");
}
public void show() {
System.out.println("第九步：show time 执行业务逻辑代码");
}
public void myInit() {
System.out.println("第七步：调用 Bean 中自定义的 init-method 方法");
}
public void myDestroy() {
System.out.println("第十一步：调用 Bean 中自定义的 destroy-method 方法");
}
@Override
public void setBeanName(String arg0) {
System.out.println("第三步：如果 Bean 实现 BeanNameAware 执行 setBeanName" + info);
}
@Override
public void setApplicationContext(ApplicationContext arg0) throws BeansException {
System.out.println("第四步：如果 Bean 实现 BeanFactoryAware 或 ApplicationContextAware 执行 setBeanFactory 或 setApplicationContext");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("第六步：如果 Bean 实现 InitializingBean 执行 afterPropertiesSet");
}
@Override
public void destroy() throws Exception {
System.out.println("第十步：如果 Bean 实现 DisposableBean 执行 destroy");
}
}
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyProcessor implements BeanPostProcessor{
@Override
public Object postProcessAfterInitialization(Object arg0, String arg1) throws BeansException {
System.out.println("第八步：如果存在类实现 BeanPostProcessor 执行postProcessorAfterInitialization");
return arg0;
}
@Override
public Object postProcessBeforeInitialization(Object arg0, String arg1) throws BeansException {
System.out.println("第五步：如果存在类实现 BeanPostProcessor 执行postProcessBeforeInitialization");
return arg0;
}
}
<?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.xsd">
<bean id="helloWorld" class="com.zhangquanli.spring.life.HelloWorld" init-method="myInit" destroy-method="myDestroy">
<property name="info" value="你好啊"></property>
</bean>
<!-- 此类是针对所有其他bean类的 -->
<bean id="myProcessor" class="com.zhangquanli.spring.life.MyProcessor"/>
</beans>
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class HelloWorldTest {
@Test
public void test1() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
helloWorld.show();
context.close();
}
}
- Bean的生命周期的说明
- 第3步和第4步，是让 Bean 了解 spring 容器。
- 第5步和第8步，可以针对指定 的Bean 使用动态代理进行功能增强。
- 第6步和第10步，可以实现指定的接口来完成 init 和 destroy 操作。
- 在开发中，一般不使用第6步和第10步，因为第7步和第11步也可以完成 init 和 destroy 的操作。同时，第7步和第11步的初始化和销毁操作无耦合，只需要在配置文件制定初始化和销毁的方法。
<bean id="helloWorld" class="com.zhangquanli.spring.life.HelloWorld" init-method="myInit" destroy-method="myDestroy">
<property name="info" value="你好啊"></property>
</bean>
- Bean的生命周期的总结
- 增强 Bean 的功能，可以实现 BeanPostProcessor 来完成。
- 初始化和销毁操作，可以使用 bean 标签上的 init-method、destroy-method 方法来完成。
- <font color="red">注意：destroy-method 只在 scope="singleton" 才有效果。</font>
网友评论