Il contenitore Spring non solo istanzia un bean e cabla le sue dipendenze, ma fornisce anche lo scope di un’istanza. C’è un supporto incorporato per sei scope di bean in Spring Framework. Per esempio, lo scopo del bean può essere singleton, prototipo e così via. Questo post mostra come impostare un bean scope usando l’annotazione Spring @Scope.
Supported Spring bean scope
- Singleton scope- Una singola istanza di oggetto corrispondente alla definizione di un bean viene creata per ogni contenitore Spring IoC. Singleton scope è un bean scope di default.
- Prototype scope- Una nuova istanza dell’oggetto viene creata ogni volta che il bean viene richiesto dal contenitore Spring.
- Request scope- Per ogni richiesta HTTP viene creata una nuova istanza del bean. Questo scope di Spring bean è valido solo nel contesto di un ApplicationContext Spring web-aware.
- Session scope- Una singola istanza di bean è scoped al ciclo di vita di una sessione HTTP. Questo scope è valido solo nel contesto di un ApplicationContext Spring web-aware.
- Application scope- Una singola definizione di bean ha uno scope sul ciclo di vita di un ServletContext. Questo ambito è valido solo nel contesto di un ApplicationContext Spring web-aware.
- Ambito Websocket – Ambito di una singola definizione bean al ciclo di vita di un WebSocket. Questo scope è valido solo nel contesto di un ApplicationContext Spring web-aware.
Dove usare l’annotazione @Scope
L’annotazione @Scope può essere usata come annotazione a livello di tipo insieme alle annotazioni @Component e @Configuration. Quando viene usata come annotazione a livello di tipo, @Scope indica il nome di un ambito da usare per le istanze del tipo annotato.
L’annotazione @Scope può anche essere usata come annotazione a livello di metodo insieme a @Bean. Quando viene usata come annotazione a livello di metodo, @Scope indica il nome di uno scope da usare per l’istanza restituita dal metodo.
@Scope annotation con diversi scope
In questa sezione vedremo frammenti di codice per usare l’annotazione @Scope con diversi scope di bean. Gli scope forniti out of the box in Spring possono essere riferiti usando le costanti SCOPE_* disponibili nelle interfacce ConfigurableBeanFactory e WebApplicationContext.
@Scope con scope Singleton
@Service@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)public class BeanService{ ... ...}
@Scope con scope Prototype
@Service@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)public class BeanService{ ... ...}
@Scope con l’ambito Request bean
@Service@Scope(WebApplicationContext.SCOPE_REQUEST)public class BeanService{ ... ...}
@Scope con l’ambito Session bean
@Service@Scope(WebApplicationContext.SCOPE_SESSION)public class BeanService{ ... ...}
@Scope con Application bean scope
@Service@Scope(WebApplicationContext.SCOPE_APPLICATION)public class BeanService{ ... ...}
@Scope con WebSocket bean scope
@Component@Scope(scopeName = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)public class MyBean { ... ...}
Spring @Scope annotation Singleton example
Definire un bean con singleton scope significa che una singola istanza di quel bean è creata dal contenitore. Tutte le richieste per quel bean restituiranno lo stesso oggetto e qualsiasi modifica al campo si rifletterà in tutti i riferimenti al bean poiché tutti i riferimenti puntano allo stesso oggetto.
Lo scope singleton è lo scope di default del bean se non viene specificato esplicitamente alcuno scope.
Abbiamo una classe User con campi come firstName, lastName ed age. La classe è annotata con l’annotazione @Scope con lo scope specificato come singleton.
App config class per specificare la scansione dei componenti.
@Configuration@ComponentScan("com.knpcode.springexample")public class AppConfig {}
Ora se si esegue questo esempio e si ottengono due oggetti del bean User dal contenitore entrambi gli oggetti di riferimento punteranno allo stesso bean poiché lo scope è singleton.
Output
First Name- RayLast Name- Chandler
Come potete vedere firstName e lastName sono impostati usando il riferimento a user1, anche ottenere e stampare i valori di questi campi dal riferimento a user2 dà gli stessi valori.
Spring @Scope annotation Prototype example
Nella classe User come mostrato sopra se lo scope è cambiato in Prototype.
Esegui ora l’esempio e analizza l’output.
First Name- nullLast Name- null
I campi sono ancora nulli per l’istanza user2 poiché ora viene creata un’istanza separata a causa dello scope prototype.
Spring @Scope annotation con @Configuration
Nell’esempio precedente @Scope è usato insieme a @Component, vediamo un esempio in cui @Scope è usato con le annotazioni @Configuration e @Bean.
Ecco due classi le cui istanze saranno restituite dai metodi annotati con i metodi @Bean.
public class MyBean {public void myMethod() {System.out.println("In MyMethod of MyBean class");}}
public class ClassB {public ClassB(){System.out.println("In constructor of ClassB");}}
Classe Config
Nella classe Config @Scope è usato sia come annotazione a livello di tipo che a livello di metodo. A livello di tipo (insieme a @Configuration) l’ambito è specificato come prototipo.
A livello di metodo con un metodo non viene specificato alcun ambito, il che significa che il bean avrà il livello predefinito Singleton. Si noti che lo scope specificato a livello di tipo non è applicabile automaticamente al livello di metodo, i metodi avranno il proprio scope. Un altro metodo ha lo scope Prototype.
Possiamo controllare gli scope del bean ottenendo l’istanza di BeanDefinition che ha i metodi isSingleton e isPrototype.
Output
AppConfig has prototype scope- trueMyBean has prototype scope- falseMyBean has singleton scope- trueClassB has prototype scope- true
Dall’output si può vedere che lo scope del bean AppConfig è prototype, che è quello che abbiamo definito a livello di tipo.
Scope per l’istanza di MyBean è Singleton che è assegnato per default. Lo scope per l’istanza di ClassB è prototipo come definito a livello di metodo nella classe Config.
- Annotazione Spring @PostConstruct e @PreDestroy
- Annotazione Spring @Resource
- Annotazione Spring @Required
- Annotazione Spring @Value
- Eredità della definizione di Bean Spring
- Spring IoC Container Types – ApplicationContext e BeanFactory
- Spring + JPA (Hibernate) OneToMany Example
- Spring Boot e Dependency Injection
Questo è tutto per l’argomento Spring @Scope Annotation. Se manca qualcosa o hai qualcosa da condividere sull’argomento, scrivi un commento.
Ti potrebbe anche piacere