/ 24

demoiselle_

Mais leveza, reúso, flexibilidade e extensibilidade na nova versão do framework Java padrão do Go-verno Federal.

Após quatro anos de existência, o framework De-moiselle já está estabelecido como padrão de

desenvolvimento do Serpro, tem se tornado também a referência para desenvolvimento do governo de al-guns Estados da Federação, assim como de algumas empresas privadas que viram nele não só a possibi-lidade de poder desenvolver para os órgãos públicos, mas também como uma ferramenta útil para aten-dimento de suas próprias demandas. Na edição de número 36 de 2009 desta revista foi publicada uma matéria sobre o framework Demoiselle, apresentan-do sua primeira série de versão e os objetivos a que se propunha, e desde então, com o apoio das críticas e sugestões, o projeto tem evoluído e agregado mais interessados em sua comunidade.

Essa segunda série do projeto foi construída com base num processo aberto e colaborativo, onde foi aberto um fórum de discussões para receber as propostas da comunidade. O direcionamento para a aderência à especificação JEE6[ 4 ] foi um dos pilares do desenvolvimento. Desta forma, tanto a base nú-cleo da ferramenta como também os outros artefatos que são conhecidos como seus componentes foram renovados. Agora apresentamos o que há de novida-des nos projetos.

Um pouco da história do projetoPara aqueles que não tiveram a oportunidade

de ler na edição 36 de 2009, apresentamos aqui um pouco da cronologia do projeto, e os que já tiveram acesso poderão refrescar suas memórias. No ano de 2008 foi entregue pelo Serpro, ainda internamente, a primeira versão da ferramenta que foi criada com

base nos estudos que foram feitos com outro framework Java para desenvolvimento Web chamado Plataforma Pi-nhão que foi desenvolvido pela Celepar[ 5 ] e que também chegou a ser usado pelo Serpro, mas que não foi evoluído pela criadora e naquele momento já não atendia completamente as necessida-des do Serpro. No ano seguinte, em 2009, o projeto foi aberto para a comunidade através do ambiente colaborativo mais usado no mundo que é o SourceForge[ 6 ], e a partir deste fato todo o proces-so de planejamento e execução do desenvolvimento dos projetos têm como base as ferramentas ofereci-das por este ambiente. No ano de 2010 foi aberto o processo de planejamento para versão 2, que envol-veu a abertura de um fórum público no SourceForge para recebimento de sugestões, várias chamadas em todas as mídias digitais disponíveis e acessíveis ao projeto. Com base nestas sugestões foi implementa-da e entregue em dezembro de 2010 a primeira ver-são estável da série: a 2.0.0. A partir desta data, vá-rias melhorias foram feitas até chegar à versão atual, 2.2.2, na qual apresentamos aqui.

As novidades do projetoLançado no final de dezembro de 2010, a série

da versão 2 do framework Demoiselle, que foi criada em um processo aberto com a comunidade, foi com-pletamente modificada com relação à série anterior. Conforme os anseios dos colaboradores, a premissa principal foi a aderência à especificação Java En-

Desenvolvimento Java EE 6 com Framework Demoiselle Versão 2.

25 \

Renovado através de um processo aberto com a comu-nidade, uma das principais características do proje-to, o Framework Demoiselle, na segunda versão, tor-nou-se mais leve e flexível. Adotando como princípio a aderência à especificação Java Enterprise Edition 6 (JSR-316), além de bem atualizada, a ferramenta passa a ser mais extensível e facilmente acoplável a outras soluções compatíveis com a JEE6, permitindo

mais independência ao desenvolvedor. Por ser a pla-taforma padrão de desenvolvimento do Serpro – Ser-

viço Federal de Processamento de Dados, a nova versão da ferramenta faz com que a empresa cumpra seu papel

de agente de inovação de TI do governo federal. Por ser uma ferramenta OpenSource (código aberto), também é uma

agente da integração entre governo e sociedade, pois permite a participação de qualquer pessoa ou empresa no seu processo de

desenvolvimento. Apresentamos aqui quais foram essas mudanças.

Emerson Sachio Saito | emerson.saito@serpro.gov.br Bacharel em Análise de Sistemas pela PUC-PR, com especialização em Tecnologia da Informação pela UFPR. Possui

formação técnica em contabilidade. Trabalhou como analista de informática na Celepar (Companhia de Infor-mática do Paraná) de 2001 a 2009, onde, entre outras atividades com a linguagem JAVA e outras tecnologias,

foi um dos desenvolvedores do framework Pinhão[ 1 ]. Atualmente é analista de desenvolvimento no Serpro[ 2 ]

(Serviço Federal de Processamento de Dados), onde faz parte da equipe de desenvolvimento do framework Demoiselle[ 3 ].

terprise Edition 6, que trouxe diversas novidades e melhorias para os outros projetos que ela engloba, como, por exemplo, a Java Persistence API 2 (JPA2)[ 7 ], Java Server Faces 2 (JSF2)[ 8 ], Entreprise Java Beans 3.1 (EJB 3.1)[ 9 ], Contexts and Dependency Injection (CDI)[ 10 ], entre outras novidades. Outro direcionamento do desenvolvimento foi fazer uma ferramenta leve e flexível, e isso se traduz em um framework “mais enxuto”. Assim, a cada versão, o Demoiselle usa cada vez mais o que já está disponí-vel no mercado e oferece apenas o que serve como auxílio para o desenvolvedor usar estas tecnologias de forma mais simplificada. O grande diferencial do projeto acaba sendo as ferramentas e componentes oferecidos pela comunidade e a própria comunidade que está se tornando um ambiente de colaboração mais eficiente com o aumento da participação dos interessados. Atendendo às contribuições e opiniões da comunidade durante o processo de definição da nova versão, houve algumas mudanças com relação

