Spring Bean Scope | 5 principali tipi di Scope in Spring

Obiettivo

Nell’articolo precedente, abbiamo imparato la definizione di Spring Bean. Oggi, conosceremo lo Spring Bean Scope. Inoltre, discuteremo i diversi tipi di scope in Spring Beans. Ognuno degli scopi sarà definito con esempi di lavoro usando Eclipse IDE. Inoltre, arriveremo a sapere quando usare un ambito singleton e prototipo in Spring Framework.
Allora, iniziamo Spring Bean Scope.

Spring Bean Scope

Come sapete lo scope del bean Spring definisce il ciclo di vita e la visibilità del bean nei contesti in cui viene utilizzato. Mentre si definisce un <bean> si ha la possibilità di dichiarare l’ambito di quel particolare bean di Spring.
Esploriamo i vantaggi di Spring Framework con le limitazioni

Tipi di ambito in Spring Bean

Lo Spring Framework ha cinque tipi di ambito che supporta. Questi sono i seguenti:

a. Singleton Scope in Spring

Se lo scope di Spring Bean è reso singleton allora il contenitore Spring IoC definisce una sola istanza dell’oggetto. Questa istanza viene memorizzata nella cache dei fagioli singleton. Inoltre, tutte le richieste per quel nome restituiranno la stessa istanza che è nella cache. Insieme a questo, qualsiasi modifica fatta a quell’istanza si rifletterà in tutti i riferimenti a un bean di Spring.
Creiamo un’entità Persona come segue:

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

Fagioli Spring con ambito singleton:

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

Conosci l’ultima tendenza dei ruoli lavorativi e degli stipendi di Spring Framework
Puoi anche vedere due oggetti che si riferiscono agli stessi beans con gli stessi valori:

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

Lo scope.xml è il seguente:

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

Questo scope di una definizione bean avrà un numero qualsiasi di istanze di oggetti. Restituirà un’istanza diversa ogni volta che la richiesta arriva dal contenitore IoC.
Leggi su Spring Java Based Configuration – How to Configure Spring Beans
Il prototipo è impostato sull’annotazione @Scope nella definizione del bean:

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

Vedrai lo stesso test che viene fatto per lo scope Spring Singleton che è due oggetti che richiedono lo stesso nome del 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();}

Lo scopes.xml è definito come:

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

c. Scope della richiesta in Spring

Questa richiesta farà scope di una definizione di bean alla richiesta HTPP. Questo c’è solo nel contesto dell’applicazione Spring Application web-aware. Definirete il bean con l’ambito della richiesta sotto l’annotazione @Scope:

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

L’attributo proxyMode è necessario perché durante l’istanza del contesto dell’applicazione web, non c’è nessuna richiesta attiva. Lo Spring Framework creerà il proxy per l’iniezione come dipendenza.
In seguito, dovreste definire il controller che ha un riferimento al bean requestMessage. Per questo, è necessario accedere alla stessa richiesta più di una volta per testare gli scope specifici del 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 in Spring

Nello stesso modo, si possono definire i bean all’interno del session scope come:

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

Nello stesso modo, si definisce il controller con il riferimento al bean sessionMessage. Per questo, è necessario eseguire due richieste in modo da mostrare che il valore del campo message è lo stesso per la sessione.
Guarda Spring Transaction Management – Types and 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

Questo scopre la definizione del bean alla sessione HTTP globale ed è valido solo per il contesto Application web-aware di Spring. Questo tipo è usato nelle applicazioni portlet container dove ogni portlet ha la sua sessione. Ora vedrete il bean con scope globalSession sotto l’annotazione @Scope:

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

Così, questo era tutto su Spring Bean Scope Tutorial. Spero che vi piaccia la nostra spiegazione.

Conclusione

Quindi, in questa sessione, abbiamo visto cos’è Spring Bean Scope e come definire gli scopi dei beans. Inoltre, abbiamo discusso i diversi tipi di scope in Spring Bean. Inoltre, abbiamo visto ogni tipo di scope definito separatamente con gli esempi utilizzando Eclipse IDE. Inoltre, se hai qualche domanda riguardante Spring Bean Scope, sentiti libero di chiedere nella sezione dei commenti.
Attività correlate- Integrazione di MVC con Spring
Per riferimento