Pular para o conteúdo principal

Spring Framework - O que é afinal de contas e para onde ele vai?

A aquisição da SpringSource™ pela VMWare™ é um sinal da importância das idéias que estão por trás do Framework desenvolvido por Rod Johnson e sua trupe. Mas o que é esse framework e qual a sua importância para uma empresa que é um dos players principais nos conceitos de virtualização?

O grande apelo oferecido pelos desenvolvedores do Spring é a sua simplicidade no desenvolvimento bem como sua grande flexibilidade, o que, em conjunto com algumas ferramentas de apoio, fazem com que um código Java simples possa criar aplicações corporativas robustas e de fácil manutenção.

Mas como isso é possível, afinal?

As premissas básicas que estão por trás deste framework são simples:
  • Injeção de dependência
  • Programação Orientada a Aspecto
Mas o que é isso, afinal?

A Injeção de Dependência


Trata-se de um termo alcunhado pelo guru Martin Fowler e que de maneira simples pode se fazer o seguinte paralelo:

Para desenvolver eu dependo de algumas ferramentas (computador, monitor, software, teclado, mouse) sem o qual conseguiria criar um sistema.

Para resolver esse problema, poderia eu mesmo montar o computador (encaixando as placas, testando todos os componentes), instalar todos os softwares e conectar todos os cabos. Ufa que complicação! Mas não desenvolvi nada do sistema...

Outra possibilidade é a de alguém oferecer essa infra estrutura para mim montada (um fabricante ou a área de suporte, por exemplo) e poderia desenvolver o sistema sem grandes percalços.

Se alguém injetasse essas dependências que tenho para desenvolver como seria rápído o meu desenvolvimento!

O Spring oferece um micro servidor de aplicações (o conteiner de injeção de dependência) que é capaz de montar essas dependências, e entregá-las conforme necessidade. Ele precisa conhecer quais são as classes que serão gerenciadas e para isso necessita de um arquivo de configuração.

Nas versões mais recentes, esse arquivo deu uma emagrecida e pode ser visto a seguir:

<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<context:annotation-config />
<context:component-scan base-package="br.com.globalcode.spring" />  
</beans>

Nele, peço para ele varrer por um pacote especifico (br.com.globalcode.spring) e seus subpacotes para encontrar as classes que devem ser gerenciadas pelo Spring. Mas quais são essas classes?

Que tal o programador testar seu equipamento? Eis o programador:

package br.com.globalcode.spring;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

@Component(value="programador")
public class Programador {

@Resource(name="computador")
private Computador computador;

private boolean desenvolvedorPronto;

public void testarComputador(){
computador.ligar();
computador.logar();
computador.desligar();
desenvolvedorPronto=true;
}
public boolean isDesenvolvedorPronto() {
  return desenvolvedorPronto;
}
}


Apelidei a classe Programador através da anotação @Component(value="programador")

Disse ao Spring que o desenvolvedor precisa de um computador (@Resource(name = "computador" ))

O Computador está aqui:

package br.com.globalcode.spring;

import org.springframework.stereotype.Component;

@Component(value="computador")
public class Computador {

public void ligar() {
System.out.println("Liguei");
}

public void logar() {
System.out.println("Fazer login");

}

public void desligar() {
System.out.println("Desliguei");  
} 
public void salvar() {
System.out.println("Salvar");

}

}

Para juntar as peças, peço para o conteiner do Spring seja inicializado, e que ele crie os objetos e os disponibilize em nosso código. Para isso, foi criado um teste simples:

package br.com.globalcode.spring;

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class FuncionarioTest {

private static ApplicationContext context;
@BeforeClass
public static void setUp(){
context = new ClassPathXmlApplicationContext("spring.xml");
}

@Test
public void testCriarProgramador() throws Exception {
Programador o = context.getBean("programador",Programador.class);
o.testarComputador();
assertTrue(o.isDesenvolvedorPronto());
}
}