à série da versão 1 que fazem com que o processo de migração entre elas não seja totalmente transparen-te para o desenvolvedor, pois a adoção de tecnolo-gias ligadas a novas versões das especificações traz impacto direto no código java e, no caso do uso do JSF, nas páginas XHTML. Este foi um custo que foi pago para trazer melhor evolução ao projeto. E, para minimizar o impacto da migração, a comunidade disponibiliza um guia de mudanças para ajudar nes-te processo, e as experiências deste tipo que ocorrem no Serpro têm demonstrado que mesmo em casos de migração o esforço é compensado pelo ganho de flexibilidade e produtividade que a nova versão pro-porciona.

Arquitetura do projetoNa atual versão a arquitetura do projeto está di-

vidida em três partes: core, extensões e componen-tes, conforme representa a figura 1.

» Core: contém as implementações das funções

/ 26

básicas para o funcionamento do Framework: suas classes utilitárias, controle de mensagens, configurações, exceções etc., e é fortemente baseado nos recursos do CDI. É também onde se encontram as definições das anotações para os estereótipos das camadas, pois o Demoisel-le recomenda o uso do padrão MVC (Modelo, Visão e Controle) no desenvolvimento de apli-cações.

» Extensões: são funcionalidades dependentes do Core, mas de uso opcional, que implemen-tam facilitadores para utilização de tecnologias aderentes ao JEE6, atualmente estão disponí-veis extensões para:

» JSF: fornece um conjunto de funcionali-dades para uso na camada interface com o usuário da especificação JSF2 , e provê tam-bém alguns templates de Managed Beans com funcionalidades básicas de listagem e edição. Para o uso dessa extensão, também está disponível um arquétipo Maven para geração da estrutura de uma aplicação.

» JPA: facilitador para uso de controle de transação administrado pela aplicação e também um template com operações bá-sicas do tipo CRUD: Create, Read, Update, Delete.

» JTA: funcionalidade para delegação do controle de transação para um container JEE[ 11 ] conforme a especialização JTA[ 12 ].

» Java Standard Edition (SE): extensão para uso do Demoiselle para desenvolvimen-to de aplicações Java do tipo Desktop (ex: Swing).

» Componentes: recursos opcionais que podem não depender de nenhuma característica do Demoiselle, mas que são utilizados para agre-gar funcionalidades de implementações de ter-ceiros, e por isso em muitos casos dependentes de fornecedores, que são comumente úteis para o desenvolvimento de aplicações. Até o presen-te momento temos:

» Demoiselle-Report: baseado no JasperRe-ports[ 13 ], é um facilitador para manipula-ção de relatórios.

» Demoiselle-Mail: facilitador para envio de e-mail, baseado na API JavaMail[ 14 ], tem como diferencial a disponibilização de uma DSL (Domain Specific Language)[ 15 ] que simplifica ainda mais a manipulação do componente.

» Demoiselle-JUnit: criado para possibilitar o uso da biblioteca Junit[ 16 ], ou seja, a execução de testes de unidade em projetos com CDI, mas em ambiente de desenvolvi-mento, como o Eclipse.

» Demoiselle-Validation: este componente tem como principal objetivo fornecer um conjunto de validações aderentes com a JSR303, Bean Validation. São fornecidas algumas validações comuns a aplicações

Figura 1. Visão da arquitetura do Demoiselle.

Demoiselle-Vaadin

Demoiselle-Report

Demoiselle-JPA

Demoiselle-Extension

Demoiselle-Monitoring

Demoiselle-Mail

Demoiselle-JSF

Demoiselle-Core

Demoiselle V2

Demoiselle-Authorization

Demoiselle-JUnit

Demoiselle-JTA

Demoiselle-Validation

Demoiselle-SE

<<Maven-Archetypes>>

27 \

brasileiras, como: CEP, CPF, CNPJ, Inscri-ção Estadual e PIS/PASEP. A utilização des-tas validações é bastante simples, devendo usar apenas as anotações @Cpf, @Cnpj, @Cep, @InscricaoEstadual ou @PisPasep no atributo do Bean que deve ser validado.

» Demoiselle-Authorization: é uma iniciati-va que visa a permitir a utilização de ma-neira simplifi cada do recurso de controle de autenticação e autorização, em tecnolo-gia Java, conhecido como JAAS[ 17 ].

» Demoiselle-Vaadin: o Vaadin[ 18 ] é um framework para construção de interfaces web. Apesar de usar o GWT como meca-nismo para a exibição de seus componen-tes, eles têm algumas características que os diferenciam. No Vaadin, assim como no GWT, a construção da interface ocorre de forma bem semelhante ao modelo já co-nhecido no Swing/SWT: atrav és da com-posição de diversos componentes e usando apenas código Java. O objetivo deste com-ponente é permitir o uso desta tecnologia com o Demoiselle, possibilitando o uso de Injeção de Dependência, além das demais funcionalidades já conhecidas do fra-mework. Também são fornecidas funcio-nalidades extras que facilitam a criação de aplicações, voltadas a padrões de mercado bastante conhecidos. Um arquétipo Maven para geração da estrutura de uma aplicação usando este componente também é ofere-cido.

