Skillful and diligent assistants - beans - worked in the Spring workshop. Each of them was endowed with their own unique task: some created toys, some sorted candies, and some grew bright flowers.

To ensure that the work of the workshop was orderly and efficient, clear rules were established for bins - scopes. These rules determined how long beans could exist and how many instances of the same kind could be created at the same time. Thanks to these magical frameworks, the workshop worked smoothly and reliably.

Prototype: Hedgehog Baker

Every time someone orders a pie, the Hedgehog Baker creates a new pie with unique ingredients.

Hedgehog: "Everyone wants their own taste! That's why I create a fresh pie for every order."

@Component
@Scope("prototype")
public class Hedgehog {
    public void bakePie() {
        System.out.println("Пеку пирог!");
    }
}

This is how scope prototype works in Spring: each time a new object is requested, a unique instance of the bean is created. This is useful when you need isolated logic for each use.

For example:

The application has a bean that generates a report for each user:

@Component
@Scope("prototype")
public class ReportGenerator {
    public Report generate(String userData) {
        // Генерация уникального отчета
        return new Report(userData);
    }
}

Each call to context.getBean(ReportGenerator.class) will create a new instance. This is convenient for processing unique data in multi-user systems.

Request: Carrot Bunny

The dispensing rabbit explains to his assistants:

"For every guest who comes to the clearing, I collect carrots. But as soon as the guest leaves, the basket returns to me."

@Component
@Scope("prototype")
public class Hedgehog {
    public void bakePie() {
        System.out.println("Пеку пирог!");
    }
}

Request scope in Spring means that one bean is created for each HTTP request. Once the request is completed, the bean is destroyed.

Usage example:
Imagine that in a web application you have a component to collect user data:

@Component
@Scope("prototype")
public class ReportGenerator {
    public Report generate(String userData) {
        // Генерация уникального отчета
        return new Report(userData);
    }
}

Each user request is allocated a unique basket, which “l(fā)ives” only as part of processing the HTTP request. Once the request is completed, the bean is deleted, freeing memory.

Comparison of Prototype and Request in real development:

Prototype: Used for tasks that require unique instances on each call, such as testing, generating unique data, processing isolated tasks.
Request: Useful in web applications to provide data isolation between user requests. For example, a shopping cart, authentication data or temporary tokens.
Difference in approaches:

Prototype can be used in any context, including console applications.
Request is strictly bound to the web context because it depends on HTTP requests.

Singleton: Bob the Builder

Bob the Builder works in the forest and builds a dam for everyone. He says:

"I am alone, and I will build anything, no matter how many animals come to me!"

This means that we will always have the same instance of the object that all clients access. And every time the same Bob comes. He didn't need to be cloned or disappear. So he worked day after day.

@Component
@Scope("prototype")
public class Hedgehog {
    public void bakePie() {
        System.out.println("Пеку пирог!");
    }
}

Singleton is the default scope in Spring. One instance of the bean is created for the entire duration of the application. This bean is used when an object must be a shared resource among all application components.

Usage example:
Let's say you have a logging component:

@Component
@Scope("prototype")
public class ReportGenerator {
    public Report generate(String userData) {
        // Генерация уникального отчета
        return new Report(userData);
    }
}

This bean is created once, and all application components use it to record logs. This is efficient and saves memory.

Application:

• Logging
• Working with a database through a connection pool
• Manage caches

Session: Honey Bear

The little bear cooks honey for every guest who comes to his house. He says:

"While you are visiting me, I take care of your honey pot. But as soon as you leave, your honey pot disappears."

@Component
@Scope("request")
public class Rabbit {
    public void giveCarrot() {
        System.out.println("Вот твоя морковка!");
    }
}

The session scope in Spring means that the bean exists as long as the user's HTTP session lasts.

Technical explanation:
This scope is used in web applications to bind an object to a specific user session. When the session ends, the bean is destroyed.

Usage example:
Imagine that you have a component to store user authorization data:

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserCart {
    private List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public List<Item> getItems() {
        return items;
    }
}

This bean is created for each user for as long as their session lasts.

Application:

• Storing user data (for example, authorization, preferences)
• Session token management

Application: Filin Phil

Phil the owl tells fairy tales to all the forest dwellers every evening. He says:

"My fairy tale is the only one in the whole forest. Everyone comes to listen to me, and there is enough for everyone!"

@Component
@Scope("prototype")
public class Hedgehog {
    public void bakePie() {
        System.out.println("Пеку пирог!");
    }
}

Scope application means that the bean is created once for the entire application, but differs from singleton in that it is used only in the context of web applications.

This scope is similar to singleton, but is controlled by the web context. It is used for components that must be accessible throughout the application.

Usage example:
For example, a bean for storing global settings:

@Component
@Scope("prototype")
public class ReportGenerator {
    public Report generate(String userData) {
        // Генерация уникального отчета
        return new Report(userData);
    }
}

This bean is created once and is available to everyone.

Application:

• Application configuration
• Global settings
• Data cache shared by all users

Comparison of all Spring scopes

When to use what?
Singleton - for shared, non-changing resources.
Prototype - for isolated tasks, unique data.
Request - for temporary data within one request.
Session - for data that needs to be stored between requests of the same user.
Application - for global data that is used by all users.

The above is the detailed content of Magic scopes: How Spring organizes beans. For more information, please follow other related articles on the PHP Chinese website!