| |
>>Produtividade
para Interfaces Desktop
Alie agilidade
no desenvolvimento com ricas interfaces para desktop
utilizando o framework SwingBean.
A
criação de interfaces ricas em Swing
é uma tarefa trabalhosa pela própria
natureza portável das aplicações
desenvolvidas. Existem alguns IDEs que simplificam
o trabalho de posicionar e configurar os componentes
em uma tela, mas eles não nos livram de tarefas
braçais como colocar e recuperar um objeto
em um formulário ou em uma tabela. O SwingBean
é um framework que possui o objetivo de criar
interfaces Swing através de componentes de
mais alto nível configurados por arquivos
XML, dando mais flexibilidade e produtividade ao
desenvolvimento
Uma vez me foi apresentado o seguinte problema:
era necessário desenvolver uma aplicação
desktop em Java de uma forma bem rápida.
Como é de consenso na comunidade Java, este
não é um dos pontos fortes da tecnologia
Swing, principalmente no que diz respeito à
produtividade. Tomando como parâmetro a facilidade
de desenvolvimento de telas em ferramentas como
a das linguagens Visual Basic e o Delphi, ficava
realmente difícil não admitir que
a plataforma Java neste ponto deixava um pouco a
desejar. Surgiram então diversas ferramentas
como o NetBeans GUI Builder, o Eclipse Visual Editor
e o Jigloo GUI Builder, entre outras, que buscavam
uma edição visual das interfaces em
Java. Para não sacrificar a portabilidade
das aplicações, o uso dos diversos
layout managers deixava a criação
da interface, mesmo sendo visual, complexa se comparada
a outras linguagens, apesar de já haver um
grande ganho. Um outro problema é a compatibilidade
entre o código reconhecido e gerado por estes
editores de interface. Muitas vezes, ao mexer em
um código, ou tentar trabalhar em uma interface
já existente, a ferramenta não reconhece
a interface gerada tornando inviável a sua
utilização naquela situação.
Devido a todas essas questões, resolvi dar
uma solução diferente ao problema
de desenvolvimento das interfaces. A princípio,
foi construído um componente de interface
de mais alto nível que representa, não
um campo de formulário, mas o formulário
inteiro. O comportamento deste formulário
é definido de forma declarativa por um bom
e velho descritor XML. Este componente encapsula
comportamentos específicos (como a recuperação
de valores dos campos dos formulários) e
facilita a configuração de componentes
(para limitar o número de caracteres de um
JTextField é preciso criar um listener!).
A interação da aplicação
com este componente não acontece campo por
campo, mas utilizando os Java Beans que são
editados ou representados na interface. Daí
nasceu o framework SwingBean (Swing, porque utiliza
componentes em Swing, e Bean, porque a interação
com os componentes é feita a partir de Java
Beans), que está disponível para download
em http://sourceforge.net/projects/swingbean.
A evolução do framework levou a adição
de diversas funcionalidades como validação,
adição de diversos novos tipos de
componentes, como para imagens e seleções
múltiplas, e suporte a comportamentos mais
específicos como combos dependentes. O framework
também suporta a construção
de tabelas de edição de dados, validação,
ordenação, filtragem de dados e até
mesmo tabelas-árvores (TreeTables). O Swing-Bean
já foi utilizado com sucesso em pelo menos
três projetos que se encontram hoje em produção
e está sendo utilizado em diversos outros
que estão em desenvolvimento. O sucesso na
utilização do framework se deve ao
ganho de produtividade obtido e a flexibilidade
na alteração das interfaces gráficas.
O objetivo deste artigo é apresentar o framework
SwingBean com suas principais funcionalidades. A
apresentação do framework será
guiada a partir de exemplos. Os exemplos não
terão objetivo de representar uma aplicação
real, com interação com banco de dados,
por exemplo. Isso será feito para focar com
maior ênfase as funcionalidades do framework.
Para utilizar o framework e rodar os exemplos, basta
baixar a última distribuição
do SwingBean no SourceForge e adicionar no classpath
o arquivo SwingBean.jar e suas dependências
que estão na pasta lib: forms-1.05.jar, validation-1.0.jar
e jcalendar.jar.
Um
primeiro contato com SwingBean
Nada melhor para se familiarizar
com um framework do que criar um bom exemplo. Nesta
primeira sessão, será criado um cadastro
de um usuário, que é representado
pela classe apresentada na Listagem 1. Apesar de
ser um cadastro simples, vamos aproveitar para incluir
nesta classe diferentes tipos de dados, como texto,
numérico, booleano, data e uma lista para
ver como o framework se comporta. O objetivo é
gerar uma tela em que exista um formulário
para a inserção de dados e, ao clicar
em um botão, seja criado um objeto Usuario
e este seja inserido em uma tabela. A tabela, por
sua vez, ao receber um duplo clique em uma de suas
linhas deve pegar o objeto Usuário ali representado
e colocar no formulário. A figura 1 mostra
qual deverá ser o resultado deste primeiro
exemplo.
Figura 1. Interface gráfica gerada com o
código da Listagem 2.
Listagem 1. Classe Usuario
que possuirá seus dados representados em
um formulário e em uma tabela.
package org.mundojava.swingbean;public class Usuario
{
private String nome;
private int idade;
private String login;
private String senha;
private Date dataCadastro;
private boolean ativo;
private String[] perfisAcesso;
//Métodos Getters e Setters omitidos
}
>>MVC
sem XML
Este
artigo descreve uma visão geral do Mentawai,
um framework web MVC que garante produtividade,
estabilidade, facilidade e flexibilidade. Tudo isso
sem mexer em nenhum arquivo XML, tudo feito na linguagem
que nós conhecemos melhor: Java! Inicialmente,
explicaremos alguns conceitos do framework e, em
seguida, um pequeno exemplo para ilustrar o seu
funcionamento. Posteriormente, mostraremos uma aplicação
completa: o MentaBlog, um blog com comentários,
com suporte à Ájax, entre outras coisas
interessantes.
M uitas vezes, ao aprendermos novos frameworks passamos
por várias dificuldades: conceitos novos,
arquivos de configuração novos e certa
resistência de nossa parte em se adaptar a
algo tão estranho ao que já conhecemos.
A melhor maneira de aprendermos um framework é
com exemplos, pois com eles conseguimos medir se
um framework é simples e se pode ser produtivo
para nós. Ler a documentação
ou a API de um framework nem sempre será
suficiente para uma visão geral da situação.
Neste artigo, nós mostraremos um exemplo
completo do framework MVC Mentawai, com os principais
trechos do código comentados e algumas funcionalidades
da aplicação serão adicionadas
em partes, para facilitar a compreensão.
Com essa visão geral, conseguiremos criar
uma aplicação simples no Mentawai
e, se necessário, criarmos posteriormente
coisas mais complexas. Inicialmente, explicaremos
o conceito do framework com um exemplo simples.
Depois, estenderemos esse exemplo explicando outras
funcionalidades do framework, finalizando com uma
aplicação completa de um blog com
tela de administração, cadastro de
mensagens de cada mensagem, e um mecanismo de busca
eficiente para mostrar a integração
do framework com Ajax .
Para quem já trabalhou com Java, mas nunca
desenvolveu para Web, usar o Mentawai pode ser um
bom começo, e este artigo mostrará
tudo isso com vários exemplos.
O
framework
Há seis anos, Craig R. McClanahan
criava o Struts, o framework que implementa o padrão
MVC (Model View Controller), algo pioneiro para
quem estava preso ao mundo das APIs de JSP/servelts.
Foi tão revolucionário que rapidamente
foi adotado pela comunidade Java e, conseqüentemente,
pelas grandes empresas como padrão.
Entretanto, o tempo passa e as necessidades vão
aparecendo, assim como novas idéias e novos
pontos de vista do desenvolvimento web com um framework
MVC. Surgiram várias opções
para a comunidade, entre elas, destacando-se o Spring
MVC e o WebWork . Vários outros frameworks
apareceram, mas todos eles possuíam suas
diferentes regras e diferentes configurações
em XML. Muitas necessidades básicas de uma
aplicação web não são
implementadas por alguns frameworks, o que atrasa
o desenvolvimento e obriga o desenvolvedor a procurar
por soluções alternativas ou implementar
a sua própria. Às vezes, precisamos
conectar ao banco de dados ou de um mecanismo simples
e completo de autenticação e acabamos
buscando soluções fora do framework
ou específicas do servidor de aplicação.
Sérgio Oliveira, depois de participar de
vários projetos web, entre eles, ParPerfeito
e Gazzag, buscava algo que fosse mais reutilizável,
pois a cada novo projeto partia-se sempre para um
novo framework web caseiro. Quando ele tentou aprender
os frameworks MVC mais utilizados no mercado, percebeu
que eles possuíam uma curva de aprendizado
elevada, o que comprometia os ganhos de produtividade
prometidos. Como a necessidade é a mãe
da invenção, decidiu então
criar algo bem simples e que abstraísse os
principais problemas recorrentes de qualquer projeto
web. Algo revolucionário como isso dificilmente
seria aceito numa empresa grande, portanto ele resolveu
começar um projeto open source chamado Mentawai,
nome em homenagem às ilhas de Mentawai da
costa oeste da Indonésia, arquipélago
famoso por ser um paraíso do surf. A comunidade
open source contribuiu para melhorias do framework,
e hoje o projeto conta com membros e colaboradores
de diferentes países.
Atualmente, o Mentawai é usado em ambiente
de produção de diversas empresas,
o destaque internacional é a Sun Microsystems
que está usando em alguns servidores de sua
Intranet e o destaque nacional é o Tribunal
de Contas do Ceará. Existe uma página
no site do Mentawai que informa o que as pessoas
estão falando sobre o framework, consulte
os links no final do artigo!
Conceitos
básicos
é
um padrão de arquitetura de aplicações
que visa separar a lógica da aplicação
(Model), da interface do usuário (View) e
do fluxo da aplicação (Controller).
Permite que a mesma lógica de negócios
possa ser acessada e visualizada por várias
interfaces (web ou desktop). Mesmo que você
use só uma interface, utilizar esse padrão
vai organizar sua aplicação e proporcionar
um maior controle sobre a mesma.
Esclarecido o conceito de MVC, vamos apresentar
os conceitos básicos necessários para
trabalharmos:
1. Configuração:
A navegação da sua aplicação
é controlada em outros frameworks por arquivos
XML. No Mentawai, isso é feito com apenas
uma classe chamada ApplicationManager. Ela conterá
as informações principais de sua aplicação.
Acreditamos que XML é um complicador desnecessário
para a maioria dos frameworks web. Além de
complicar, torna a arte da programação
extremamente chata. A configuração
programática em código 100% Java é
não só mais poderosa como também
muito mais prazerosa e natural.
2.
Input e Output
Toda action possui entre outras características:
input: o input (org.mentawai.core.Input) possui
o cabeçalho e os valores dos parâmetros
da requisição. Nós podemos
acessar as informações da requisição
Http através dessa interface. Os parâmetros
podem ser quaisquer objetos Java, e não somente
Strings. Se nós realmente precisarmos, nós
poderemos, por exemplo, obter o endereço
IP de algum acesso chamando o método getRemoteAddr()
da classe HttpServletRequest por reflection, atribuindo-se
para uma variável String input.getProperty(“remoteAddr”).
output: o output (org.mentawai.core.Output) tem
o resultado da execução da action.
Por exemplo, nossa action pode buscar no banco de
dados uma lista de usuários e colocá-la
no output da action. Depois, se a conseqüência
da action for FORWARD, nós poderemos acessar
o output da action na camada view.
3.
Filtros
Os filtros são a principal funcionalidade
do framework a partir da qual todas as outras são
implementadas: validação, autenticação,
integração com Hibernate, Ajax, Spring,
etc. No Mentawai, nós definimos os filtros
na classe ApplicationManager do mesmo jeito que
definimos cada configuração de action
(ActionConfig.). O filtro é uma interface
Java, logo você pode estender e criar os seus
próprios filtros se desejar.
4.
Actions
Quando estendemos org.mentawai.core.BaseAction,
a nossa classe tem acesso a alguns dados úteis
de membros protected, além de tornar-se uma
action.
O ciclo de vida da action é:
• o controller recebe a requisição
(javax.servlet.http.HttpServletRequest);
• o controller procura pela action correspondente;
• o controller prepara o Input, Output, contextos
(Session, Application, Cookies, etc.) e injeta na
action;
• o controller executa a action junto com
seus possíveis filtros;
• O retorno da action é um resultado
(java.lang.String), normalmente SUCCESS ou ERROR;
• para cada resultado, existe uma conseqüência
(org.mentawai.core.Consequence), normalmente um
FORWARD ou REDIRECT;
• o controller executa a conseqüência
Isso é só para entendermos o que acontece
internamente, mas não precisamos nos preocupar
com isso. Tudo o que precisamos fazer é escrever
nossas actions e nossos filtros.
5.
Extras
Várias implementações interessantes
foram feitas no Mentawai, mostraremos algumas em
seguida. Inicialmente, destacaremos duas: o suporte
a diferentes idiomas (i18n) e listas de dados, ambas
que são facilmente implantadas em nossa aplicação.
>>VRaptor
2: O pulo do Raptor
Do Struts Action
1 ao VRaptor 2: desenvolvendo para a web com facilidade,
sem a burocracia dos frameworks clássicos
e da javax.servlet
Diversas
tecnologias surgiram para facilitar o uso e a integração
de seu código Java com a camada de visualização
web. O padrão MVC, nascido com Smalltalk,
deu gás para o surgimento do primeiro controlador
Java que estourou no mercado, o Struts.
Nessa linha, porém agnóstica à
API de servlets, o VRaptor é uma iniciativa
brasileira que foi criada para o desenvolvimento
do GUJ 2 (www.guj.com.br) e de alguns serviços
utilizados na Universidade de São Paulo em
2004. Atualmente, é aplicado em diversas
empresas e projetos open source, em especial na
nova versão do já consagrado JForum.
Mostraremos
neste artigo como o programador Java ganha produtividade
ao escolher o VRaptor como seu controlador MVC para
seu sistema web, além de como este framework
pode ajudar a disponibilizar seus componentes como
serviços para terceiros, facilitando a criação
de sua arquitetura orientada a serviços de
maneira não intrusiva.
Partiremos da premissa que o leitor já teve
dificuldade no lento desenvolvimento com jsp e servlets,
além de já ter utilizado um controlador
MVC para tentar resolver alguns problemas. Mostraremos
algumas falhas que tais controladores clássicos
apresentam e como poderíamos contorná-las.
Para um framework ser útil, não deveríamos
programar pensando em como nos adaptar a ele: vamos
passar a fazer com que ele se adapte ao que precisamos,
ao código que deve ser executado.
O framework escolhido
deve facilitar nosso trabalho, e não torná-lo
mais burocrático por causa de seus recursos
de difícil uso.
Desde
os primórdios do Struts em 2000, diversas
outras idéias surgiram. O ódio contra
xml, as anotações do Java 5, os padrões
e a disponibilização de serviços
são algumas idéias que se tornaram
populares nesse tempo e moldam os novos frameworks.
Essa nova geração de controladores
foca mais em produtividade e tenta acertar onde
seus antecessores falharam: na simplicidade de uso.
Antes de mostrar o VRaptor 2, daremos uma forte
motivação para usá-lo e o porquê
de sua criação, mostrando os problemas
do Struts 1.x (atualmente, conhecido como Struts
Action 1.x) e similares. Daí sim escreveremos
a mesma ação da nossa maneira.
Exemplo
inicial
Iniciamos
nosso caminho com um exemplo de lógica de
negócios utilizando o Struts, porém
sem nenhum dos seus recursos. É fácil
notar como as classes, interfaces e apetrechos do
framework infectam o nosso código e começamos
a programar voltado para ele. Em alguns passos,
chegaremos ao esquema de classes que é utilizado
no VRaptor.
O código da Listagem 1 mostra uma ação
que utiliza um DAO para incluir um contato no banco
de dados, e que popula um objeto do tipo Contato
para adicioná-lo através do DAO. Aqui
ainda está faltando o mapeamento da servlet
do Struts no web.xml e o mapeamento dessa ação
no struts-config.xml. Haja mapeamento para tão
pouco!
Listagem
1. Exemplo de AdicionaContato para o Struts.
public class AdicionaContato extends Action {
public ActionForward execute(ActionMapping map,
ActionForm form,HttpServletRequest req, HttpServletResponse
res)
throws Exception {
Contato contato = new Contato();
contato.setNome(req.getParameter("nome"));
contato.setEndereco(req.getParameter("endereco"));
contato.setEmail(req.getParameter("email"));
ContatoDAO dao = new ContatoDAO(); // talvez alguns
parâmetros aqui
dao.adiciona(contato);
return map.findForward("ok");
}
}
Baseado
neste código, percebemos que estamos fortemente
atrelados a HttpServletRequest e seu método
getParameter. Fora isso, usamos diversas classes
estranhas ao nosso projeto: Action, ActionMapping,
ActionForward, HttpServletRequest e HttpServletResponse.
E, em um código real, teríamos uma
série de conversões e validações
com Integer.parseInt, SimpleDateFormat e familiares.
É muito chato, e nada prático, repetir
isso em toda a sua aplicação. Visando
facilitar esse tipo de trabalho, o Struts abstrai
o acesso aos parâmetros do request com o ActionForm.
Veja Listagem 2.
Começando
com o VRaptor
Você
está apenas folheando a revista ou está
com muita pressa?
Faça a configuração habitual
de uma aplicação web e coloque o Vraptor
e suas dependências no WEB-INF/lib (são
elas XStream e log4j). Considere um POJO Produto
com os atributos nome, descricao e preco e crie
a classe ProdutoComponent em qualquer pacote que
desejar, como na figura deste quadro.
O VRaptor descobrirá sozinho a sua @Component,
e elá será registrada com o nome de
produto. O formulário html da figura está
apontando para produto.adiciona.logic, que o VRaptor
irá interpretar e acessar o método
adiciona do nosso componente produto, passando como
parâmetro um produto instanciado e populado
através dos inputs do formulário html.
Depois de invocar esse método, o VRaptor
irá fazer o dispatch para o arquivo adicionar.ok.jsp
dentro do diretório contato da sua aplicação
web. Onde isso tudo foi configurado? Em lugar algum!
Você pode configurar todos esses comportamentos:
desde o nome dos parâmetros do formulário
que vão popular o Produto passado como parâmetro
até o nome do jsp para o qual você
será dispatched. O importante é que
para os casos mais comuns o VRaptor possui inúmeros
defaults muito úteis. Neste artigo, você
encontra um exemplo mais completo onde esses produtos
são realmente gravados no banco de dados
com apenas poucas linhas a mais.
E se você quer listar todos os produtos dessa
List<Produto>? Basta colocar um c:forEach
na variável ${produtos}, pois o VRaptor expõe
todos os getters do seu componente para a view.
Convenções em vez de configurações.
Listagem 2. Exemplo
de AdicionaContato usando Struts Action 1.x
public class AdicionaContato extends Action {
public ActionForward execute(ActionMapping map,
ActionForm form,
HttpServletRequest req, HttpServletResponse res)
throws Exception {
Contato contato = ((ContatoForm) form).getContato();
ContatoDAO dao = new ContatoDAO(); // talvez alguns
parâmetros aqui
dao.adiciona(contato);
return map.findForward("ok");
}
}
>>Desenvolvimento
Web em alta velocidade
O
desenvolvedor de software é cobrado constantemente
para ser cada vez mais produtivo e repetitivo na
construção de seus sistemas. Sendo
assim, é necessário aprender novos
frameworks, templates, bibliotecas e novas tecnologias
para o desenvolvimento dos sistemas. A ferramenta
JSenna foi elaborada para servir como uma plataforma
de gerenciamento de metadados e geradores de aplicações
para que, uma vez utilizada uma tecnologia/framework
em um projeto, esta possa ser reutilizada de uma
maneira mais produtiva e repetitiva em futuros projetos.
A produtividade
em uma equipe de desenvolvimento de sistemas é
fundamental para garantir o cumprimento de prazos
e a manutenção de baixos custos dos
projetos. Para a construção de aplicações
baseadas na web, são utilizadas diversas
tecnologias (HTML, JavaScript, XML, DHTML, Java,
DOM, AJAX, XSL, SQL, etc.) que requerem um alto
custo de treinamento de cada membro da equipe para
desempenhar com qualidade suas tarefas. A ferramenta
de software livre JSenna (licença LGPL),
objeto de estudo deste artigo, gera aplicações
web utilizando as melhores práticas e padrões
definidos para diversas tecnologias, frameworks
e plataformas, mesmo quando o desenvolvedor não
as domina completamente. Dessa forma, a inclusão
de um membro novo na equipe pode ser realizada de
forma rápida e com baixo custo. O JSenna
disponibiliza para o desenvolvedor um conjunto de
recursos visuais e facilidades que tornam a criação
de uma aplicação web uma tarefa extremamente
rápida e intuitiva. A primeira seção
deste artigo aborda a motivação que
levou a criação dos projetos JSenna
e JBanana, ambos projetos de software livre destinados
a aumentar a velocidade e produtividade no desenvolvimento
de aplicações web usando Java. A seção
seguinte comenta e justifica a seleção
das tecnologias empregadas para a construção
da ferramenta JSenna. As próximas seções
mostram uma visão geral da ferramenta JSenna,
bem como seu funcionamento, seu uso e possíveis
evoluções que o próprio desenvolvedor
pode realizar na ferramenta; aspectos da ergonomia
visual de uma aplicação web gerada
através do JSenna; conclusões sobre
o trabalho desenvolvido até este momento
e as perspectivas futuras.
Motivação
No início
do ano 2000, com a explosão da web, um grande
número de empresas direcionou o desenvolvimento
de seus sistemas para esse ambiente. Nessa época,
os desenvolvedores e empresas sentiram uma drástica
perda de produtividade ao trocarem as tradicionais
ferramentas RAD pelas ferramentas de desenvolvimento
para web. Mesmo imaturas, as ferramentas e o ambiente
web já ofereciam uma melhor capacidade para
resolver problemas complexos, oferecendo principalmente
mais escalabilidade, muito mais portabilidade, mais
organização do código resultando
numa maior facilidade de manutenção
dos mesmos. Porém, a produtividade do desenvolvimento
era péssima. Não existia nenhuma ferramenta
RAD ou CASE capaz de, com cliques de mouse ou no
famoso estilo “CCNF”, construir sistemas
de maneira rápida e eficiente. Nossa equipe
de desenvolvimento, naquela época, cresceu
de apenas três desenvolvedores para mais de
30 em menos de três meses devido a demanda
por sistemas web que, no nosso caso, eram escritos
em Java. O mundo web estava explodindo, mas tudo
ainda era muito recente. A tecnologia Java tinha
sido lançada somente em 1995/1996 enquanto
que os primeiros servidores de aplicações
Java para web começaram a ser usados em 1999.
Como não existia uma ferramenta que padronizasse
e facilitasse todo o desenvolvimento, resolvemos
nesse momento criar uma maneira de agilizar o processo
de construção de software em Java
voltado para a web. Foi aí que nasceu o projeto
de software livre chamado JBanana. Resolvemos em
um primeiro momento criar bibliotecas Java que padronizassem
o desenvolvimento, fazendo com que os desenvolvedores
criassem projetos web sempre de maneira semelhante.
Também identificamos tarefas e algoritmos
recorrentes entre os diversos sistemas implementados
pela equipe que poderiam ser componentizados e reutilizados.
Para isso, criamos bibliotecas Java que implementavam
entre outras coisas o padrão de projeto MVC.
A mais famosa destas bibliotecas foi o Framework
JBanana Controller e foi por causa dele que o projeto
foi batizado de Projeto JBanana. Várias bibliotecas
Java com inúmeras funcionalidades foram implementadas
dentro do projeto JBanana desde sua criação
em 2000/2001. Hoje, no Projeto JBanana existem três
frameworks diferentes implementando todo o modelo
MVC proposto pela literatura como padrão
para desenvolvimento web. Estes frameworks também
implementam vários outros Design Patterns.
Porém, toda essa “tecnologia”
desenvolvida dentro do projeto JBanana era voltada
para os desenvolvedores Java, pois exigia que estes
adquirissem um alto conhecimento técnico
para utilizar corretamente essas bibliotecas. Para
minimizar este problema, foi construída uma
ferramenta de desenvolvimento e geração
de código, o JSenna.
Percebemos, em 2004, que existiam várias
soluções “casadas” que
facilitavam o desenvolvimento web. Uma solução
casada, por exemplo, pode ser identificada no dueto
das ferramentas IReport e o framework JasperReport,
ambos usados para criação de relatórios
usando a tecnologia Java. Observando-se a ferramenta
IReport e o framework JasperReport, pode-se notar
que elas funcionam de forma integrada, mesmo sendo
projetos de software livre de diferentes autores
(um é francês enquanto o outro é
italiano). O JasperReports é uma biblioteca
Java parametrizada através de arquivos XMLs
que permite ao desenvolvedor gerar relatórios
em diversos formatos, sem nenhuma codificação,
desde que o desenvolvedor saiba como escrever e
configurar corretamente os arquivos XMLs. O IReports
nasceu para suprir essa deficiência do JasperReports
e simplificar a vida do desenvolvedor que queria
“desenhar” o relatório de forma
visual e não somente escrever um arquivo
XML. O IReports é esta ferramenta visual
com a qual pessoas que não dominam totalmente
a tecnologia Java, podem com alguns cliques de mouse,
desenhar os relatórios, e automaticamente
a ferramenta IReports pode gerar os arquivos XMLs
de configuração do JasperReports.
Notamos então que poderíamos usar
a mesma estratégia em nossos frameworks Java
que já eram todos parametrizáveis
e configurados através de arquivos XML. Sendo
assim, em 2004, resolvemos desenvolver a primeira
versão de uma ferramenta visual, na qual
o desenvolvedor não necessitasse mais codificar
em Java para usar as bibliotecas do projeto JBanana
e, assim, simplificar o desenvolvimento de aplicações
web. Através dessa ferramenta, com cliques
de mouse, drag and drop, menus e da configuração
de uma paleta de propriedades, o desenvolvedor poderia
configurar graficamente todo o seu sistema, e a
ferramenta gráfica seria capaz de gerar uma
aplicação Web usando todas as bibliotecas
Java preexistentes. Foi nesse momento que nasceu
o projeto JSenna, um projeto de software livre disponibilizado
no site do SourceForge , atualmente maior repositório
de software livre do mundo. O JSenna aumenta o nível
de abstração e assim ao invés
de codificar, o desenvolvedor pode descrever o sistema
identificando as telas, os campos e tipos de dados,
bem como toda a navegação entre as
telas. Ele informa tudo isso em uma interface gráfica
bastante intuitiva. Dessa maneira, protótipos
do sistema são gerados rapidamente facilitando
a validação dos requisitos com o cliente
e permitindo que mesmo desenvolvedores sem muita
expertise na tecnologia possam criar aplicações
web voltadas para bancos de dados relacionais. Hoje,
o JSenna encontra-se na versão 2 e foi totalmente
remodelado e transformado em um plug-in do Eclipse.
Ele estrapolou os limites dos três frameworks
iniciais e também está gerando código
para outros frameworks, como hibernate, jasperreports,
BIRT, dentre outros. Mais do que isso, ele está
sendo usado até mesmo em outras plataformas
como .Net, Mono, indo além até mesmo
do próprio Java.
Selecionando uma plataforma para o JSenna
A comunidade
Eclipse é uma comunidade aberta cujos projetos
são focados em prover uma plataforma de desenvolvimento
independentemente de fabricante e frameworks de
aplicações para construção
de software. Dentre os produtos mais conhecidos
desta comunidade, está o Eclipse IDE. O Eclipse
IDE é uma ferramenta gráfica de arquitetura
de plug-ins. Quando você faz download do Eclipse
IDE, vários plug-ins já podem estar
instalados. Por exemplo, para o desenvolvimento
de soluções Java, o Eclipse pode vir
previamente configurado com plug-ins para codificação,
compilação e debug Java. Porém,
existem inúmeros outros plug-ins no próprio
site do Eclipse, ou mesmo em sites especializados,
que permitem que o Eclipse IDE seja usado como uma
ferramenta de desenvolvimento C, C++, C#, JavaScript,
Cobol, HTML e muitas outras linguagens, com acesso
a banco de dados e tudo mais que o desenvolvedor
necessita para construir suas aplicações
web ou desktop de maneira centralizada. Talvez seja
por isso que essa IDE foi largamente adotada pelos
desenvolvedores sendo hoje a ferramenta de software
livre mais usada pela comunidade Java, competindo
e ganhando a preferência da maioria, mesmo
se comparada com as IDEs comerciais. Essa foi também
uma das razões que nos levou a adotar o Eclipse
como Plataforma de desenvolvimento para a segunda
versão do JSenna. Para construir Plug-Ins
para o Eclipse, você deve usar uma biblioteca
gráfica conhecida como SWT. Apesar da SWT
ser muito performática e ter um excelente
acabamento visual, ela não possui um nível
de abstração tão grande quanto
a tradicional biblioteca Swing disponível
na JRE do Java, que é normalmente utilizada
na construção das demais IDEs Java.
Existem algumas outras bibliotecas complementares
como a JFaces, que melhoram a abstração
da SWT, mas ainda assim dá muito trabalho
codificar manualmente um plug-in para o Eclipse.
Em suma, você tem que escrever muito código.
Percebemos que isso dificultaria muito a manutenção
e evolução do JSenna e então
decidimos utilizar outros frameworks do próprio
Eclipse para gerar grande parte do código
do plug-in JSenna. A solução encontrada
foi usar o framework EMF - Eclipse Modeling Framework.
O EMF é um framework de modelagem e geração
de código que facilita justamente a construção
de ferramentas e aplicações baseadas
em um modelo de dados estruturado.
Dentro do próprio Eclipse, começamos
a construir o Plug-In JSenna. Definimos quais as
informações que uma aplicação
Web necessitaria serem coletadas pelo desenvolvedor
junto ao cliente. Estruturamos e modelamos essas
informações em estruturas de dados
que foram definidas através de arquivos XML-Schemas
(XSD ). Um exemplo da modelagem de informações
estruturadas pode ser visto na figura 1.
Figura
1. Definição dos esquemas XMLs (XSD)
representando como a informação deve
ser coletada.
Graficamente,
desenhamos e validamos estas estruturas de dados
e o próprio Eclipse transformou-as, na medida
em que construíamos os diagramas, em arquivos
XML-Schemas. Com base nestes arquivos XSDs e usando
o framework EMF do Eclipse, o Eclipse IDE gerou
todas as estruturas de dados previamente definidas,
criando todos os objetos e seus relacionamentos
bem como o mecanismo de persistência dos dados
em arquivos XML. O Eclipse também gera automaticamente
vários plug-ins para visualizar, criar e
editar estas estruturas de dados. Tudo através
de wizards com muita produtividade. Dessa forma,
se no futuro, o desenvolvedor decidir coletar informações
adicionais para o seu projeto web, basta evoluir
o esquema de dados (XSD) e regerar o plugin do JSenna.
Isso é, grande parte das telas do JSenna
são geradas automaticamente através
da definição de arquivos XSDs com
a ajuda do framework EMF. Com essa estratégia,
a própria evolução do JSenna
é realizada através dos wizards EMF
do Eclipse, facilitando em muito a manutenção
e evolução da ferramenta. Esses foram
os motivos que nos levaram a adotar o Eclipse IDE
e o EMF como plataforma core de desenvolvimento
do JSenna.
Leia
o artigo completo na revista MUNDOJAVA, já
nas bancas!
|
|