» Demoiselle-Monitoring: é um componen-te para monitoração de aplicações em Java desenvolvidas com o Demoiselle. Como objetivo geral, o componente fornece me-canismos que possibilitam a uma aplicação Java responder as requisições provenien-tes de um servidor (modalidade polling) e enviar automaticamente notifi cações a um servidor (modalidade trapping). Atual-mente, o componente suporta as seguintes

tecnologias e padrões de monitoramento: JMX, SNMP e Zabbix.

Impulso no crescimento da comunidadeA versão 2.0.0 do Demoiselle, primeira da séria,

foi lançada no fi nal de dezembro de 2010, e já no mês seguinte, o número de participações na lista de dis-cussões atingiu um número maior que qualquer ou-tro anterior desde a abertura do projeto no ambiente SourceForge (conforme ilustra a fi gura 2). Este núme-ro tem se mantido sempre superior, demonstrando que a nova versão trouxe maior interesse da comu-nidade. Vale lembrar que os funcionários do Serpro, fundador do projeto, raramente utilizam este canal de comunicação para procurar ajuda, pois contam com outros meios de suporte interno.

A comunidade Demoiselle conta também com um portal de notícias que é independente do ambien-te SourceForge, pois atualmente há outros recursos fora do SourceForge sendo utilizados pelo projeto e este portal faz o papel de direcionador e concentra-dor destes recursos.

Outro fator que também demonstra o aumento da participação foi a mudança do repositório de fon-tes do projeto do ambiente SVN[ 19 ] no SourceForge para o GitHub[ 20 ]. Talvez alguns ainda não conhe-çam, mas o Git é um sistema de controle de versão distribuído com ênfase em velocidade e inicialmen-te projetado e desenvolvido por Linus Torvalds para o desenvolvimento do kernel Linux. O GitHub é um serviço web que oferece recursos baseados no Git. E pela sua forma de uso, é uma ferramenta muito mais democrática para colaboração entre desenvolvedo-res. No caso do Demoiselle, apesar de ainda discreta, a participação direta no código através do GitHub já ocorre, mas no repositório anterior, que era o SVN, não houve contribuições diretas, sendo apenas atra-vés de registros na ferramenta de BugTrack.

O projeto tem sido representado em vários even-tos de tecnologia Java e antes mesmo de ser entregue ofi cialmente, a versão 2 foi escolhida para ser apre-sentada durante o JavaOne Brasil de 2010, e também é frequente em eventos já consagrados no Brasil,

Figura 2. Quadro-resumo das mensagens na lista de usuários.

/ 28

como o JustJava. E isso tem proporcionado um efeito positivo no interesse dos desenvolvedores pelo pro-jeto.

São vários os casos relatados, na lista de discus-sões, sobre trabalhos de conclusão de curso que usam o Demoiselle em algumas universidades e faculdades no País, o que demonstra também um bom interesse da área acadêmica.

Disseminação do conhecimentoAlém da documentação de referência[ 21 ] que

contém as instruções básicas para uso do framework Demoiselle, são disponibilizados materiais em for-mato de tutorias, geralmente acompanhados de vi-deoaulas, que podem ser utilizados para auto-estudo e estão disponíveis no portal do projeto. Na confecção do material, tem se procurado inserir boas práticas de programação como o desenvolvimento orientado a testes, conhecido como TDD (Test Driven Develo-pment).

Outra forma de disseminação é através de cursos de ensino à distância (EAD) utilizando a plataforma chamada Moodle[ 22 ]. Atualmente está disponível o curso “Demoiselle 2 − Introdução ao Desenvolvimen-to com Framework Demoiselle versão 2” e, através da lista de usuários, são divulgadas as aberturas de inscrições onde qualquer desenvolvedor interessado pode participar de forma gratuita. Também há planos para elaboração de cursos e tutoriais que abordem as principais tecnologias usadas em conjunto com o Demoiselle para desenvolvimento de soluções, que são os casos do Apache Maven, CDI, JSF2 e JPA2. O principal diferencial nesta modalidade é que o par-ticipante conta com o apoio de um tutor durante o curso e ao final é emitido um certificado.

O desenvolvimento do framework tem se baseado em práticas ágeis, sendo o Scrum[ 23 ] a principal me-todologia. Assim, o colaborador também acaba tendo contato com estas práticas ao participar do processo de desenvolvimento do Demoiselle.

Ferramentas de apoio à configuração de ambiente

Uma tarefa que parece ser bastante simples para o usuário experiente pode se tornar um verdadeiro desafio para o iniciante, que é a configuração do am-biente de desenvolvimento. Por padrão, o Demoisel-le recomenda o software Eclipse como ambiente de desenvolvimento, e como em vários projetos do tipo JEE, é comum o uso de vários plugins de apoio que, no caso do Demoiselle, podemos citar o M2Eclipse[ 24 ], que é suporte para vários facilitadores disponi-bilizados pelo projeto como os arquétipos, e o JBoss Tools[ 25 ], que possui uma série de funcionalidades que ajudam no desenvolvimento do projeto. Mesmo com a conveniência que foi trazida com o Eclipse

