Spring Bean Scope | 5 Principaux types de Scope dans Spring

Objectif

Dans l’article précédent, nous avons appris la définition de Spring Bean. Aujourd’hui, nous allons apprendre à connaître la portée de Spring Bean. De plus, nous allons discuter des différents types de Scopes dans les Spring Beans. Chacun de ces scopes sera défini à l’aide d’exemples pratiques dans l’IDE Eclipse. En outre, nous apprendrons à savoir quand utiliser un scope singleton et prototype dans Spring Framework.
Donc, commençons Spring Bean Scope.

Spring Bean Scope

Comme vous le savez, le scope du bean Spring définit le cycle de vie et la visibilité du bean dans les contextes dans lesquels il est utilisé. Lors de la définition d’un < bean>, vous avez la possibilité de déclarer le scope de ce bean Spring particulier.
Explorons les avantages du Spring Framework avec ses limites

Types de scope dans le Spring Bean

Le Spring Framework possède cinq types de scope qu’il supporte. Ce sont les suivants :

a. Singleton Scope dans Spring

Si le Spring Bean scope est rendu singleton, alors le conteneur IoC de Spring définit une seule instance de l’objet. Cette instance est stockée dans le cache des singleton beans. Aussi, toutes les requêtes pour ce nom retourneront la même instance qui est mise en cache. En plus de cela, toute modification apportée à cette instance sera reflétée dans toutes les références à un Spring bean.
Créons une entité Personne comme suit:

public class Person { private String name; // standard constructor, getters and setters}

Spring Beans avec une portée singleton :

@Bean@Scope("singleton")public Person personSingleton() { return new Person();}

Savez-vous quelle est la dernière tendance en matière de rôles d’emploi et de salaire de Spring Framework
Vous pouvez également voir deux objets faisant référence aux mêmes beans avec les mêmes valeurs:

private static final String NAME = "Sam";@Testpublic void givenSingletonScope_whenSetName_thenEqualNames() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scopes.xml"); Person personSingletonA = (Person) applicationContext.getBean("personSingleton"); Person personSingletonB = (Person) applicationContext.getBean("personSingleton"); personSingletonA.setName(NAME); Assert.assertEquals(NAME, personSingletonB.getName()); ((AbstractApplicationContext) applicationContext).close();}

Les scopes.xml est le suivant:

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean class="org.example.scopes.Person" scope="singleton"/></beans>

b. Prototype Scope dans Spring

Ceci va scope une définition de bean pour avoir un nombre quelconque d’instances d’objets. Il retournera une instance différente à chaque fois que la requête viendra du conteneur IoC.
Lire à propos de la configuration basée sur Spring Java – Comment configurer les beans de Spring
Le prototype est défini sur l’annotation @Scope dans la définition du bean:

@Bean@Scope("prototype")public Person personPrototype() { return new Person();}

Vous verrez le même test qui est fait pour le scope Spring Singleton qui est deux objets demandant le même nom de bean:

private static final String NAME = "Sam";private static final String NAME_OTHER = "Hari";@Testpublic void givenPrototypeScope_whenSetNames_thenDifferentNames() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scopes.xml"); Person personPrototypeA = (Person) applicationContext.getBean("personPrototype"); Person personPrototypeB = (Person) applicationContext.getBean("personPrototype"); personPrototypeA.setName(NAME); personPrototypeB.setName(NAME_OTHER); Assert.assertEquals(NAME, personPrototypeA.getName()); Assert.assertEquals(NAME_OTHER, personPrototypeB.getName()); ((AbstractApplicationContext) applicationContext).close();}

Le scopes.xml est défini comme:

<bean class="org.example.scopes.Person" scope="prototype"/>

c. Scope de la requête dans Spring

Cette requête va scope une définition de bean à la requête HTPP. Ceci n’existe que dans le contexte d’une application Spring consciente du web. Vous allez définir le bean avec le scope de la requête sous l’annotation @Scope:

@Bean@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)public HelloMessageGenerator requestMessage() { return new HelloMessageGenerator();}

L’attribut proxyMode est nécessaire car lors de l’instanciation du contexte d’application web, il n’y a pas de requête active. Le Spring Framework créera le proxy pour l’injection en tant que dépendance.
Puis, vous devez définir le contrôleur qui a une référence au bean requestMessage. Pour cela, vous devez accéder à la même requête plusieurs fois pour tester les scopes spécifiques au web.

@Controllerpublic class ScopesController { @Resource(name = "requestMessage") HelloMessageGenerator requestMessage; @RequestMapping("/scopes") public String getScopes(Model model) { requestMessage.setMessage("Good morning!"); model.addAttribute("requestMessage", requestMessage.getMessage()); return "scopesExample"; }}

d. Session Scope dans Spring

De la même manière, vous pouvez définir les beans dans la session scope comme:

@Bean@Scope(value = WebApplicationContext.SCOPE_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)public HelloMessageGenerator sessionMessage() { return new HelloMessageGenerator();}

De la même manière, on définit le contrôleur avec la référence au bean sessionMessage. Pour cela, il faut exécuter deux requêtes de manière à montrer que la valeur du champ message est la même pour la session.
Voir Spring Transaction Management – Types et méthodes

@Controllerpublic class ScopesController { @Resource(name = "sessionMessage") HelloMessageGenerator sessionMessage; @RequestMapping("/scopes") public String getScopes(Model model) { sessionMessage.setMessage("Hello there!"); model.addAttribute("sessionMessage", sessionMessage.getMessage()); return "scopesExample"; }}

e. Global Session Scope in Spring

Ce type scope la définition du bean à la session HTTP globale et n’est valable que pour le contexte d’application web-aware de Spring. Ce type est utilisé dans les applications de conteneur de portlet où chaque portlet ayant leur session. Maintenant, vous verrez le bean avec le scope globalSession sous l’annotation @Scope:

@Bean@Scope(value = WebApplicationContext.SCOPE_GLOBAL_SESSION, proxyMode = ScopedProxyMode.TARGET_CLASS)public HelloMessageGenerator globalSessionMessage() {return new HelloMessageGenerator();}

So, c’était tout sur le tutoriel Spring Bean Scope. J’espère que vous avez aimé nos explications.

Conclusion

Hence, dans cette session, nous avons vu ce qu’est Spring Bean Scope et comment définir les scopes des beans. De plus, nous avons discuté des différents types de scopes dans Spring Bean. Nous avons également vu chacun des types de scopes définis séparément avec des exemples utilisant l’IDE Eclipse. En outre, si vous avez une question concernant Spring Bean Scope, n’hésitez pas à demander dans la section des commentaires.
Thème connexe- Intégration de MVC avec Spring
Pour référence

.