No método setUp é carregado o arquivo de configuração do Spring, e no método testCriarFuncionario() é realizado a busca pelo programador no interior do conteiner. Ele encontra o "programador" e disponibiliza-o para o meu código o objeto do tipo Programador. Peço para chamar o método testarComputador, que em nosso intrépido programador ligava, logava e desligava o computador. E por fim avalio se o desenvolvedor está pronto para programar.

A Programação Orientada a Aspectos


Se ele consegue criar essa infra estrutura, é possivel incrementar as capacidades daquilo que fabrica também. Alguma coisa como um carro com motor mais potente, ou uma ferramenta mais robusta.

Se ele consegue fabricar objetos para montar a infra, posso instrumentá-la para incorporar novas funcionalidades. Alterar o código fonte sem modificar a estrutura do codigo (incorporação de aspectos) é algo que o Spring é capaz de fazer tornando ainda mais o seu codigo enxuto.

O meu computador deve gravar o codigo fizer qualquer operação no micro. Mas para viabilizar essa gravação automatizada, tenho que copiar e colar um código no final de todos os métodos, o que fere um principio chamado Don't Repeat Yourself (DRY).

Infelizmente não é possivel evitar essa cópia através da programação Orientada a Objetos e nesse momento a Programação Orientada a Aspectos brilha. No fundo se criarmos um código que será adicionado a todos os métodos existentes na classe Computador sem que eu tenha que copiar e colar seria o ideal. Isso é algo viabilizado através do conteiner de injeção de dependência na medida que ao construir os objetos ele consegue enxertar o código na minha aplicação.

Para isso vamos criar uma classe que faça essa operação toda vez que uma pessoa desligar o computador:

package br.com.globalcode.spring;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class SalvarAspecto {

@Around("execution(public * br.com.globalcode.spring.Computador.desligar(..))")
public Object gravar(ProceedingJoinPoint pjp) throws Throwable {
Computador computador = (Computador) pjp.getThis();
computador.salvar();
Object retVal = pjp.proceed();
return retVal;
}
}

Criamos uma classe que é diferenciada por uma annotation (@Aspect) .Nela identificamos a chamada de método desligar que existe na classe Computador(@Around). Nesse momento, o método gravar solicita ao computador que sejam gravadas quaisquer alterações.

A única mudança necessária éno arquivo de configuração que necessita uma referência ao uso da programação por aspectos.

<aop:aspectj-autoproxy proxy-target-class="true" /<

E a partir de agora ele consegue interceptar o momento de desligar o computador e antes de efetuar a operação é realizada a gravação daquilo que estiver ativo.
Note que se quisermos incorporar outros métodos podemos cadastrar no aspecto e não no código Java.Isso possibilita a ativação ou desativação sem que o código Java seja mudado.

Mas como posso usar tudo isso?

A maneira mais imediata a se entender como isso pode ajudar o desenvolvimento, é observar que essas premissas simples são usadas por um projeto do SpringSource™ chamado Spring ROO. Através dele, criamos projetos que se baseiam fortemente em programação orientada a aspecto (pois muitas operações de um sistema são muito similares e que poderiam ser extraidas em códigos externos). O código com a inteligência do sistema fica num conjunto de classes muito simples e de fácil leitura, o que garante uma manutenibilidade muito grande.

Como isso se encaixa com o contexto da VMWare™?


O Spring, pela sua natureza, consegue trabalhar em muitas JVM's usando-se de um projeto chamado Terracotta™ que pode ser usado num conjunto de servidores virtualizados e que garantem a escalabilidade de qualquer sistema desenvolvido em Spring/Hibernate.

Ao oferecer multiplas máquinas virtuais, a VMWare™ consegue garantir que esse código possa rodar um multiplos processadores, sem que o código tenha que conhecer dessa infra estrutura.

Isso garante um código simples de se manter e que é capaz de rodar em multiplas máquinas, fazem com que o Spring Framework se torne uma tecnologia bastante sedutora para criar aplicações escaláveis e que precisam de uma infra mais leve.