MarketPlace, ainda não é tão simples para o desen-volvedor inexperiente fazer a relação entre todos os plugins necessários e suas respectivas configurações. Também é preciso escolher um servidor de aplicações (atualmente o Demoiselle é testado com JBoss-AS e Apache-Tomcat) e configurá-lo no Eclipse.

Pensando neste público, a comunidade Demoi-selle dispõe de um projeto chamado Demoiselle-In-fra[ 26 ], que tem por objetivo criar formas de simpli-ficar esse trabalho de criação de ambiente. A forma mais simples de todas é através de uma imagem de DVD que contém uma distribuição do Linux-Ubuntu já com o ambiente de desenvolvimento instalado e configurado para uso. A imagem pode ser baixada di-retamente do SourceForge no link indicado acima e também é possível conseguir a mídia junto à comu-nidade principalmente em eventos onde o projeto é apresentado.

Para sistemas operacionais do tipo Linux que operam com pacotes de instalação do tipo Debian (.deb), como é o caso do próprio Debian, Ubuntu, Mint etc., com a colaboração da Universidade Federal do Paraná, é disponibilizado um repositório conten-do os pacotes necessários para a criação e configura-ção do ambiente de desenvolvimento, que pode ser feito através do famoso “apt-get install” ou o aplica-tivo Synaptic. Para distribuições Linux que usam pa-cotes .rpm, são feitas versões convertidas dos pacotes e colocados para download no Sourceforge.

Para o sistema operacional MS-Windows, existe alguns instaladores para algumas das versões mais utilizadas, e que também estão disponíveis para do-wnload na área do Sourceforge.

Novo patrocinadorQue o framework Demoiselle é um projeto Open-

Source e possui uma comunidade livre, não há dúvi-das. Mas alguns questionam sobre o projeto ser um produto oferecido pelo Governo e, portanto, só ser-viria para Governo. Aqueles que acompanharem a co-munidade através de alguns dos seus canais de comu-nicação logo perceberão que há bastante participação de pessoas e entidades que não têm relação alguma com o governo e que simplesmente encontraram um produto e uma comunidade onde podem confiar para desenvolverem suas soluções. O Serpro foi o fundador do projeto e, pela organização da comunidade que sempre foi pública e aberta[ 27 ], se posicionou como o primeiro patrocinador e por algum tempo o único. Durante uma etapa de um evento que foi promovido pela comunidade, e que aconteceu em Recife-PE no dia 15 de maio de 2012, foi oficializado o segundo pa-trocinador do projeto, que é a empresa BankSystem[ 28]. Os técnicos desta empresa já haviam se tornado assíduos na lista de usuários e fóruns do projeto por orientação da sua direção, que começou a usar o fra-

29 \

mework Demoiselle para prestar serviços para o Es-tado de Pernambuco, e adotou o projeto de tal forma que se tornou um padrão de desenvolvimento dela para suas soluções e, diante desse cenário, resolveu se inserir de forma mais próxima do projeto se tor-nando um patrocinador.

A IDE Eclipse, que é a ferramenta de desenvolvi-mento padrão do projeto, é um bom exemplo de um projeto que foi concebido por uma organização, que foi a IBM, depois liberada para comunidade e que foi amadurecendo ao ponto de hoje ser totalmente inde-pendente. O Serpro não possui mecanismos de fazer algo como a IBM que, além de liberar o código, ain-da aportou uma considerável quantia de fundos para que a comunidade pudesse se manter sozinha, mas cumpre seu papel de instituição pública ao tornar o projeto público e criar mecanismos para que ele se torne independente.

Atualmente, o Serpro mantém alguns recursos dedicados ao projeto, primeiramente por interesse próprio, pois é a sua plataforma padrão de desenvol-vimento de soluções, e também com o papel de atuar junto e com comunidade para cumprir também seu papel de patrocinador. Com a chegada de novos pa-trocinadores, a tendência é que o projeto se torne cada vez mais uma ótima alternativa para o apoio ao desenvolvedor.

Um exemplo prático

Ambiente de desenvolvimento utilizadoComo já foi comentado, existe um projeto que

provê formas de montagem automática do ambien-te de desenvolvimento. E caso queira reproduzir este exemplo, vamos listar os softwares necessários para o caso, e que fazem parte do ambiente que foi utili-zado:

» Eclipse IDE 3.7 (Indigo), com os plugins: Jboss--tools, M2E (Maven to Eclipse) e Demoiselle--Nimble. Com catálogo de arquétipo remoto configurado para: http://demoiselle.sourcefor-ge.net/repository/archetype-catalog.xml.

» Servidor de aplicações JBoss-AS 6.1 ou Jboss--AS 7.1 (a partir da versão 2.3 do Demoiselle).

Note que um dos plugins do Eclipse é um produ-to desenvolvido pela comunidade Demoiselle, que é chamado Demoiselle-Nimble. Esse subprojeto é uma iniciativa de criar uma ferramenta para geração au-tomática do código comum e repetitivo, que geral-mente toma certo tempo do desenvolvedor e não é o objetivo principal do desenvolvimento. A ferramenta é desenvolvida com a linguagem Groovy[ 29 ] e utili-za templates Apache-Velocity. E como as aplicações estão baseadas no framework, é possível criar várias partes da aplicação, pois estarão em um formato bem definido. Mas também é possível criar templates para

geração de qualquer tipo de aplicação, desde que haja um padrão de construção.

