Spring Bean Scope | 5 belangrijke soorten Scope in Spring

Objective

In het vorige artikel hebben we geleerd over de definitie van Spring Bean. Vandaag zullen we meer te weten komen over de Spring Bean Scope. Bovendien zullen we verschillende types van Scopes in Spring Beans bespreken. Elk van de scopes zal worden gedefinieerd met werkende voorbeelden met behulp van Eclipse IDE. Daarnaast zullen we te weten komen wanneer je een singleton en prototype scope in Spring Framework moet gebruiken.
Dus, laten we beginnen met Spring Bean Scope.

Spring Bean Scope

Zoals je weet definieert de scope van de Spring bean de levenscyclus en de zichtbaarheid van de bean in contexten waarin deze wordt gebruikt. Bij het definiëren van een < boon> heb je de mogelijkheid om de scope van die specifieke Spring boon te declareren.
Laten we de voordelen van Spring Framework met beperkingen

Types of Scope in Spring Bean

Het Spring Framework heeft vijf types van scope die het ondersteunt. Deze zijn als volgt:

a. Singleton Scope in Spring

Als de Spring Bean scope singleton is gemaakt dan definieert de Spring IoC container slechts één instantie van het object. Die instantie wordt opgeslagen in de cache van singleton beans. Ook zullen alle requests voor die naam dezelfde instantie teruggeven die in de cache zit. Bovendien zullen alle wijzigingen die aan die instantie worden aangebracht, worden weerspiegeld in alle verwijzingen naar een Spring boon.
Laten we een entiteit Person als volgt maken:

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

Spring Beans met singleton scope:

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

Kent u de nieuwste Job Roles and Salary trend van Spring Framework
U kunt ook twee objecten zien die verwijzen naar dezelfde beans met dezelfde waarden:

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();}

De scopes.xml ziet er als volgt uit:

<?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 in Spring

Hiermee kan een baandefinitie een willekeurig aantal objectinstanties bevatten. Het zal elke keer een andere instantie teruggeven als er een verzoek komt van de IoC container.
Lees over Spring Java Based Configuration – How to Configure Spring Beans
Het prototype is ingesteld op de @Scope annotatie in de boondefinitie:

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

Je zult dezelfde test zien die wordt gedaan voor de Spring Singleton scope, dat zijn twee objecten die dezelfde boonnaam aanvragen:

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();}

De scopes.xml is gedefinieerd als:

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

c. Request Scope in Spring

Dit verzoek zal een bean definitie scopen naar HTPP verzoek. Dit is er alleen in de context van web-aware Spring Application context. Je definieert de bean met de request scope onder de @Scope annotatie:

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

Het attribuut proxyMode is nodig omdat tijdens de instantiatie van web applicatie context, er geen actief request is. Het Spring Framework zal de proxy maken voor de injectie als een dependency.
Volgende, je moet de controller definiëren die een verwijzing heeft naar de requestMessage bean. Daarvoor moet je hetzelfde request meer dan eens benaderen om de web-specifieke scopes te testen.

@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 in Spring

Op dezelfde manier kun je de bonen binnen de session scope definiëren als:

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

Op dezelfde manier wordt de controller met de verwijzing naar de sessionMessage bean gedefinieerd. Daarvoor moet je twee requests uitvoeren om te laten zien dat de waarde van het message veld hetzelfde is voor de sessie.
Kijk eens naar Spring Transaction Management – Types en Methods

@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

Dit scoopt de baandefinitie naar een globale HTTP sessie en is alleen geldig voor web-aware Application context van Spring. Dit type wordt gebruikt in portlet container applicaties waar elke portlet zijn eigen sessie heeft. Nu zie je de boon met globalSession scope onder de @Scope annotatie:

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

Zo, dit was alles over Spring Bean Scope Tutorial. Hopelijk heb je wat aan onze uitleg.

Conclusie

Hiermee hebben we in deze sessie gezien wat Spring Bean Scope is en hoe je de scopes van beans kunt definiëren. Daarnaast hebben we verschillende soorten scopes in Spring Bean besproken. Ook zagen we elk van de types scopes afzonderlijk gedefinieerd met de voorbeelden met behulp van Eclipse IDE. Als je vragen hebt over Spring Bean Scope, stel ze dan in de commentaar sectie.
Gerelateerd onderwerp- Integratie van MVC met Spring
Voor referentie