dia.com.br/site/netgold/edicao45JM/artigo5.zip">Clique aqui para ler esse artigo em PDF.
Indo além com o Spring
Explorando alguns dos principais recursos do framework
Conheça recursos para controlar como a injeção de dependências e o gerenciamento de beans ocorrem dentro do Spring framework, e veja um exemplo prático mostrando várias dessas funcionalidades em ação
O framework Spring tem por objetivo facilitar o desenvolvimento, possibilitar a redução de código e aumentar a produtividade do desenvolvedor. Isso tudo ocorre através de recursos como a injeção de dependências e o suporte a abstrações para várias bibliotecas do Java SE e do Java EE. Para se tornar robusto o suficiente e ser utilizado em qualquer tipo de aplicação, o Spring oferece uma série de recursos que fornecem o controle total sobre seu comportamento. É isso que será explorado nesse artigo.
Para um melhor aproveitamento do que será apresentado a seguir, é necessário um conhecimento básico sobre Spring. Apresentamos os fundamentos do framework na Edição 40. O exemplo do artigo básico será utilizado, com extensões, para ilustrar os recursos apresentados aqui.
Beans
Qualquer objeto declarado dentro do Spring é denominado bean, o que não obriga o objeto a necessariamente ser um JavaBean, apesar de ser necessário que o mesmo siga algumas regras deste padrão, especialmente no que diz respeito à definição das propriedades através de métodos get/set. A definição de beans é o ponto central dentro da configuração do Spring e é através dele que os objetos e suas propriedades são declarados e se tornam disponíveis no container. É possível ter controle total sobre como o Spring opera sobre os beans, como veremos a seguir.
Controlando como ocorre a criação
É possível controlar como um bean será criado/instanciado. Pode-se definir que a instanciação seja feita utilizando outros objetos ou métodos de fábrica, o que nos leva para alguns padrões de projeto como o Factory Method. A instanciação de um bean pode ocorrer de três formas:
· Construtor: A instanciação do bean é efetuada através do construtor declarado na classe. Esse é o tipo padrão para a instanciação e não requer configurações adicionais. Tanto o construtor padrão (sem parâmetros), quanto construtores que recebam parâmetros podem ser utilizados.
· Factory Method: O bean é criado através de um método declarado como static em sua classe. A única declaração que deverá estar presente no arquivo de configuração é o método a ser invocado. A seguir, um exemplo hipotético de como ficaria essa declaração no arquivo de configuração do Spring. Aqui o método criarInstancia() seria responsável pela instanciação da classe.
<bean id="meuBean" class="br.com.jm.spring.MeuBean"
factory-method="criarInstancia">
· Factory: O bean é criado através de um outro objeto, declarado também no arquivo de configuração do Spring como um bean. A código a seguir ilustra esse cenário. O bean minhaFabrica é o objeto responsável por criar instâncias do bean beanQualquer através de chamadas ao método criarBeanQualquer():
<bean id="meuBean" class="br.com.jm.spring.MeuBean"
factory-bean="minhaFabrica" factory-method="criarMeuBean">
<bean id="minhaFabrica" class="br.com.jm.spring.MinhaFabrica" />
Para qualquer uma das três formas de instanciação, é possível passar parâmetros para a criação do bean. Os parâmetros são sempre informados através do elemento <constructor-arg>.
Controlando quando ocorre a criação
O Spring nos permite especificar também quando ele irá instanciar nossos beans, o que pode ser ao obter a BeanFactory (ou ApplicationContext) ou somente ao utilizar o bean. Esta última forma é chamada de carregamento tardio ou “lazy loading”. A configuração do momento da instanciação poderá ser feita de forma global, ou para cada um dos beans de forma distinta.
A declaração global é efetuada no elemento <beans>, através da declaração <beans default-lazy-init="...">, onde podemos indicar que os beans serão criados no momento da criação da BeanFactory (default-lazy-init="false"), ou que serão criados sob demanda (default-lazy-init="true"), que é o valor padrão.
A declaração do comportamento de instanciação para um bean específico é feita através do atributo lazy-init, que pode ser declarado no elemento <bean> para cada objeto da seguinte forma: <bean id="..." class="..." lazy-init="true"/>. A diferença entre essa declaração e a apresentada para o elemento <beans> é a possibilidade de utilizar o valor default para o atributo lazy-init. Isso indica que o bean deve obedecer à declaração do elemento no qual está contido (<beans>). A declaração do atributo lazy-init local, independente do valor, sempre tem precedência sobre a declaração global.
Controlando o escopo
Dentro do Spring, os beans podem possuir dois tipos de configurações distintas em relação a seu escopo: singleton e prototype. Os singletons são instâncias únicas, armazenadas internamente pelo Spring e retornadas a todos que solicitam aquele bean diretamente ou quando o mesmo é injetado em outros beans. Esta é a configuração padrão.
Já os prototypes são os beans que têm uma nova instância criada sempre que solicitados (ou injetados em outros beans). Apesar do nome prototype, não há correlação com o pattern homônimo[1]. Os beans são simplesmente instanciados através do mecanismo indicado: construtor, factory ou factory method.
A indicação do escopo de um bean ocorre através do atributo singleton, caso utilizarmos o DTD antigo do Spring no XML de configuração (spring-beans.dtd), da seguinte forma:
<bean id="..." class="..." singleton="true"/>
O escopo é indicado da seguinte maneira, se utilizarmos o DTD do Spring 2.0 (spring-beans-2.0.dtd) ou a configuração baseada
<bean id="..." class="..." scope="singleton"/>
A declaração para um bean do tipo prototype consiste em declarar singleton como false (utilizando a versão antiga do DTD), ou declarar o atributo scope como prototype (caso sejam usados os novos mecanismos de configuração da versão 2.0).
Essa configuração é de extrema importância, pois destaca que os beans para os quais os atributos singleton ou scope são omitidos (pois singleton é o valor padrão), ou os beans configurados como singleton=“true” ou scope=“singleton” ...