Gerando uma aplicação de exemploO primeiro passo é criar uma aplicação com o

arquétipo maven disponibilizado pelo Demoiselle, através da ferramenta Eclipse nos menus: File > New > Project > Maven Project.

Selecionamos o arquétipo: demoiselle-jsf-jpa, conforme exemplificado na figura 3.

Figura 3. Selecionando o arquétipo demoiselle-jsf-jpa.

Isso significa que nossa aplicação usará o JSF como camada de apresentação.

Em seguida, informamos os dados da aplicação no estilo gerenciado pelo Apache-Maven: Group Id, Artifact Id e Version. A partir destas informações, o plugin gera no nome do pacote para a aplicação, con-forme pode ser visto na figura 4.

Figura 4. Informando os dados da aplicação.

Isso é suficiente para criar a estrutura do projeto com os artefatos necessários e o Apache Maven fará o gerenciamento das bibliotecas. Na figura 5, pode-se ver o resultado.

/ 30

Figura 5. Aplicação criada pelo arquétipo demoiselle-jsf-jpa.

O arquétipo nesta versão já cria uma aplicação de exemplo usando a biblioteca PrimeFaces 3, como implementação para JSF. Basta incluí-la no servidor de aplicações (no caso o Jboss 6.1) e executá-lo, o re-sultado é o mostrado na fi gura 6.

Figura 6. Aplicação de exemplo funcionando.

Para continuar o exemplo, primeiro vamos veri-fi car o arquivo de confi guração chamado persistence.xml, do diretório /src/main/resources, e é o arquivo usado pelo JPA para estabelecer a conexão e confi gu-ração com o banco de dados. O arquétipo já traz uma série de exemplos comentados para que o desenvol-vedor possa escolher o que melhor lhe atende. Neste exemplo usaremos a confi guração “default” que é a

primeira tag “persistence-unit” do arquivo e exclui-remos todas as outras que estão comentadas. Em se-guida editaremos o arquivo POM.XML para incluir o componente Demoiselle-validation, acrescentando as linhas abaixo:

Listagem 1. Linhas para incluir no arquivo POM.XML:

<dependency> <groupId>br.gov.frameworkdemoiselle.component </groupId> <artifactId>demoiselle-validation</artifactId> <scope>compile</scope></dependency><dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <scope>compile</scope></dependency>

Agora vamos preparar algumas classes para exe-cutar o nosso gerador de códigos, que é o Demoiselle--Nimble. Dentro do pacote chamado domain, criare-mos as seguintes classes:

Listagem 2. Implementação da classe Pessoa.java:

package br.org.frameworkdemoiselle.exemplo.domain;

import java.util.Date;import javax.persistence.Column;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.MappedSuperclass;import javax.persistence.Temporal;import javax.persistence.TemporalType;import br.gov.frameworkdemoiselle.validation.annotation.Cpf;

@MappedSuperclasspublic abstract class Pessoa { @Id @GeneratedValue private Long id; @Column @Cpf private String cpf; @Column(nullable = false, length = 255) private String nome; @Column(nullable = false) @Temporal(value = TemporalType.DATE) private Date dataNascimento; public void setId(Long id) { this.id = id; }

31 \

public void setCpf(String cpf) { this.cpf = cpf; } public String getCpf() { return cpf; } public void setDataNascimento(Date dataNascimento) { this.dataNascimento = dataNascimento; } public Date getDataNascimento() { return dataNascimento; }} public Long getId() { return id; } public void setNome(String nome) { this.nome = nome; } public String getNome() { return nome; }

Listagem 3. Implementação da classe Contato.java:

package br.org.frameworkdemoiselle.exemplo.domain;

import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Table;

@Entity@Table(name=”Contato”)public class Contato extends Pessoa implementsSerializable { private static fi nal long serialVersionUID = 1L; @Column(nullable=false) private String email; @Column private int numeroTelefone; public String getEmail() { return email; } public void setEmail(String email) { this.email = email; }

public int getNumeroTelefone() { return numeroTelefone; } public void setNumeroTelefone(int numeroTelefone) { this.numeroTelefone = numeroTelefone; }}

Perceba que as classes das Listagens 2 e 3 estão apenas com anotações padrão da especifi cação JPA. Poderia ser utilizado, por exemplo, uma ferramen-ta que faz esse tipo de mapeamento diretamente de uma base de dados já existente. Portanto, o Demoi-selle procura não interferir nas soluções que já estão estabelecidas.

Em seguida, voltamos para o ambiente Eclipse e executaremos o Nimble, que é acionado por um ícone na barra de ferramentas conforme mostrado na fi gura 7.

Figura 7. Ícone acionador da ferramenta Demoiselle-Nimble.

Ao clicar no acionador, a tela da ferramenta de-verá ser apresentada, onde devermos escolher um dos templates distribuídos com o plugin na IDE Eclipse. Perceba que são apresentadas várias opções, pois es-tão disponíveis templates para geração de artefatos para a série anterior da versão do Demoiselle e tam-bém para outras versões da biblioteca PrimeFaces. Escolheremos a opção para CRUD com Primefaces 3[ 30 ], conforme pode ser visto na fi gura 8.

Figura 8. Escolhendo um template.

Na tela seguinte, mostrada na fi gura 9, devere-mos informar os itens:

» Output Folder: o diretório da aplicação no workspace do Eclipse.

» Package Name: nome do pacote principal da aplicação.

