Genesis - Desenvolvendo Aplicações Desktop de maneira simples e organizada

Olá a todos,

Quem aqui já desenvolveu aplicações desktop em qualquer linguagem (Delphi, C++, VB, Java) sabe que existem duas partes que tendem a transformarem-se no famoso "código macarronico" se você não possuir um padrão de desenvolvimento ou uma boa capacidade de organização.

1. Ligação dos campos com as variáveis que os representam.
2. Controle de Habilitação e Desabilitação de campos baseados em regras de Negócio.

Para resolver esse tipo de problema diversos modelos foram criados, entre eles pode-se citar o MVC utilizado hoje em dia no Swing (É uma das mais conhecidas APIs para desenvolvimento Desktop em Java). Apesar do MVC do swing proporcionar uma organização no código o que acaba padronizando tudo, ele sempre foi criticado por ser muito complexo, assim, tornando o desenvolvimento caro pois você sempre precisa de desenvolvedores experientes.

Seguindo nesta mesma linha surgiu o Genesis que é uma ferramenta OpenSource (disponivel em sua totalidade e com manual em Português) desenvolvida pela Summa Technologies do Brasil sendo que os principais culpados pela criança são Michael Nascimento e Allan Jones . A idéia básica do Genesis é permitir que programadores com pouca experiência conseguiam desenvolver aplicações Desktop com suporte a conexão a EJBs transparentemente. O Genesis pode ser divido em duas partes: client e shared.

O lado client é conhecido como binding, essa parte da API vincula todos os elementos de uma Interface (Construida em Swing, SWT ou Thinlet) a um Pojo (Plain Old Java Object). Imagine que você tenha uma interface como na figura.

O Genesis Client permite que você crie uma classe java simples sem herança nem dependencias de nenhum tipo contendo os campos relacionados a interface/métodos e vincule a interface com essa classe (Esta classe é chamada de Form). Além disso ainda possibilita constrolar a ativação e desativação dos botões, validação de campos etc.
Outro bônus é que como a interface é totalmente separada do "negócio" é possivel construir Unit Tests (outra hora faço um post sobre isso) o que permite testar a aplicação inteira sem interação humana.

O lado shared é assim chamado pois utiliza Aspectos (falo disso outra hora tb) para executar um conjunto de operações dentro de um EJB Container de maneira transparente, assim pode-se dizer que as classes estão entre (shared) a parte cliente e servidora, entretando neste post não vou entrar em detalhes.

Um bom começo seria assistir o vídeo que mostra como fazer binding simples: dois campos texto e um botão. É importante salientar que como no exemplo foi utilizadas anotações, é necessária a utilização do jdk1.5, entretando, o genesis também pode ser utilizado com jdk1.4, maiores informações podem ser encontradas na página da API.

Continuando o exemplo apresentado no vídeo, imagine que você deseja colocar um ComboBox na interface, basta para isso utilização a anotação @DataProvider, que pode ser utilizado para Combos, Listas e Tabelas. Para utilizar esta funcionalidade você deve criar um método qualquer que retorna uma lista de Objetos e informar qual a propriedade na classe que irá receber o objeto selecionando:

@DataProvider(objectField="sistema", widgetName="sistemas")
public List populaSistema() {
List sistemas = new ArrayList();
sistemas.add(new Sistema("JPA","JPA"));
sistemas.add(new Sistema("EJB","EJB"));
return sistemas;
}

Neste exemplo, o campo ComboBox com o nome sistemas será populado com a lista retornada e quando um item do combo for selecionado ele estará disponível na propriedade sistema do form.
Outra configuração importante é informar ao Genesis qual propriedade (do objeto Sistema) será apresentadas na tela, para isso deve-se adicionar as seguintes linhas na inicialização da inteface:

sistemas.putClientProperty(SwingBinder.KEY_PROPERTY, "sigla");
sistemas.putClientProperty(SwingBinder.VALUE_PROPERTY, "nome");
sistemas.setRenderer(new KeyValueListCellRenderer(sistemas));

