Portées magiques : comment Spring organise les haricots

Des assistants habiles et diligents - des haricots - ont travaillé dans l'atelier du printemps. Chacun d'eux était doté de sa propre tâche : certains créaient des jouets, d'autres triaient des bonbons et certains faisaient pousser des fleurs aux couleurs vives.

Pour garantir que le travail de l'atelier soit ordonné et efficace, des règles claires ont été établies pour les bacs - portées. Ces règles déterminaient la durée pendant laquelle les beans pouvaient exister et combien d'instances du même type pouvaient être créées en même temps. Grâce à ces cadres magiques, l'atelier s'est déroulé de manière fluide et fiable.

Prototype : Hérisson Boulanger

Chaque fois que quelqu'un commande une tarte, le Hérisson Baker crée une nouvelle tarte avec des ingrédients uniques.

Hérisson : "Chacun veut son propre goût ! C'est pourquoi je crée une tarte fraîche pour chaque commande."

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

Voici comment fonctionne le scope prototype au Spring : chaque fois qu'un nouvel objet est demandé, une instance unique du bean est créée. Ceci est utile lorsque vous avez besoin d'une logique isolée pour chaque utilisation.

Par exemple :

L'application dispose d'un bean qui génère un rapport pour chaque utilisateur :

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

Chaque appel à context.getBean(ReportGenerator.class) créera une nouvelle instance. Ceci est pratique pour traiter des données uniques dans des systèmes multi-utilisateurs.

---

Requête : Lapin Carotte

Le lapin distributeur explique à ses assistants :

"Pour chaque invité qui vient à la clairière, je ramasse des carottes. Mais dès que l'invité part, le panier me revient."

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

La portée

Request au Spring signifie qu'un bean est créé pour chaque requête HTTP. Une fois la requête terminée, le bean est détruit.

Exemple d'utilisation :
Imaginez que dans une application web vous disposez d'un composant pour collecter les données utilisateur :

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

Chaque requête utilisateur se voit attribuer un panier unique, qui « vit » uniquement dans le cadre du traitement de la requête HTTP. Une fois la requête terminée, le bean est supprimé, libérant ainsi de la mémoire.

Comparaison du Prototype et de la Demande en développement réel :

Prototype : utilisé pour les tâches qui nécessitent des instances uniques à chaque appel, telles que les tests, la génération de données uniques, le traitement de tâches isolées.
Requête : utile dans les applications Web pour assurer l’isolation des données entre les demandes des utilisateurs. Par exemple, un panier d'achat, des données d'authentification ou des jetons temporaires.
Différence d'approches :

Le prototype peut être utilisé dans n'importe quel contexte, y compris les applications console.
La requête est strictement liée au contexte web car elle dépend des requêtes HTTP.

---

Singleton : Bob le bricoleur

Bob le Bricoleur travaille dans la forêt et construit un barrage pour tout le monde. Il dit :

"Je suis seul et je construirai n'importe quoi, peu importe le nombre d'animaux qui viennent à moi !"

Cela signifie que nous aurons toujours la même instance de l'objet à laquelle tous les clients accèdent. Et à chaque fois, c'est le même Bob qui revient. Il n'avait pas besoin d'être cloné ou de disparaître. Il a donc travaillé jour après jour.

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

Singleton est la portée par défaut au printemps. Une instance du bean est créée pour toute la durée de l'application. Ce bean est utilisé lorsqu'un objet doit être une ressource partagée entre tous les composants de l'application.

Exemple d'utilisation :
Disons que vous disposez d'un composant de journalisation :

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

Ce bean est créé une seule fois et tous les composants de l'application l'utilisent pour enregistrer les journaux. Ceci est efficace et économise de la mémoire.

Candidature :

• Journalisation
• Travailler avec une base de données via un pool de connexions
• Gérer les caches

---

Séance : Ours au miel

Le petit ours prépare du miel pour chaque invité qui vient chez lui. Il dit :

"Pendant que vous me rendez visite, je m'occupe de votre pot de miel. Mais dès que vous partez, votre pot de miel disparaît."

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

La portée de la session au Spring signifie que le bean existe aussi longtemps que dure la session HTTP de l'utilisateur.

Explication technique :
Cette portée est utilisée dans les applications Web pour lier un objet à une session utilisateur spécifique. À la fin de la session, le bean est détruit.

Exemple d'utilisation :
Imaginez que vous disposez d'un composant pour stocker les données d'autorisation des utilisateurs :

@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;
    }
}

Ce bean est créé pour chaque utilisateur aussi longtemps que dure sa session.

Candidature :

• Stockage des données utilisateur (par exemple, autorisation, préférences)
• Gestion des jetons de session

---

Application : Filin Phil

Phil le hibou raconte chaque soir des contes de fées à tous les habitants de la forêt. Il dit :

"Mon conte de fées est le seul de toute la forêt. Tout le monde vient m'écouter, et il y en a pour tout le monde !"

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

Portée application signifie que le bean est créé une fois pour l'ensemble de l'application, mais diffère du singleton en ce qu'il est utilisé uniquement dans le contexte d'applications Web.

Cette portée est similaire au singleton, mais est contrôlée par le contexte Web. Il est utilisé pour les composants qui doivent être accessibles dans toute l'application.

Exemple d'utilisation :
Par exemple, un bean pour stocker les paramètres globaux :

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

Ce bean est créé une seule fois et est disponible pour tout le monde.

Candidature :

• Configuration des applications
• Paramètres globaux
• Cache de données partagé par tous les utilisateurs

Comparaison de tous les scopes Spring

Portée Cycle de vie Exemple d'utilisation ête>

Scope	Жизненный цикл	Пример использования
Singleton	Всё время работы приложения	Логирование, работа с базами данных
Prototype	Новый объект при каждом вызове	Генерация отчётов, тестирование
Request	Один HTTP-запрос	Корзина покупок, временные данные
Session	Вся HTTP-сессия пользователя	Данные авторизации, настройки пользователя
Application	Всё время работы приложения	Глобальные настройки, кэш на уровне приложения

Célibataire Tout le temps que l'application est en cours d'exécution Journalisation, utilisation de bases de données Prototype Nouvel objet à chaque appel Génération de rapports, tests Demande Une requête HTTP Panier, données temporaires Séance Session utilisateur HTTP entière Données d'autorisation, paramètres utilisateur Application Tout le temps que l'application est en cours d'exécution Paramètres globaux, cache au niveau de l'application

Quand utiliser quoi ?
Singleton - pour les ressources partagées et immuables.
Prototype - pour des tâches isolées, des données uniques.
Demande - pour des données temporaires dans une seule demande.
Session - pour les données qui doivent être stockées entre les requêtes du même utilisateur.
Application - pour les données globales utilisées par tous les utilisateurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!