» Entity Name: nome da entidade (uma classe do pacote domain).

/ 32

Figura 9. Informação de dados para geração de código.

Ao clicar no botão Finish, serão gerados todos os artefatos necessários para uma operação CRUD sim-ples segundo o padrão do Demoiselle.

No pacote sugerido como o da camada de persis-tência será gerada uma classe, vista na Listagem 4, com o sufixo DAO.

Listagem 4. Implementação da classe ContatoDAO.java:

package br.org.frameworkdemoiselle.exemplo.persistence;import javax.inject.Inject;import org.slf4j.Logger;import br.gov.frameworkdemoiselle.stereotype.PersistenceController;import br.gov.frameworkdemoiselle.template.JPACrud;import br.org.frameworkdemoiselle.exemplo.domain.Contato;

@PersistenceControllerpublic class ContatoDAO extends JPACrud<Contato, Long> { private static final long serialVersionUID = 1L; @Inject @SuppressWarnings(“unused”) private Logger logger; }

Esta classe estende a classe de template forneci-da pelo Demoiselle chamada JPACrud que já contém as funcionalidades básicas de criação, recuperação, atualização e exclusão de dados, e os tipos genéri-cos são o nome da entidade e o tipo da chave iden-tificadora da entidade. A classe recebe a anotação @PersistenceController que é o estereótipo que a iden-tifica como uma classe da camada de persistência. É incluído também um código de injeção de uma classe de log, somente como orientação de exemplo.

No pacote de sugestão de camada de negócios, encontraremos uma classe, vista na Listagem 5, com o sufixo BC.

Listagem 5. Implementação da classe ContatoBC.java:

package br.org.frameworkdemoiselle.exemplo.business;

import br.gov.frameworkdemoiselle.stereotype.BusinessController;import br.gov.frameworkdemoiselle.template.DelegateCrud;import br.org.frameworkdemoiselle.exemplo.domain.Contato;import br.org.frameworkdemoiselle.exemplo.persistence.ContatoDAO;

@BusinessControllerpublic class ContatoBC extends DelegateCrud<Contato, Long, ContatoDAO> { private static final long serialVersionUID = 1L; }

Aqui vemos apenas a extensão da classe de tem-plate chamada DelegateCrud, cujos tipos genéricos são a classe de entidade, o tipo da chave identifica-dora da entidade e a classe de persistência. A classe recebe a anotação @BusinessController, que é o es-tereótipo que a identifica como uma classe da cama-da de negócios.

E no pacote sugerido como o de camada de visão, encontraremos duas classes com sufixo MB: uma que implementa a funcionalidade de apresentação dos dados da entidade (Listagem 6) e outra (Listagem 7) para manipulação dos dados.

Listagem 6. Implementação da classe Contato-ListMB.java:

package br.org.frameworkdemoiselle.exemplo.view;

import java.util.Iterator;import java.util.List;import javax.inject.Inject;import br.gov.frameworkdemoiselle.annotation.NextView;import br.gov.frameworkdemoiselle.annotation.PreviousView;import br.gov.frameworkdemoiselle.stereotype.ViewController;import br.gov.frameworkdemoiselle.template.AbstractListPageBean;import br.gov.frameworkdemoiselle.transaction.Transactional;import br.org.frameworkdemoiselle.exemplo.business.ContatoBC;import br.org.frameworkdemoiselle.exemplo.domain.Contato;@ViewController@NextView(“/contato_edit.xhtml”)@PreviousView(“/contato_list.xhtml”)

33 \

public class ContatoListMB extends AbstractListPageBean<Contato, Long> { private static final long serialVersionUID = 1L; @Inject private ContatoBC contatoBC; @Override protected List<Contato> handleResultList() { return this.contatoBC.findAll(); } public String deleteSelection() { boolean delete; for (Iterator<Long> iter = getSelection().keySet().iterator(); iter.hasNext();) { Long id = iter.next(); delete = getSelection().get(id); if (delete) { contatoBC.delete(id); iter.remove(); } } return getPreviousView(); }}

A classe da Listagem 6 estende a classe de tem-plate chamada AbstractListPageBean que já contém algumas funcionalidades básicas de recuperação de dados, como paginação, por exemplo, e que por es-tarem nesta camada poderão ser acionadas pelas pá-ginas JSF (.xhtml). Os tipos genéricos são o nome da entidade e o tipo da chave identificadora da entida-de. A classe recebe a anotação @ViewController, que é o estereótipo que a identifica como uma classe da camada de visão e também como um ManagedBean da especificação JSF. As anotações @NextView e @PreviousView são facilitadores para a navegação no novo padrão JSF2, onde não é preciso editar o arquivo faces-config.xml. É incluído também um método para execução da listagem dos dados na página JSF e outro para exclusão de um item que pode ser selecionado de um componente JSF (Primefaces).

Listagem 7. Implementação da classe ContatoE-ditMB.java:

package br.org.frameworkdemoiselle.exemplo.view;

import javax.inject.Inject;import br.gov.frameworkdemoiselle.annotation.PreviousView;import br.gov.frameworkdemoiselle.stereotype.ViewController;import br.gov.frameworkdemoiselle.template.AbstractEditPageBean;import br.gov.frameworkdemoiselle.transaction.Transactional;

import br.org.frameworkdemoiselle.exemplo.business.ContatoBC;import br.org.frameworkdemoiselle.exemplo.domain.Contato; package br.org.frameworkdemoiselle.exemplo.view;