Neste caso, a propriedade que será mostrada na lista será NOME.

Outra funcionalidade interessante é a utilização de Formatadores. Imagine que você possui um campo de um tipo qualquer mas deseja que o texto para o usuário seja formatado de uma maneira especifica, por exemplo, você quer que o nome apresentado no combo acima seja iniciado com -- e finalizado com --, basta você adicionar o seguinte código na inicialização da interface:

Formatter f = new Formatter() {
public String format(Object o) {
return "--"+o+"--";
}
};

e registrar o Formatador após fazer o Binder

binder.registerFormatter("sistema.nome", f);

Toda vez que a propriedade nome for inserida no list o Genesis irá chamar o formatador definido. Obviamente esse exemplo não tem muito sentido pratico, foi feito apenas para demostração. Um exemplo mais prático poderia envolver formatação de números, datas, códigos etc. Salienta-se que os formatadores podem ser utilizados com qualquer tipo de campo.

No exemplo passo a passo foi demostrado como vincular um botão a um método utilizando-se a anotação @Action, agora imagine que você precisar ativar esse botão apenas em uma determinada condição. Em nosso exemplo poderiamos ativar o botão apenas se todos os campos estiverem selecionados, para isso deve-se utilizar a anotação @Condition.

Primeiro você cria a condição (você pode utilizar diversas sintaxes para criá-la, vou utilizar aqui a que considero mais simples):

