The scope of the bean in spring is detailed

How to use the scope of spring:
<bean id= "Role" class= "Spring.chapter2.maryGame.Role" scope= "singleton"/>
This scope is used to configure the scope of the spring bean, which identifies the scope of the bean.
Before spring2.0 beans had only 2 scopes: Singleton (singleton), Non-singleton (also known as prototype), Spring2.0 later, added session, request, global Session three beans dedicated to the context of the Web application. Therefore, by default Spring2.0 now has five types of beans. Of course, Spring2.0 the design of the bean type, and design a flexible bean type support, theoretically can have countless types of beans, users can according to their own needs, add new bean type, to meet the actual application needs.
1. Singleton scope (default value of scope)
When the scope of a bean is set to Singleton, only one shared bean instance exists in the spring IOC container, and all requests to the bean, as long as the ID matches the bean definition, will return only the same instance of the bean. In other words, when a bean definition is set to singleton scope, the Spring IOC container only creates a unique instance of the bean definition. This single instance is stored in the singleton cache (singleton cache), and all subsequent requests and references to the bean will return the cached object instance, noting that the singleton in the singleton scope and GOF design pattern is completely different, The singleton design pattern indicates that only one class exists in a ClassLoader, and here the singleton represents a container for a bean, which means that when a bean is identified as Singleton, Only one of the beans will exist in spring's IOC container.
Configuration instance:
<bean id= "Role" class= "Spring.chapter2.maryGame.Role" scope= "singleton"/>
Or
<bean id= "Role" class= "Spring.chapter2.maryGame.Role" singleton= "true"/>
2, prototype
Prototype-scoped beans, each request (injecting it into another bean, or invoking the container's Getbean () method programmatically) produces a new bean instance, which is equivalent to the operation of an For prototype-scoped beans, it is important to note that spring cannot be responsible for the entire life cycle of a prototype bean, which is given to the client after it is initialized, configured, decorated, or assembled with a prototype instance. The prototype instance is then ignored. Regardless of the scope, the container invokes the initialization lifecycle callback method for all objects, and for prototype, any configured destructor life-cycle callback methods will not be called. Clearing prototype-scoped objects and releasing expensive resources held by any prototype bean is the responsibility of the client code. (One possible way for the spring container to release the resource that is consumed by the singleton scope Bean is by using the bean's post processor, which holds a reference to the bean to be purged.) ）
Configuration instance:
<bean id= "Role" class= "Spring.chapter2.maryGame.Role" scope= "prototype"/>
Or
<beanid= "Role" class= "Spring.chapter2.maryGame.Role" singleton= "false"/>
3. Request
The request indicates that a new bean will be generated for each HTTP request, and that the bean is only valid within the current HTTP requests, configuring the instance:
When you use the request, session, global session, you first need to configure the following configuration in Web. XML, which is initialized:
If you are using a Web container of servlet 2.4 and above, you only need to add the following contextlistener to the Web application's XML declaration file:

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

, if the previous Web container was Servlet2.4, you would use a Javax.servlet.Filter implementation:
<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>

The

can then configure the scope of the bean:
<bean id= "role" class= "Spring.chapter2.maryGame.Role" scope= "request"/>
4. The session
Session scope indicates that a new bean is generated for each HTTP request, and that the bean is valid only within the current HTTP session, configuration instance:
Configuration instance:
and the request configuration instance, Configuring a Web Boot file can be configured as follows:
<bean id= "role" class= "Spring.chapter2.maryGame.Role" scope= "session"/>
5, Global The session
Global session scope is similar to the standard HTTP session scope, but it only makes sense in portlet-based Web applications. The Portlet specification defines the concept of a global session, which is shared by all the various portlets that make up a portlet Web application. The bean defined in the global session scope is limited to the lifetime of the world Portlet session. If you use the global session scope to identify the bean in the Web, the Web is automatically used as the session type.
Configuration instance:
As with the request configuration instance, the configuration of the Web boot file can be configured as follows:
<bean id= "role" class= "Spring.chapter2.maryGame.Role" Scope= "Global Session"/>
6, Custom bean assembly scope
Scopes can be arbitrarily extended in spring2.0, you can customize scopes, and even you can redefine existing scopes (but you can't overwrite Singleton and prototype), The scope of spring is defined by the interface Org.springframework.beans.factory.config.Scope, as long as you implement the interface, and here's an example:
We create a scope for a thread, The scope is valid in representing a thread, and the code is as follows:

Publicclass MyScope implements Scope {
privatefinal ThreadLocal threadscope = new ThreadLocal () {
Protected Object InitialValue () {
Returnnew HashMap ();
}
};
Public Object Get (String name, Objectfactory objectfactory) {
Map scope = (map) threadscope.get ();
Object object = Scope.get (name);
if (object==null) {
Object = Objectfactory.getobject ();
Scope.put (name, object);
}
return object;
}
Public Object Remove (String name) {
Map scope = (map) threadscope.get ();
return Scope.remove (name);
}
Publicvoid Registerdestructioncallback (String name, Runnable callback) {
}
Public String Getconversationid () {
TODO auto-generated Method Stub
Returnnull;
}
}