Spring bean scope --scopes

The scope of spring's bean is mainly used to specify how to create a bean object. The system has implemented five main types, namely: singleton, prototype, request, session and globalSession, of which request, session and globalSession are only available in Used in the web environment , when you use them in a non-web environment, the system will throw them. IllegalStateException异常， Of course, this can also be defined by yourself.

Note: When using request, session and globalSession, if you are not using springMVC, you need to do a little configuration. The specific method is :

a. If you are using servlet2.4+, then you need to add a RequestContextListener listener to web.xml

    Xml code   
    
  
<web-app>  
...  
<listener>  
  <listener-class>  
      org.springframework.web.context.request.RequestContextListener  
  </listener-class>  
</listener>  
...  
</web-app>  

b. Of course, if you are using an older version, you need to add a RequestContextFilter to web.xml

    Xml code   
    
  
<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>  

XML-based scope specification:

    Xml code   
    
<bean id="test" class="com.xxx.spring.cope.Test" scope="singleton"/>

1.singleton, the default scope of the system is singleton, which means that only one bean object will be created during the entire request process. After the object is created, it will be saved in the cache of singleton beans, and will be obtained every time it is needed in the future. a bean object.

It is worth noting that the singleton (singleton) in spring is different from the singleton in the GOF design pattern. The singleton in GOF is that there is only one object under each class loader, while the singleton in spring is each Each spring container (BeanFactory and ApplicationContext) will have an object.

2.prototype:

The prototype is not a singleton, it will generate a new object every time there is a new request for the current object.

It is worth noting that when a singleton bean A depends on a prototype bean B, since the singleton bean A will only be initialized once, if a prototype bean B is injected into it when it is initialized, A The owned B will only be initialized once when A is initialized, and the same object B is used every time A uses B, which is a bit contrary to our original idea that B is a prototype, not the result we want , the solution is to make bean A implement an ApplicationContextAware interface, and take a B object from the ApplicationContext every time A needs to use B, and the B object taken at this time will be different each time.

    Java代码   
    
  
import org.springframework.beans.BeansException;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.ApplicationContextAware;  
import org.springframework.stereotype.Component;  
  
@Component  
public class A implements ApplicationContextAware {  
  
    private ApplicationContext applicationContext;  
      
    private B b;  
      
    @Override  
    public void setApplicationContext(ApplicationContext applicationContext)  
            throws BeansException {  
        // TODO Auto-generated method stub  
        this.applicationContext = applicationContext;  
    }  
  
    public B getB() {  
        return applicationContext.getBean(B.class);  
    }  
  
    public void setB(B b) {  
        this.b = b;  
    }  
  
}  

    Java代码   
    
  
import org.springframework.context.annotation.Scope;  
import org.springframework.stereotype.Component;  
  
@Component  
@Scope("prototype")  
public class B {  
    //类里面的其他内容  
}  

3、request：

先看下面这样一个bean定义：

    Xml代码   
    
<bean id="loginAction" class="com.xxx.LoginAction" scope="request"/>

上面的情况，在每次有一个http Request请求LoginAction的时候，spring容器都会新建一个全新的LoginAction对象。这就是Request级别的scope。由于每个请求都对应一个全新的LoginAction对象，所以在请求过程中，你可以随意改变其中包含的实例属性。当一次Request请求完毕之后，其对应的LoginAction对象也就被销毁了。

4、session：

先看下面这样一个bean定义：

    Java代码   
    
<bean id="UserService" class="com.xxx.UserService" scope="session"/>

在上面这种情况，spring容器会为每个处于活跃状态的http Session创建一个UserService对象，这就是session级别的scope。其是和httpSession一起销毁的。

5.globalSession:

先看下面这样一个bean定义：

    Java代码   
    
<bean id="UserService" class="com.xxx.UserService" scope="globalSession"/>

globalSession表示在一个全局的HttpSession下会拥有一个单独的实例，通常用于Portlet环境下。

当需要把一个http级别的scope的对象注入到其他bean中的时候，需要在声明的http级别的scope的对象中加入<aop:scoped-proxy/>，如下面的userPreferences对象

    Xml代码   
    
  
<!-- an HTTP Session-scoped bean exposed as a proxy -->  
  <bean id="userPreferences" class="com.foo.UserPreferences" scope="session">  
  
        <!-- this next element effects the proxying of 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>  

这样做的原因是正常情况下singleton的userService中有一个session级别的对象，这样singleton的userService只初始化一次，而其所依赖的session级别的userPreferences也只初始化一次。这就与我们所定义的每个session对应一个对象的初衷相违背了，而使用<aop:scoped-proxy/>的时候，就会在实际调用的时候每次使用代理去代理userPreferences调用其对应的方法，代理访问的是对应的session中的对象，这样就可以实现每个session对应一个对象。而在代理的时候有两种方式，一种是基于JDK的interface的，一种是CGLIB形式的，如果要代理的类是面向对象的，就可以直接使用JDK的代理，否则就需要开启对CGLIB代理的支持，同时要引入CGLIB的jar包。

    Xml代码   
    
  
<bean id="userPreferences" class="com.foo.DefaultUserPreferences" scope="session">  
  <aop:scoped-proxy proxy-target-class="false"/><!-- 为true则为开启对CGLIB的支持  -->  
</bean>  

Spring bean scope --scopes

Guess you like