Java Simples » exemplo

Java + FLEX Parte 1 -> Integrando Java e FLEX

Felipe Saab — Fri, 22 Apr 2011 23:39:00 +0000

Hoje iremos abordar uma integração (que eu particularmente acho) fantástica: Java e FLEX (cuja versão mais atual se chama Flash Builder 4).

A primeira grande (super, ultra, …) vantagem que me vem na cabeça quando falo deste assunto é a facilidade para criar belas interfaces. Eu sou uma negação quando o assunto é criar interfaces, design me dá arrepios…

Outro ponto que é um grande vantagem é que toda a interface roda em cima do Flash, ou seja, basta ter o flash instalado no navegador e é certeza que o programa vai abrir exatamente do jeito que você o projetou! Não dá pau de navegador pra navegador!!!! Quem meche com CSS sabe do que eu estou falando, tua página está perfeita no Firefox e quando abre ela no IE dá até medo. Hahahaha quem nunca passou por isso que atire a primeira pedra.

Enfim, veremos como é possível ter uma interface fácil de desenvolver e ao mesmo tempo amigável para o usuário final com um backend poderosíssimo rodando o nosso bom e (não tão) velho Java e todos os frameworks que estamos acostumados a usar, como Spring e Hibernate.

Esta série será dividida (a princípio) em 2 partes:

Parte 1 – Comunicação básica entre Java e FLEX
Parte 2 – Integrando Spring e Hibernate na nossa aplicação

Antes de começarmos propriamente dito com o tutorial deixe me falar como funciona essa integração: como o FLEX roda na máquina virtual do Flash que fica no browser (diferente do AIR que é desktop) a nossa aplicação Java também vai rodar em um servidor de aplicativos web (neste caso o Tomcat) para eles poderem se comunicar.

Ambos (FLEX e Java) rodando na web fazem com que o canal de comunicação fique na nossa cara: a própria WEB! Sendo assim, toda vez que o FLEX precisa se comunicar com o Java (quando o usuário manda salvar um objeto por exemplo) o FLEX envia uma mensagem (utilizando o protocolo AMF) para o Java através da WEB.

No servidor Java vai haver um servlet responsável por receber essas mensagens, decodificá-las, transformar os dados em objetos Java e encaminhar para a classe e método que tais objetos devem ser encaminhados e retornar o resultado para o FLEX.

Dita a teoria vamos a prática! hehehe

Vamos precisar ter algumas coisas instaladas:

Eclipse IDE
Flash Builder 4 Eclipse Plugin (Trial por 60 dias)
BlazeDS 4 (Site da Adobe) ou local

Caso você já tenha o Eclipse instalado em sua máquina basta informar o caminho para ele durante a instalação que ele já instalará todos os plugins necessários. Caso não tenha o Eclipse basta baixar uma versão do Flash Builder que já vem com uma versão da IDE (porém não é a mais recente).

Depois que tudo estiver instalado vamos começar importando a estrutura base do projeto Java que vem junto com o arquivo do BlazeDS. No Eclipse selecione o menu Arquivo > Importar e selecione Arquivo WAR na categoria Web.

Na próxima tela informe o caminho para o arquivo blazeds.war (que veio no arquivo do BlazeDS que você baixou) e informe o nome que o novo projeto vai ter. Iremos fazer uma simples (e bonita! hehe) agenda de contatos onde guardaremos os telefones e emails dos nossos amigos, então irei chamar o projeto de AgendaJ.

*OBS: Para o desenvolvimento Java + FLEX são criados 2 projetos: uma projeto Java e um projeto FLEX. Eu tenho o costume (e diria que é uma boa prática) de dar o mesmo nome aos dois projetos adicionando como sufixo J ou F caso o projeto seja Java ou FLEX, respectivamente.

Ok. Agora podemos dar uma espiada para ver como funciona toda a configuração da nossa aplicação Java. Vamos começar olhando para o deployment descriptor WebContent/WEB-INF/web.xml*:

*Apaguei os comentários que vieram junto com o arquivo pois não vamos utilizá-los.

