Spring Bean Scope | 5 Principais Tipos de Escopo na Primavera

Objectivo

No artigo anterior, tomámos conhecimento da definição do Spring Bean. Hoje, vamos conhecer o Âmbito do Feijão de Primavera. Além disso, discutiremos diferentes tipos de âmbitos de aplicação no Feijão de Primavera. Cada um dos âmbitos será definido com exemplos de trabalho utilizando a IDE Eclipse. Além disso, saberemos quando utilizar um escopo de um único botão e protótipo no Spring Bean Framework.
Então, vamos iniciar o Spring Bean Scope.

p>Escopo do Feijão da Primavera | 5 Principais Tipos de Escopo na Primavera

Escopo do Feijão da Primavera

Como se sabe, o escopo do feijão da Primavera define o ciclo de vida e a visibilidade do feijão nos contextos em que é utilizado. Ao definir um <bean> tem a possibilidade de declarar o âmbito desse feijão de Primavera em particular.
Vantagens da Estrutura da Primavera com Limitações

Tipos de Âmbito no Feijão de Primavera

A Estrutura da Primavera tem cinco tipos de âmbito que suporta. Estes são os seguintes:

a. Escopo Singleton em Spring

Se o escopo Spring Bean é feito singleton então o contentor Spring IoC define apenas uma instância do objecto. Essa instância é armazenada na cache de singleton feijão. Além disso, todos os pedidos para esse nome devolverão a mesma instância que está em cache. Juntamente com isso, quaisquer modificações feitas a essa instância serão reflectidas em todas as referências a um feijão de primavera.
Vamos criar uma entidade Pessoa como se segue:

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

Feijão de Primavera com um único botão de alcance:

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

Conhece a mais recente tendência de funções e salários da Estrutura da Primavera
Também pode ver dois objectos referentes aos mesmos feijões com os mesmos valores:

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

Os âmbitos.xml é o seguinte:

<?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. Âmbito do Protótipo na Primavera

Esta será uma definição de feijão para ter qualquer número de instâncias de objectos. Irá retornar instâncias diferentes cada vez que o pedido vier do recipiente IoC.
Ler sobre a configuração baseada em Spring Java – Como configurar Spring Beans
O protótipo é definido para a anotação @Scope na definição do feijão:

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

Verá o mesmo teste que é feito para o escopo Spring Singleton que são dois objectos que solicitam o mesmo nome de feijão:

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

Os escopos.xml é definido como:

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

c. Âmbito do pedido na Primavera

Este pedido terá uma definição de feijão para o pedido HTPP. Isto só existe no contexto de aplicação de primavera na web. Definirá o feijão com o âmbito do pedido sob a anotação @Scope:

O atributo proxyMode é necessário uma vez que durante a instanciação do contexto de aplicação web, não há nenhum pedido activo. O Spring Framework irá criar o proxy para a injecção como uma dependência.
Next, deverá definir o controlador que tem uma referência ao requestMessage bean. Para isso, é necessário aceder ao mesmo pedido mais de uma vez para testar os âmbitos específicos da 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

Da mesma forma, pode definir os feijões dentro do âmbito da sessão como:

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

Da mesma forma, é definido o controlador com a referência ao feijão sessionMessage. Para isso, é necessário executar dois pedidos de modo a mostrar que o valor do campo de mensagem é o mesmo para a sessão.
Dê uma olhada 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. Âmbito da Sessão Global na Primavera

Este campo alarga a definição do feijão para a sessão HTTP global e é válido apenas para o contexto da Aplicação da Primavera sensível à web. Este tipo é utilizado em aplicações de contentores portlet onde cada portlet tem a sua sessão. Agora verá o feijão com escopo globalSession sob a anotação @Scope:

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

Então, isto foi tudo sobre o Spring Bean Scope Tutorial. Espero que goste da nossa explicação.

Conclusion

Hence, nesta sessão, vimos o que é o Spring Bean Scope e como definir os âmbitos do feijão. Além disso, discutimos diferentes tipos de âmbitos de aplicação no Spring Bean. Também vimos cada um dos tipos de âmbitos definidos separadamente com os exemplos utilizando o Eclipse IDE. Além disso, se tiver alguma dúvida sobre o Spring Bean Scope, não hesite em perguntar na secção de comentários.
Tópico relacionado – Integração de MVC com Spring
Para referência