A detailed description of the value of the scope scope of the spring bean

The scope of scope is studied today. The default is the singleton mode, which is scope= "singleton". In addition, scope also has prototype, request, session, global session scope. Scope= "prototype" multiple examples. When you configure the scope of the bean, its header file is as follows:

How to use the scope of spring:

<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 when a bean's   scope is set to Singleton, only a shared bean instance exists in the spring IOC container, and all requests to the bean, as long as the ID matches the bean definition, Only the same instance of the bean is returned. 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: 

<id= "role" class= "Spring.chapter2.maryGame.Role" scope= "Singleton"/> or <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: 

<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 valid only within the current HTTP requests, configuration instance: request, session, global When using the session, the first thing to do is to configure Web. XML in the Web to initialize the following configuration: If you are using servlet 2.4 and above, Then 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 you are Servlet2.4 a previous web container, then you need to 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</filter-name> <url-pattern</url-pattern > </> ... </web-app>  

You can then configure the scope of the bean:

<id= "role" class= "Spring.chapter2.maryGame.Role" scope= "Request"/> 

4. Session

The session scope indicates that a new bean will be generated for each HTTP request, and that the bean is valid only within the current HTTP session, configuration instance: configuration instance: As with the request configuration instance, the configuration of the Web boot file can be configured as follows:

<id= "role" class= "Spring.chapter2.maryGame.Role" Scope= "session"/> 

5. Global session

The 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:

<id= "role" class= "Spring.chapter2.maryGame.Role" scope= "Global Session"/> 

A detailed description of the value of the scope scope of the spring bean