Spring Framework: Uso de beans gerenciáveis em Aplicações Stand-Alone

� comum vermos hoje em dia o uso do Spring para realizar inje��o de depend�ncias no lado do servidor, evitando que o desenvolvedor tenha que preocupar-se com a instancia��o e controle das inst�ncias das classes que est�o sendo gerenciadas.

O problema come�a a aparecer quando al�m dessa aplica��o WEB temos uma aplica��o stand-alone que precisa usar os mesmos recursos gerenci�veis do Spring, em outras palavras, imagine que temos um formul�rio que precisa usar recursos que o Spring est� gerenciando, os beans. Nesse caso precisaremos fazer uso de uma classe chamada ClassPathXmlApplicationContext para capturar a inst�ncia do Bean. Nosso artigo ter� como principal foco mostrar como realizar a captura de beans do Spring atrav�s desta classe.

Projeto com Spring

� importante entender que uma aplica��o stand-alone n�o precisa que um container como o TomCat ou um servidor de aplica��o como o glassfish esteja em execu��o para funcionar, por isso chama-se �stand-alone�, pelo fato de conseguir manter-se ativa por si pr�pria.

Aqui torna-se muito claro porque trabalhar com MVC (Model-View-Controller): Se voc� desenvolver a sua camada Model e Controller ao ponto que estes n�o saibam qual ser� o View (Mobile, Web, Standalone �) que os usar� ent�o voc� ter� um sistema com baixo acoplamento e alta reusabilidade. Imagine que hoje nosso sistema possui uma View toda em WEB (com p�ginas HTML), amanh� poderemos criar mais uma View Stand-alone (com Formul�rios em JSE) para aqueles usu�rios que desejarem usar o sistema de forma privada sem nenhuma conex�o externa. Voc� tem exatamente a mesma l�gica sendo executada para duas Views distintas: essa � uma boa pr�tica para trabalhar-se pois qualquer mudan�a realizada nessas camadas de l�gica refletem diretamente em todas as Views ligadas a elas.

Vamos criar um projeto simples apenas para entender o que foi explicado anteriormente, uma View WEB e uma View Stand-alone conectadas ao mesmo modelo de neg�cio, mas em contextos diferentes. Primeiramente vamos configurar um projeto que usar� o Spring e injetar uma classe.

Criamos um projeto usando o Maven, assim poderemos usar o gerenciamento de bibliotecas atrav�s do arquivo pom.xml. Nosso projeto possui a mesma estrutura apresentada na Figura 1.

Vamos entender a estrutura de pastas do nosso projeto:

src/main/java: Cont�m todo o c�digo Java, tais como Beans, Helpers, Utils e etc.;
src/main/resourcers: Cont�m o arquivo de configura��o do Spring (em nosso caso, mas pode possuir outros recursos que ser�o utilizados pelo projeto);
src/main/webapp: Local onde ficar� o conte�do web acess�vel pelo usu�rio;
src/main/webapp/WEB-INF: Local que n�o pode ser acessado pelo usu�rio mesmo sendo dentro do webapp, esta � uma exce��o para que possam ser colocados arquivos de configura��o, como � o caso do web.xml e as bibliotecas do projeto.

Usamos o pom.xml para configurar as bibliotecas do spring e todas as suas depend�ncias, como mostra o c�digo da Listagem 1.


<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>br.com.springlab</groupId>
   <artifactId>springlab</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Springlab</name>
   <url>http://maven.apache.org</url>
   <properties>
         <org.springframework.version>3.0.6.RELEASE
         </org.springframework.version>
   </properties>

   <dependencies>             
         
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${org.springframework.version}</version>
         </dependency>
         
   </dependencies>

   <build>
         <finalName>springlab</finalName>
         <plugins>
                <plugin>
                       <groupId>org.apache.maven.plugins</groupId>
                       <artifactId>maven-pmd-plugin</artifactId>
                       <version>2.5</version>
                       <configuration>
                              <targetJdk>1.6</targetJdk>
                       </configuration>
                </plugin>

                <plugin>
                       <groupId>org.apache.maven.plugins</groupId>
                       <artifactId>maven-compiler-plugin</artifactId>
                       <version>3.1</version>
                       <configuration>
                              <source>1.6</source>
                              <target>1.6</target>
                       </configuration>
                </plugin>

         </plugins>
         <resources>
                <resource>
                       <directory>src/main/resources</directory>
                </resource>
         </resources>
   </build>
