The spring bean's scope

The spring bean's scope

spring容器中的bean默认“单实例”的，即不管你调用 getBean() 方法多少次，得到的始终是一个bean实例。

Spring provides us with beans after instantiating and coniguring them. Spring

Container manages objects. This means that any object can refer to any other object from Spring Container using the bean's ID, and Spring Container provides an instance of the requesting object.

When we start Spring Container, ApplicationContext reads the Spring coniguration,file looks for all bean deinitions available there, and then initializes beans before any call to the getBean() method.

During initialization, ApplicationContext itself has initialized all the Spring beans conigured in Spring XML. When another object makes a call to the getBean() method, ApplicationContext returns the same reference of bean that has already been initialized.
This is the default behavior of beans.

Singleton

By default, all Spring beans are singleton. Once ApplicationContext is initialized,

it looks at all the beans in XML and initializes only one bean per bean deinition in

Spring Container. On each call to the getBean() method, Spring Container returns

the same instance of the bean.

The first bean scope in Spring that is called is singleton, which initializes only one

bean per bean deinition in the container and returns the same instance reference

on each call to the getBean() method. This scope makes Spring initialize all beans

during the load time itself without waiting for the getBean() call.

当我们讨论单实例模式时候，一般要涉及到jvm实例。不过，在spring中，单实例就被限制在了spring容器内了。

当然，一个jvm实例可以运行多个spring容器，所以一个jvm实例内可以有一个bean的多个实例。

The singleton pattern in general says that overall there will be only one instance of

the object. But when we talk about singleton in the Spring Framework, we are talking

about Spring Container alone.

We can have multiple containers running in the same JVM, so we can have multiple

instances of the same bean in same JVM.

So, singleton in Spring represents in a particular Spring container, and there is only

one instance of a bean created in that container that is used across different references.

Prototype

原型模式，每次获取的bean实例都是全新的。

The prototype is second bean scope in Spring, which returns a brand-new instance of

a bean on each call to the getBean() method. When a bean is deined as a prototype,

Spring waits for getBean() to happen and only then does it initialize the prototype.

For every getBean() call, Spring has to perform initialization, so instead of doing

default initialization while a context is being created, it waits for a getBean() call.

So, every time getBean() gets called, it creates a new instance.

Request

The third bean scope in Spring is request, which is available only in web applications

that use Spring and create an instance of bean for every HTTP request. Here, a new

bean is created per Servlet request. Spring will be aware of when a new request is

happening because it ties well with the Servlet APIs, and depending on the request,

Spring creates a new bean. So, if the request scope has getBean() inside it, for every

new request, there will be a new bean. However, as long as it's in the same request

scope, the same bean is going to be used.

Session

The session is the fourth bean scope in Spring, which is available only in web

applications that use Spring and create an instance of bean for every HTTP session.

Here, a new bean is created per session. As long as there is one user accessing in a

single session, each call to getBean() will return same instance of the bean. But if

it's a new user in a different session, then a new bean instance is created.

Global session

The global session is the ifth bean scope in Spring, which works only in portlet

environments that use Spring and create a bean for every new portlet session.