当我们创建一个bean定义时,我们创建了一个根据定义来实例化class的规则。
我们不仅能够控制各种依赖和配置,也包括从bean定义创建的实例的范围
spring framework支持六种范围
singleton : (默认)每一个spring容器中,一个bean定义只有一个对象实例
prototype : 一个bean定义有任意多个对象实例
request : 一个bean定义的范围对应一个HTTP request的生命周期,也就是每一个HTTP请求都有自己的bean实例,仅在web相关的ApplicationContext中有效
session : 一个bean定义的范围对应一个HTTP session的生命周期,仅在web相关的ApplicationContext中有效
注意:Spring 3.0起,我们可以使用线程范围
sigleton
spring的单例与GOF的单例模式不同,GOF中单例是每个ClassLoader中有且只有一个class的实例,而Spring的单例,可以描述为一个容器一个实例。也就是说,如果你为某个类定义一个bean,然后该容器根据该bean定义创建一个且只有一个该class的实例。
spring的单例为默认模式
<bean id="accountService" class="com.foo.DefaultAccountService"/> <!-- the following is equivalent, though redundant (singleton scope is the default) --> <bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>
原型模式
bean部署的原型模式,每一次对指定bean的请求,都会创建一个新的bean实例。
<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>与其他模式对比,Spring不会管理原型模式的整个生命周期,容器实例化、配置、组合一个原型对象,将它交给调用者,然后就不再记录该原型对象实例。
因此,尽管无论任何模型,生命周期中的回调函数都会被调用,但在原型模式下,配置好的生命周期析构函数不会被调用。调用端代码必须清理原型模式的对象,回收原型对象占用的资源。
Request、session、application、Websocket模式
初始化web模式的配置
1,使用spring web mvc,无需做特殊设置,DispatcherServlet已经显式相关状态
2,使用servlet 2.5,不使用DispatcherServlet的情况下,需要注册org.springframework.web.context.request.RequestContextListener监听器。
3,使用servlet3.0+,类似的使用WebApplicationInitializer接口。
<web-app> ... <listener> <listener-class> org.springframework.web.context.request.RequestContextListener </listener-class> </listener> ... </web-app>
如果监听器设置有问题,可以使用Spring的RequestContextFilter过滤器替代
<web-app> ... <filter> <filter-name>requestContextFilter</filter-name> <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class> </filter> <filter-mapping> <filter-name>requestContextFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ... </web-app>
Request 模式
xml配置
<bean id="loginAction" class="com.foo.LoginAction" scope="request"/>java注解配置
@RequestScope @Component public class LoginAction { // ... }
XML配置
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>java注解配置
@SessionScope @Component public class UserPreferences { // ... }
xml配置
<bean id="appPreferences" class="com.foo.AppPreferences" scope="application"/>
java注解配置
@ApplicationScope @Component public class AppPreferences { // ... }
各范围bean的依赖
Spring IOC 容器不仅管理beans的实例化,同时也管理bean的集成与依赖。如果你想将一个HTTP请求范围的bean注入另一个更长生命周期范围的bean中,你可以选择在HTTP请求范围的bean中注入AOP代理。
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- an HTTP Session-scoped bean exposed as a proxy --> <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"> <!-- instructs the container to proxy the surrounding bean --> <aop:scoped-proxy/> </bean> <!-- a singleton-scoped bean injected with a proxy to the above bean --> <bean id="userService" class="com.foo.SimpleUserService"> <!-- a reference to the proxied userPreferences bean --> <property name="userPreferences" ref="userPreferences"/> </bean> </beans>
定制范围
bean范围机制可扩展,你可以定义自己的范围,或者重新定义已存在的范围,尽管后一种被认为是坏习惯,并且你不能覆盖内嵌的单例和原型范围。
创建定制范围
实现org.springframework.beans.factory.config.Scope接口
使用定制范围
Scope threadScope = new SimpleThreadScope(); beanFactory.registerScope("thread", threadScope);
<bean id="..." class="..." scope="thread">也可以通过CustomScopeConfigurer类来使用
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer"> <property name="scopes"> <map> <entry key="thread"> <bean class="org.springframework.context.support.SimpleThreadScope"/> </entry> </map> </property> </bean> <bean id="bar" class="x.y.Bar" scope="thread"> <property name="name" value="Rick"/> <aop:scoped-proxy/> </bean> <bean id="foo" class="x.y.Foo"> <property name="bar" ref="bar"/> </bean> </beans>
生命周期中的回调
初始化的回调
org.springframework.beans.factory.InitializingBean接口允许一个bean在所有需要的属性都被容器设置好之后执行初始化工作。InitializingBean接口指定了一个方法:
void afterPropertiesSet() throws Exception;
<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>
public class AnotherExampleBean implements InitializingBean { public void afterPropertiesSet() { // do some initialization work } }与通过xml的配置是相同的
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>
public class ExampleBean { public void init() { // do some initialization work } }
析构函数的回调
实现org.springframework.beans.factory.DisposableBean接口,可以使一个bean在包含它的容器释放它后获取一个回调。DisposableBean指定了一个方法。
void destroy() throws Exception;
<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>
public class AnotherExampleBean implements DisposableBean { public void destroy() { // do some destruction work (like releasing pooled connections) } }与通过xml的配置是相同的
<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>
public class ExampleBean { public void cleanup() { // do some destruction work (like releasing pooled connections) } }默认的初始化和析构的回调
我们可以配置容器,去查找每一个bean的初始化和析构的回调函数
配置如下
public class DefaultBlogService implements BlogService { private BlogDao blogDao; public void setBlogDao(BlogDao blogDao) { this.blogDao = blogDao; } // this is (unsurprisingly) the initialization callback method public void init() { if (this.blogDao == null) { throw new IllegalStateException("The [blogDao] property must be set."); } } }
<beans default-init-method="init"> <bean id="blogService" class="com.foo.DefaultBlogService"> <property name="blogDao" ref="blogDao" /> </bean> </beans>default-destroy-method与之类似
多种机制的结合
Spring 2.5后,我们有三种控制bean生命周期行为的方式
1,InitializingBean和DisposableBean回调接口;
2,定制init()和destroy()方法;
3,@PostConstruct和@PreDestroy注解;
这几种机制可以混合使用
如果一个bean上有多种机制同时存在,且指定的不是同一个方法,则初始化回调按照如下顺序依次执行
@PostConstruct注解的方法
InitializingBean回调接口定义的afterPropertiesSet()方法
一个配置的init()方法
析构函数回调按照同样顺序
@PreDestroy注解的方法
DisposableBean回调接口定义的destroy()方法
一个配置的destroy()方法
启动和关闭回调回调
Lifecycle为任何有生命周期需求的对象定义了关键的方法
public interface Lifecycle { void start(); void stop(); boolean isRunning(); }任何实现了该接口的spring对象,在ApplicationContext接收到开始或结束信号时,它会传递该信号给该context中所有Lifecycle的实现 。通过委托给
LifecycleProcessor
来做这个工作。
注意
LifecycleProcessor
自身扩展了Lifecycle接口。它也增加了两个其他的方法来与上下文交互,使得可以刷新和关闭。
public interface LifecycleProcessor extends Lifecycle { void onRefresh(); void onClose(); }
非web环境下,合理的关闭Spring IOC 容器
定义一个关闭钩子关闭容器,可以使容器合理的调用bean的destroy方法
我们可以通过嗲用ConfigurableApplicationContext接口中定义的registerShutdownHook()方法,来注册一个关闭钩子
import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public final class Boot { public static void main(final String[] args) throws Exception { ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext( new String []{"beans.xml"}); // add a shutdown hook for the above context... ctx.registerShutdownHook(); // app runs here... // main method exits, hook is called prior to the app shutting down... } }
ApplicationContextAware和BeanNameAware
当一个ApplicationContext创建一个实现了org.springframework.context.ApplicationContextAware接口的对象实例时,这个实例会拥有该ApplicationContext的一个引用
public interface ApplicationContextAware { void setApplicationContext(ApplicationContext applicationContext) throws BeansException; }
当一个ApplicationContext创建一个实现了org.springframework.beans.factory.BeanNameAware接口的对象实例时,这个实例会拥有该对象名称的一个引用
public interface BeanNameAware { void setBeanName(String name) throws BeansException; }
其他的意识接口
ApplicationContextAware
ApplicationEventPublisherAEwvaenrte
BeanClassLoaderAware
BeanFactoryAware
BeanNameAware
BootstrapContextAware
LoadTimeWeaverAware
MessageSourceAware
NotificationPublisherAwareSpring
ResourceLoaderAware
ServletConfigAware
ServletContextAware