How to use spring's scope:
<bean class="spring." scope="singleton"/>
The scope here is used to configure the scope of the spring bean, which identifies the scope of the bean.
Before spring 2.0, beans had only two scopes: singleton (singleton), non-singleton (also known as prototype). After Spring 2.0, three beans specifically designed for web application contexts were added. Therefore, Spring 2.0 now has five types of beans by default. Of course, Spring 2.0 has refactored the design of bean types and designed flexible bean type support. In theory, there can be countless types of beans. Users can add new bean types according to their needs to meet practical application needs.
1. Singleton scope (scope default value)
When abeanThe scope ofsingleton, SoSpring IOCThere will only be one shared in the containerbeanExample，And all thebeanRequest，if onlyidWith thisbeanDefinition match，It will only returnbean的同一Example。 In other words, when setting a bean definition to singleton scope, the Spring IOC container only creates a unique instance of the bean definition. This single instance will be stored in the singleton cache, and all subsequent requests and references to the bean will return the cached object instance. It should be noted here that the singleton scope and the singleton in the GOF design pattern are completely different. The singleton design pattern means that only one class exists in a ClassLoader, and the singleton here means that a container corresponds to a bean, that is, when a bean is identified as a singleton, only one bean will exist in the spring IOC container.
Configuration instance:
<bean class="spring." scope="singleton"/>
or
<bean class="spring." singleton="true"/>
2、prototype
Every request (injecting it into another bean, or calling the container's getBean() method in the form of a program) will produce a new bean instance, which is equivalent to a new operation. For beans with prototype scope, one is very important, that is, Spring cannot be responsible for the entire life cycle of a prototype bean. After the container initializes, configures, decorates or assembles a prototype instance, it handes it to the client, and then ignores the prototype instance. Regardless of the scope, the container will call the initialized lifecycle callback method of all objects, and for prototype, any configured destructed lifecycle callback method will not be called. It is the responsibility of the client code to clear the prototype scoped object and free any expensive resources held by the prototype bean. (One feasible way to have the Spring container free resources occupied by a singleton-scoped bean is by using the bean's postprocessor, which holds a reference to the bean to be cleared.)
Configuration instance:
<bean class="spring." scope="prototype"/>
or
<bean class="spring." singleton="false"/>
3、request
The request indicates that a new bean will be generated for each HTTP request. At the same time, the bean is only valid in the current HTTP request. The configuration instance is:
When using request, session, and global session, you must first make the following configuration in the initialized web:
If you are using a web container with Servlet 2.4 and above, you only need to add the following ContextListener to the XML declaration file of the web application:
<web-app>
...
<listener>
<listener-class></listener-class>
</listener>
...
</web-app>
, if it is a web container before Servlet 2.4, then you need to use an implementation:
<web-app>
..
<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class></filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
...
</web-app>
Then you can configure the scope of the bean:
<bean class="spring." scope="request"/>
4、session
The session scope indicates that a new bean will be generated for each HTTP request. At the same time, the bean is only valid in the current HTTP session. The configuration instance is:
Configuration instance:
Just like the prerequisite for configuring the request instance, after configuring the web startup file, you can configure it as follows:
<bean class="spring." 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 different portlets that make up a certain portlet web application. Beans defined in the global session scope are limited to the life cycle of the global portlet session. If you use the global session scope in the web to identify beans, the web will automatically be used as the session type.
Configuration instance:
Just like the prerequisite for configuring the request instance, after configuring the web startup file, you can configure it as follows:
<bean class="spring." scope="global session"/>
6. Custom bean assembly scope
In spring 2.0, scope can be expanded arbitrarily. You can customize the scope, and you can even redefine the existing scope (but you cannot override singleton and prototype). The scope of spring is defined by the interface. You can customize your own scope as long as you implement the interface. Here is an example:
We create a thread's scope, which 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) ();
Object object = (name);
if(object==null) {
object = ();
(name, object);
}
return object;
}
public Object remove(String name) {
Map scope = (Map) ();
return (name);
}
publicvoid registerDestructionCallback(String name, Runnable callback) {
}
public String getConversationId() {
// TODO Auto-generated method stub
returnnull;
}
}