Essas idéias simples, mas revolucionárias, tem sido alvo de estudos e até foram incorporadas ao conjunto de tecnologias que Java padroniza (vide JSR299). E é uma das formas da VMWare em participar desse grupo de elite de desenvolvedores que fazem parte da Especificação de Java.

Comentários

Julio Viegas disse…
Oi Ricardo, tudo bem?

Primeiramente, grande post!

A aquisicao da SpringSource consolida a VMWare como player de PaaS, adicionando mais valor ao stack. Imagine VMs jah com arquitetura de desenvolvimento rica com varios utilitarios abordando diversos cenarios de demanda Java EE. Agregue a isso o Grails, que fornece esse ambiente com agilidade de desenvolvimento. Isso habilita players SaaS instalar sua app sem complicacoes de infra.

A tendencia hj eh utilizar desenvolvimento agil e integracao de tecnologias. Containers de IoC promovem isso. E o Spring em especial jah vem com integracoes para as principais tecnologias e suportes que orbitam Java EE. E jah estah consolidado em mercado.

Se tudo se consolida, isso pode diminuir mercado e opcoes? Acho que nao. Acho que isso facilita a gerencia de configuracao e permite maior acesso a infra pelo time de desenvolvimento. Eh o sonho de qualquer desenvolvedor diminuir a latencia de configuracao de infra. E opcoes vao surgir e serao consolidadas em algum futuro com padronizacao...

Eu acho que estamos vivendo um grande momento de mudanca de paradigma com a entrada de cloud. A historia mostra que a tecnologia tende a virar commodity, partindo principalmente do software mais basico. E nesse movimento eh bom ver o que serah relevante para o mercado e o que nao serah.

Abs,
JV -- julioviegas.com
Anônimo disse…
Onde fala sobre spring framework nesse artigo ?
blogdoricardo disse…
A minha duvida é: Por onde eu começo a aprender Spring,desevolvo java desktop usando swing,conheço de html e jsp, mais por onde eu começo com o spring?

Postagens mais visitadas deste blog

Melhorando Performance de JPA com Spring Web Flow

No TDC2009 realizado pela Globalcode em São Paulo foi apresentado um Lightning Talk sobre um problema específico de performance em aplicações Web com JPA e uma possível solução usando o Spring Web Flow . Num período de 15 minutos, os slides a seguir foram apresentados e seguidos de alguns vídeos de demonstração de uma aplicação Web em execução. Melhorando performance do JPA com Spring Web Flow View more presentations from Dr. Spock . Nesta apresentação foi dito que temos encontrado problemas de performance em aplicações Web que utilizam as tecnologias JSF + JPA + Ajax quando precisamos gerenciar um contexto de persistência (EntityManager). Estes problemas se manifestam quando aplicamos uma resposta errada para a pergunta: Como gerenciar o contexto de persistência numa aplicação Web? Se as aplicações não usam Ajax e limitam-se ao modelo orientado a requisições, a solução mais comum é o uso do design pattern chamado "Open Session In View Filter". Através deste design

O que é Lógica de programação?

Este é o segundo de uma série de posts voltados aos leitores do blog que estão dando início à carreira de desenvolvimento de software. O assunto de hoje é a lógica de programação. Para ler antes: Entendendo como funciona a programação de computadores: linguagens de programação, lógica, banco de dados A lógica de programação é um pré-requisito para quem quer se tornar um desenvolvedor de software, independente da linguagem de programação que se pretende utilizar. Mas o que é de fato a Lógica de Programação e como saber se eu tenho esse pré-requisito? A lógica de programação nada mais é do que a organização coerente das instruções do programa para que seu objetivo seja alcançado. Para criar essa organização, instruções simples do programa, como mudar o valor de uma variável ou desenhar uma imagem na tela do computador, são interconectadas a estruturas lógicas que guiam o fluxo da execução do programa. Isso é muito próximo ao que usamos em nosso cotidiano para realizar atividad

Dica rápida: Apagando registros duplicados no MySQL