import javax.inject.Inject;import br.gov.frameworkdemoiselle.annotation.PreviousView;import br.gov.frameworkdemoiselle.stereotype.ViewController;import br.gov.frameworkdemoiselle.template.AbstractEditPageBean;import br.gov.frameworkdemoiselle.transaction.Transactional;import br.org.frameworkdemoiselle.exemplo.business.ContatoBC;import br.org.frameworkdemoiselle.exemplo.domain.Contato;

@ViewController@PreviousView(“/contato_list.xhtml”)public class ContatoEditMB extends AbstractEditPageBean<Contato, Long> { private static final long serialVersionUID = 1L; @Inject private ContatoBC contatoBC; @Override public String delete() { this.contatoBC.delete(getId()); return getPreviousView(); } @Override public String insert() { this.contatoBC.insert(getBean()); return getPreviousView(); } @Override public String update() { this.contatoBC.update(getBean()); return getPreviousView(); } @Override protected void handleLoad() { setBean(this.contatoBC.load(getId())); } }

A classe da Listagem 7 estende a classe de tem-plate chamada AbstractEditPageBean, que já contém algumas funcionalidades básicas que auxiliam na ma-nipulação de dados, como o FacesContext, por exem-plo. O template usado recebe os parâmetros que são o nome da entidade e o tipo da chave identificadora da entidade. Os métodos padrão foram sobrescritos para

/ 34

adicionar as funcionalidades de navegação no padrão JSF2, e exemplificar que podem ser incluídas outras funcionalidades.

O Demoiselle-Nimble altera os arquivos persis-tence.xml, para incluir o mapeamento da classe de domínio, e o message.properties, para gerar os textos de mensagens que poderão ser customizadas e/ou in-ternacionalizadas.

Também são geradas as páginas JSF (.xhtml) cor-respondentes às classes da camada de visão (Lista-gens 6 e 7). Para exemplificar, apresentamos apenas a página de edição (Listagem 8), pois excetuando-se os parâmetros o restante são tags do core JSF e da biblioteca Primefaces.

Listagem 8. Página JSF gerada pelo Demoiselle--Nimble, contato_edit.xhml:

<ui:composition xmlns=”http://www.w3.org/1999/xhtml”

xmlns:f=”http://java.sun.com/jsf/core” xmlns:p=”http://primefaces.org/ui” xmlns:h=”http://java.sun.com/jsf/html” xmlns:ui=”http://java.sun.com/jsf/facelets” template=”/template/main.xhtml”> <ui:define name=”body”> <h:form prependId=”false”> <p:toolbar> <p:toolbarGroup align=”left”> <p:commandButton

value=”#{messages[‘button.save’]}” action=”#{contatoEditMB.insert}” rendered=”#{!contatoEditMB.updateMode}” ajax=”false” /> <p:commandButton

value=”#{messages[‘button.save’]}” action=”#{contatoEditMB.update}” rendered=“#{contatoEditMB.updateMode}” ajax=”false” /> <p:commandButton value=”#{messages[‘button.delete’]}” onclick=”confirmation.show()” rendered=“#{contatoEditMB.updateMode}” type=”button” immediate=”true” ajax=”false” /> <p:confirmDialog message= “#{messages[‘label.confirm.delete’]}” showEffect=”bounce” hideEffect=”explode” header= “#{messages[‘label.dialog.delete’]}” severity=”alert” widgetVar=”confirmation”> <h:commandButton

value=”#{messages[‘button.dialog.yes’]}” action=”#{contatoEditMB.delete}” immediate=”true” ajax=”false” /> <h:commandButton value=”#{messages[‘button.dialog.no’]}” onclick=”confirmation.hide()” type=”button” /> </p:confirmDialog> </p:toolbarGroup> </p:toolbar> <br /> <p:fieldset

> 1 – Projeto Pinhão: http://www.frameworkpinhao.pr.gov.br

> 2 – Serpro: http://www.serpro.gov.br

> 3 – Portal do Projeto Demoiselle – http://www.

frameworkdemoiselle.gov.br/

> 4 – Especificação do JEE6 – http://jcp.org/en/jsr/detail?id=316

> 5 – Celepar – http://www.celepar.pr.gov.br

> 6 – Projeto no SourceForge – http://sourceforge.net/projects/

demoiselle/

> 7 – Especificação da JPA2 – http://jcp.org/en/jsr/detail?id=317

> 8 – Especificação do JSF2 – http://jcp.org/en/jsr/detail?id=314

> 9 – Especificação do EJB 3.1 – http://jcp.org/aboutJava/

communityprocess/final/jsr318/index.html

> 10 – Especificação do CDI – http://jcp.org/en/jsr/detail?id=299

> 11 – JEE Conteiners – http://docs.oracle.com/javaee/1.3/

tutorial/doc/Overview4.html

> 12 – JTA (http://www.oracle.com/technetwork/java/javaee/jta/

index.html)

> 13 – JasperReports – http://jasperforge.org/projects/

jasperreports

> 14 – Java Mail – http://www.oracle.com/technetwork/java/

javamail/index.html

35 \

