Java detailed analysis of Bean scope

This article brings you relevant knowledge about java. The Spring framework is an IoC container that manages Beans, so Beans are naturally important resources in Spring. The scope of Beans is What's the meaning? How many types are there? Let’s take a look at it together, I hope it will be helpful to everyone.

Recommended study: "java Video Tutorial"

Spring framework is an IoC container that manages Beans, so Beans are naturally Spring An important resource in Bean, what does the scope of Bean mean? How many types are there? Let’s take a look next.

PS: Public classes in Java can be called Beans or Java Beans.

1. Scope

The scope of a Bean refers to a certain behavior mode of the Bean in the entire Spring framework. For example, the singleton scope means that there is only one copy of the Bean in the entire Spring, and it is shared globally. When someone modifies the value, what another person reads is the modified value.

For example, we define a singleton Bean object user in Spring (the default scope is singleton). The specific implementation code is as follows:

@Component
public class UserBean {
    @Bean
    public User user() {
        User user = new User();
        user.setId(1);
        user.setName("Java"); // 此行为重点：用户名称为 Java
        return user;
    }
}

Then, in class A The user object is used and modified in class B. The specific implementation code is as follows:

@Controller
public class AController {
    @Autowired
    private User user;
    public User getUser() {
        User user = user;
        user.setName("MySQL"); // 此行为重点：将 user 名称修改了
        return user;
    }
}

Finally, the user object is also used in class B. The specific implementation code is as follows:

@Controller
public class BController {
    @Autowired
    private User user;
    public User getUser() {
        User user = user;
        return user;
    }
}

At this time we access the B object In the getUser method, you will find that the user name at this time is "MySQL" modified in class A instead of the original "Java". This means that the Bean object user defaults to the singleton scope. If this singleton object is modified anywhere, other classes will get a modified value when called again.

2. Scope classification

In Spring, there are five common scopes of Bean:

• singleton: singleton scope;
• prototype: prototype scope (multiple instance scope);
• request: request scope;
• session: session scope;
• application: global scope .

Note: The last three scopes are only applicable to the Spring MVC framework.

2.1 singleton

Official description: (Default) Scopes a single bean definition to a single object instance for each Spring IoC container.

Description: This scope There is only one instance of the Bean below in the IoC container: the obtained Bean (that is, obtained through applicationContext.getBean and other methods) and the assembled Bean (that is, injected through @Autowired) are both the same object.

Scenario: Usually stateless beans use this scope. Stateless means that the property state of the Bean object does not need to be updated.

Note: Spring selects this scope by default.

2.2 prototype

Official description: Scopes a single bean definition to any number of object instances.

Description: Each time the Bean under this scope is New instances will be created for every request: obtaining beans (ie, obtaining them through applicationContext.getBean and other methods) and assembling beans (ie, injecting them through @Autowired) are both new object instances.

Scenario: Usually stateful beans use this scope.

2.3 request

Official description: Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

Description: Each Http request creates a new Bean instance, similar to prototype.

Scenario: An Http request and response shared bean.

Note: Limited to use in Spring MVC framework.

2.4 session

Official description: Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

Description : In an Http Session, define a Bean instance.

Scenario: Shared Bean of user session, for example: recording a user’s login information.

Note: Limited to use in Spring MVC framework.

2.5 application

Official description: Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.

Description: In an Http Servlet Context, define a Bean instance.

Scenario: Context information of Web applications, such as recording shared information of an application.

Note: Limited to use in Spring MVC framework.

3. Scope setting

We can set the scope of the Bean through the @Scope annotation. There are two ways to set it:

Set the scope directly Specific values, such as: @Scope("prototype");

Set the SCOPE_XXX variables provided by ConfigurableBeanFactory and WebApplicationContext, such as @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE).

The specific setting code is as follows:

The scope of a Bean refers to a certain behavioral pattern of the Bean in the entire Spring framework. There are 5 common scopes of Bean: singleton (single case scope), prototype (prototype scope), request (request scope), session (request scope), and application (global scope). Pay attention to the last three functions. Domains are only available in the Spring MVC framework.

Recommended study: "java video tutorial"

The above is the detailed content of Java detailed analysis of Bean scope. For more information, please follow other related articles on the PHP Chinese website!