Ola pessoal, Sei que vocês estão acostumados a ver posts meus sobre tecnologia móvel ou algo relacionado, mas hoje vou falar sobre um pequeno "truque" que usei esse final de semana com o MySQL. Eu estava desenvolvendo o lado servidor de uma nova aplicação mobile (ahh, então "tem a ver" com mobile hehe), e quando fui fazer alguns testes percebi que tinha quase 7 mil registros duplicados (!!!) na minha base de dados! Bom, o meu primeiro reflexo como programador foi pensar em fazer um "programinha" Java para buscar e deletar todos esses registros duplicados. Mas ai, resolvi tirar as teias de aranha dos neurônios e usar os vários anos de experiência que passei com SQL e criar uma query que fizesse esse trabalho todo de uma vez!! E a query ficou assim: delete from TABLE_NAME USING  TABLE_NAME, TABLE_NAME  AS  auxtable WHERE   ( NOT  TABLE_NAME.id  =  auxtable.id ) AND   ( TABLE_NAME.name  =  auxtable.name ) Explicação direta: TABLE_NAME

Muitas vagas, otimismo e sensação de reaquecimento da economia

2010 começou cedo, contrariando a expectativa que muitos Brasileiros tem de "O ano começa mesmo depois do carnaval".  Embora o inicio do ano tenha sido "repleto" de catástrofes naturais e muita chuva aqui no Brasil, no campo profissional o otimismo está evidente, as pessoas estão cheias de energia e boas perspectivas em relação as oportunidades de JavaEE 6 e muitas outras tecnologias. Mas, parece que não são somente as pessoas que estão otimistas, os anúncios de vagas voltaram a crescer, empresas anunciando boas vagas, ou grandes quantidades de vagas, refletindo o que podemos chamar de "Otimismo corporativo" . Veja algumas empresas que anunciaram vagas: IBM SpringSource   Yahoo!  Elumini   Cyberlynxx   Google Kaizen SPC Brasil Se em 2009, um ano de crise fizemos tudo isto , imagine em 2010. E você está preparado ?  Está otimista ? []s Yara http://twitter.com/yarasenger http://twitter.com/globalcode

Devo fazer um curso ou ler um livro?

Acredito que todos os instrutores ou professores, independentemente da área, escola ou centro de treinamento, já devam ter recebido essa pergunta alguma vez na vida: devo fazer um curso ou ler um livro? Para responder a essa pergunta, precisamos avaliar os prós e contras de cada opção. Trabalho com treinamento há algum tempo e, hoje, recebi essa pergunta de um aluno. Não adianta responder a ou b sem argumentar, demonstrando as opções conforme a situação do aluno. O conteúdo, a forma de transmissão e a capacidade de assimilação do indivíduo são chaves para haver benefício maior de aprendizado. Tanto em um bom curso quanto em um bom livro, o conteúdo é a premissa básica . Por conteúdo entendemos: se está organizado; se respeita pré-requisitos; se promove o aprendizado guiado e incremental; se aborda de forma satisfatória os principais pontos; se tem bom balanço entre teoria, exemplos e prática (favorecendo exemplos e prática); se tem como premissa a acessibilidade possível (e cabível) pa

JavaLi no Lançamento mundial do JDK7 em São Paulo

O Lançamento mundial do JDK7 foi realizado no dia 7/7 em três cidades simultaneamente: São Paulo (SouJava), Londres (London User Group) e São Francisco (Oracle) com transmissão ao vivo via satélite! Evidentemente as cidades não foram escolhidas por acaso, e podemos enxergar a escolha da cidade de São Paulo como um sinal de reconhecimento à comunidade Java Brasileira, ao SouJava e à Globalcode. Com certeza houveram várias pessoas fundamentais para isto, como o Bruno Souza e o Mauricio Leal responsáveis pela organização e realização do Mês de Java! Veja a entrevista com o JavaLi no TDC2011: Veja também as fotos do Lançamento do JDK7 na cobertura realizada aqui no Globalcoders. É isso aí pessoal, próxima parada ? Trilha Java TDC2011 Goiânia! E você, já se inscreveu? Participe, colabore, divulgue esta iniciativa. []s Yara Senger http://twitter.com/yarasenger