</project>

Listagem 1. pom.xml

Configurado o pom.xml temos agora as bibliotecas necess�rias para fazer uso dos recursos do Spring Framework, principalmente a inje��o de depend�ncias. O arquivo applicationContext.xml possui as configura��es necess�rias para o Spring saber o que dever� ser gerenciado por ele, como mostra a Listagem 2.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

   <!-- Seta anota�oes para serem usadas pelo Spring -->
   <context:annotation-config />

   <!-- Define o pacote onde o Spring vai procurar por beans anotados -->
   <context:component-scan base-package="br.com.springlab" />

   <!-- define que as transa�oes irao ser anotadas -->
   <tx:annotation-driven proxy-target-class="true" />    

</beans>

Listagem 2. applicationcontext.xml

Nesse arquivo definimos que o Spring dever� ler as anota��es realizadas no projeto, tais como @Service, @Component e etc. Logo em seguida definimos o pacote que o spring dever� ler, no caso apenas o br.com.springlab.

Pronto, nosso projeto est� configurado com Spring Framework e pronto para realizar as inje��es de depend�ncias necess�rias. Criaremos dois pacotes: o br.com.springlab.logic e o br.com.springlab.standalone, onde o primeiro ter� a l�gica que desejamos executar e o segundo apenas far� a chamada a ele.

Vejamos a classe MyLogic, presente na Listagem 3.


package br.com.springlab.logic;
 
import org.springframework.stereotype.Service;
 
@Service(value = "myLogic")
public class MyLogic {

   public void showPI(){
         System.out.println("Iniciando display PI");
         for(int i = 1; i <= 10; i++){
                System.out.println(i * Math.PI);
         }
         System.out.println("Finalizando display PI");
   }      
 
}

Listagem 3. Classe MyLogic

A nossa classe MyLogic tem a anota��o @Service(value = �myLogic�), isso significa que em qualquer ponto gerenci�vel pelo spring (apenas dentro do escopo br.com.springlab) podemos fazer chamada ao bean �myLogic� que ele dever� retornar � inst�ncia atual da classe MyLogic. O Spring trabalha com o padr�o de projeto Singleton por padr�o ao gerenciar essas classes, sendo a inst�ncia retornada sempre ser� igual enquanto a aplica��o n�o for reiniciada, seja por um container web (Tomcat, por exemplo) ou por uma aplica��o stand-alone.

A nossa l�gica � bem simples, cont�m um m�todo chamado showPI() que mostra o valor de PI multiplicado pelo valor de I, que � incrementado de 1 at� 10, ou seja: PI * 1, PI * 2, PI * 3 e assim por diante. Essa l�gica foi colocada apenas para mostrarmos o uso do Spring Context, mas voc� poderia usar qualquer outra l�gica ou at� mesmo um simples �System.out.println(�hello world from Spring Context�);� que a ideia seria a mesma.

Podemos usar essa classe gerenci�vel pelo Spring atrav�s de uma aplica��o stand-alone ou uma p�gina web, como JSF por exemplo. Em nosso caso vamos demonstrar como funciona o uso atrav�s do stand-alone, como mostra a Listagem 4.


package br.com.springlab.standalone;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import br.com.springlab.logic.MyLogic;

public class MainApp {

   /**
    * @param args
    */
   public static void main(String[] args) {
             ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
             MyLogic myLogic = (MyLogic) context.getBean("myLogic");
             myLogic.showPI();

   }

}

Listagem 4. Aplica��o stand-alone

Stand-alone trata-se de um conceito para aplica��es que podem ser executadas sem ferramentas auxiliares. O Java por si s� n�o pode ser considerado stand-alone por precisar de uma JVM para ser executado, diferente do C, que ap�s compilado n�o precisa de ferramentas auxiliares. Mas em nosso contexto podemos considerar como uma aplica��o stand-alone pois trata-se da execu��o das depend�ncias gerenci�veis pelo Spring sem a necessidade de um servidor de aplica��o ou container web.

A classe MainApp � bem simples, mas eficaz no que precisamos realizar, que no caso � o retorno do bean gerenci�vel MyLogic. Vejamos em detalhes:


ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Criamos um objeto do tipo ClassPathXmlApplicationContext passando como par�metro o caminho do arquivo de configura��o �applicationContext.xml�, neste caso o arquivo deve estar na pasta src/main/resources, assim como explicamos logo no in�cio. Ao passo por essa linha o console j� demonstra algo sendo realizado, parecido com a Listagem 5.