>
	>BlazeDS>
	>BlazeDS Application>
 
	
	>
		>flex.messaging.HttpFlexSession>
	>
 
	
	>
		>MessageBrokerServlet>
		>MessageBrokerServlet>
		>flex.messaging.MessageBrokerServlet>
		>
			>services.configuration.file>
			>/WEB-INF/flex/services-config.xml>
		>
		>1>
	>
 
	>
		>MessageBrokerServlet>
		>/messagebroker/*>
	>
 
	>
		>index.html>
		>index.htm>
	>
>

Foi definido um servlet chamado MessageBrokerServlet da classe flex.messaging.MessageBrokerServlet que recebe o parâmetro services.configuration.file indicando qual é o arquivo que contém as configurações dos serviços do FLEX. Conseguimos ver também que o MessageBrokerServlet recebe todas as requisições que chegam para a URL “…/messagebroker/*”, ou seja, sempre que o FLEX envia uma requisição para o Java já sabemos que é seguindo este padrão de URL (caso ainda não esteja claro já já vai ficar ).

Olhando o arquivo de configuração dos serviços (WebContent/WEB-INF/flex/services-config.xml)* podemos observar que:

*Retirei alguns comentários e fiz alguns pequenos ajustes nesse arquivo.

ele inclui três outros arquivos de configuração através da tag dentro da tag ;
diz qual classe vai ser responsável pela segurança (autenticação e autorização) em um servidor de aplicativos J2EE;
define quais canais estarão disponíveis para a comunicação através da tag . Cada canal definido dentro desta tag indica o mapeamento de um padrão de URL para uma classe em específico, por exemplo, a classe flex.messaging.endpoints.AMFEndpoint irá receber todas as requisições que forem para a URL “…/messagebroker/amf”;
configura o Logging das comunicações;
configura o redeploy automático de alguns arquivos que ele fica “observando” em intervalos de tempo definidos.

>
    >
         file-path="remoting-config.xml" />
         file-path="proxy-config.xml" />
         file-path="messaging-config.xml" />
    >
 
    >
         class="flex.messaging.security.TomcatLoginCommand" server="Tomcat"/>
    >
 
    >
         id="my-amf" class="mx.messaging.channels.AMFChannel">
             url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint"/>
        >
 
         id="my-secure-amf" class="mx.messaging.channels.SecureAMFChannel">
             url="https://{server.name}:{server.port}/{context.root}/messagebroker/amfsecure" class="flex.messaging.endpoints.SecureAMFEndpoint"/>
            >
                >false>
            >
        >
 
         id="my-polling-amf" class="mx.messaging.channels.AMFChannel">
             url="http://{server.name}:{server.port}/{context.root}/messagebroker/amfpolling" class="flex.messaging.endpoints.AMFEndpoint"/>
            >
                >true>
                >4>
            >
        >
    >
 
    >
         class="flex.messaging.log.ConsoleTarget" level="Error">
            >
                >[BlazeDS] >
                >true>
                >true>
                >true>
                >true>
            >
            >
                >Endpoint.*>
                >Service.*>
                >Configuration>
            >
        >
    >
 
    >
        >
            >true>
            >20>
            >{context.root}/WEB-INF/flex/services-config.xml>
            >{context.root}/WEB-INF/flex/proxy-config.xml>
            >{context.root}/WEB-INF/flex/remoting-config.xml>
            >{context.root}/WEB-INF/flex/messaging-config.xml>
            >{context.root}/WEB-INF/web.xml>
        >
    >
>

OBS: perceba que todos os canais tem o padrão de URL parecido (“…/messagebroker/…”). Por isso que o MessageBrokerServlet recebe todas as requisições para a URL “…/messagebroker/*”, ele verifica para qual canal ela vai e encaminha para a classe correta.

Os outros arquivos de configuração não contém nada que precise chamar a atenção agora. Então já dá pra dizer que sabemos como o Java recebe e trata as requisições do FLEX!

Vamos preparar o backend da nossa aplicação então: vamos criar a classe que vai representar um contato da nossa agenda e um serviço para executar as regras de negócio da nossa aplicação:

Contato.java

public class Contato implements Serializable {
 
	private static final long serialVersionUID = -1549466344815889020L;
 
	private String nome;
 
	private String telefone;
 
	private String email;
 
	public String getNome() {
		return nome;
	}
 
	public void setNome(String nome) {
		this.nome = nome;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		sb.append(this.getNome()+",");
		sb.append(this.getTelefone()+",");
		sb.append(this.getEmail());
		sb.append("]");
		return sb.toString();
	}
}

A classe que representa um contato possui apenas o nome, telefone e email do contato. Suficiente para nossa pequena agenda.

OBS: essa classe implementa a interface java.io.Serializable pois ela vai trafegar na Web (do Java para o FLEX e vice versa). É aconselhavel que todo objeto que for ser transmitido através de um canal (socket, web, etc) implemente esta interface e tenha o serialVersionUID (que o Eclipse gerou pra mim hehe) que indica um número único para identificar aquela classe.

Vamos ver agora o serviço que irá tratar a inserção de novos contatos na nossa agenda:

ContatoService.java

public class ContatoService {
 
	private static List<contato> agenda = new ArrayList<contato>();
 
	public void salvar(Contato contato) {
		ContatoService.agenda.add(contato);
		System.out.println("Contato adicionado: " + contato);
	}
 
	public List<contato> getAgenda() {
		return ContatoService.agenda;
	}
}

Como ainda não vamos utilizar o banco de dados e o Hibernate nesta parte do tutorial vamos simular um “banco de dados” (está entre aspas duplas tá.. hehehe) com uma lista estática.

O método salvar(Contato) simplesmente adiciona um novo contato na agenda e o método getAgenda() retorna a nossa agenda com todos os contatos.

Esses métodos vão ser utilizados para o FLEX pedir para o Java salvar um novo contato na agenda e para ele recuperar a agenda com os contatos atualizados.

Para finalizar o desenvolvimento do nosso backend precisamos apenas expor nossa classe de serviço para que as classes que recebem a requisição do FLEX (pacote flex.messaging.endpoint) consigam localizá-la em tempo de execução.

Para isso adicionaremos uma nova tag no arquivo WebContent/WEB-INF/flex/remoting-config.xml informando um ID para este novo destino e qual classe é responsável por tratar as requisições destinadas a ele. Desta maneira nós informaremos este mesmo ID no FLEX quando precisarmos chamar algum método desta classe.

 id="remoting-service" class="flex.messaging.services.RemotingService">
 
	>
		 id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true" />
	>
 
	>
		 ref="my-amf" />
	>
 
	 id="contatoService">
		>
			>br.blog.javasimples.agenda.service.ContatoService>
		>
	>
 
>

Agora já podemos deixar o Java um pouco de lado e ir pra parte nova: o FLEX!

Vamos criar um novo projeto no Eclipse: Arquivo > Novo > Projeto. Na categoria Flash Builder vamos escolher um Flex Project. Na primeira tela configuramos o nome do projeto (vou colocar AgendaF como já comentei lá em cima), dizemos que ele vai rodar na Web e vai se comunicar com um servidor J2EE utilizando o BlazeDS.

OBS: tenha certeza de que o checkbox “Create combined Java/Flex project using WTP” está DESMARCADO.

Na próxima tela informamos algumas configurações do servidor J2EE (no meu caso o Tomcat):

Root folder –> O caminho pra raiz da aplicação Java no disco;
Root URL –> O caminho para a raiz da aplicação Java através do servidor;
Context Root –> O contexto da aplicação no servidor;
Output Folder (o Eclipse sugere) –> Caminho para a pasta onde o projeto FLEX será compilado e ficará “guardado”. Fica dentro da raiz da aplicação Java pra ser executada junto com o servidor.

Na próxima tela temos que adicionar uma pasta que será a raíz dos códigos fonte. Na aba Source Path apenas clique em Add Folder… e crie uma nova pasta com o nome src.

Após criado o projeto temos mais um ajuste a fazer: caso o Flash Builder 4 que você tenha baixado veio na língua inglesa e seu sistema operacional esteja em português o Eclipse vai criar uma configuração em português (porque ele “reflete” o locale do SO) e o Flash Builder não vai se dar muito bem com ele não… hehehe

Para corrigir esse parâmetro vamos nas propriedades do projeto (botão direito no projeto > Propriedades) e na categoria Flex Compiler existe o campo de texto Additional compiler arguments onde está escrito “-services …\services-config.xml –locale pt_BR”. Vamos apenas trocar o parâmetro “-locale pt_BR” por “-locale en_US”.

Legal, vamos começar a programar mesmo. Mude a perspectiva do Eclipe para Flash (caso ainda não tenha o feito). Vamos entrar em outro mundo agora, vamos deixar o Java um pouco de lado e programar em ActionScript 3 (aka AS3), linguagem utilizada na plataforma FLEX (e outras da Adobe).

OBS: eu não vou entrar em detalhes da linguagem propriamente dita, uma vez que o nome do blog não é AS3 Simples.. kkkkkkkk Mas não tem diferenças muito grandes não, uma pessoa que está acostumada com Java consegue pegar o AS3 rapidinho.

Vamos começar criando a classe que representa um contato da agenda. Vamos criar um pacote com o mesmo nome do pacote no Java (outra boa prática) e criar uma ActionScript Class com o mesmo nome (Contato.as):

package br.blog.javasimples.agenda.model
{
	[Bindable]
	[RemoteClass(alias="br.blog.javasimples.agenda.model.Contato")]
	public class Contato
	{
		public var nome:String;
		public var telefone:String;
		public var email:String;
 
		public function Contato()
		{
		}
	}
}

A classe que representa o contato do lado do FLEX deve possuir os atributos com os mesmos nomes do nome de atributo extraído dos getters da classe Java. Estranho né… heheheh Vamos ver com um pequeno exemplo:

Na classe Contato.java eu tenho os getters getNome(), getTelefone() e getEmail(). Quando o BlazeDS vai enviar os dados do Java para o FLEX ele vai fazer um algorítmo que siga uma lógica parecida com essa (não olhei no código fonte pra saber se é assim mesmo, porém o resultado final é algo assim):

String getterName = "getEmail";
String attributeName = getterName.replaceFirst("get",""); // attributeName == "Email"
attributeName = attributeName.substring(0,1).toUpperCase() + attributeName.substring(1); // // attributeName == "email"

Ou seja, com os getters getNome(), getTelefone() e getEmail() o BlazeDS vai enviar os valores para a classe Contato.as esperando que existam os atributos nome, telefone e email.

O BlazeDS segue esse mesmo padrão para enviar os dados do FLEX para o Java, ou seja, os setters devem seguir esse mesmo padrão de nomenclatura.

Continuando com a nossa classe, algo novo para quem nunca usou AS3 são as anotações: [Bindable] e [RemoteClass(alias)].

Se essas anotações fossem em Java seriam: @Bindable e @RemoteClass(alias=”…”). Só a primeira vista que confunde um pouco, mas é a mesma coisa.

Segue o significado de tais anotações:

[Bindable] – é algo como a implementação do design pattern Observer. Todo lugar que estiver referenciando alguma propriedade dessa classe será imediatamente avisado assim que alguma delas sofrer alguma mudança;
[RemoteClasse(alias)] – indica para o BlazeDS qual a classe correspondente a essa na aplicação Java.

Tão simples quanto fazer um POJO no Java não?! hehehe

Agora vem a parte que me fascina no FLEX: layout!

Vamos abrir o arquivo AgendaF.mxml que o Eclipse gerou para nós. Ao mudar para a aba design nós podemos criar a nossa tela com um simples clicar e arrastar de componentes. Arrastei alguns componentes e mudei os labels e em menos de 10 minutos eu fiz o design da nossa aplicação de exemplo:

O código do arquivo AgendaF.mxml ficou assim:

 xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx">
 
     width="500">
         label="Nome" width="100%" direction="horizontal">
             id="txtNome" width="220"/>
             width="100%" height="10"/>
             label="Telefone" direction="horizontal">
                 width="100" id="txtTelefone"/>
            >
        >
         label="Email" width="100%" direction="horizontal">
             width="220" id="txtEmail"/>
             width="100%" height="10"/>
             label="Salvar"/>
        >
         width="100%">
             width="100%">
                >
                     headerText="Nome"/>
                     headerText="Telefone"/>
                     headerText="Email"/>
                >
            >
        >
    >
 
>

OBS: perceba que os TextInputs tem ids definidos. Isso para que possamos recuperar os seus valores via programação logo mais.

Para vermos como vai ficar esse layout no browser basta rodar o projeto AgendaJ primeiro e depois o AgendaF.

AgendaJ – botão direito no projeto > Run As > Run on Server
AgendaF – botão direito no projeto > Run As > Web Application

Vamos fazer isso funcionar agora!

Vamos começar com a funcionalidade de salvar um contato: toda vez que o botão Salvar for pressionado iremos criar um objeto Contato e enviar para o Java, mais especificamente para o método salvar(Contato) da classe ContatoService.

Para isso vamos precisar de uma área para programar em ActionScript dentro do arquivo AgendaF.mxml, que como o nome indica (e conseguimos ver através da aba Source) é um XML. Tal área fica disponível através da tag .

Segue o código que salva um novo contato:

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx">
 
<fx:Script>
        [CDATA[
            import br.blog.javasimples.agenda.model.Contato;
 
            import mx.controls.Alert;
            import mx.rpc.AsyncToken;
            import mx.rpc.Responder;
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            import mx.rpc.remoting.RemoteObject;
 
            private var remoteObject:RemoteObject=new RemoteObject("contatoService");
 
            private function salvaContato():void
            {
                var contato:Contato=new Contato();
                contato.nome=txtNome.text;
                contato.telefone=txtTelefone.text;
                contato.email=txtEmail.text;
 
                // Insere esse contato na lista do Java
                var token:AsyncToken=remoteObject.salvar(contato);
                token.addResponder(new mx.rpc.Responder(salvarSucesso, erro));
            }
 
            private function salvarSucesso(result:ResultEvent):void
            {
                Alert.show(“Contato salvo com sucesso!”);
            }
 
            private function erro(event:FaultEvent):void
            {
                Alert.show("Ocorreu o seguinte erro: " + event.fault.faultString);
            }
 
        ]]>
    fx:Script>
 
   -- ..... -->
 
s:Application>

Vamos começar de cima para baixo:

Primeiro temos a declaração e instanciação de um objeto da classe RemoteObject. Essa classe é a responsável por fazer a comunicação com outra classe do lado do Java. Para criarmos esse vínculo basta passarmos o ID que definimos para a classe Java (no arquivo WebContent/WEB-INF/flex/remoting-config.xml) no construtor do RemoteObject.

No nosso caso a classe ContatoService.java está vinculada dentro da tag no arquivo remoting-config.xml então utilizamos este mesmo ID no construtor do nosso obejto.

Vamos olhar agora para o método salvaContato(): é criado um novo objeto Contato e seus dados são preenchidos com os valores dos TextInputs. Logo depois utilizamos o RemoteObject para invocar o método salvar(Contato) da classe a que ele está vinculado (ContatoService.java).

Para invocar os métodos remotos nós temos que imaginar que o RemoteObject é a classe que queremos utilizar (neste caso ContatoService). Exemplo: na classe ContatoService nós temos o método salvar(Contato). Para executar esse método através do RemoteObject basta executar um método com o mesmo nome e com os mesmos parâmetros (super usual né ).

Continuando, todas as chamadas a métodos remotos são assíncronas, ou seja, temos que esperar voltar uma resposta do Java para receber o retorno do método ou uma possível falha (caso seja jogada alguma Exception).

Para lidarmos com isso, todo método remoto executado através do RemoteObject retorna um AsyncToken. Através deste AsyncToken nós podemos ser notificados sempre que o método remoto retorna algo (o retorno do método ou uma exception).

Para isso nós adicionamos um Responder no AsyncToken. O construtor do Responder requer que passemos duas funções de parâmetro: a primeira será chamada quando o método remoto for concluído com sucesso e a segunda será chamada quando o método remoto jogar um erro.

A função que vai ser chamada quando o método remoto for concluído vai receber um ResultEvent como parâmetro (na grande maioria das vezes, porém não é regra) e caso o método remoto retornasse algum objeto nós conseguimos acessar esse retorno atavés do atributo result do objeto ResultEvent.

Já no caso da função que vai ser chamada quando o método remoto jogar um erro, ela recebe um FaultEvent (na maioria dos casos, porém também não é regra). E para acessar detalhes sobre o erro que foi jogado utilizamos o atributo fault do objeto FaultEvent.

Voltando para o nosso código, quando o método ContatoService.salvar(Contato) terminar de salvar o contato na lista nós exibiremos uma mensagem informando o usuário de que o novo contato foi salvo.

Ao executarmos o projeto e inserir um novo contato acontece o seguinte:

E se observarmos o console do Eclipse também vamos ver:

Porém a grid ainda continua vazia… Vamos configurá-la então:

Todos os registros que aparecem em uma DataGrid devem estar em um array, uma lista ou algo parecido (por hora um Array está ótimo! hehehe). O Array que contém os dados que serão mostrados na DataGrid deve alimentar o atributo dataProvider dela. Vamos então criar um Array e alimentar a nossa grid:

 xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx">
 
    >
        [CDATA[
            import br.blog.javasimples.agenda.model.Contato;
 
            import mx.collections.ArrayCollection;
            import mx.controls.Alert;
            import mx.rpc.AsyncToken;
            import mx.rpc.Responder;
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            import mx.rpc.remoting.RemoteObject;
 
            private var remoteObject:RemoteObject=new RemoteObject("contatoService");
 
            [Bindable]
            private var agenda:ArrayCollection=new ArrayCollection();
 
            private function salvaContato():void
            {
                var contato:Contato=new Contato();
                contato.nome=txtNome.text;
                contato.telefone=txtTelefone.text;
                contato.email=txtEmail.text;
 
                // Insere esse contato na lista do Java
                var token:AsyncToken=remoteObject.salvar(contato);
                token.addResponder(new mx.rpc.Responder(salvarSucesso, erro));
            }
 
            private function salvarSucesso(result:ResultEvent):void
            {
                Alert.show("Contato salvo com sucesso!");
            }
 
            private function erro(event:FaultEvent):void
            {
                Alert.show("Ocorreu o seguinte erro: " + event.fault.faultString);
            }
 
        ]]>
    >
 
     width="500">
         label="Nome" width="100%" direction="horizontal">
             id="txtNome" width="220"/>
             width="100%" height="10"/>
             label="Telefone" direction="horizontal">
                 width="100" id="txtTelefone"/>
            >
        >
         label="Email" width="100%" direction="horizontal">
             width="220" id="txtEmail"/>
             width="100%" height="10"/>
             label="Salvar" click="this.salvaContato()"/>
        >
         width="100%">
             width="100%" dataProvider="{this.agenda}">
                >
                     headerText="Nome" dataField="nome"/>
                     headerText="Telefone" dataField="telefone"/>
                     headerText="Email" dataField="email"/>
                >
            >
        >
    >
 
>

Foi criado um ArrayCollection chamado agenda e talvariável foi passada para o atributo dataProvider da DataGrid, sendo assim todos os elementos que estiverem dentro do ArrayCollection irão aparecer na grid também.

Indicamos também nas colunas qual atributo dos objetos que estão dentro do dataProvider deve ser exibido através do atributo dataField.

Tudo o que precisamos fazer agora é adicionar os nossos contatos nesse ArrayCollection agora. Vamos fazer o seguinte, toda vez que um novo contato for salvo nós iremos chamar o método getAgenda() da classe ContatoService e armazenar o retorno do método na variável agenda que acabamos de criar, assim manteremos a lista sempre atualizada e consequentemente a grid com todos os nossos contatos.

"1.0" encoding="utf-8"?>
 xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx">
 
    >
        [CDATA[
            import br.blog.javasimples.agenda.model.Contato;
 
            import mx.collections.ArrayCollection;
            import mx.controls.Alert;
            import mx.rpc.AsyncToken;
            import mx.rpc.Responder;
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;
            import mx.rpc.remoting.RemoteObject;
 
            private var remoteObject:RemoteObject=new RemoteObject("contatoService");
 
            [Bindable]
            private var agenda:ArrayCollection=new ArrayCollection();
 
            private function salvaContato():void
            {
                var contato:Contato=new Contato();
                contato.nome=txtNome.text;
                contato.telefone=txtTelefone.text;
                contato.email=txtEmail.text;
 
                // Insere esse contato na lista do Java
                var token:AsyncToken=remoteObject.salvar(contato);
                token.addResponder(new mx.rpc.Responder(salvarSucesso, erro));
            }
 
            private function salvarSucesso(result:ResultEvent):void
            {
                Alert.show("Contato salvo com sucesso!");
 
                // Recupera a lista completa
                var token:AsyncToken=remoteObject.getAgenda();
                token.addResponder(new mx.rpc.Responder(getAgendaSucesso, erro));
            }
 
            private function getAgendaSucesso(event:ResultEvent):void
            {
                this.agenda=event.result as ArrayCollection;
            }
 
            private function erro(event:FaultEvent):void
            {
                Alert.show("Ocorreu o seguinte erro: " + event.fault.faultString);
            }
 
        ]]>
    >
 
     width="500">
         label="Nome" width="100%" direction="horizontal">
             id="txtNome" width="220"/>
             width="100%" height="10"/>
             label="Telefone" direction="horizontal">
                 width="100" id="txtTelefone"/>
            >
        >
         label="Email" width="100%" direction="horizontal">
             width="220" id="txtEmail"/>
             width="100%" height="10"/>
             label="Salvar" click="this.salvaContato()"/>
        >
         width="100%">
             width="100%" dataProvider="{this.agenda}">
                >
                     headerText="Nome" dataField="nome"/>
                     headerText="Telefone" dataField="telefone"/>
                     headerText="Email" dataField="email"/>
                >
            >
        >
    >
 
>

Prontinho! Ao rodar a aplicação de novo e adicionar mais contatos conseguimos ver que agora tudo está funcionando perfeitamente!

Bom, confesso que este post ficou um pouco maior do que eu imaginei inicialmente… hehehe

Mas o importante é que deu pra passar a idéia sobre como funciona a integração do Java e do FLEX e como pessoas cujo dom na área de design não é muito elevado (como eu) podem fazer aplicações bonitas e amigáveis para o usuário final!

O código fonte desses projeto está disponível aqui.

Veja a parte 2 também..!

[]s e até a próxima,

Saab.

PS: Gostou? Não gostou? Ajudou? Não ajudou? Quebrou um galho? Perdeu 10 minutos da tua vida lendo? Comente! Divulgue! Fale mal! Compartilhe sua opinião com toda a comunidade!

Spring Framework Parte 3 -> Java Database Connectivity (JDBC)

Felipe Saab — Thu, 02 Sep 2010 12:50:56 +0000

Bem vindo leitor a mais um post da série Spring Framework.

Caso você ainda não leu os posts anteriores, por favor dê um pulinho bem rápido neles:

Vamos ao nosso próximo assunto então: JDBC e como o Spring facilita esse cara pra gente!

Tirando essa imagem do livro Spring in Action 2 (Manning, 2008) nós já conseguimos ver bem por cima como que o Spring pretende acessar de maneira padronizada a base de dados (Hitting the database) através de um objeto de acesso aos dados (DAO), um template (provido pelo próprio Spring) e caso nós quiséssemos, o Spring também oferece suporte padrão para alguns frameworks de persistência (será um dos próximos artigos desta série).

Tudo muito legal, muito bonito! Vamos tentar seguir este modelinho porque ele é bem bonitinho e vai nos ajudar um pouco. Apenas avisando que o jeito que descreverei neste tutorial não é o único jeito de acessar os dados através do seu driver JDBC, porém é um jeito que eu achei bem interessante e que vale a pena todos sabermos um pouquinho… =]

Existem apenas 2 conceitos básicos que o Spring nos sugere para o acesso rápido e fácil aos dados através de drivers JDBC: DataSource (DAO fornecido pelo Spring) e JdbcTemplate (template para acesso a dados através de um driver JDBC fornecido pelo Spring):

DataSource é uma classe provida pelo nosso querido Spring Framework e que se preocupa com toda a conexão e conversação com o driver JDBC que iremos utilizar (neste exemplo iremos utilizar o driver JDBC para o banco de dados MySQL). Em palavras um pouco mais técnicas, esta classe irá se resonsabilizar por nos entregar um objeto java.sql.Connection, java.sql.Statement, entre esses objetos que utilizamos quando o assunto é conexão de dados JDBC.

JdbcTemplate é uma outra classe muito útil provida pelo nosso ~~adorado~~ Spring! Este template provê métodos padronizados para acessarmos os dados (selecioná-los e manipulá-los), ou seja, fazer tudo o que podemos fazer com eles de um jeito bem fácil de acessar (como você irá descobrir logo a frente).

Muito bem, com esses dois conceitos já pintados na sua cabeça, por favor responda corretamente a próxima pergunta: “Já que estas classes são providas pelo nosso amigo Spring, quem instancia elas?”. Exato!! O próprio Spring cria os beans para estas classes, tudo o que temos que fazer é declarar estes beans no arquivo de configuração do Spring. Vamos a ele então:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
     id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         name="driverClassName" value="com.mysql.jdbc.Driver" />
         name="url" value="jdbc:mysql://localhost/spring_jdbc" />
         name="username" value="root" />
         name="password" value="123" />
    >
 
     id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         name="dataSource" ref="dataSource" />
    >
 
>

Tão simples quanto encher um copo com água! Eu sinto até orgulho de mostrar como é fácil conectar com uma fonte de dados JDBC através do Spring!

O nosso primeiro bean é o dataSource. Como eu já disse ali em cima, esse é o cara responsável por conversar com o driver JDBC. Então nada mais justo que a gente ensinar ele a se comunicar com o driver passando os parâmetros corretos não é… Os parâmetros (injetados através da DI) passados para o dataSource foram: dataClassName (qual driver JDBC será usado), url (caminho do JDBC para se conectar até o banco de dados desejado), username (login do banco de dados) e password (senha do banco de dados).

No caso desse nosso exemplo, o driver JDBC é do MySQL, nunca esqueça que o driver deve estar no classpath em!!! Segue uma foto te ensinando como adicionar o driver JDBC do MySQL no NetBeans:

E o segundo bean do arquivo de configuração é o jdbcTemplate que é o template provido pelo Spring para facilitar a manipulação dos dados. A unica dependência que este bean tem é o próprio dataSource, ou seja, ele precisa de uma referência para um dataSource para saber em qual banco ele vai executar os comandos que quisermos. Sendo assim, de um jeito muito fácil (injeção de dependência), nós passamos uma referência do nosso dataSource já criado para ele. ^^

Só fazendo uma pequena pausa no Spring agora, vamos falar um pouquinho do banco de dados: criei uma tabela de Pessoas para fazermos nossos teste aqui. Dê uma olhada no script de criação:

CREATE TABLE  `Pessoas` (
    `pes_cod` INT NOT NULL ,
    `pes_nome` VARCHAR( 100 ) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL ,
    `pes_idade` INT NOT NULL ,
    PRIMARY KEY (  `pes_cod` )
) ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Muuuito bem! A esta altura nós já temos os arquivos base para a conexão com o banco de dados E o banco de dados! Vamos continuar a codificar mais algumas classes e veremos o quão fácil o Spring tornou o acesso aos dados através do JDBC para nós.

Já que temos a tabela pronta no banco de dados, precisamos desenvolver uma classe Java que irá representar cada registro dessa tabela (para manipulação em memória né…):

Pessoa.java

public class Pessoa {
 
    private int cod;
    private String nome;
    private int idade;
 
    public Pessoa() {
        this.cod = -1;
        this.nome = "Não Encontrado";
        this.idade = -1;
    }
 
    public int getCod() {
        return cod;
    }
 
    public void setCod(int cod) {
        this.cod = cod;
    }
 
    public int getIdade() {
        return idade;
    }
 
    public void setIdade(int idade) {
        this.idade = idade;
    }
 
    public String getNome() {
        return nome;
    }
 
    public void setNome(String nome) {
        this.nome = nome;
    }
 
    @Override
    public String toString() {
        return "Codigo: " + String.valueOf(this.cod)
                + " | Nome: " + this.nome
                + " | Idade: " + String.valueOf(this.idade);
    }
}

Pronto, com a classe Pessoa agora fica bem mais fácil nós termos uma “Pessoa” em memória! Vamos daqui pra frente tentar unir a classe Pessoa que acabamos de escrever com o banco de dados, ou seja, inserir um objeto da classe Pessoa no banco de dados, recuperar um objeto Pessoa do banco, e por ai vai…

Caso você acompanha este blog regularmente, já deve ter percebido que eu virei fã de utilizar as interfaces no desenvolvimento (os motivos são muitos! então apenas acredite: compensa!). Já que eu sou um cara que gosta de seguir padrões e tudo mais, vamos codificar uma interface que será muito útil para o nosso acesso ao banco de dados:

IBanco.java

public interface IBanco {
 
    public void InserirPessoa(Pessoa pessoa);
 
    public void AtualizarPessoa(Pessoa pessoa);
 
    public void ApagarPessoa(Pessoa pessoa);
 
    public Pessoa SelecionarPessoa(Pessoa pessoa);
}

Esta interface obriga a classe que implementá-la a dar suporte para as operações CRUD referêntes aos objetos Pessoa juntamente com a tabela do banco de dados Pessoa (ficou meio confusa essa frase? hehehe).

Como o código sempre resolve tudo, vamos a ele que você irá entender do que eu estou falando:

BancoDados.java

public class BancoDados implements IBanco {
 
    private JdbcTemplate jdbcTemplate;
 
    public BancoDados() {
    }
 
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public void InserirPessoa(Pessoa pessoa) {
        String sql = "INSERT INTO Pessoas(pes_cod,pes_nome,pes_idade) VALUES(?,?,?)";
        jdbcTemplate.update(sql, new Object[]{pessoa.getCod(), pessoa.getNome(), pessoa.getIdade()});
    }
 
    public void AtualizarPessoa(Pessoa pessoa) {
        String sql = "UPDATE Pessoas SET pes_nome = ?, pes_idade= ? WHERE pes_cod = ?";
        jdbcTemplate.update(sql, new Object[]{pessoa.getNome(), pessoa.getIdade(), pessoa.getCod()});
    }
 
    public void ApagarPessoa(Pessoa pessoa) {
        String sql = "DELETE FROM Pessoas WHERE pes_cod = ?";
        jdbcTemplate.update(sql, new Object[]{pessoa.getCod()});
    }
 
    public Pessoa SelecionarPessoa(Pessoa pessoa) {
        String sql = "SELECT * FROM Pessoas WHERE pes_cod = ?";
 
        List resultados = jdbcTemplate.query(sql, new Object[]{pessoa.getCod()},
                new RowMapper() {
 
                    public Object mapRow(ResultSet rs, int i) throws SQLException {
                        Pessoa p = new Pessoa();
                        p.setCod(rs.getInt("pes_cod"));
                        p.setNome(rs.getString("pes_nome"));
                        p.setIdade(rs.getInt("pes_idade"));
                        return p;
                    }
                });
 
        Pessoa pes = new Pessoa();
        if (resultados.size() > 0) {
            pes = (Pessoa) resultados.get(0);
        } else {
            pes.setCod(pessoa.getCod());
        }
 
        return pes;
    }
}

Muito bem, vamos com calma…

A primeira coisa que devemos notar é que temos uma variável de instância chamada jdbcTemplate. Como eu imagino que você leitor é um cara que associa tudo muito rápido e já viu que um pouco mais pra baixo dessa variável tem o setter dela, eu imagino que você já entendeu que essa variável vai ser injetada através do container do Spring né… =]

Como nós já pedimos pro Spring criar um bean do tipo JdbcTemplate no arquivo de configuração, daqui a pouco nós voltaremos nele e pediremos pra ele enviar uma referência do JdbcTemplate aqui pra essa nossa classe poder usar. Tudo muito prático!

Depois disso o que nós podemos entender é que a classe reescreveu os métodos que a interface obriga e os implementou de fato! Vamos entender eles rapidinho…

Para as operações de inserção, alteração e exclusão os métodos são absolutamente iguais: primeiro foi definido o SQL referente a operação e depois foi chamado o método update da nossa classe super amigável: jdbcTemplate.

Existem dois detalhes para chamar a atenção na execução destas operações:

1 – O SQL que foi montado não possui os valores finais. Ao invés deles estão presentes pontos de interrogação ( ? ) representando parâmetros.

2 – Os parâmetros informados no SQL são enviados como o segundo parâmetro do método update do jdbcTemplate. Para a padronização na chamada do método é necessário que todos os parâmetros definidos no SQL sejam passados dentro de um vetor de Object (mesmo que seja só um parâmetro, ele também deve estar dentro do vetor). Outra coisa que vale ser lembrada é que o primeiro item do vetor irá ser incluído no lugar do primeiro parâmetro do SQL (primeiro ponto de interrogação) então tome cuidado para passar os parâmetros na ordem correta para o vetor de Object.

Só mais um comentário para a operação de seleção: também foi utilizado um SQL com parâmetro e um vetor de Object referenciando os parâmetros porém o método do jdbcTemplate utilizado não foi o update, e sim o query!

O funcionamento deste método é bem interessante: ao invés de apenas 2 parâmetros (como no método update), depois do vetor de Object é passado um objeto org.springframework.jdbc.core.RowMapper que é responsável por mapear cada registro retornado por um ResultSet interno ao jdbcTemplate em um objeto correspondente ao registro e após o mapeamento o objeto customizado é adicionado a um java.util.List que é o retorno final do método query.

Exemplo do nosso caso: caso sejam retornadas 3 pessoas pelo SQL utilizado, o método mapRow do objeto RowMapper será invocado 3 vezes (uma para cada registro). Cada vez que ele for invocado será configurado um novo objeto Pessoa com os dados de cada registro retornado do banco de dados e cada vez que o método retornar um novo objeto Pessoa ele será guardado na lista que será retornada pelo método query.

Logo depois deste método eu apenas retorno o primeiro objeto que está na lista ou então retorno um objeto com o mesmo código da busca caso não foi encontrado nenhum registro.

Sempre muito simples esses códigos… adoro isso… ehheheh

Vamos adicionar um bean ao arquivo de configuração do Spring para o container também instanciar a nossa classe responsável pelo banco de dados e é claro, vamos também já injetar o JdbcTemplate no nosso novo bean:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
     id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         name="driverClassName" value="com.mysql.jdbc.Driver" />
         name="url" value="jdbc:mysql://localhost/spring_jdbc" />
         name="username" value="root" />
         name="password" value="123" />
    >
 
     id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         name="dataSource" ref="dataSource" />
    >
 
     id="banco_dados" class="spring_jdbc.BancoDados">
         name="jdbcTemplate" ref="jdbcTemplate" />
    >
 
>

E isso é tudo!!
Nossas classes base para o acesso e manipulação da entidade Pessoa no banco de dados e no nosso próprio software já estão codificadas e bem funcionais. Tudo que precisamos agora é de um programinha exemplo para testarmos estas classes e ver como iriam ser realmente usadas.

Segue a classe que contém o método main desta aplicação:

public class Principal {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/conf/spring_jdbc.xml");
 
        BancoDados banco = (BancoDados) ctx.getBean("banco_dados");
 
        //cria os objetos Pessoa
        Pessoa p1 = criar_pessoa(1, "Felipe", 18);
        Pessoa p2 = criar_pessoa(1, "Felipe Saab", 21);
        Pessoa felipe = null;
 
        //insere no banco
        try {
            banco.InserirPessoa(p1);
            System.out.println("1 - Pessoa Inserida");
        } catch (Exception e) {
            System.out.println("Não foi possível inserir o registro: " + e);
        }
 
        //recupera
        try {
            felipe = banco.SelecionarPessoa(p1);
            System.out.println("2 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
 
        //altera
        try {
            banco.AtualizarPessoa(p2);
            System.out.println("3 - Pessoa Atualizada");
        } catch (Exception e) {
            System.out.println("Não foi possível atualizar o registro: " + e);
        }
 
        //recupera novamente
        try {
            felipe = banco.SelecionarPessoa(p2);
            System.out.println("4 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
 
        //apaga
        try {
            banco.ApagarPessoa(p2);
            System.out.println("5 - Pessoa Apagada");
        } catch (Exception e) {
            System.out.println("Não foi possível apagar o registro: " + e);
        }
 
        //procura pela ultima vez
        try {
            felipe = banco.SelecionarPessoa(p2);
            System.out.println("6 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
    }
 
    public static Pessoa criar_pessoa(int cod, String nome, int idade) {
        Pessoa p = new Pessoa();
        p.setCod(cod);
        p.setNome(nome);
        p.setIdade(idade);
        return p;
    }
}

Concordo que o exemplo é meio grandinho mas é bem fácil de entender não é?
Primeiro foram criados 3 objetos Pessoa (p1 – “Felipe”, p2 – “Felipe Saab” e felipe que irá receber o resultado da busca no banco), depois foi inserido um dos objetos, procurado por ele no banco, depois ele foi alterado com as informações do outro objeto e foi recuperado novamente, e por fim a Pessoa foi apagada do banco e só para garantir foi feita uma última busca.

Este exemplo foi só para testar todas as operações que nós implementamos. Caso você use algo parecido no seu software do dia a dia irá ver que tudo funciona perfeitamente bem (cada operação no teu lugar certo).

É isso ai leitor! Você chegou ao fim deste post grandão!!
Espero que tenha gostado da leitura e da função que foi descrita aqui.

Caso queira fazer o download do projeto que eu desenvolvi como exemplo pode fazer o download aqui (OBS: o projeto está com bibliotecas do NetBeans 6.8 (Spring 2.5 e MySQL JDBC) então ele só vai rodar 100% certo caso você abra ele no NetBeans 6.8 ou superior, caso contrario, apenas aproveite os códigos fonte =] ).

[]s e até a próxima,
Saab.

Spring Framework Parte 1 -> Dependency Injection

Felipe Saab — Mon, 09 Aug 2010 19:11:13 +0000

Quem é dessa área e nunca ouviu falar de Spring Framework por favor levante a mão………….. Ótimo, todo mundo pelo menos já ouviu falar desse tal de Spring.

Durante esta série de tutoriais eu vou demonstrar o que é, pra que server e como vc pode utilizar o Spring para facilitar seus projetos.

Primeiramente, o que é esse tal de Spring afinal de contas? Spring é um framework que propicia um container para sua aplicação, ou seja, sua aplicação roda em cima do container do Spring. Tal container provê principalmente a Injeção de Dependência (ou Inversão de Controle, como era conhecido anteriormente) e a Programação Orientada a Aspectos.

Nesta primeira parte eu vou falar sobre o padrão Injeção de Dependência e os benefícios que ele provê. Vamos lá então:

O padrão de projeto Injeção de Dependência diz que uma classe não deve criar as suas dependências, em outras palavras, uma classe não deve instanciar seus atributos. Ao invés disso, eles devem ser injetados na classe através de um mecanismo externo, ou através de quem criou o objeto desta classe.

Ainda não está claro né… Vamos a um exemplo (baseado em um dos exemplos do livro Spring in Action 2, 2008) para facilitar as coisas.

Vamos imaginar que fomos contratados para desenvolver o software do Ídolos Spring?, uma competição de talentos musicais onde as pessoas cantam e/ou tocam. Primeiro de tudo vamos desenvolver uma interface genérica o suficiente para todos os nossos competidores:

public interface Competidor
    public void apresentar();
}

Pronto, agora todo mundo que for competir no Ídolos Spring vai ter que implementar essa interface para poder participar (é quase como se fosse a inscrição da competição… hahahahah péssima analogia.. ).

Vamos então aos competidores, vamos começar com um cantor. Um cantor não toca nenhum instrumento musical, ele apenas canta uma música. Vamos então à interface que descreve uma música:

public interface Musica
    public void cantar();
}

Baseado na interface, já podemos criar uma música:

public class AtireiOPauNoGato implements Musica {
 
    private static String[] letra = {
        "Atirei o páu no gato tô tô",
        "Mas o gato tô tô",
        "Não morreu reu reu",
        "Dona Chica cá",
        "Admirou-se se",
        "Do berro, do berro que o gato deu",
        "Miau !!!!!!"};
 
    public void cantar() {
        for (int i = 0; i &lt; letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

Legal, alguém vai cantar a famosa cantiga Atirei o pau no gato. Vamos codificar o cantor que irá fazer isso então:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
        this.musica = new AtireiOPauNoGato();
    }
 
    public void apresentar() {
        musica.cantar();
    }
 
}

Prontinho. Agora toda vez que um cantor for se apresentar ele irá cantar Atirei o Pau no Gato. Mas pera ai, tem alguma coisa que não faz muito sentido aqui não tem?

Será que TODO cantor da nossa competição vai cantar a mesma música? Acho que não né… E do jeito que esta classe está implementada, nós temos que mudar a classe para ele cantar uma outra musica. Isso não é lá muito viável…

O que a Injeção de Dependência prega é que ao invés de o cantor se preocupar em ficar preparando a música que ele vai cantar, ele apenas vai receber a música impressa um pouco antes da competição e pronto.

Pensando nisso, o cantor ficaria assim:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
    }
 
    public void setMusica(Musica musica) {
        this.musica = musica;
    }
 
    public void apresentar() {
        musica.cantar();
    }
}

Pronto, o cantor já não está mais preparando a sua música, pouco antes da apresentação ele vai receber a música (através do setter) e vai cantá-la (porque quem é bom faz ao vivo! hehehe).

Ok ok, até aqui não teve absolutamente NADA do tal do Spring, e vc provavelmente ainda não entendeu o porque desse monte de interfaces que parecem bobas não é mesmo?…

Vamos lá, advinhem quem vai dar a musica para o cantor? EXATO!! O container do Spring é quem vai ser responsável por entregar a música para o nosso cantor, ou em termos mais técnicos, o container é quem faz toda a linkagem dos beans (cada objeto manipulado pelo container é um bean, ex: uma musica, um cantor, um objeto que acessa o banco de dados, etc).

Para nós vermos como isso tudo funciona (pq ngm gosta de bla bla bla), vou abrir o NetBeans 6.8, criar uma nova Aplicação Java e criar as interfaces e classes descritas até aqui.

O NetBeans já traz as bibliotecas do Spring Framework junto com a IDE, o que te economiza um tempinho baixando-as. Clique com o botão direito na pasta Bibliotecas e cliquem “Adicionar bliblioteca…” e adicione a biblioteca “Spring Framework 2.5″

Uma vez que o Spring já está no classpath nós já podemos criar um arquivo de configuração para descrever os beans da nossa aplicação. Toda a configuração do container é feita através de arquivos XML.

Sendo assim eu criei mais um pacote (conf) e criei o arquivo idolos.xml dentro dele, este será o arquivo que o Spring irá utilizar para o container da nossa aplicação.

A tag root dos arquivos de configuração do Spring é a tag que define os namespaces e os DTDs necessários. De começo deixe o arquivo assim:

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

Essa é a estrutura básica de um arquivo de configuração (não se assuste com o tamanho dessa tag, vc não precisa decorar essas coisas).

Já que nossas classes estão prontas, vamos para o nosso primeiro competidor: José. O José vai cantar Atirei o Pau no Gato. Para declará-lo e dar a música pra ele vai ficar assim:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
        id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
 
        id="jose" class="injecaodependencia.Cantor">
            name="musica" ref="atireiopau" />
       >
 
>

Aqui é que o Spring começa a trabalhar, cada tag no arquivo de configuração representa um objeto que o container irá gerenciar. No nosso exemplo, temos o bean “atireiopau” que é um objeto da classe AtireiOPauNoGato e o bean “jose” que eh um Cantor e vai cantar a música referenciada pelo bean “atireiopau”.

Em termos de código, seria como se o container fizesse o seguinte:

injecaodependencia.AtireiOPauNoGato atireiopau = new injecaodependencia.AtireiOPauNoGato();
injecaodependencia.Cantor jose = new injecaodependencia.Cantor();
jose.setMusica(atireiopau);

Essa é a mágica da Injeção de Dependência, o José teve a música “injetada” nele, se a gente quiser que ele cante outra música não precisamos reescrever a classe Cantor, apenas injetar uma música diferente nele.

Isso torna a aplicação muito mais desacoplada, muito mais fácil de testar e de reusar os módulos!!!

Mas e para usar isso agora? Como que a gente põe isso pra funcionar? Eu quero ver o José cantar!!!! hehehe

Vamos lá então, vamos ao código da classe principal do nosso exemplo:

public class Main {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("jose");
 
        competidor.apresentar();
    }
 
}

A interface ApplicationContext é justamente o container (um dos existentes) do Spring Framework. Existe também a BeanFactory mas essa é bem mais simples e eu não irei comentá-la.

O que acontece nesse código então é o seguinte: é criado o container passando o arquivo de configuração que ele irá utilizar, depois é recuperado o bean “jose” do container (nesse momento o container instancia o bean e todas as suas dependências) e por fim, nós pedimos pro José se apresentar.

Você deverá ver ele cantando incrivelmente bem o clássico Atirei o Pau no Gato.

Porém o próximo competidor promete! Ele irá cantar E tocar Ciranda Cirandinha com uma gaita!! Essa eu quero ver!!

Vamos às classes necessárias para o próximo competidor:

public class CirandaCirandinha implements Musica {
 
    private static String[] letra = {
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar",
        "",
        "O anel que tu me destes,",
        "Era vidro",
        "E se quebrou.",
        "O amor que tu me tinhas",
        "Era pouco e se acabou.",
        "",
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar"};
 
    public void cantar() {
        for (int i = 0; i < letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

public interface Instrumento {
    public void tocar();
}

public class Gaita implements Instrumento {
    public void tocar() {
        System.out.println("FUU FUU FII FII");
    }
}

public class CantorTocador extends Cantor {
 
    private Instrumento instrumento;
 
    public CantorTocador() {
        super();
    }
 
    public void setInstrumento(Instrumento instrumento) {
        this.instrumento = instrumento;
    }
 
    public void apresentar() {
        instrumento.tocar();
        super.apresentar();
        instrumento.tocar();
    }
 
}

Pronto, agora nosso próximo competidor está pronto para se apresentar. Sras e Srs dêem as boas vindas para Carlos:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
        id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
        id="jose" class="injecaodependencia.Cantor">
            name="musica" ref="atireiopau" />
       >
 
        id="ciranda" class="injecaodependencia.CirandaCirandinha" />
        id="gaita" class="injecaodependencia.Gaita" />
        id="carlos" class="injecaodependencia.CantorTocador">
            name="musica" ref="ciranda" />
            name="instrumento" ref="gaita" />
       >
 
>

Agora basta chamar o Carlos para se apresentar ao invés do José:

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("carlos");
 
        competidor.apresentar();
    }
}

E se a gente quisesse que o Carlos tocasse piano cantando Atirei o Pau no Gato? Simples:

public class Piano implements Instrumento {
    public void tocar() {
        System.out.println("PLIN PLIN PLIN");
    }
}

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
        id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
        id="jose" class="injecaodependencia.Cantor">
            name="musica" ref="atireiopau" />
       >
 
        id="ciranda" class="injecaodependencia.CirandaCirandinha" />
        id="gaita" class="injecaodependencia.Gaita" />
 
        id="piano" class="injecaodependencia.Piano" />
        id="carlos" class="injecaodependencia.CantorTocador">
            name="musica" ref="atireiopau" />
            name="instrumento" ref="piano" />
       >
 
>

Basta “injetar” os beans desejados nas dependências e boa! Tudo segue seu fluxo natural.

Esta foi uma pequena (eu diria mínima) introdução à Injeção de Dependências no Spring Framework. O container ApplicationContext possui muuuuuito mais funções para gerenciar os seus beans, porém isso iria extender demais este assunto.

Acho que se você leu o post até aqui, vc conseguiu pegar o que eu quis passar: programar utilizando interfaces torna o seu código muito mais limpo, fácil de entender, fácil de dar manutenção, fácil de reutilizar, fácil de extender, ou seja, melhora tudo!!

Adicionando isso com a técnica de Injeção de Dependência torna a aplicação altamente desacoplada em termos de componentes (você pode utilizar a classe Cantor em qualquer outra aplicação, só precisa passar uma classe que implemente a interface Musica pra ele e tudo vai funcionar perfeitamente).

Os códigos fontes utilizados neste tutorial estão aqui.

[]s e até a próxima,
Saab.

Annotations: O que é, pra que serve?

Felipe Saab — Fri, 02 Apr 2010 14:33:01 +0000

Annotations… recurso interessante.

Sempre tive a curiosidade de saber como funcionavam, então fui perguntar pro Google.
Pretendo demonstrar aqui o que eu aprendi nas minhas pesquisas.

Annotations são… advinhem… anotações! É um jeito que você tem de fazer alguma marcação em um atributo, método, classe, entre outros.

Elas sempre devem ser digitadas antes do objeto que você queira anotar (método, atributo…) e o nome das anotações são sempre precedidos de @ (arroba). Ex:

@MinhaAnotacao
class MinhaClasse{
}

Até ai tudo bem, mas você deve estar se perguntando: “Pra que diabos eu vou usar isso? Pra que ficar enfeitando meu código?”. Calma. Tudo tem seu propósito.

Para poder trabalhar com as anotações, iremos utilizar a reflexão computacional, portanto sugiro que você leitor, leia meus posts antigos sobre Reflexão Computacional:

Java e seus Espelhos: Reflexão Computacional e

Reflexão Computacional: Exemplo Prático

Daqui pra frente vou supor que você entende e sabe utilizar a reflexão computacional…

Exemplo 1: Testando seus métodos

Então vamos lá: imagine que você é um bom programador com uma ótima noção de engenharia de software (o que realmente deve ser verdade neh… ). Você sabe que uma fase importante no desenvolvimento de um software é a fase de testes. Porém você não gosta dos frameworks existentes para teste unitário (ou qualquer outro tipo), então você decide criar o seu próprio!

Para não ficar muito chato de utilizar, você decide que durante o desenvolvimento, todo método que possuir a anotação “@Testar” será testado pelo seu framework.

OK, com essa idéia na cabeça vamos criar a nossa anotação @Testar:

Testar.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Testar { }

Reparem que a nossa anotação deve ser anotada com meta-anotações.

A anotação @Retention(RetentionPolicy.RUNTIME) diz que a VM deve manter essas anotações em tempo de execução para podermos ler elas através da reflexão. Outras opções seriam: SOURCE e CLASS.

E a anotação @Target(ElementType.METHOD) indica que a nossa anotação só é aplicada a métodos. Outras opções seriam: FIELD, TYPE (classe e interface), PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, e PACKAGE.

Reparem que para declarar a nossa própria anotação, deve-se utilizar “@interface” antes do nome da anotação.

Pronto! Só isso! É assim que as anotações são criadas. Uma vez que já temos ela, vamos criar a classe que irá ser testada.

ClasseParaTestar.java

public class ClasseParaTestar {
 
    @Testar
    public void metodo1() {
        throw new RuntimeException("Deu zebra!");
    }
 
    @Testar
    public void metodo2() {
    }
 
    @Testar
    public void metodo3() {
    }
 
    public void metodo4() {
    }
 
    @Testar
    public void metodo5() {
        throw new RuntimeException("Ixi maria... Erro!");
    }
 
    public void metodo6() {
    }
 
    @Testar
    public void metodo7() {
    }
 
    public void metodo8() {
    }
}

Como o propósito é só demonstrar as anotações, os métodos não fazem nada.

Beleza, agora os métodos que eu quero testar já estão “anotados”. Vamos criar a classe principal do nosso framework de testes.

Testador.java

public class Testador {
 
    public static void testar(Object obj) {
        Class classe = obj.getClass();
        int passou = 0;
        int falhou = 0;
 
        System.out.println("-------------Inicio dos Testes--------------");
        for (Method m : classe.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Testar.class)) {
                try {
                    System.out.print("Testando o método: "; + m.getName());
                    m.invoke(obj);
                    passou++;
                    System.out.println(" => passou!");
                } catch (Throwable t) {
                    falhou++;
                    System.out.println(" => falhou! " + t.getCause());
                }
            }
        }
        System.out.println("---------------Fim dos Testes---------------");
        System.out.println("Passaram: " + passou + ", Falharam: " + falhou);
    }
}

Simples simples (caso você entenda a reflexão)… Tudo o que a gente faz é verificar se o método possui a anotação @Testar, caso ele possua, o método é invocado. Se não ocorrer nenhuma exceção, então ele passou no teste, caso contrário ele falhou.

Para utilizar o nossa pequeno (micro) framework, basta chamar o método estático passando um objeto da nossa classe para testar:

Testador.testar(new ClasseParaTestar());

Para o nosso exemplo, você deve obter a seguinte saída:

-------------Inicio dos Testes--------------
Testando o método: metodo1 => falhou! java.lang.RuntimeException: Deu zebra!
Testando o método: metodo2 => passou!
Testando o método: metodo3 => passou!
Testando o método: metodo5 => falhou! java.lang.RuntimeException: Ixi maria... Erro!
Testando o método: metodo7 => passou!
---------------Fim dos Testes---------------
Passaram: 3, Falharam: 2

Obs: Eu tirei este exemplo da documentação oficial.

Exemplo 2: Validando seus atributos

Vamos criar uma classe genérica que faz a validação dos atributos de qualquer classe que você peça para ele validar. É claro que os atributos a serem validados devem possuir as anotações que nós vamos criar.

Vamos criar as nossas anotações então: @ValidarContemTexto e @ValidarPositivo.

ValidarPositivo.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ValidarPositivo { }

ValidarContemTexto.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ValidarContemTexto {
    int min() default 1;
}

Opa! Apareceu uma coisa nova aqui. A anotação @ValidarContemTexto possui um atributo???

É isso mesmo! As anotações podem conter atributos para realizar alguma lógica durante o processamento delas.

No nosso caso, a anotação @ValidarContemTexto irá validar se o atributo que está decorado com a anotação possui pelo menos min caracteres (que por default é 1).

Reparem que a meta-anotação @Target é ElementType.FIELD, porque vamos utilizar essas anotações para decorar atributos.

A classe Usuario para o nosso teste será a seguinte:

Usuario.java

public class Usuario {
 
    @ValidarContemTexto(min = 10)
    private String login;
 
    @ValidarContemTexto(min = 20)
    private String senha;
 
    @ValidarPositivo
    private int nivel;
 
    //Construtores, getters e setters
    //...
}

O login deverá possuir pelo menos 10 caracteres, a senha deverá possuir pelo menos 20 caracteres (para garantir alguma segurança… hehehe) e o nível deverá ser um inteiro positivo maior ou igual a zero.

Vamos ver a classe responsável pela validação:

Validador.java

public class Validador {
 
    public static boolean validar(Object obj) {
        Class classe = obj.getClass();
        boolean ok = true;
 
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
 
            //Annotation @ValidarPositivo
            if (f.isAnnotationPresent(ValidarPositivo.class)) {
                try {
                    int num = Integer.parseInt(f.get(obj).toString());
                    if (num < 0) {
                        ok = false;
                        throw new Exception();
                    }
                } catch (Throwable t) {
                    System.out.println(f.getName() + " deve ser um valor inteiro positivo.");
                }
            }
 
            //Annotation @ValidarContemTexto
            if (f.isAnnotationPresent(ValidarContemTexto.class)) {
                ValidarContemTexto anotacao = f.getAnnotation(ValidarContemTexto.class);
                try {
                    String texto = f.get(obj).toString();
                    if (texto.length() < anotacao.min()) {
                        ok = false;
                        System.out.println(f.getName() + " deve possuir pelo menos " + anotacao.min() + " caracteres.");
                    }
                } catch (Throwable t) {
                    System.out.println(f.getName() + ": " + t.getCause());
                }
            }
        }
        return ok;
    }
}

Quase igual ao exemplo anterior, porém nós percorremos os atributos (getDeclaredFields()) ao invés do métodos (getDeclaredMethods()).

Um if para cada anotação… nada muito novo. A única novidade aqui é a recuperação da anotação @ValidarContemTexto para poder acessar o valor que foi definido para o seu atributo min. Mas também não é nada de outro mundo.

O código a seguir cria 3 usuários e executa a validação com cada um deles:

ArrayList<usuario> usuarios = new ArrayList<usuario>();
usuarios.add(new Usuario("login", "senha", 2));
usuarios.add(new Usuario("felipesaab", "SaabRocks", -5));
usuarios.add(new Usuario("javasimples", "javasimplesjavasimples", 0));
 
for (Usuario u : usuarios) {
    System.out.println("Validando usuario: " + u.getLogin());
    if (Validador.validar(u)) {
        System.out.println("Usuário OK.");
    } else {
        System.out.println("Corrija os erros.");
    }
    System.out.println();
}

O resultado será o seguinte:

Validando usuario: login
login deve possuir pelo menos 10 caracteres.
senha deve possuir pelo menos 20 caracteres.
Corrija os erros.
 
Validando usuario: felipesaab
senha deve possuir pelo menos 20 caracteres.
nivel deve ser um valor inteiro positivo.
Corrija os erros.
 
Validando usuario: javasimples
Usuário OK.

Chegamos ao fim de mais um post aqui do Java Simples. Espero que tenham gostado, eu pelo menos achei esse assunto interessantíssimo.

Quem quiser pode pegar os arquivos que eu fiz e testei aqui.

[]s e até a próxima,

Saab.

Internacionalização – Um software, vários idiomas!

Felipe Saab — Sat, 20 Mar 2010 17:17:44 +0000

Tudo bem, eu admito. Esse nome é muito grande e chato de pronunciar (porém muito útil!).

Imagine que você desenvolveu um super software (em Java é claro…) para atender um determinado nicho de mercado, levou 1 ano da sua vida para fazer isso. Quando você começou a vendê-lo foi o maior sucesso, seus clientes falaram bem do seu software pra todo mundo. Cada dia apareciam mais clientes, maravilha!

Até que um certo dia um americano ouviu falar do seu software e diz que paga um preço 5x maior do que você está acostumado a cobrar, porém o software tem que ser totalmente em Inglês…

E agora José???? Vai copiar o projeto e sair mudando todas as strings? Boa sorte…

Se tivesse pensado nisso antes, você teria planejado melhor o seu software e teria utilizado as facilidades que o Java oferece para Internacionalizar seu programa.

Mais chega de história, vamos a algo um pouco mais prático. Vamos criar uma pequena aplicação apenas para demonstrar como é fácil e útil internacionalizar seu programa em Java.

Crie um novo projeto Java para Área de Trabalho no NetBeans e apague tudo que ele já cria. Crie 2 pacotes: internacionalizacao e internacionalizacao.linguas:

Dentro do pacote internacionalizacao crie um JFrame e o deixe parecido com este:

Eu mudei os nomes dos JLabel’s e do JComboBox para:

jL_Lingua
jL_Nome
jL_Telefone
jL_Email
jCB_Lingua

Fique a vontade para nomear como achar melhor.

Essa vai ser a cara do nosso aplicativo. Quando o usuário selecionar uma língua no combobox, todos os JLabel’s e o título do JFrame vão mudar para a língua escolhida.

Como as coisas não caem do céu, as informações de cada idioma devem estar armazenadas em algum lugar. E esse lugar é um arquivo que vai ficar no pacote internacionalizacao.linguas. Um arquivo para cada idioma.

O nome dos arquivos devem serguir um padrão: __.properties
O padrão pode variar um pouco pois existem alguns parâmetros opcionais, porém o que nos interessa é este mesmo.

* O nome de todos os arquivos devem ser iguais. Ex:

Idioma_pt_BR
Idioma_en_US

Sabendo disso, adicione 4 arquivos ao pacote internacionalizacao.linguas. Para adicioná-los clique com o botão direito no projeto e em Novo > Outro. Selecione a categoria “Java” e o tipo de arquivo “Arquivo de Propriedade”.

Adicione os seguintes arquivos:

Eu dei o nome padrão de “Linguas” aos meus arquivos. Como já foi dito, cada arquivo é responsável por um idioma:

Linguas_de_DE –> Alemão
Linguas_en_US –> Inglês
Linguas_fr_FR –> Francês
Linguas_pt_BR –> Português

Segue o conteúdo de cada arquivo de Línguas:

Linguas_de_DE.properties

titulo = Internationalisierung  - EinfacheJava
lingua = Sprache
nome = Name
telefone = Telefon
email = E-Mail

Linguas_en_US.properties

titulo = Internationalization - SimpleJava
lingua = Language
nome = Name
telefone = Phone
email = Email

Linguas_fr_FR.properties

titulo =  Internationalisation - SimpleJava
lingua = Langue
nome = Nom
telefone = Téléphone
email = Email

Linguas_pt_BR.properties

titulo =  Internacionalização - JavaSimples
lingua = Língua
nome = Nome
telefone = Telefone
email = Email

Uma vez que os arquivos de idioma já contenham tudo o que vamos precisar, vamos atualizar o combobox. Mude a propriedade “model” e adicione os seguintes itens:

pt_BR
en_US
fr_FR
de_DE

Agora só falta adicionar o evento que vai cuidar da mudança dos idiomas de acordo com a seleção do usuário. Adicione o seguinte código ao evento ActionPerfomed do jCB_Linguas:

String[] selecionado = jCB_Lingua.getSelectedItem().toString().split("_");
Locale.setDefault(new Locale(selecionado[0],selecionado[1]));
internacionaliza();

O vetor de String “selecionado” recebe o item que o usuário selecionou, porém separado pelo _ (underscore). Ex: se o usuário selecionar “pt_BR” –> “selecionado = {pt , BR}”.

Depois o Locale** default é setado para o que o usuário selecionou e é chamada a função internacionaliza().

** A Locale object represents a specific geographical, political, or cultural region. Um objeto Locale representa uma região geográfica, política ou cultural específica. (de acordo com a Documentação). Por default é a configuração do sistema operacional no qual a JVM foi instalada, ex: se o seu Windows é em português do Brasil, provavelmente sua Locale default será pt_BR.

Por fim, vamos ao código da função internacionaliza(), que é onde a mágica acontece:

public void internacionaliza() {
    Locale locale = Locale.getDefault();
    ResourceBundle palavras = ResourceBundle.getBundle("internacionalizacao.linguas.Linguas", locale);
 
    this.setTitle(palavras.getString("titulo"));
    jL_Lingua.setText(palavras.getString("lingua"));
    jL_Nome.setText(palavras.getString("nome"));
    jL_Telefone.setText(palavras.getString("telefone"));
    jL_Email.setText(palavras.getString("email"));
}

Primeiro é recuperado o Locale atual do computador e depois é instaciado o objeto palavras da classe ResouceBundle através do método estático ResourceBundle.getBundle(String,Locale). O que este método faz é procurar o arquivo cujo nome seja igual o passado no primeiro parâmetro e o Locale seja igual ao passado no segundo parâmetro.

Ex: A execução desse método:

ResourceBundle.getBundle("internacionalizacao.linguas.Linguas", new Locale(“pt”,”BR”);

Vai resultar na escolha do arquivo “Linguas_pt_BR.properties” do pacote “internacionalizacao.linguas”.

OBS Importante: É necessário passar o caminho completo do arquivo, ou seja: “pacote.NomePadrao”.

Agora que o objeto palavras contém a referência para todas as palavras daquele idioma, basta atribuí-las aos respectivos JLabels e ao título.

Muito legal não?

Quem quiser pode baixar o projeto através desse link.

É isso ai galera, qualquer dúvida é só deixar um comentário e prometo que respondo o mais rápido possível.

[]s,

Saab.

PS: Esse post também foi dica do Dang do Programei.org. Valew!

Robot ? O Que é isso?

Felipe Saab — Mon, 15 Mar 2010 01:47:04 +0000

Tempo é um troço foda… Só falta… nunca tem sobrando…
Depois de muito tempo sem um post, aqui estamos nós.

Hoje a gente vai desvendar a classe Robot, muito útil para testes automáticos, criação de bots e outros.

Em resumo, a classe Robot simula eventos do teclado, mouse e outros.

É tudo muito fácil, vamos ao código:

try {
	Robot robot = new Robot();
	robot.delay(1000);
	robot.keyPress(KeyEvent.VK_J);
	robot.keyPress(KeyEvent.VK_A);
	robot.keyPress(KeyEvent.VK_V);
	robot.keyPress(KeyEvent.VK_A);
	robot.keyPress(KeyEvent.VK_SPACE);
	robot.keyPress(KeyEvent.VK_S);
	robot.keyPress(KeyEvent.VK_I);
	robot.keyPress(KeyEvent.VK_M);
	robot.keyPress(KeyEvent.VK_P);
	robot.keyPress(KeyEvent.VK_L);
	robot.keyPress(KeyEvent.VK_E);
	robot.keyPress(KeyEvent.VK_S);
} catch (Exception ex) {
	System.out.println(ex.getMessage());
}

Para testar esse código basta executar o aplicativo e alternar para um editor de texto qualquer (em menos de 1 segundo).

Tudo o que esse código faz é criar um novo objeto da classe Robot, esperar por um segundo (pra dar tempo de alternar para um editor de texto) e simular o pressionamento de algumas teclas.

Um efeito bem legal é colocar um delay entre cada uma das teclas. Isso faz parecer que as teclas estão sendo digitas. Segue o código:

try {
	Robot robot = new Robot();
	robot.delay(1000);
	robot.keyPress(KeyEvent.VK_J);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_A);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_V);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_A);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_SPACE);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_S);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_I);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_M);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_P);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_L);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_E);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_S);
} catch (Exception ex) {
	System.out.println(ex.getMessage());
}

A classe Robot permite a simulação de eventos do mouse também:

try {
    Robot robot = new Robot();
    robot.mouseMove(1100, 10);
    robot.delay(500);
    robot.mousePress(InputEvent.BUTTON1_MASK);
} catch (Exception ex) {
    System.out.println(ex.getMessage());
}

O código acima apenas coloca o mouse na posição 1100,10 da tela e simula um clique do botão esquerdo.

Post curto pra um assunto de fácil entendimento. Espero que ninguem encontre dificuldades quando estiver utilizando essa classe tão legal.

[]s,

Saab.

PS: Esse post foi uma dica do Dang do Programei.org. Valew fera!

Reflexão Computacional – Exemplo prático

Felipe Saab — Tue, 09 Feb 2010 00:09:54 +0000

E ae galera,
Primeiro de tudo, obrigado pelas visitas… estava vendo as estatísticas do site e todo dia tem alguém dando uma olhada no blog. Obrigado mesmo.

No último post eu mostrei uma técnica bem interessante da programação dinâmica: a reflexão, através da qual agente consegue perguntar pra um objeto qualquer quais são suas variáveis de instância (inclusive os seus valores) e seus métodos.

Beleza, daí um monte de gente me perguntou: “Pra que diabos eu preciso saber disso?” ou então “Quando eu vou usar?” entre outras… Para exemplificar o uso da reflexão vamos criar uma pequena aplicação. Nada muito complicado… uma agenda de contatos. OK, só mais um detalhe: não vou explicar nada sobre a conexão com o banco de dados, ou tratamento de erros ou outras coisas que vou utilizar no tutorial, o foco vai ser a reflexão. Qualquer dúvida é só deixar um comentário que a gente resolve.

Então vamos ao que interessa! Primeiro vamos criar uma tabela no banco de dados para representar um contato:

CREATE TABLE `contatos` (
 
`con_id` INT NOT NULL ,
`con_nome` VARCHAR( 60 ) NOT NULL ,
`con_endereco` VARCHAR( 100 ) NOT NULL ,
`con_email` VARCHAR( 50 ) NOT NULL ,
`con_telefone` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `con_id` )
 
) ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Pronto, com o banco pronto vamos para a aplicação. Crie uma nova aplicação no NetBeans (aplicação para área de trabalho, porque ela já importa o .jar do swing), apague tudo que ele crie a seguinte estrutura:

Vamos aplicar um pequeno padrão aqui, algo que lembra o MVC, que é utilizar uma estrutura de 3 camadas:

Apresentação: mostra os dados para o usuário;
Negócios: cuida das regras de negócio da aplicação (nada muito complexo nessa nossa agenda);
Persistência: cuida do armazenamento físico dos dados.

Não vou explicar muito a engenharia da coisa portanto vamos em frente. Vamos começar de baixo pra cima, ou seja, vamos ver primeiro a classe da camada de persistência:

public class ConexaoMySQL {
 
    private Connection connect;
    private String erro = "";
 
    public static ConexaoMySQL getConexao() throws Exception {
        ConexaoMySQL c = new ConexaoMySQL();
        Connection connect = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost/agenda";
            connect = DriverManager.getConnection(url, "root", "123");
            c.setConnection(connect);
        } catch (ClassNotFoundException cnfex) {
            throw new Exception("Falha ao ler o driver JDBC" + cnfex.toString());
        } catch (SQLException sqlex) {
            throw new Exception("Impossível conectar com a base de dados" + sqlex.toString());
        } catch (Exception ex) {
            throw new Exception("Outro erro" + ex.toString());
        }
        return c;
    }
 
    public void close() {
        try {
            this.connect.close();
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }
 
    private void setErro(String erro) {
        this.erro = erro;
    }
 
    private void setConnection(Connection connection) {
        this.connect = connection;
    }
 
    public Connection getConnection() {
        return this.connect;
    }
 
    public String getMensagemErro() {
        return erro;
    }
 
    public boolean getEstadoConexao() {
        if (connect == null) {
            return false;
        } else {
            return true;
        }
    }
 
    public boolean manipular(String sql) // inserir, alterar,excluir
    {
        try {
            Statement statement = connect.createStatement();
            int result = statement.executeUpdate(sql);
            statement.close();
            if (result != 1) {
                return true;
            }
        } catch (SQLException sqlex) {
            erro = "Erro: " + sqlex.toString();
            return false;
        }
        return false;
    }
 
    public int getMaxPK(String tabela, String chave) {
        String sql = "select max(" + chave + ") as max from " + tabela;
        int max = 0;
        ResultSet rs = null;
        try {
            Statement statement = connect.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_READ_ONLY);
            System.out.println(sql);
            rs = statement.executeQuery(sql);
 
            if (rs.next()) {
                max = rs.getInt("max");
            }
            statement.close();
        } catch (SQLException sqlex) {
            erro = "Erro: " + sqlex.toString();
            return -1;
        }
 
        return max;
    }
 
    //aqui que a mágica da reflexão acontece
    public void Insere(String tabela, Object objeto) throws Exception {
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
        String sql = "INSERT INTO " + tabela.toUpperCase() + "(";
 
        //percorre os atributos vendo o nome dos campos
        Class classe = objeto.getClass();
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
            sql += f.getName() + ",";
        }
 
        sql = sql.substring(0, sql.length() - 1); //retira a ultima virgula..
        sql += ") VALUES(";
 
        //percorre os atributos vendo o valor dos campos
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
            if (f.getType().getSimpleName().equals("String")) {
                sql += "'" + f.get(objeto) + "',";
            } else {
                sql += f.get(objeto) + ",";
            }
        }
 
        sql = sql.substring(0, sql.length() - 1); //retira a ultima virgula..
        sql += ")";
 
        //executa a query
        System.out.println(sql);
        if (!manipular(sql)) {
            throw new Exception(getMensagemErro());
        }
    }
}

O único método que merece explicações é o método Insere(String tabela, Object objeto) que utiliza da reflexão computacional para criar dinâmicamente o SQL referente à inserção do objeto “objeto” na tabela “tabela”.

O código é bem simples de entender:

Inicializa a variável responsável por guardar o SQL;
Passa por todos os atributos do objeto adiciondo os nomes deles ao SQL;
Passa pelos atributos novamente, só que desta vez adicionando os valores dos atributos (caso seja uma variável da classe String, adiciona aspas simples antes e depois do valor).
Executa a query. Se algo deu errado, joga uma nova exceção com a mensagem de erro.

Muito simples não?!?!?
Vamos ver como funciona na prática então, vamos subir uma camada e ver como funciona a classe Contatos.java:

public class Contatos {
 
    private int con_id;
    private String con_nome;
    private String con_endereco;
    private String con_telefone;
    private String con_email;
 
    public Contatos(String con_nome, String con_endereco, String con_telefone, String con_email) throws Exception {
        ConexaoMySQL c = ConexaoMySQL.getConexao();
        this.con_id = c.getMaxPK("contatos", "con_id") + 1;
        c.close();
        this.con_nome = con_nome;
        this.con_endereco = con_endereco;
        this.con_telefone = con_telefone;
        this.con_email = con_email;
    }
 
    public void Insere() throws Exception{
        if (this.con_nome.equals("") || this.con_telefone.equals("")){
            throw new Exception("Preencha pelo menos o nome e o telefone.");
        }
 
        ConexaoMySQL c = ConexaoMySQL.getConexao();
        c.Insere("contatos", this);
        c.close();
    }
 
//getters e setters
}

Uma classe extremamente simples que representa fielmente a tabela que criamos no banco de dados.

O construtor não exige o ID do contato, ao invés disso ele pega um novo para o contato (busca no banco o maior ID existente e soma 1).

O método Insere() não faz nada além de validar se pelo menos o nome e o telefone estão preenchidos e chamar o método Insere(..) da camada inferior passando uma String com o nome da tabela e passando ele mesmo (o objeto Contato) através da palavra reservada this. Caso ocorra algum erro na query, será retornada uma exceção do método Insere(…) da classe ConexaoMySQL.java para o método Insere() da classe Contato.java e este por sua vez irá retornar essa mesma exceção para quem o chamou.

Os nomes dos atributos devem ser iguais aos nomes das colunas da tabela, pois o método Insere(..) da classe ConexaoMySQL.java trata cada atributo como uma coluna da tabela para montar o SQL, como já vimos antes.

Agora vem a última (ou a primeira, depende do ponto de vista.. ) camada: a responsável pela apresentação. A classe Principal.java é um JFrame que vai fornecer a interface visual para o usuário. Deve ficar mais ou menos assim:

Os campos de texto são JTextFields com os respectivos nomes: jTF_Nome, jTF_Endereco, jTF_Telefone e jTF_Email.

Creio que eu nem precise comentar sobre o que o botão Limpar faz não é?

O código do botão Inserir segue abaixo:

public void Inserir() {
    try {
        Contatos c = new Contatos(jTF_Nome.getText(), jTF_Endereco.getText(), jTF_Telefone.getText(), jTF_Email.getText());
        c.Insere();
        JOptionPane.showMessageDialog(this, "Contato adicionado com sucesso");
    } catch (Exception e) {
        JOptionPane.showMessageDialog(this, e.getMessage());
    }
}

Cria-se um objeto Contato a partir dos dados do formulário e chama o método Insere(), caso ocorra algum erro, o programa desviará para o bloco catch(…) e será mostrado o erro, mas se der tudo certo, será mostrada a mensagem de sucesso.

DICA: Debuge o projeto para ver como o SQL é montado dinâmicamente. É bem interessante.

É isso! Repare como o código fica simples e fácil de ler.
Ao invés de ter uma classe só que cuida de mostrar os dados, validá-los, tratar a conexão com o banco e tratar o SQL (como eu mesmo já fiz e sei que muita gente faz), agora a gente tem uma estrutura muito bem projetada que facilita a manutenção e futuras mudanças, como por exemplo:

Se você quiser guardar o twitter do contato também, basta criar uma nova coluna no banco, um novo atributo na classe Contatos.java e um novo campo de texto na classe de apresentação. Não precisa se preocupar com SQL pois a reflexão cuida disso pra nós.
Se precisar mudar o banco para o SQL Server, basta trocar a classe ConexaoMySQL por uma ConexaoSQLServer. Não há necessidade de alteração na lógica nem na apresentação do projeto.

Minha intenção neste post era mostrar um exemplo somente sobre reflexão, mas eu acabei mostrando um pouco sobre o modelo de desenvolvimento em 3 camadas, algo realmente muito útil quando se trata do desenvolvimento de software.

Obrigado a você que teve paciência de ler até aqui.
Quem quiser o projeto do NetBeans, basta pegar aqui.
Qualquer dúvida é só deixar um comentário.

[] e até a próxima,
Saab.

PS: Só queria deixar uns créditos a outras pessoas:

Professor Silvio Carro (FIPP) que criou a base para a classe de conexão com o banco. A maior parte do código foi feito por ele.

Professor Emerson Silas Dória (FIPP) que mostrou esses conceitos de reflexão e camadas em aula, o que motivou a criação destes posts.

Java e seus espelhos: Reflexão Computacional

Felipe Saab — Sat, 23 Jan 2010 23:06:49 +0000

Hoje vou abordar um tema bem interessante: Reflexão Computacional e como o Java trata tal assunto.

Quem se diz “programador” e nunca ouviu falar disso tem que rever seus conceitos. Existe toda uma filosofia por trás do conceito de Reflexão Computacional (ou apenas reflexão), mas eu não vou falar muito sobre isso (até porque eu não sei muita coisa sobre a teoria… ), vamos mais a prática.

Bom, vamos viajar um pouquinho: imagine que vc tem a missão de construir um método que receba um objeto que você não sabe qual é, e tenha que aprender a usá-lo em tempo de execução, ou seja, descobrir quais métodos esse objeto possui, quais variáveis de instância e etc (CALMA! Eu sei que parece besteira e que vc deve estar pensando: “Onde diabos eu vou usar um troço desses?!?” mas CALMA, vou dar uns exemplos mais adiante e em outros posts).

Como Java é uma linguagem quase completamente orientada a objetos, presume-se que TUDO é um objeto: um método é representado por um objeto da classe java.lang.reflect.Method, toda variável de instância também é representada um objeto da classe java.lang.reflect.Field e uma classe (qualquer uma delas, seja String, Integer, Float, ou aquela que vc escreveu) é representado por um objeto genérico: o objeto Class.

Chega de historinha, vamos escrever alguma coisa para demonstrar tudo isso. Vamos criar uma classe com algumas variáveis e alguns métodos bem inúteis, só para exemplificar.

public class Contato {
    private String nome;
    private int idade;
    private String email;
 
    public Contato() {
    }
 
    public Contato(String nome, int idade, String email) {
        this.nome = nome;
        this.idade = idade;
        this.email = email;
    }
 
    public void emString() {
        System.out.println(nome + " - " + idade + " - " + email);
    }
 
    public int idadeEmDias() {
        return idade * 365;
    }
 
    public void enviarEmail(String assunto, String mensagem) {
        System.out.println("Email");
        System.out.println("Para: " + email);
        System.out.println("Assunto: " + assunto);
        System.out.println("Mensagem: " + mensagem);
        System.out.print("Enviando...");
        System.out.println("concluído");
    }
}

Como da pra ver… uma classe bem simples e que não faz absolutamente nada.
Vamos ao código de reflexão que depois eu explico ele:

public class Reflexao{
 
    public Reflexao(){
        Contato c = new Contato("Felipe", 20, "fesaab@gmail.com");
        infoClasse(c.getClass());
    }
 
    public void infoClasse(Class classe){
        //percorrendo as variáveis de instancia
        for (Field f : classe.getDeclaredFields()){
            System.out.println(f.getName());
        }
 
        //percorrendo os métodos
        for (Method m : classe.getDeclaredMethods()){
            System.out.print(m.getReturnType().getName()+" ");
 
            System.out.print(m.getName()+" ");
 
            Class c[] = m.getParameterTypes();
            if (c.length == 0){
                System.out.println("()");
            }else{
                System.out.print("(");
            }
 
            for (Class cl : c){
                System.out.print(cl.getName()+",");
            }
            System.out.println(")");
        }
    }
}

Muito bem, logo no construtor da classe Reflexao foi criado o objeto “c” da classe Contato e logo em seguida foi invocado o método “infoClasse(Class)” passando como parâmetro um objeto da classe “Class” que for retornado pelo método “getClass()” que QUALQUER objeto tem.

No método infoClasse(..), a primeira instução for percorre todas as variáveis de instância da classe passada no parâmetro.
A segunda instrução for percorre todos os métodos da classe. Eu dei uma “enfeitada” nesse segundo for, mais foi só para demonstrar alguns métodos da classe Method. A execução do código gera a seguinte saída:

nome
idade
email
void emString ()
int idadeEmDias ()
void enviarEmail (java.lang.String,java.lang.String,)

Repare que apenas foram exibidas informações da CLASSE, nada do objeto foi revelado. Para tal propósito, devemos explorar alguns outros métodos, vamos ao código:

public void infoObjeto(Object o) throws Exception{
    Class classe = o.getClass();
 
    for (Field f :classe.getDeclaredFields()){
        f.setAccessible(true);
        System.out.println(f.getName()+": "+f.get(o));
    }
}

Para descobrir o conteúdo das variável de instância, deve-se:

Recuperar o objeto Field da respectiva variável
Se a variável não possuir visibilidade pública (como é o caso das nossas, são privadas), deve-se liberar o acesso para seu conteúdo através do método setAccessible(true).
Recuperar o conteúdo da variável através do método get(Object) da classe Field. Lembrando que o método pertence ao objeto da classe Field, esse objeto não sabe o valor da variável de instância que agente quer, mas ele sabe como recuperar esse valor porque esse objeto representa a variável. Portanto agente simplesmente fala assim: “ô objeto da classe Field, recupera o valor da variável que você representa. A variável que eu quero está nesse objeto aqui”. Por isso agente passa o objeto como parâmetro para o método.

A execução do método infoObjeto(…) gera a seguinte saída:

nome: Felipe
idade: 20
email: fesaab@gmail.com

Antes de finalizar essa pequena introdução, só mais uma coisa: eu mostrei como recuperar os objetos Field e Method que representam as variáveis de instância e os métodos de um objeto de uma classe qualquer, mostrei também como recuperar o conteúdo de qualquer variável de instância, só falta ver como agente executa um método.

É extramente simples… uma vez que agente já sabe como recuperar os objetos Method que representam os métodos, basta chamar o método invoke(Object, Object[]).
O primeiro parâmetro é o objeto que agente quer que execute o método, e o segundo é um vetor que contém os parâmetros que o método exige. Vamos a um exemplo:

public void executaMetodos(Object o) throws Exception {
    Class classe = o.getClass();
 
    for (Method m : classe.getDeclaredMethods()) {
        if (m.getParameterTypes().length == 0) {
            System.out.println("Invocando o método: " + m.getName());
            if (m.getReturnType().getName().equals("void")) {
                m.invoke(o, new Object[0]);
            } else {
                System.out.println(m.invoke(o, new Object[0]));
            }
        }
    }
}

Só para simplificar eu restringi a invocar apenas os métodos que não tem parâmetro nenhum para passar, se tivesse, bastava descobrir através do método “getParameterTypes()” da classe Method e criar o array de Object com os parametros corretos.

No código eu também separei a chamada de métodos que não tem retorno dos que tem utilizando o método “getReturnType()”, quando tiver retorno eu simplesmente imprimo ele na tela. O resultado da execução do código é o seguinte:

Invocando o método: emString
Felipe - 20 - fesaab@gmail.com
Invocando o método: idadeEmDias
7300

Bom galera, essa foi uma pequena introdução sobre reflexão computacional. Espero que ajude um pouco quem estava procurando sobre o assunto.
Nos próximos posts eu vou utilizar esse conceito numa abordagem bem mais próxima da realidade (onde usar isso).

[] e até a próxima,
Saab.