legend=”#{messages[‘contato.label’]}” toggleable=”true” toggleSpeed=”500”> <h:panelGrid id=”fields” columns=”3”> <h:outputLabel value= “#{messages[‘contato.label.email’]}: “ for=”email” styleClass=”text-input” /> <h:inputText id=”email” value= ”#{contatoEditMB.bean.email}” title=”#{messages[‘contato.alt.email’]}” /> <p:message for=”email” /> <h:outputLabel value= “#{messages[‘contato. label.numeroTelefone’]}: “ for=”numeroTelefone” styleClass=”text-input” /> <h:inputText id=”numeroTelefone” value= “#{contatoEditMB.bean.numeroTelefone}” title=”#{messages[ ‘contato.alt.numeroTelefone’]}” /> <p:message for=”numeroTelefone”/> <h:outputLabel value= “#{messages[‘contato.label.id’]}: “ for=”id” styleClass=”text-input” /> <h:outputText id=”id” value=”#{contatoEditMB.bean.id}” /> <p:message for=”id” /> <h:outputLabel value= “#{messages[‘contato.label.nome’]}: “ for=”nome” styleClass=”text-input” />

<h:inputText id=”nome” value=”#{contatoEditMB.bean.nome}” title=”#{messages[‘contato.alt.nome’]}” /> <p:message for=”nome” /> <h:outputLabel value= “#{messages[‘contato.label.cpf’]}: “ for=”cpf” styleClass=”text-input” /> <h:inputText id=”cpf” value= “#{contatoEditMB.bean.cpf}” title=”#{messages[‘contato.alt.cpf’]}” /> <p:message for=”cpf” /> <h:outputLabel value= “#{messages[ ‘contato.label.dataNascimento’]}: “ for=”dataNascimento” styleClass=”text-input” /> <p:calendar id=”dataNascimento” value=

“#{contatoEditMB.bean.dataNascimento}” pattern=

“#{messages[‘label.date.pattern’]}” navigator=”true” showButtonPanel=”true” locale=”#{currentLocale}” title=”#{messages[

‘contato.alt.dataNascimento’]}” /> <p:message for=”dataNascimento” /> </h:panelGrid> </p:fieldset> </h:form> </ui:define></ui:composition>

> 15 – Domain Specific Language – http://en.wikipedia.org/wiki/

Domain-specific_language

> 16 – JUnit – http://www.junit.org/

> 17 – JAAS – http://docs.oracle.com/javase/1.4.2/docs/guide/

security/jaas/JAASRefGuide.html

> 18 – VAADIN – http://vaadin.com

> 19 – SVN – http://subversion.tigris.org/

> 20 – GitHub – https://github.com/demoiselle/

> 21 – Documentação de referência do Demoiselle – http://

demoiselle.sourceforge.net/docs/

> 22 – EAD Demoiselle – https://moodle.eadevs.serpro.gov.br

> 23 – Scrum – http://www.scrum.org/

> 24 – Maven to Eclipse – http://www.eclipse.org/m2e/

> 25 – JBoss Tools – http://www.jboss.org/tools

> 26 – Demoiselle-Infra – http://demoiselle.sourceforge.net/

infra/site/

> 27 – Constituição da Comunidade – http://sourceforge.net/

apps/mediawiki/demoiselle/index.php?title=Comunidade

> 28 – BankSystem – http://www.banksystem.com.br/

> 29 – Linguagem Groovy – http://groovy.codehaus.org/

> 30 – PrimeFaces – http://primefaces.org/

/referências

/ 36

Podemos verificar o resultado final nas figuras 10 e 11. Mesmo se tratando de um exemplo bem simpli-ficado é possível verificar algumas facilidades que o Demoiselle pode trazer ao processo de desenvolvi-mento.

Figura 10. Tela de listagem de contatos.

Figura 11. Tela de edição de contatos.

> Na edição número 40 (março/2010) desta revista, o Java

EE 6 foi destaque da capa e também trouxe alguns artigos

que trataram algumas das principais especificações que

fazem parte da plataforma JEE 6:

A revolução do Java EE 6, Um overview sobre as novidades

da JSR 316, páginas 30 a 34, de Pedro Henrique S.

Mariano.

CDI Injeção de Dependências e Gerenciamento de

Contextos no Java EE 6, fala sobre a JSR 299 que é um

recurso bastante utilizado pelo Demoiselle, páginas 35 a

45, de Alessandro Lazarotti.

As Novidades do JSF 2.0, que é tecnologia padrão para

camada de apresentação da JEE 6, e aborda sobre as

características e vantagens em relação à versão anterior,

páginas 46 a 50, de Sérgio Lopes.

/para saber mais

Considerações finais

Sabemos que o projeto está em fase

de amadurecimen-to e ainda tem muito a

evoluir, e é isso que tem acontecido na medida do

possível. Esperamos que este artigo possa ter mostrado um

pouco como a ferramenta tem me-lhorado, com o apoio dos usuários e

colaboradores, durante esses poucos anos de existência e como um projeto OpenSource está

aberto a qualquer colaboração. A comunidade De-moiselle procura criar não só boas ferramentas de apoio ao desenvolvedor, mas também um ambiente colaborativo e incentivador onde as pessoas podem encontrar ajuda e preparação. E muito menos é nos-sa intenção criar a melhor e definitiva ferramenta de apoio ao desenvolvedor. O que oferecemos é uma boa alternativa e uma oportunidade de participar de uma comunidade aberta e nacional. Quem tiver interesse em conhecer mais, está convidado a visitar o nosso portal e, caso queira, participar da lista de discussões.