Jul 09, 2015 8:15:07 PM org.springframework.context.support.AbstractApplicationContext 
prepareRefresh
Informa��es: Refreshing 
org.springframework.context.support.ClassPathXmlApplicationContext@556292a4: startup date 
[Thu Jul 09 20:15:07 BRT 2015]; root of context hierarchy
Jul 09, 2015 8:15:07 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader 
loadBeanDefinitions
Informa��es: Loading XML bean definitions from class path resource [applicationContext.xml]
Jul 09, 2015 8:15:08 PM org.springframework.beans.factory.support.DefaultListableBeanFactory 
preInstantiateSingletons
Informa��es: Pre-instantiating singletons in 
org.springframework.beans.factory.support.DefaultListableBeanFactory@646282c1: defining beans
Informa��es: Pre-instantiating singletons in 
org.springframework.beans.factory.support.DefaultListableBeanFactory@646282c1: defining beans
Informa��es: Pre-instantiating singletons in 
org.springframework.beans.factory.support.DefaultListableBeanFactory@646282c1: defining beans 
[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org
.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework
.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation
.internalCommonAnnotationProcessor,myLogic,org.springframework.aop.config
.internalAutoProxyCreator,org.springframework.transaction.annotation
.AnnotationTransactionAttributeSource#0,org.springframework.transaction.interceptor
.TransactionInterceptor#0,org.springframework.transaction.config.internalTransactionAdvisor]; 
root of factory hierarchy
[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org
.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework
.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation
.internalCommonAnnotationProcessor,myLogic,org.springframework.aop.config
.internalAutoProxyCreator,org.springframework.transaction.annotation
.AnnotationTransactionAttributeSource#0,org.springframework.transaction
.interceptor.TransactionInterceptor#0,org.springframework.transaction.config
.internalTransactionAdvisor]; root of factory hierarchy

[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,
org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org[org.
springframework.context.annotation.internalConfigurationAnnotationProcessor,org.
springframework.context.annotation.internalAutowiredAnnotationProcessor,org.
springframework.context.annotation.internalRequiredAnnotationProcessor,org.
springframework.context.annotation.internalCommonAnnotationProcessor,myLogic,
org.springframework.aop.config.internalAutoProxyCreator,org.springframework.
transaction.annotation.AnnotationTransactionAttributeSource#0,org.springframework.
transaction.interceptor.TransactionInterceptor#0,org.springframework.transaction.
config.internalTransactionAdvisor]; root of factory hierarchy.springframework.
context.annotation.internalRequiredAnnotationProcessor,org.springframework.
context.annotation.internalCommonAnnotationProcessor,myLogic,org.springframework.
aop.config.internalAutoProxyCreator,org.springframework.transaction.annotation.
AnnotationTransactionAttributeSource#0,org.springframework.transaction.interceptor.
TransactionInterceptor#0,org.springframework.transaction.config.internalTransactionAdvisor]; 
root of factory hierarchy
[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,
org.springframework.context.annotation.internalAutowiredAnnotationProcessor,
org.springframework.context.annotation.internalRequiredAnnotationProcessor,
org.springframework.context.annotation.internalCommonAnnotationProcessor,myLogic,
org.springframework.aop.config.internalAutoProxyCreator,org.springframework.
transaction.annotation.AnnotationTransactionAttributeSource#0,org.springframework.
transaction.interceptor.TransactionInterceptor#0,org.springframework.transaction.
config.internalTransactionAdvisor]; root of factory hierarchy
[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,
org.springframework.context.annotation.internalAutowiredAnnotationProcessor,
org.springframework.context.annotation.internalRequiredAnnotationProcessor,
org.springframework.context.annotation.internalCommonAnnotationProcessor,myLogic,
org.springframework.aop.config.internalAutoProxyCreator,org.springframework.
transaction.annotation.AnnotationTransactionAttributeSource#0,org.springframework.
transaction.interceptor.TransactionInterceptor#0,org.springframework.transaction.
config.internalTransactionAdvisor]; root of factory hierarchy

Listagem 5. In�cio do console

Lendo de forma resumida, no console percebemos que o Spring est� fazendo a leitura do arquivo XML e preparando os beans para serem utilizados.

O Spring reconhece o pacote que est� sendo gerenciado e permite que voc� capture os beans que desejar, em nosso caso usamos o seguinte:


MyLogic myLogic = (MyLogic) context.getBean("myLogic");

O getBean() retorna a inst�ncia do �myLogic� e agora podemos fazer a chamada ao m�todo necess�rio:


myLogic.showPI();

E nosso retorno ser�:


Iniciando display PI
3.141592653589793
6.283185307179586
9.42477796076938
12.566370614359172
15.707963267948966
18.84955592153876
21.991148575128552
25.132741228718345
28.274333882308138
31.41592653589793
Finalizando display PI

Vimos neste artigo que a reusabilidade de c�digo � um ponto importante a ser notado quando trabalhamos com qualquer tipo de projeto, principalmente com mais de uma View (mobile, web, desktop e etc.).

Neste caso o ideal � criar uma classe respons�vel apenas por fazer a chama aos beans, n�o precisando criar uma inst�ncia de ClassPathXmlApplicationContext a cada chamada, sobrecarregando muito o sistema.

Tecnologias:

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Assista grátis a nossa aula inaugural

Perguntas frequentes

Quem somos?

Por que a programação se tornou a profissão mais promissora da atualidade?

Como faço para começar a estudar?

Em quanto tempo de estudo vou me tornar um programador?

Sim, você pode se tornar um programador e não precisa ter diploma de curso superior!

O que eu irei aprender estudando pela DevMedia?

Principais diferenciais da DevMedia

Qual o investimento financeiro que preciso fazer para me tornar um programador?

Como funciona a forma de pagamento da DevMedia?

Por Ronaldo Em 2015

Nossos casos de sucesso

Leonardo Carlos

Eu sabia pouqu�ssimas coisas de programa��o antes de come�ar a estudar com voc�s, fui me especializando em v�rias �reas e ferramentas que tinham na plataforma, e com essa bagagem consegui um est�gio logo no in�cio do meu primeiro per�odo na faculdade.

Lucas Rodrigues

Estudo aqui na Dev desde o meio do ano passado! Nesse per�odo a Dev me ajudou a crescer muito aqui no trampo.
Fui o primeiro desenvolvedor contratado pela minha empresa. Hoje eu lidero um time de desenvolvimento!
Minha meta � continuar estudando e praticando para ser um Full-Stack Dev!

Her�clito J�nior

Economizei 3 meses para assinar a plataforma e sendo sincero valeu muito a pena, pois a plataforma � bem intuitiva e muuuuito did�tica a metodologia de ensino. Sinto que estou EVOLUINDO a cada dia. Muito obrigado!

Julio Cablen

Nossa! Plataforma maravilhosa. To amando o curso de desenvolvimento front-end, tinha coisas que eu ainda n�o tinha visto. A did�tica � do jeito que qualquer pessoa consegue aprender. S�rio, to apaixonado, adorando demais.

Joelberth Sena

Adquiri o curso de voc�s e logo percebi que s�o os melhores do Brasil. � um passo a passo incr�vel. S� n�o aprende quem n�o quer. Foi o melhor investimento da minha vida!

Felipe Nunes

Foi um dos melhores investimentos que j� fiz na vida e tenho aprendido bastante com a plataforma. Voc�s est�o fazendo parte da minha jornada nesse mundo da programa��o, irei assinar meu contrato como programador gra�as a plataforma.

Wanderson Oliveira

Comprei a assinatura tem uma semana, aprendi mais do que 4 meses estudando outros cursos. Exerc�cios pr�ticos que n�o tem como n�o aprender, est�o de parab�ns!

Jos� Lucas

Obrigado DevMedia, nunca presenciei uma plataforma de ensino t�o presente na vida acad�mica de seus alunos, parab�ns!

Eduardo Dorneles

Aprendi React na plataforma da DevMedia h� cerca de 1 ano e meio... Hoje estou h� 1 ano empregado trabalhando 100% com React!

Adauto Junior

J� fiz alguns cursos na �rea e nenhum � t�o bom quanto o de voc�s. Estou aprendendo muito, muito obrigado por existirem. Est�o de parab�ns... Espero um dia conseguir um emprego na �rea.

Ver todos os casos de sucesso

Uso de beans gerenci�veis em Aplica��es Stand-Alone

Veja neste artigo como fazer uso de beans gerenci�veis atrav�s de aplica��es stand-alone com Spring Framework