@Condition("loginSenhaOk=
genesis.isNotEmpty('form:usuario') &&
genesis.isNotEmpty('form:senha') &&
genesis.isNotEmpty('form:sistema')")

Criamos aqui uma condição denominada loginSenhaOk que será verdadeira quando todos os campos da inteface estiverem selecionados. Está anotação deverá ser feita no inicio do Pojo, e poderá ser utilizada em quaisquer campos ou ações utilizando-se as anotações @VisibledWhen, @EnabledWhen entre outras.

Como os próprios nomes dizem @VisibledWhen fará com que o botão fique visivel quando a condição for verdadeira e o @EnabledWhen deve ser utilizado para habilitar o botão. Estas anotações devem estar antes do método a ser controlado:

@Action
@VisibledWhen("loginSenhaOk")
public void limpar() {
setUsuario(null);
setSenha(null);
setSistema(null);
}

Outras anotações de controle podem ser utilizadas, no site do Genesis você pode encontrar uma lista completa.

Agora, imagine que você queira apresentar uma tela de confirmação antes de executar uma ação. Para isso você pode utilizar a anotação @BeforAction, ela permite que um método seja executado antes de uma ação, este método pode retornar void ou boolean, caso retornar void a ação será sempre executada, caso retornar boolean a ação será executada se o retorno for true.

No nosso caso vamos criar um método que apresenta uma tela perguntando se o usuário deseja limpar realmente a tela e executar este método antes da ação limpar.

@BeforeAction
public boolean limpar()
{
if ( JOptionPane.showConfirmDialog(null,"Limpar?", "Limpar?" ,JOptionPane.YES_NO_OPTION) == 0 )
return true;
return false;
}

O método deverá possui o mesmo nome do método da ação, entretando deverá ser declado na interface e não no Pojo ou Form.

O exemplo completo pode ser baixado aqui.

Aconselho a quem está iniciando um projeto com Swing, Thinlet ou SWT a fazer um exemplo de tela o mais complexa possível utilizando-se as APIs acima em sua maneira original e depois a mesma interface utilizando o Genesis, vocês perceberam que o código utilizando o genesis fica mais simples e organizado com pouco esforço.

[]s

Listagem e Edição de 2 Tabelas com Relacionamento em 2 min

Ae pessoal, lá vou eu para mais uma entrada no blog. Agora vou falar um pouquinho sobre JPA, da mesma maneira que antes não vou ficar entrando em muitos detalhes apenas o suficiente para que vocês consigam fazer uma implementação básica.

A idéia básica é mostrar como se utilizar JPA (Java Persistence Api). JPA é o que se pode chamar de o novo Entity Beans que faz parte da especificação Java EE.

Mas não precisa ficar chateado, é muito, muito melhor que o Entity Bean. Quem conhece hibernate (que apesar de não fazer parte da especificação do J2EE acabou virando padrão de mercado devido a uma série de vantagens sobre o Entity Bean) vai achar o JPA muito parecido e não vai ter dificuldades em utilizá-lo. Em minha opinião sempre se deve utilizar padrões a não ser que a qualidade de uma ferramenta não padrão seja muito superior como foi o caso do Hibernate.

Para quem não sabe o que é Entity Bean e nunca ouviu falar em Hibernate não fique preocupado, siga lendo que você já vai entender, mas basicamente estas duas ferramentas fazem parte de um grupo de apis denominadas de Object/Relational que possibilitam que o programador crie Classes java as quais podem ser persistidas diretamente no banco de dados com o mínimo de uso de SQL o que possibita a utilização de Orientação a Objetos de uma maneira mais completa pois você não precisa quebrar o paradigma no momento da gravação dos dados.

JPA provê um tipo de "Interface" entre o programador e o que chama-se de Provider. O Interessante é que funcionando dessa maneira você poderia teóricamente modificar além do banco de dados o Provider sem nenhum impacto no código. O provider é a api que realmente persiste os dados no banco de dados como o topLink, Hibernate entre outros.

Como havia dito antes a arquitetura do JPA é muito semelhante a do Hibernate, diferente do Entity Bean que deveria obrigatoriamente ser rodado dentro do EJB Container, o JPA pode ser rodado dentro do servlet Container como o Tomcat. Você deverá utilizar um componente denominado Entity Manager que é semelhante do Session do Hibernate e para recuperar e modificar dados.

Basicamente uma Entidade JPA contém a seguinte sintaxe:

@Entity
@Table(name = "pessoa")
public class Pessoa implements Serializable {

@Id
@Column(name = "identificador", nullable = false)
private Integer identificador;

@Column(name = "nome", nullable = false)
private String nome;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "identificadorPessoa")
private Collection telefoneCollection;

...

Você também vai precisar de um .xml contendo as informações de seu banco de dados e provider. No nosso exemplo o xml é criado transparentemente.

Para obter o EntityManager você simplesmente cria um Factory que lê o XML e cria o EntityManager.

EntityManagerFactory emf = Persistence.createEntityManagerFactory("WebApplication3PU");

EntityManager em = emf.createEntityManager();

Agora você já pode manipular os dados utilizando diretamente as classes:

em.getTransaction().begin();
em.persist(pessoa);
em.getTransaction().commit();
...
Pessoa o = (Pessoa) em.find(Pessoa.class, id);

Utilizando-se JPA você aumenta em muito a produtividade (comparando a utilizar JDBC na mão), entrentando existe uma maneira de aumentar ainda mais a produtividade. O Netbeans versão 5.5 vem com uma série de recursos que permite você construir praticamente tudo utilizando-se o "Pattern Next Next Next ;)". Server para fazer cruds rapidamente e também para construir a base de um sistema.

Aqui você pode acompanhar a criação de um crud para manipuação das entidades: Pessoa e Telefone.

Qualquer banco de dados pode ser utilizado desde que exista um driver JDBC compatível e que você possa criar Foreign Keys, entretando sugiro a utilização do Mysql 5 já que foi o utilizado para fazer o exemplo aqui disponivel. Você pode seguir os passos abaixo para instalar da maneira mais simples possível.

1. Baixe o Mysql em formato msi (Instalador Windows) e instale deixando todas as opções como padrão, apenas lembre-se de no momento da requisição de senha optar por criar um usuário anonimo (não é a maneira politicamente correta, mas é a mais simples).

2. Baixe O GUI Tools que é um grupo de ferramentas para gráficas para manutenção do banco e Instale. A imagem acima foi criada utilizando-se a ferramenta MySql Workbench.

3. Também será necessário baixar o Connector/J que contém o driver JDBC.

Após instalar utilize a ferramenta Mysql Query Browser para criar as tabelas. Como você criou um usuário anonimo apenas use o login anonymous sem senha com o schema test que já vem criado no mysql. Você deve clicar com o botão direito no schema e optar por criar tabela.

Os scripts abaixo também podem ser utilizados:

CREATE TABLE `test`.`pessoa` ( `identificador` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `nome` VARCHAR(45) NOT NULL, PRIMARY KEY(`identificador`) ) ENGINE = InnoDB;

CREATE TABLE `test`.`telefone` ( `identificador` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `numero` VARCHAR(45) NOT NULL, `identificador_pessoa` INTEGER UNSIGNED NOT NULL, PRIMARY KEY(`identificador`), CONSTRAINT `FK_telefone` FOREIGN KEY `FK_telefone` (`identificador_pessoa`) REFERENCES `pessoa` (`identificador`) ON DELETE RESTRICT ON UPDATE RESTRICT ) ENGINE = InnoDB;

Entrentando a GUI é bem simples e eficiente. Você deverá criar as tabelas Pessoa e Telefone. Não esquecendo de criar a Foreign Key na tabela telefone referenciando a tabela Pessoa.

Depois que você tiver criado o banco você assista o passo a passo da criação do crud.

Você pode baixar o projeto aqui.

É isso ai. Espero que tenham gostado.

Acabe com a sua Tese antes que ela acabe com você

Ontem acabei de escrever a minha Tese, já envei para o meu orientador e estou esperando para fazer as correções necessárias e defender essa pesquisa de uma vez. Apenas para citar, o título é Intersecção das Técnicas de Term Extration e Query Expansion aplicadas a Recuperação de Documentos Textuais. A idéia básica é construir uma Engine de Busca Textual que consiga usar semântica. Utilizei na construção do prototótipo o Lucene e o Jena. O Lucene pra quem não conhece é uma ótima ferramenta para indexação e busca de textos e o Jena é uma ferramenta para criação e utilização de ontologias.

Summanoides e Tecnologia Java

Então, essa vai ser a primeira entrada no blog falando sobre tecnologia java. Foi montado um grupo de estudo na Summa chamado de summanoides com o objetivo de estudar as tecnologias emergentes e publica-las em um blog do proprio grupo de estudos, farei a publicação em paralelo aqui. O primeiro assunto é Stateful Session Beans.

A tecnologia java pode ser dividida em três grandes grupos: Java SE, Java ME e Java EE. Fazendo um super resumo pode-se dizer que Java SE é são as funcionalidade básicas, aquelas que você viu na faculdade (se fez computação ou algo similar), Java ME é utilizado para fazer aplicações para aparelhos móveis tipo celular, pdas entre outros e Java EE é utilizado quando se deseja fazer aplicações de grande porte.

stateful session beans é um dos componentes que estão disponiveis no Java EE, ou seja, utilizado em geral para aplicações de grande porte. O Objetivo aqui não é escrever um artigo e sim explicar na prática como se faz uso desta funcionalide, portanto não vou entrar em muito detalhes técnicos apenas o necessário para entender onde e como usar.

Quando você desenvolve uma aplicação de grande porte em qualquer linguagem você acaba precisando de uma série de funcionalidades que em geral as linguagens proporcionam de maneira transparente ou quase transparente. Basicamente pode-se dizer que um stateful session bean é uma classe java a qual é executada dentro de um Servidor (Container EJB) que pode adicionar uma série de funcionalidades se necessárias.

Por exemplo: Você Fez um cliente Desktop e deseja executar um processo para gravar dados em um banco de dados, mas esse banco está em um servidor. Os Session Beans (existe outro tipo chamado Stateless) permite que você execute um método de uma classe que está rodando no Servidor, esta caracteristica é chamada de remotabilidade.

Existem outras caracteristicas como Controle Transacional, mas vou falar sobre isso quando falar sobre JPA que é a parte do Java EE que serve para persistir ou gravar informações no banco de dados.

Então, voltando ao stateful session bean. Ele tem uma caracteristica que o diferencia do outro bean (stateless) pois mantém seu estado. Isso quer dizer que o EJB container deverá manter um stateful session bean por cliente e tudo o que estiver dentro dessa classe é mantido por um determinado tempo (que pode ser configurado). Exatamente por este motivo que muitas pessoas tem receio de utilizar pois imagine um sistema com uma quantidade enorme de usuários simultâneos, o EJB Container terá que alocar (e manter alocada) memória suficiente para manter o estado de cada Instância. Então este tipo de session bean deve ser utilizado com cuidado, sempre se deve analisar a quantidade de recurso alocada pois ele mantem seu estado. Uma péssima pratica é por exemplo manter o estado da conexão com o banco aberta, imagine se uma quantidade enorme de usuários resolve fazer isso, sua aplicação dificilmente será escalável.

Um exemplo de simples entendimento para o uso de stateful session bean é um carrinho de compras. Imagine que você tem uma página com uma lista de produtos e o usuário vai selecionando os produtos para comprar, você vai armazendo os mesmos e no final do processo você grava esses dados no Banco. Você pode utilizar um Stateful Session Bean para fazer isso. E é exatamente esse o exemplo que será implementado e disponibilizado aqui.


Desta primeira vez vou mostrar como configurar o ambiente da maneira mais simples possível já que não encontrei nenhum Post por ai que explique de maneira simples. Eu constumo utilizar o Netbeans e neste caso vou ensinar a instalar o GlassFish (É uma versão OpenSource do Sun Application Server 9). Então vamos aos passos:

1. Primeiro você tem que ter a versão 1.5 do JDK, clique no Download do JDK 5.0 Update 10 , selecine o arquivo Windows Offline Installation, Multi-language e instale.

2. Baixar o Netbeans 5.5 simplesmente clique no Download Netbeans IDE e instale.
ps: A versão do GlassFish que vem com o netbeans tá com problema (pelo menos estava) então baixe separado.

3. Baixar o GlassFish na página da Sun. Você deve baixar o Java EE SDK Update 1. Clique no Download simples. Instale. Lembre-se da senha, será necessária mais tarde.

4. Abra o Netbeans (Será necessário configurar o GlassFish). Clique em Tools > Server Manager. Add Server. Sun Java System Application Server. Next. Browse e selecione o diretório onde você instalou o GlassFish, se tudo der certo o Netbeans preencherá as informações abaixo (Domain etc). Apenas clique Finish.

5. Parabéns seu ambiente para desenvolvimento Java EE está pronto. (aaa .. agradeça ao céus, isso nem sempre funciona).

Assista o passo a passo (Foi feito com o Wink )

A apresentação acima não mostra o projeto todo (senão ficava muito grande o arquivo), apenas os passos para você aprender a utilizar as ferramentas que o Netbeans tem para auxiliar na criação de classes, beans, projeto etc.

O bean criado ManterCarrinhoBean está totalmente funcional. Como ele é um stateful ele será criado quando o usuário acessar pela primeira vez e destruido depois que um determinado tempo passar ser ele ser utilizado (isso quem controla é o servidor, não vou entrar em detalhes). Então se você por exemplo criar uma ArrayList privado e adicionar o codigoProduto a cada chamada do método adicionarItem, o array irá sendo incrementado e voilá .. você tem seu carrinho de compras implementado com stateful session beans. Obviamente para ficar um exemplo legal você terá que implementar outras coisas como:

1. classe Produto com Código e Descrição.
2. classe ProdutoItem com um Produto e a quantidade comprada.
3. Um stateless session bean que trará a lista de produtos que você tem na sua loja. Esse pode ser stateless .. explico isso em outro post, apenas copie o código. rs.
4. Um outro managed bean que será utilizado para buscar a lista dos produtos e apresentar ao usuário.
5. Alterar o stateful + managed bean (CarrinhoBO) para poder adicionar e remover itens do carrinho.
6. Modificar o JSF para que sejam apresentados controles para tudo isso.

Você pode baixar o Código Completo aqui.

Existem algumas anotações que você pode utilizar para controlar melhor o seu stateful session bean, elas devem ser colocadas sobre métodos com assinatura void metodo().

@PostConstruct: Executa o método após o container inicializar o objeto;
@PreDestroy: Antes do container destruir o objeto

O container pode ser configurado para passivar e ativar objetos, ou seja, é mais ou menos como a memória virtual de um sistema operacional, o servidor se encarrega de guardar no disco (serializados) objetos pouco utilizados e colocá-los na memória quando forem necessários.

@PrePassivate: Antes do container passivar o objeto
@PostActivate: Após o containier ativar o objeto

Essas anotações podem ser uteis caso você deseje inicializar ou fechar algum tipo de recurso, por exemplo, conexão com um mail server ou algo do tipo.

É isso ai .. espero que tenha sido útil.

Falando um pouco de filmes .. to com sono e esse vai ser a ultima coisa que coloco hj. Essa não podia passar em branco. Eu e uma turma de floripa começamos (50%) a fazer um filme. O nome é alucinação, foi sinceramente umas das coisas mais engraçadas da minha vida. Vou postar o script aqui outra hora que tiver paciência. Ficam algumas fotos engraçadas. O "branquinho" sou eu fantasiado de "O Mal" e o lobisomem (que parece mais um ursinho de pelúcia) é o Bogo, depois mexo aqui e coloco o Blog dele (massa .. fala sobre filmes trash). Saca o teaser no google video

Eu estava pensando em publicar um monte de fotos, tenho mais de 1000 de lugares bem legais. Mas pensando melhor vou começar a colocar apenas as fotos a partir do dia de hoje, a nãos ser algumas que considero imperdiveis como as abaixo: Noronha, aaaaaa lugarzinho, sério, acho que dos lugares que conheci (no brasil pois ainda não inaugurei meu passaporte) fica no TOPO. Pra comparar só Bonito que infelizmente não tenhos fotos digitais.

É .. isso ai

Então, essas são umas fotos de Florianópolis, a primeira é do bar chamado Rancho de Canoa, altos lugarzinho conhecido mais pelo pessoal que mora na ilha (ou morava ...) fica na Fortaleza da Barra da Lagoa. As duas outras são da Lagoa da Conceição, tiradas no morro entre a Fortaleza da Barra e a Praia Mole. A idéia aqui foi testar o Picasa, pra quem não sabe é um software gratuito da google para organizar fotos digitais.


 

Inauguração do Blog

Olá,

Meu nome é Raphael Winckler de Bettio, nasci em Xaxim, mas morei em Xanxerê até os 16 anos de idade quando fui morar em Blumenau onde fiz faculdade de Ciências da Computação (FURB). Após concluir a faculdade fui para florianópolis, ali, estudei na UFSC onde fiz meu mestrado em Engenharia de Produção e Sistemas e agora estou tentando concluir meu doutorado em Engenharia e Gestão do Conhecimento. Atualmente estou morando em São Paulo (dai o nome do blog) e trabalhando na Summa Technlogies como consultor Java.

A idéia basica desse blog é falar de três coisas que eu adoro: Viajar, Assistir Filmes e Séries e Desenvolver Software.

A idéia eh postar algumas fotos e falar um pouco sobre lugares que conheci, fazer um pouco de critica sobre os filmes/séries e também postar um pouco sobre tecnologias que estudo.

É isso ..