Mdulo 1

O Demoiselle uma composio de projetos, e no apenas um framework Java como muita gente acha. fcil entender porque pensam assim: o Framework surgiu primeiro e at hoje o carrochefe. Ento vamos deixar bem claro, o projeto Demoiselle um agregado de subprojetos, que so: Framework. Este o foco do curso. Vamos conhecer e praticar as facilidades que este projeto oferece para o desenvolvimento de aplicaes Java baseado nas tecnologias da JEE 6. Definio em duas palavras: simplicidade e flexibilidade. Component. Conjunto de componentes reusveis que do mais poder ao Framework. Nem todos componentes esto atrelados ao Framework, mas os utilizados neste curso esto. Infra. Se voc sente calafrios ao pensar na trabalheira que d para preparar um ambiente de desenvolvimento, este projeto foi feito para voc. Sim, vamos utiliz-lo neste curso. Sample. Est precisando de exemplos para entender melhor o Framework e os Componentes? Disponibilizamos algumas amostras para voc. Neste curso no utilizaremos este projeto. Process. Trata-se de um processo livre de desenvolvimento de software inspirado em metodologias geis. No utilizaremos este projeto neste curso. Community. Todos os projetos Demoiselle so livres e colaborativos. Este projeto promove a gesto transparente e a participao ativa da comunidade. Citaremos algumas ferramentas no decorrer deste curso. Tools. So ferramentas focadas em produtividade que podem ser usadas em conjuntos com o Framework. Especificamente a ferramenta Demoiselle Nimble ser citada neste curso.

Objetivo
O objetivo deste curso bsico do Demoiselle mostrar, explicar e experimentar as principais funcionalidades do Framework, tais como: Testes Log Resource Bundle Tratamento de excees Configurao Persistncia Transao Controladores Inicializadores Controle de acesso Web Mensagem

Apoio
Ao final deste curso voc ser capaz de compreender o funcionamento do Demoiselle e utiliz-lo para construir suas aplicaes. Para facilitar a sua vida, adicione nos favoritos do seu browser: http://demoiselle.sourceforge.net/docs. Neste link voc encontrar dois guias de referncia muito importantes: do Framework e dos Componentes. Recorra a eles sempre que precisar de detalhamentos. Aproveite o embalo e cadastre-se na lista de usurios, ferramenta indispensvel para quem quer mandar bem e se manter atualizado: https://lists.sourceforge.net/lists/listinfo/demoiselle-users. Alm de tirar dvidas bsicas e avanadas, voc poder colaborar com outros usurios.

Infra
Chega de lero-lero e vamos para a prtica, o primeiro passo a preparao do ambiente. Se voc utiliza uma distribuio Linux baseada no Debian, como o Ubuntu, no tem com o que se preocupar, o Demoiselle Infra vai ajudar muito nesta tarefa: 1. Acesse o menu Instalao no site do Infra: http://demoiselle.sourceforge.net/infra. 2. Neste curso convencionamos utilizar a distribuio Linux via APT (Advanced Package Tool). Siga o passa-a-passo e instale o pacote demoiselle-dev. 3. Instale tambm o pacote demoiselle-jboss-6.0. 4. No terminal, rode o comando demoiselle-workspace para poupar tempo com configurao do Eclipse. 5. Abra o Eclipse no menu do sistema: Aplicativos / Desenvolvimento / Demoiselle Eclipse 3.7. 6. Veja que o Eclipse j est todo configurado e voc poupou bastante tempo. Ponto para o Demoiselle! Se usurio de Windows ou outro sistema operacional, precisar montar seu ambiente. No menu Instalao no site do Infra tambm tem a explicao de como montar o ambiente no Windows o onde a instalao feita.

Novo projeto
Agora que o ambiente est instalado, vamos criar o nosso primeiro projeto. nele que experimentaremos as funcionalidades do Framework: 1. No Eclipse, acesse File / New / Project. 2. Agora v em Maven / Maven project e clique em Next duas vezes. 3. Escolha o Catalog Demoiselle. 4. Na listagem, escolha o demoiselle-minimal e clique em Next. 5. Defina o Group Id br.gov.serpro, o Artifact Id inscricao conforme mostrados abaixo e clique em Finish.

6. Aguarde o Maven criar o seu projeto. Voc acabou de utilizar o Maven, uma ferramenta livre que auxilia na criao de projetos. Na realidade ele muito mais que isto, porm tudo que voc precisa saber no momento. No catlogo Demoiselle esto todos os moldes de projeto que fizemos. O Maven denomina-os de archetypes, portanto utilizaremos o termo arqutipos. O demoiselle-minimal o arqutipo que traz o bsico para utilizar o Demoiselle. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=Hq8nPJztXsE ou www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-da-versao2/videos/demoiselle-e-d_-modulo-1-video-1

O que gerou?
No Maven tudo artefato, inclusive este seu novo projeto. Todos os artefatos so identificados pelo Group Id acrescidos do Artifact Id, e foi isto que voc informou para gerao do seu projeto. Seguindo o padro do Maven, seu projeto possui a seguinte estrutura: Pasta src/main/java: aqui ficaro todas as classes do seu projeto. Pasta src/main/resources: armazenar os arquivos de configurao de sua aplicao. Pasta src/test/java: coloque aqui suas classes de teste. Pasta src/test/resources: os arquivos de configurao dos seus testes ficaro aqui. Pasta target: esta uma pasta temporria utilizada exclusivamente pelo Maven para armazenar as classes compiladas e arquivos de configurao processados. Voc no precisa mexer nela. Arquivo pom.xml: configurao do Maven para o seu projeto. Geralmente este arquivo contm muitas informaes, porm, com a utilizao da herana de configuraes, conseguimos torn-lo bem simples para voc. Tudo graas ao demoiselle-minimal-parent.

Abra o pom.xml e d uma olhada. Simples, no?!

Desafio
Vamos incrementar o projeto gerado para criar uma aplicao de verdade. cada mdulo deste curso exploraremos algumas funcionalidades do Framework. O desafio criar um sistema simples de inscrio com as seguintes regras: Possibilitar a matrcula do aluno na turma. O aluno s pode matricular-se uma vez. A turma tem um limite de alunos matriculados.

At o final do curso, voc criar uma aplicao web utilizando JSF, JPA, JTA, CDI e diversas outras siglas. No momento apropriado voc saber o significado de cada uma delas. Um passo de cada vez, assim que vamos evoluir.

Testes
Voc j ouviu falar em TDD? a sigla para Test Driven Development, algo como Desenvolvimento Orientado a (ou Dirigido por) Testes. Resumidamente, a ideia criar os testes antes da soluo propriamente dita (por isso, alguns usam o termo Test First). Em quase todos os mdulos deste curso praticaremos o desenvolvimento orientado a testes. Ento vamos converter as regras da nossa aplicao-desafio em casos de teste: 1. No Eclipse, abra a pasta src/test/java e selecione o pacote br.gov.serpro.inscricao. 2. Acesse o menu v em File / New / Class. 3. Defina o nome da classe TurmaTest e clique em Finish.

4. Crie os mtodos public void matricularAlunoComSucesso(), public void falhaAoTentarMatricularAlunoDuplicado() e public void falhaAoTentarMatricularAlunoNaTurmaCheia(). 5. Anote os mtodos com @Test. A sua classe vai ficar assim:
public class TurmaTest { @Test public void matricularAlunoComSucesso(){ } @Test public void falhaAoTentarMatricularAlunoDuplicado(){ } @Test public void falhaAoTentarMatricularAlunoNaTurmaCheia(){ }

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=nVS21PrmEdM ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-1-video-2

Retrospectiva
O Demoiselle composto por diversos outros projetos. Vimos que o Framework prov vrias funcionalidades que sero exploradas neste curso. Aprendemos como chegar na documentao de referncia e onde pedir ajuda. Preparamos o ambiente de desenvolvimento e criamos o projeto que ser utilizado nos demais mdulos deste curso. Descobrimos os artefatos gerados automaticamente pelo arqutipo demoiselle-minimal e vimos que o pom.xml do projeto ficou bem simples graas s facilidades providas pelo Demoiselle Conhecemos o problema desafio e preparamos o terreno para consolidar os requisitos em forma de testes automatizados. No prximo mdulo, utilizaremos o componente demoiselle-junit experimentando as funcionalidades de log e internacionalizao da aplicao.

Mdulo 2
No mdulo anterior configuramos o ambiente de desenvolvimento e geramos um projeto vazio. Criamos tambm uma classe com a definio de alguns testes. Neste mdulo implementaremos os testes, a soluo e conheceremos algumas funcionalidades do Demoiselle. Se voc ainda no tomou nota, no esquea de guardar o link para as documentaes de referncia nos favoritos do seu browser: http://demoiselle.sourceforge.net/docs. Vale a pena cadastrar-se na lista de usurios tambm: https://lists.sourceforge.net/lists/listinfo/demoiselle-users. Nos prximos mdulos no haver mais citao a estes links. Quem avisa, amigo !

Matrcula
Vamos comear pelo mais simples, a matrcula do aluno. Para facilitar, consideraremos que s existe uma turma. 1. Crie a classe Turma na pasta src/main/java no pacote br.gov.serpro.inscricao. 2. Crie os mtodos public void matricular(String aluno) e public boolean estaMatriculado(String aluno). 3. Apenas corrija os erros de compilao, faa o mtodo estaMatriculado retornar false. Pelo nome dos mtodos voc j imaginou para que servem, no ? Sua classe vai ficar assim:
public class Turma { public void matricular(String aluno){ } public boolean estaMatriculado(String aluno){ return false; } }

Antes de elaborar a soluo, vamos fazer o teste. Abra a classe TurmaTest e implemente o mtodo de teste matricularAlunoComSucesso. Utilizaremos as assertivas do JUnit para verificar se o aluno foi matriculado. Seu teste vai ficar assim:
@Test public void matricularAlunoComSucesso(){ Turma turma = new Turma(); turma.matricular("Santos Dumont"); Assert.assertTrue(turma.estaMatriculado("Santos Dumont")); }

Importe a classe org.junit.Assert. Na linha Assert.assertTrue(turma.estaMatriculado(Santos Dumont)) utilizamos a o mtodo assertTrue do JUnit que verifica se o retorno da chamada turma.estaMatriculado(Santos Dumont) true. Caso no seja, o teste falhar. Rode o teste e veja o resultado: 1. Clique com o boto direito na classe TurmaTest. 2. No menu que apareceu acesse Run As / JUnit Test. O resultado ser este:

Agora implemente a sua soluo na classe Turma. Para facilitar, vamos armazenar os alunos matriculados numa lista. 1. Crie o atributo private List<String> alunosMatriculados = new ArrayList<String>(). 2. Implemente o mtodo matricular que inclui o aluno na lista de matriculados. 3. Implemente o mtodo estaMatriculado que verifica se o aluno est na lista. A classe Turma vai ficar assim:
public class Turma { private List<String> alunosMatriculados = new ArrayList<String>(); public void matricular(String aluno){ alunosMatriculados.add(aluno); } public boolean estaMatriculado(String aluno){ return alunosMatriculados.contains(aluno); }

Rode o teste novamente e perceba que agora vai passar:

Voc deve estar se perguntando: Onde est o Demoiselle neste cdigo?. Por enquanto, em lugar nenhum! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=47lbMgC2tog ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/video-1-do-modulo-2

Logger
Vamos incrementar nossa aplicao. Sempre que um aluno for matriculado o sistema deve gerar um log no console. Se voc pensou em usar System.out.println(), esquea! Esta soluo gera problemas catastrficos de performance, por isso inventaram o Logger. As vantagens de utilizar Logger so vrias: desde melhoria de desempenho em relao ao

preemptivo System.out at flexibilidade no formato do log. Para utilizar, voc precisaria criar o seguinte atributo na classe Turma: private Logger logger = LoggerFactory.getLogger(br.gov.serpro.inscricao.Turma.class); Seria melhor assim: @Inject private Logger logger; Com o Demoiselle voc poder fazer da segunda forma. O que voc precisa saber agora que as duas maneiras so equivalentes, porm na segunda voc est utilizando um recurso importante do Framework: a Injeo de Dependncias. Ento mos obra: 1. Inclua o atributo @Inject private Logger logger na classe Turma. 2. Corrija o erro de compilao, importe a interface org.slf4j.Logger. 3. Acrescente no mtodo matricular a gerao do log utilizando logger.info(...). As modificaes na classe so estas:
... @Inject private Logger logger; public void matricular(String aluno){ ... logger.info("Aluno matriculado com sucesso"); } ...

Rode novamente o teste. Desta vez vai falhar com o seguinte erro: java.lang.NullPointerException na linha que contm logger.info(), na classe Turma. Ou seja, a injeo no funcionou! Em outras palavras, ningum criou uma instncia de org.slf4j.Logger e a atribuiu propriedade logger de Turma. Quem deveria fazer isto? Vamos corrigir isto! 1. Na classe TurmaTest a turma no pode ser instanciada com new. Crie o atributo @Inject private Turma turma. 2. Anote a classe de teste com @RunWith(DemoiselleRunner.class). Injees nos casos de teste no funcionam, pois o JUnit no oferece suporte nativo ao CDI. Por isto criamos o componente demoiselle-junit com a classe br.gov.frameworkdemoiselle.junit.DemoiselleRunner. O componente demoiselle-junit cria um ambiente CDI utilizando o projeto Weld (Implementao de referncia da especificao do CDI) tornando possvel a injeo de dependncias. Feitos todos os ajustes, TurmaTest ficar assim:

@RunWith(DemoiselleRunner.class) public class TurmaTest { @Inject private Turma turma; @Test public void matricularAlunoComSucesso(){ turma.matricular("Santos Dumont"); Assert.assertTrue(turma.estaMatriculado("Santos Dumont")); } ... }

Execute o teste novamente, agora passar. Observe o log gerado no console: 18:17:57,187 INFO [inscricao.Turma] Aluno matriculado com sucesso

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=aR3GJ72HzW8 ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-2-video-2

Injeo de Dependncias
Injeo de dependncia um padro de desenvolvimento utilizado para manter o baixo nvel de acoplamento entre os mdulos da aplicao. Em Java, o conceito foi popularizado por diversos frameworks, tais como: Spring, JBoss Seam, Google Guice e a primeira verso do Demoiselle. Dentre as novidades do JavaEE 6, o mecanismo de injeo de dependncias se tornou padro atravs da JSR-299, comumente referenciada como CDI (Contexts and Dependency Injection). Uma das principais vantagens desse recurso o gerenciamento do ciclo de vida dos objetos pelo container. A anotao @javax.inject.Inject utilizada para solicitar ao container a criao dos seus objetos. Caso seu objeto seja criado com new, o CDI no tomar conhecimento e o gerenciamento do ciclo de vida ser de sua responsabilidade. O Demoiselle 2 permite injetar classes que que no foram originalmente criadas de acordo com a JSR-299, como o caso do org.slf4j.Logger. Se voc estivesse utilizando CDI sem o Demoiselle, voc teria que resolver por conta prpria.

Resource Bundle
Tambm conhecido como I18N, o recurso de internacionalizao permite que a aplicao suporte diversos idiomas. Voc deve estar pensando: Nunca precisei disto na vida!. Ento responda, onde voc guarda as mensagens da aplicao? No prprio cdigo-fonte, em constantes ou em arquivo de mensagens? Sem sombra de dvidas, o pior cenrio espalhar as mensagens pelo cdigo-fonte, o melhor guardar em arquivo.

A plataforma Java prov a classe java.util.ResourceBundle que possibilita a manipulao de arquivos de mensagens, porm no h integrao nativa com CDI. Vejamos como o Demoiselle oferece esta facilidade: 1. Acrescente o atributo @Inject private ResourceBundle bundle na classe Turma. 2. Corrija o erro de compilao, importe a classe java.util.ResourceBundle. 3. Modifique o mtodo matricular para buscar a mensagem utilizando bundle.getString("matricula.sucesso"). 4. Crie o arquivo messages.properties na pasta src/main/resources. 5. Abra o arquivo e inclua a linha matricula.sucesso=Aluno matriculado com sucesso. A classe Turma vai ficar assim:
... @Inject private ResourceBundle bundle; public void matricular(String aluno) { ... logger.info(bundle.getString("matricula.sucesso")); } ...

Rode o teste e verifique que a mensagem continua aparecendo no console. Seria interessante que o log indicasse o aluno matriculado? 1. Abra o arquivo messages.properties. 2. Modifique a linha para ficar assim: matricula.sucesso=Aluno {0} matriculado com sucesso. 3. Abra a classe Turma 4. Exclua o import java.util.ResourceBundle . 5. Acrescente o import br.gov.frameworkdemoiselle.util.ResourceBundle. 6. Passe o parmetro na chamada bundle.getString("matricula.sucesso", aluno). A classe Turma vai ficar assim:
... @Inject private ResourceBundle bundle; public void matricular(String aluno) { ... logger.info(bundle.getString("matricula.sucesso", aluno)); } ...

A classe java.util.ResourceBundle no suporta a passagem de parmetros, por isso o Framework disponibiliza o utilitrio br.gov.frameworkdemoiselle.util.ResourceBundle. O smbolo {0} ser substitudo pelo primeiro parmetro. possvel utilizar chave={1} {2} {3} desde que os parmetros sejam passados no getString, ex: bundle.getString("chave, param1, param2, param3) e

assim por adiante. Mas se voc precisar de uma aplicao multi-idiomas, o quefazer? Recorra ao guia de referncia, pois no vamos aprofundar nesta funcionalidade no curso bsico. Vamos ver outras situaes agora. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=7eOKOeKgtLg ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-2-video-3

Aluno duplicado ou sala cheia

Vamos partir para a implementao dos testes do fluxo de exceo, ou seja, quando a nossa aplicao deve falhar propositalmente. No falhaAoTentarMatricularAlunoDuplicado, espera-se que o mtodo matricular da classe Turma lance java.lang.RuntimeException. Se a exceo no ocorrer o teste falhar automaticamente.
@Test(expected = RuntimeException.class) public void falhaAoTentarMatricularAlunoDuplicado() { turma.matricular("Orville Wright"); turma.matricular("Orville Wright"); }

Convencionando que a turma lota com 5 alunos, vamos implementar o teste falhaAoTentarMatricularAlunoNaTurmaCheia. Seguindo o mesmo raciocnio do teste anterior, o teste falhar caso a matrcula do 6 aluno no gere a exceo esperada.
@Test(expected = RuntimeException.class) public void falhaAoTentarMatricularAlunoNaTurmaCheia() { for (int i = 1; i <= 5; i++) { turma.matricular("Aluno " + i); } turma.matricular("Aluno 6"); }

Rode o teste e observe que ir falhar. A propriedade expected utilizada na anotao @Test indica que para este teste ser executado com sucesso, ele ter que receber uma exceo daquele tipo. Neste caso RuntimeException. Chegou a hora de ajustar o mtodo matricular da classe Turma. O mtodo ficar assim, aps implementar as validaes:
public void matricular(String aluno) { if (estaMatriculado(aluno) || alunosMatriculados.size() == 5) { throw new RuntimeException(); } } ...

Rode novamente o teste, agora tem que passar!

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=xsfGChvezCI ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-2-video-4

Retrospectiva
Implementamos os testes da nossa aplicao. Conhecemos o componente demoiselle-junit que possibilita a injeo nos cases de teste. Experimentamos as facilidades do Demoiselle para manipulao de arquivos de log e internacionalizao do projeto. Comeamos praticar o lanamento de excees. No prximo mdulo aprenderemos como capturlas utilizando as funcionalidades do Framework. Veremos tambm como parametrizar a aplicao com arquivos de configurao.

Mdulo 3
No mdulo anterior experimentamos injeo em casos de testes graas ao componente demoisellejunit. Praticamos injees de Logger e ResourceBundle providas pelo Framework, pois tais elementos no suportam nativamente o CDI. Neste mdulo conheceremos mais funcionalidades do Demoiselle, tais como tratamento de excees e configurao da nossa aplicao. Antes de prosseguir, execute os testes automatizados e garanta que est tudo verde, como quando terminamos o mdulo anterior.

Tratamento de excees
Dando continuidade nossa aplicao, interceptaremos as excees lanadas pelo mtodo matricular da classe Turma. Para cada exceo, um alerta no log. Poderamos fazer isto da seguinte forma: public void matricular(String aluno) { try { ... } catch (RuntimeException e) { logger.warn(...); }
}

Supondo que a classe Turma necessitasse deste tratamento em outros mtodos, como voc faria? Repetiria o cdigo em todos eles? Como esta necessidade muito comum em aplicaes, o Framework oferece um mecanismo de tratamento de excees. 1. Na classe Turma, crie o mtodo public void tratar(RuntimeException e). 2. Anote o mtodo com @ExceptionHandler. 3. Anote a classe Turma com @Controller. 4. No mtodo tratar, adicione o comando logger.warn(bundle.getString("matricula.erro")). 5. No arquivo messages.properties, inclua a linha matricula.erro=Aluno matriculado ou turma cheia. O mtodo tratar ser invocado pelo Demoiselle sempre que uma java.lang.RuntimeException no tratada ocorrer. O nome do mtodo anotado com @ExceptionHandler no segue nenhum padro pr-definido, sugerimos, apenas, que seja intuitivo. A classe Turma vai ficar assim:

@Controller public class Turma { ... @ExceptionHandler public void tratar(RuntimeException e){ logger.warn(bundle.getString("matricula.erro")); } ... }

Rode o teste, vai ficar vermelho. O que aconteceu? O mtodo tratar registrou o alerta e abafou a exceo, no atendendo s regras implementadas nos testes. Faa o seguinte experimento: 1. Inclua a linha throw e no mtodo tratar logo abaixo da linha de logger. 2. Observe o comportamento dos testes. O que aconteceu? Por que aconteceu isso? O mtodo vai ficar assim:
@ExceptionHandler public void tratar(RuntimeException e){ ... throw e; }

O tratador registrou o alerta e passou a exceo lanada adiante, atendendo as especificaes dos testes que estavam esperando exceo. Agora sim ficou verde! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=4_OIj7gK240 ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-3-video-1

Exceo especfica
De acordo com a cartilha de boas prticas no recomendado lanar excees nativas na aplicao. Vamos refatorar nosso projeto para lanar a nossa prpria exceo: 1. Crie a classe TurmaException na pasta src/main/java no pacote br.gov.serpro.inscricao.exception herdando de RuntimeException. 2. Modifique os testes que esperavam RuntimeException e que agora devem esperar TurmaException. A classe TurmaException ficar assim:
public class TurmaException extends RuntimeException { }

As anotaes nos testes ficaro assim:

@Test(expected = TurmaException.class) public void falhaAoTentarMatricularAlunoDuplicado() { ... } @Test(expected = TurmaException.class) public void falhaAoTentarMatricularAlunoNaTurmaCheia() { ... }

Rode os testes, vai falhar! Modifique a implementao da classe Turma para lanar TurmaException ao invs de RuntimeException. Atualize tambm o parmetro do mtodo tratar:
public void matricular(String aluno) { if (...) { throw new TurmaException(); } ... } @ExceptionHandler public void tratar(TurmaException e){ ... }

Agora rode os testes, vai ficar verde! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=GJ4REA1rkgs ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-3-video-2

Configurao da aplicao
A validao no mtodo matricular da classe Turma no est elegante, pois a capacidade da turma est fixa sem a possibilidade de parametrizao: alunosMatriculados.size() == 5 Vamos utilizar mais uma funcionalidade do Framework para incrementar o nosso projeto: 1. Crie o arquivo inscricao.properties na pasta src/main/resources. 2. Acrescente no arquivo a linha capacidade.turma=5. 3. Crie a classe InscricaoConfig na pasta src/main/java no pacote br.gov.serpro.inscricao.config. 4. Anote-a com @Configuration(resource = "inscricao").

5. Acrescente o atributo private int capacidadeTurma. 6. Gere o mtodo public int getCapacidadeTurma() que retorna o respectivo atributo. 7. Abra a classe Turma. 8. Acrescente o atributo @Inject private InscricaoConfig config. 9. Modifique a validao do mtodo matricular para utilizar a configurao. A classe IncricaoConfig ficar assim:
@Configuration(resource = "inscricao") public class InscricaoConfig { private int capacidadeTurma; public int getCapacidadeTurma(){ return capacidadeTurma; }

O parmetro resource = inscricao da anotao @Configuration indica que o arquivo de configurao ser inscricao.properties. Por conveno, o Demoiselle deduz que o atributo capacidadeTurma ser preenchido com o parmetro capacidade.turma do arquivo de configurao. possvel mudar o nome desse parmetro atravs da anotao @Name. Para isto, basta anotar o atributo com @Name(nome.do.atributo) e o nome do parmetro do arquivo de configurao. As modificaes na classe Turma sero:
@Inject private InscricaoConfig config; public void matricular(String aluno) { if (... alunosMatriculados.size() == config.getCapacidadeTurma()) { ... } ... }

Rode os testes, vai ficar verde! Esta funcionalidade do Demoiselle oferece muita flexibilidade e detalhes na configurao. Alm de arquivos de propriedades, voc pode utilizar XML ou variveis de ambiente. Se quiser explorar estes e outros recursos, consulte o guia de referncia do Framework. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=5-MZEOcI9O0 ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-3-video-3

A classe Aluno
Que tal tornar nosso projeto mais elegante? Ao invs de utilizar apenas uma String representando um aluno, vamos criar a classe Aluno!

1. Crie a classe Aluno na pasta src/main/java no pacote br.gov.serpro.inscricao.entity. 2. Acrescente o atributo private String nome. 3. Gere os mtodos get e set para o atributo nome. 4. Crie um construtor vazio. (A especificao JPA exige que toda entidade tenha uma construtor vazio) 5. Crie um construtor com o nome do aluno atribuindo ao respectivo atributo. 6. Crie o mtodo equals conforme a classe abaixo. A entidade Aluno ficar assim:
public class Aluno { private String nome; public Aluno() { } public Aluno(String nome) { this.nome = nome; } @Override public boolean equals(Object outro) { return ((Aluno)outro).nome.equals(this.nome); } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } }

Modifique os testes, substituindo a String pela classe Aluno:

@Test public void matricularAlunoComSucesso(){ Aluno aluno = new Aluno("Santos Dumont"); turma.matricular(aluno); Assert.assertTrue(turma.estaMatriculado(aluno));

@Test(expected = TurmaException.class) public void falhaAoTentarMatricularAlunoDuplicado() { turma.matricular(new Aluno("Orville Wright")); turma.matricular(new Aluno("Orville Wright")); } @Test(expected = TurmaException.class) public void falhaAoTentarMatricularAlunoNaTurmaCheia() { for (int i = 1; i <= 5; i++) { turma.matricular(new Aluno("Aluno " + i)); } turma.matricular(new Aluno("Aluno 6")); }

Modifique tambm o atributo e os mtodos da classe Turma:

private List<Aluno> alunosMatriculados = new ArrayList<Aluno>(); ... public void matricular(Aluno aluno) { ... logger.info(bundle.getString("matricula.sucesso", aluno.getNome())); } public boolean estaMatriculado(Aluno aluno) { ... }

Para finalizar, rode os testes. Tem que passar! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=2xghkTJg1Ww ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriais-daversao-2/videos/modulo-3-video-4

Retrospectiva
Aprendemos as facilidades que o Demoiselle oferece para tratamento de excees. Seguindo boas prticas, criamos uma exceo especfica do projeto. Parametrizamos a aplicao com arquivo de configurao e ajustamos a classe Turma para referenciar estruturas complexas ao invs de String. No prximo mdulo, persistiremos as informaes em um banco de dados. Utilizaremos a extenso demoiselle-jpa para facilitar a nossa vida. Alm disso, experimentaremos o controle transacional provido pelo Framework. At l!

Mdulo 4
No mdulo anterior evolumos bastante nosso projeto. Experimentamos o mecanismo de tratamento de excees e a parametrizao da aplicao atravs do arquivo de configurao. Fizemos refatoraes importantes como a criao da classe Aluno. Neste mdulo vamos explorar as facilidades do Demoiselle para persistncia de dados e controle transacional. Sim, vamos utilizar JPA.

Extenses
O Framework Demoiselle est estruturado em um ncleo (Core) e extenses (Extensions). O ncleo prov funcionalidades bsicas, como todas que vimos at agora. Porm, muitas vezes as aplicaes precisam acessar bancos de dados ou serem acessadas via web, a que entram as extenses. Voc pode estar se perguntando: Por que o Core no oferece funcionalidades de persistncia?. Lembre que o Core o ncleo do Framework, ento tudo que tem nele estar disponvel para todas aplicaes. No recomendvel que o Framework seja impositivo. Onde estaria a liberdade de escolha? E a flexibilidade? Como voc atento e curioso, deve pensar: Ah! Ento o demoiselle-junit uma extenso?. A resposta no! O Framework, composto pelo Core e Extensions, s faz referncias s especificaes (Java Specification Requests - JSR). Como o JUnit no uma especificao, ele no pode ser Extension, e sim um Component.

Dependncias
Vamos agora estender nosso projeto incluindo as dependncias JPA Extension e seus agregados: 1. Abra o arquivo pom.xml. 2. Inclua as dependncias ao demoiselle-jpa, eclipselink e hsqldb. A sesso dependencies do pom.xml vai ficar assim:
<dependencies> <dependency> <groupId>br.gov.frameworkdemoiselle</groupId> <artifactId>demoiselle-jpa</artifactId> </dependency> <dependency> <groupId>org.eclipse.persistence</groupId> <artifactId>eclipselink</artifactId> </dependency> <dependency> <groupId>hsqldb</groupId> <artifactId>hsqldb</artifactId> </dependency> </dependencies>

A dependncia demoiselle-jpa inclui a JPA Extension no seu projeto, porm necessrio escolher o fornecedor da implementao de persistncia. Esta a vantagem das JSRs, voc no fica preso ao fornecedor. Vamos escolher EclipseLink, que a implementao de referncia da especificao (JSR-317), mas poderamos escolher Hibernate ou qualquer outro aderente especificao JPA. O HSQLDB um banco de dados relacional, totalmente escrito em Java, que vai facilitar nossa vida.

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=6Qkp4BDz5tE ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-4-video-1

Entidade
Na JPA as entidades refletem as tabelas no banco. Ento indicaremos que a classe Aluno uma entidade: 1. Abra a classe Aluno. 2. Inclua a anotao @Entity na classe. 3. Acrescente o atributo @Id @GeneratedValue private Integer matricula. 4. Gere os mtodos get e set para o atributo matricula. A entidade Aluno vai ficar assim:
@Entity public class Aluno { @Id @GeneratedValue private Integer matricula; ... public Integer getMatricula() { return matricula; } public void setMatricula(Integer matricula) { this.matricula = matricula; } }

O que fizemos? Indicamos que a entidade Aluno possui uma chave-primria chamada matricula gerada automaticamente e uma coluna chamada nome. No foco deste curso explorar detalhes do mapeamento objeto-relacional da JPA. Vamos seguir com a configurao do persistence.xml: 1. Abra a pasta src/main/resources. 2. Crie o arquivo persistence.xml dentro de META-INF. Copie estas linhas para o seu persistence.xml:

<?xml version="1.0" encoding="UTF-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"> <persistence-unit name="inscricao-ds" transaction-type="RESOURCE_LOCAL"> <class>br.gov.serpro.inscricao.entity.Aluno</class> <properties> <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver" /> <property name="javax.persistence.jdbc.user" value="sa" /> <property name="javax.persistence.jdbc.password" value="" /> <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:mem:." /> <property name="eclipselink.logging.level" value="FINE" /> <property name="eclipselink.ddl-generation" value="create-tables" /> <property name="eclipselink.ddl-generation.output-mode" value="database" /> </properties> </persistence-unit> </persistence>

O persistence.xml o arquivo de configurao da JPA que contm informaes sobre a conexo. O nosso banco HSQLDB armazenar temporariamente os dados na memria, como especificado na propriedade javax.persistence.jdbc.url. Utilizaremos a funcionalidade de criao automtica das estruturas do banco de dados (DDL Generation) do EclipseLink. Tudo configurado, bola pra frente! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=SdqgeEABJwU ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-4-video-2

Gerenciador de entidades
Abra a classe Turma, vamos persistir os dados no banco. 1. Acrescente o atributo @Inject private EntityManager em. 2. Remova o atributo alunosMatriculados. 3. Crie o mtodo private List<Aluno> obterAlunosMatriculados() que obtm os dados persistidos. 4. Ajuste a validao no mtodo matricular que fazia referncia ao atributo removido. 5. Modifique o mtodo matricular para persistir no banco de dados. 6. Modifique o mtodo estaMatriculado para verificar se o aluno est persistido. 7. Importe a classe javax.persistence.Query As modificaes vo deixar a classe Turma assim:

... @Inject private EntityManager em; public void matricular(Aluno aluno) { if (... obterAlunosMatriculados().size() == config.getCapacidadeTurma()) { ... } em.getTransaction().begin(); em.persist(aluno); em.getTransaction().commit(); ... } public boolean estaMatriculado(Aluno aluno) { return obterAlunosMatriculados().contains(aluno); } private List<Aluno> obterAlunosMatriculados() { return em.createQuery("select a from Aluno a").getResultList(); } ...

Fique atento, a injeo do EntityManager no suportada nativamente pela JPA. O Demoiselle prov esta funcionalidade atravs da JPA Extension. Se no fosse pela injeo, voc precisaria escrever algumas linhas de cdigo para obter um EntityManager. O mtodo persist do javax.persistence.EntityManager converte o objeto no comando insert do banco de dados. Para qualquer operao de atualizao, deve-se iniciar (begin) e finalizar (commit) a transao. Na operao de consulta utiliza-se uma linguagem similar ao SQL, porm orientada a objetos. Por fim, rode os testes e viva o verde! Veja no console os comandos SQL que voc no escreveu. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=t-2Qvh0lCBM ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-4-video-3

Controle transacional
Controlar a transao manualmente chato! Portanto delegaremos esta responsabilidade para o Demoiselle: 1. Abra a classe Turma. 2. Anote o mtodo matricular com @Transactional. 3. Remova as linhas em.getTransaction().begin() e em.getTransaction().commit(). O mtodo matricular ficar assim:

@Transactional public void matricular(Aluno aluno) { ... em.persist(aluno); ... }

A anotao @br.gov.frameworkdemoiselle.transaction.Transactional faz com que o Demoiselle abra transao antes da execuo do matricular e finalize aps o seu trmino. Caso ocorra alguma exceo, ser feito rollback automaticamente. Rode os testes e leia a mensagem de erro: br.gov.frameworkdemoiselle.DemoiselleException: Nenhuma transao foi definida. Para utilizar @Transactional preciso definir a estratgia de transao desejada no arquivo beans.xml. Bem intuitiva, no?! As mensagens do Demoiselle te ajudam a resolver o problema. Ento vamos l: 1. Abra a pasta src/main/resources. 2. Abra o arquivo beans.xml que est dentro de META-INF. 3. Defina a alternativa de controle transacional desejada. O beans.xml o arquivo de configurao do CDI. Aps definir a alternativa, ele ficar assim:
... <alternatives> <class>br.gov.frameworkdemoiselle.transaction.JPATransaction</class> </alternatives> ...

A estratgia br.gov.frameworkdemoiselle.transaction.JPATransaction delega o controle para o EntityManager de forma similar a que fizemos manualmente, porm preocupando-se com mais detalhes, como o rollback por exemplo. A JPATransaction mais uma das facilidades providas pela JPA Extension. Rode os testes, agora vai passar! Confira as mensagens do controle transacional no console. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=MFeX9y0QrUA ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-4-video-4

Exceo da aplicao
E se no quisermos que o rollback ocorra automaticamente? Podemos mudar o comportamento do gerenciador de transao: 1. Abra a classe TurmaException. 2. Anote-a com @ApplicationException(rollback = false). A anotao @br.gov.frameworkdemoiselle.exception.ApplicationException deve ser utilizada para

identificar as excees da aplicao. Alm do atributo rollback, existem outras facilidades que sero exploradas nos mdulos seguintes. Rode os testes e analise o console. Perceba que no ocorre mais rollback. Agora que j experimentou, coloque o valor correto no atributo: 1. Abra a classe TurmaException. 2. Ajuste o atributo para rollback = true. A classe TurmaException vai ficar assim:
@ApplicationException(rollback = true) public class TurmaException extends RuntimeException { }

Use a criatividade e refatore o mtodo matricular da classe Turma para explorar melhor o rollback. No modifique os testes, ao final do experimento tem que ficar tudo verde. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=XDLT5Qw2RFs ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-4-video-5

Retrospectiva
Aprendemos como o Demoiselle Framework est dividido (Core e Extensions) e o porqu. Descobrimos a diferena entre Extensions e Components. Partimos para a configurao da persistncia da nossa aplicao utilizando a extenso demoiselle-jpa. Fizemos ajustes no projeto para habilitar o JPA. Modificamos a classe Turma para persistir os dados no banco. Experimentamos o mecanismo de controle transacional do Demoiselle, verificando o funcionamento do rollback com excees da aplicao. No prximo mdulo focaremos na arquitetura da aplicao, dando uma cara mais profissional ao nosso projeto. Faremos diversas refatoraes para adequ-lo arquitetura em camadas.

Mdulo 5
No mdulo anterior adaptamos nosso projeto para persistir as informaes no banco de dados utilizando as facilidades da extenso demoiselle-jpa. Experimentamos o controle transacional do Framework utilizando a estratgia JPATransaction. O Demoiselle prope diversos padres e arquiteturas para sua aplicao. A ideia no obrig-lo a fazer deste ou daquele jeito, e sim apresentar uma sugesto abrangente e facilmente adaptvel s especificidades de cada aplicao.. Cada aplicao pode ter necessidades especficas, por isto necessrio que o Framework seja flexvel. Considerar que seu projeto diferente de tudo que existe, antes de fazer uma anlise mais aprofundada, pode ser um grande equvoco. Constata-se que na maioria das as aplicaes corporativas possuem arquiteturas similares, variando apenas em pequenos detalhes. Neste mdulo vamos refatorar nosso projeto para abordar estas questes.

Camadas
Por enquanto a nossa aplicao no possui diviso em camadas. Note que a classe Turma mistura validaes de negcio com persistncia em banco. Em pequenas aplicaes isto no chega atrapalhar, mas, quando o projeto ganha maiores propores, a falta de organizao impacta negativamente na manutenibilidade e legibilidade do cdigo-fonte. Na figura abaixo representa o estgio atual da nossa aplicao. A partir de agora iremos fazer os ajustes necessrios para criar uma estrutura ilustrada por .

Vamos refatorar nossa aplicao para adequ-la arquitetura em camadas: 1. Abra a classe Turma. 2. Renomeia-a para TurmaBC utilizando as ferramentas de refatorao do Eclipse. 3. Mova a nova classe para o pacote br.gov.serpro.inscricao.business. 4. Substitua a anotao @Controller por @BusinessController. O sufixo sugerido (BC) significa Controlador de Negcio (Business Controller). Um objeto de negcio representa as operaes que podemos fazer sobre uma determinada entidade. A classe TurmaBC sintetiza o que podemos fazer numa turma, tal como matricular ou verificar se um aluno est matriculado. O esteretipo @BusinessController indica que a classe TurmaBC um controlador especfico da camada de negcio. Voc lembra por que utilizamos a anotao @Controller? No?! Ento recorra ao mdulo 3 para refrescar a memria. Com as mudanas a classe TurmaBC vai ficar assim:

@BusinessController public class TurmaBC { ... }

Rode os testes, tem que passar. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=sSioVUMpfuU ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-5-video-1

Agora vamos transpor os detalhes de acesso ao banco para a camada de persistncia. 1. Crie a classe AlunoDAO no pacote br.gov.serpro.inscricao.persistence. 2. Anote-a com @PersistenceController. 3. Crie os mtodos public void insert(Aluno aluno) e public List<Aluno> findAll(). 4. Mova o atributo @Inject private EntityManager em do BC para o DAO. 5. Mova a linha de cdigo em.persist(aluno); do mtodo matricular para o mtodo insert. 6. Em seguida mova a linha return em.createQuery("select a from Aluno a").getResultList(); do mtodo obterAlunosMatriculados para o mtodo findAll. 7. Crie o atributo @Inject private AlunoDAO alunoDAO no BC. 8. Adicione a linha alunoDAO.insert(aluno); ao mtodo matricular. 9. E adicione a linha return alunoDAO.findAll(); ao mtodo obterAlunosMatriculados. Basicamente o que fizemos at agora foi separar as responsabilidades. O BC responsvel pelas regras de negcio e o DAO pela persistncia, via EntityManager. Agora o BC desconhece onde os dados esto sendo persistidos. O acrnimo DAO significa Objeto de Acesso aos Dados (Data Access Objects). Estamos comeando a isolar as coisas! Ao final do processo, os mtodos alterados da TurmaBC vo ficar assim:
@Transactional public void matricular(Aluno aluno) { if (estaMatriculado(aluno) || obterAlunosMatriculados().size() >= config.getCapacidadeTurma()) { throw new TurmaException(); } alunoDAO.insert(aluno); logger.info(bundle.getString("matricula.sucesso", aluno.getNome())); } private List<Aluno> obterAlunosMatriculados() { return alunoDAO.findAll(); }

E a classe AlunoDAO, assim:

@PersistenceController public class AlunoDAO { @Inject private EntityManager em; public void insert(Aluno aluno){ em.persist(aluno); } public List<Aluno> findAll(){ return em.createQuery("select a from Aluno a").getResultList(); } }

Resumo da pera: tornamos uma aplicao monoltica em uma estrutura modularizada . Dai a Csar o que de Csar.

Para garantir que a refatorao foi bem sucedida, rode novamente os testes. Tem que continuar tudo verde. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=V3fidpscGmk ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-5-video-2

Simplificando as coisas
verdade que nossa aplicao est bem simples. de propsito! A inteno no criar regras complexas, explorar o JPA, criar relacionamentos no banco de dados ou dificultar as coisas. Tudo aqui tem uma razo de existir. Se voc est com a mo coando para criar novas entidades, acrescentar relacionamentos ou possibilitar a matrcula de alunos em diversas turmas, controle a ansiedade. Vamos manter a estrutura simples e suficiente para o que precisamos neste momento. Para as regras do nosso projeto, o ato de matricular um aluno nada mais do que persisti-lo numa tabela do banco de dados. Se o aluno est l, convencionamos que ele est matriculado.

CRUD
Voc sabe o que CRUD? a sigla para create, retrieve, update e delete. Em outras palavras, como chamamos as telas de cadastro bsico da aplicao. Vamos conhecer algumas facilidades que o Framework prov: 1. Abra a classe AlunoDAO. 2. Herde de JPACrud<Aluno, Integer>. 3. Apague todos os atributos e mtodos. A classe AlunoDAO vai ficar assim:
@PersistenceController public class AlunoDAO extends JPACrud<Aluno, Integer>{ }

Voc deve estar se perguntando: O que significa <Aluno, Integer>? Isto um recurso da linguagem conhecido como Generics. Assim possvel determinar que AlunoDAO CRUD para a entidade Aluno, a qual possui uma chave-primria do tipo Integer. A classe AlunoDAO herdar os seguintes mtodos previamente implementados em br.gov.frameworkdemoiselle.template.JPACrud: Aluno load(Integer id) void insert(Aluno aluno) void update(Aluno aluno) void delete(Integer id) List<Aluno> findAll()

A classe JPACrud mais uma funcionalidade da extenso demoiselle-jpa. Rode os testes, vai passar! Conceitualmente no recomendado que uma classe de negcio referencie uma classe de persistncia de outra entidade. Na prtica, TurmaBC no deve referenciar AlunoDAO. Vamos fazer os devidos ajustes: 1. Crie a classe AlunoBC no pacote br.gov.serpro.inscricao.business. 2. Anote-a com @BusinessController. 3. Herde de DelegateCrud<Aluno, Integer, AlunoDAO>. 4. Abra a classe TurmaBC. 5. Remova o atributo @Inject private AlunoDAO alunosDAO. 6. Acrescente o atributo @Inject private AlunoBC alunoBC. 7. Modifique os mtodos que esto utilizando alunoDAO para utilizarem alunoBC. A classe AlunoBC vai ficar assim:
@BusinessController public class AlunoBC extends DelegateCrud<Aluno, Integer, AlunoDAO>{ }

A modificao em TurmaBC ser a seguinte:

@BusinessController public class TurmaBC { ... @Inject private AlunoBC alunoBC; @Transactional public void matricular(Aluno aluno) { ... alunoBC.insert(aluno); ... } private List<Aluno> obterAlunosMatriculados() { return alunoBC.findAll(); }

A classe AlunoBC herdar de br.gov.frameworkdemoiselle.template.DelegateCrud, que delega as chamadas para outra classe CRUD, no nosso caso AlunoDAO. Rode os testes, vai passar! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=vOolWUVYvNY ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-5-video-3

Inicializadores e finalizadores
Muitas vezes precisamos executar tarefas na inicializao ou finalizao da aplicao, tais como: Gerar carga inicial Limpar arquivos temporrios Consultar informaes de outro sistema Enviar e-mails Gerar informaes no log

Para capturar os eventos de inicializao e finalizao da aplicao, o Demoiselle disponibiliza as anotaes @Startup e @Shutdown. Para exemplificar, vamos gerar mensagens no log quando a aplicao iniciar e finalizar: 1. Abra a classe TurmaBC. 2. Crie o mtodo @Startup public void iniciar(). 3. Gere uma mensagem informativa utilizando o logger. As modificaes em TurmaBC sero estas:

@BusinessController public class TurmaBC { ... @Startup public void iniciar(){ logger.info("Iniciando ..."); } }

Rode os testes, que continuaro passando, e observe a mensagem no console. 18:00:54,240 INFO [business.TurmaBC] Iniciando Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=-tk4Y3ILYYk ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-5-video-4

Retrospectiva
Aprendemos sobre arquitetura em camadas. Modularizamos a classe Turma e delegamos a manuteno do usurio para as classes UsuarioBC e UsuarioDAO. Renomeamos a classe Turma para TurmaBC. Experimentamos as facilidades providas pelas abstraes JPACrud e DelegateCrud. Criamos um mtodo inicializador em nosso projeto. Nossa aplicao est ficando cada vez mais robusta. No prximo mdulo, iremos garantir o controle de acesso utilizando os recursos providos pelo Demoiselle. Vamos implementar nosso autenticador e autorizador personalizado.

Mdulo 6
No mdulo anterior aprendemos um pouco sobre arquitetura em camadas e refatoramos nossa aplicao. Criamos objetos da camada de negcio, Business Controllers, e da camada de persistncia, Persistence Controllers. Criamos alguns CRUD utilizando as facilidades providas pelo Demoiselle. Neste mdulo iremos incorporar uma soluo que praticamente todas as aplicaes corporativas necessitam, o controle de acesso. Vamos conhecer a funcionalidade do Framework que auxilia a implementao de mecanismos de autenticao e autorizao da aplicao.

Autorizao
A primeira coisa que vamos fazer marcar os pontos crticos da nossa aplicao: 1. Abra a classe TurmaBC. 2. Anote o mtodo matricular com @RequiredPermission(resource = "turma", operation = "matricular"). 3. Anote o mtodo estaMatriculado com @RequiredPermission(resource = "turma", operation = "consultar"). A classe TurmaBC ficar assim:
... @Transactional @RequiredPermission(resource = "turma", operation = "matricular") public void matricular(Aluno aluno) { ... } @RequiredPermission(resource = "turma", operation = "consultar") public boolean estaMatriculado(Aluno aluno) { ... } ...

A anotao @br.gov.frameworkdemoiselle.security.RequiredPermission define um ponto de checagem de segurana. O Framework s permitir que os mtodos anotados sejam executados caso o usurio autenticado tenha permisso. O atributo resource indica o recurso protegido e operation a ao executada sobre o recurso. Poderamos ter escolhido qualquer nome para o recurso ou operaes. Definidos os pontos de checagem, agora implementaremos a classe decisora: 1. Crie a classe Autorizador no pacote br.gov.serpro.inscricao.security implementando a interface br.gov.frameworkdemoiselle.security.Authorizer. 2. Anote a classe com @Alternative do CDI. 3. Crie os mtodos exigidos pela interface. 4. Implemente os mtodos para que retornem true. 5. Inclua no beans.xml sua estratgia de autorizao na sesso de alternativas. A classe Autorizador ficar assim:

@Alternative public class Autorizador implements Authorizer{ @Override public boolean hasPermission(String arg0, String arg1) { return true; } @Override public boolean hasRole(String arg0) { return true; } }

Nosso autorizador ser invocado automaticamente pelo Demoiselle. Se retornarmos true o Framework permitir acesso ao recurso, caso contrrio no. Como no utilizamos a anotao @RequiredRole, o mtodo hasRole no ser invocado. Focaremos ento no hasPermission, que responde pela anotao @RequiredPermission. Os mtodos decisores podem ser implementados de diversas maneiras. possvel decidir com base em arquivo XML, banco de dados, Web Service, consulta a outro sistema, etc. As possibilidades so infinitas. Para facilitar, simplesmente retornaremos true. O beans.xml agora possui duas estratgias definidas: transao e autorizao:
... <alternatives> <class>br.gov.frameworkdemoiselle.transaction.JPATransaction</class> <class>br.gov.serpro.inscricao.security.Autorizador</class> </alternatives> ...

Execute os testes, voc ver o seguinte erro: br.gov.frameworkdemoiselle.DemoiselleException: Nenhum mecanismo de autenticao foi definido. Para utilizar SecurityContext preciso definir o mecanismo de autenticao desejado no arquivo beans.xml. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=kl0Rb98v-Go ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-6-video-1

Autenticao
Para utilizar funcionalidades de autorizao, preciso definir o mecanismo de autenticao. isto que vamos fazer agora: 1. Crie a classe Autenticador no pacote br.gov.serpro.inscricao.security implementando a interface br.gov.frameworkdemoiselle.security.Authenticator. 2. Anote a classe com @Alternative do CDI. 3. Crie os mtodos exigidos pela interface. 4. No mtodo authenticate() retorne true. 5. No mtodo getUser() retorne um novo usurio. 6. Inclua no beans.xml sua estratgia de autenticao na sesso de alternativas. O Autenticador ficar assim:
@Alternative public class Autenticador implements Authenticator{ @Override public boolean authenticate() { return true; } @Override public User getUser() { return new User() { @Override public void setAttribute(Object arg0, Object arg1) { } @Override public String getId() { return null; } @Override public Object getAttribute(Object arg0) { return null; } }; } @Override public void unAuthenticate() { } }

Os mtodos do autenticador sero invocados automaticamente pelo Framework. O authenticate reponder true, indicando que o processo de autenticao foi bem sucedido. O getUser devolver uma instncia de User, representando o usurio autenticado. Em momento algum invocamos o processo de logon, ento vamos ajustar os testes: 1. Abra a classe TurmaTest. 2. Acrescente o atributo @Inject private SecurityContext securityContext.

3. Crie o mtodo @Before public void setUp() que ser invocado pelo JUnit automaticamente antes de cada teste. 4. Implemente o mtodo setUp invocando securityContext.login(). As modificaes na classe TurmaTest sero as seguintes:
... @Inject private SecurityContext securityContext; @Before public void setUp(){ securityContext.login(); } ...

Voc nunca deve invocar o Autenticador diretamente, isto responsabilidade do Demoiselle. Para acessar as funcionalidades de segurana utilize a interface br.gov.frameworkdemoiselle.security.SecurityContext, que dispe dos seguintes mtodos: void login() void logout() boolean isLoggedIn() boolean hasPermission(String resource, String operation) boolean hasRole(String role) User getUser()

Execute os testes novamente, agora tem que ficar tudo verde. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=TGZclhD1mG0 ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-6-video-2

Credenciais
Para o processo de autenticao ser efetivo, fundamental checar as credenciais do usurio. Nunca vi efetuar o logon sem informar senha, certificado, impresso digital ou qualquer outra credencial. Voc j viu?! Evoluiremos nosso processo de autenticao exigindo o nome do usurio e a senha: 1. Crie a classe Credenciais no pacote br.gov.serpro.inscricao.security implementando a interface Serializable. 2. Anote-a com @SessionScoped. 3. Crie os atributos private String nome e private String senha. 4. Gere os mtodos get e set para os atributos.

5. Abra a classe TurmaTest. 6. Acrescente o atributo @Inject private Credenciais credenciais. A classe Credenciais ficar assim:
@SessionScoped public class Credenciais implements Serializable{ private String nome; private String senha; public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getSenha() { return senha; } public void setSenha(String senha) { this.senha = senha; } }

A anotao @javax.enterprise.context.SessionScoped, pertencente ao CDI, mantm a instncia na sesso do usurio. Como precisamos transportar as credenciais, importante que a instncia no seja recriada a cada nova injeo. Para que o armazenamento seja feito automaticamente pelo CDI, preciso implementar a interface java.io.Serializable, caso contrrio ocorrer erro na injeo. No mtodo setUp de TurmaTest, defina o nome do usurio secretaria e a senha segredo. A classe ficar assim:
@Inject private Credenciais credenciais; @Before public void setUp(){ credenciais.setNome("secretaria"); credenciais.setSenha("segredo"); securityContext.login(); }

Para finalizar, faremos os ajustes no autenticador: 1. Abra a classe Autenticador. 2. Acrescente o atributo @Inject private Credenciais credenciais. 3. Implemente a lgica da autenticao. A classe Autenticador ficar assim:

... @Inject private Credenciais credenciais; @Override public boolean authenticate() { boolean autenticado = false; if (credenciais.getNome().equals("secretaria") && credenciais.getSenha().equals("segredo")) { autenticado = true; } return autenticado; } ...

Rode os testes e veja que eles esto passando.

Componentes
Se voc quiser poupar tempo com implementao do mecanismo para controle de acesso, acesse a documentao de referncia dos componentes e veja o que o Demoiselle preparou para voc. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=xFNOVILDxyg ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-6-video-3

Retrospectiva
Aprendemos como o Demoiselle trata alguns conceitos relacionados ao controle de acesso. Implementamos um autenticador e um autorizador personalizado para nossa aplicao. Conhecemos a porta de acesso para as funcionalidades de segurana do Framework, a interface SecurityContext. Experimentamos tambm o gerenciamento de escopo do CDI com a classe Credenciais. No prximo mdulo, vamos converter nosso projeto em uma aplicao web utilizando JSF e o servidor de aplicaes JBoss AS.

Mdulo 7
No mdulo anterior aprendemos o mecanismo de controle de acesso provido pelo Demoiselle para facilitar a implementao de autenticadores e autorizadores. Experimentamos a anotao @RequiredPermission e conhecemos a interface que rene funcionalidades de segurana do Framework, a SecurityContext. Nossa aplicao j atende aos requisitos bsicos da arquitetura em camadas: entidades que transportam dados entre as camadas e separao entre regras de negcio e persistncia dos dados. Nos preocupamos com log, resource bundle, tratamento de excees, persistncia, controle transacional e arquitetura. O que faremos neste mdulo ento? Vamos dar uma cara web ao nosso projeto utilizando JSF.

Arquitetura
At agora validamos as implementaes com casos de teste utilizando JUnit. A partir deste momento focaremos na camada de apresentao, e no mais no negcio ou persistncia. A camada de apresentao responsvel por exibir as funcionalidades implementadas nas camadas internas da aplicao (negcio e persistncia) para o usurio. Uma discusso muito polmica : quem o usurio de nossa aplicao? Depende! Poderamos desenvolver aplicaes destinadas a programadores ou operadores tcnicos, neste caso criaramos bibliotecas de funes ou programas de linha de comando. Outra hiptese seria disponibilizar servios web (Web Services) para serem acessados por outros sistemas (usurios dos servios) atravs de protocolos especficos. Contudo, na maioria das aplicaes corporativas, os usurios no tem intimidade com programao e interagem com o sistema por meio de telas. Em todos os casos estamos falando da camada de apresentao.

Por questes de organizao, recomenda-se que nenhuma camada seja burlada. Em termos prticos, a camada de apresentao acessa a camada de negcio que por sua vez acessa a de persistncia. Perceba que a comunicao entre elas ocorre em apenas um sentido. Isto significa que a camada de persistncia no deve acessar as camadas de negcio ou apresentao, e assim por diante.

MVC
Ns vamos utilizar a especificao JSF (JavaServer Faces) no nosso projeto. O JSF foi criado com o intuito de facilitar a integrao dos elementos web com o mundo Java. Veremos isto na prtica! Assim como diversas outras tecnologias para a camada de apresentao, o JSF implementa o padro MVC (Model-View-Controller). Voc sabe exatamente qual o objetivo do MVC? Para dificultar sua vida? No mesmo! Antes da popularizao do MVC, as aplicaes web pareciam espaguete: elementos HTML misturados com lgica de programao e SQL. Quem j teve o desprazer de trabalhar num ambiente hostil como este sabe exatamente o que estou falando. O MVC surgiu para pr ordem nesta baguna, separando o que visual (View) e o que lgica do negcio (Model). Separar o visual da lgica de negcio no foi suficiente, ainda havia uma costura a fazer. Foi da que surgiu o controlador (Controller) com a responsabilidade de intermediar a comunicao entre os outros dois elementos.

Na prtica, o padro MVC recomenda que o visual, tambm conhecido como viso, no acesse (linha contnua) diretamente a lgica da aplicao, tambm conhecida como modelo. O controlador funciona como uma espcie de pombo correio e implementa o cdigo-cola. Agora sim tem-se as responsabilidades bem definidas: visual (View), lgica (Model) e cola (Controller). Utilizamos na nossa aplicao os esteretipos @BusinessController e @PersistenceController. Seriam eles controladores MVC? No! O sufixo Contoller utilizado pelo Demoiselle para representar os controladores das camadas nada tem a ver com o MVC. Alis, muito comum confundirem MVC com arquitetura em camadas. No seja um deles!

Estrutura
Abra o pom.xml e observe a sesso parent. Nos mdulos anteriores utilizamos o demoiselleminimal-parent. Atualizaremos o nosso projeto para herdar do demoiselle-jsf-parent, que contm uma srie de definies prontas para aplicaes JSF, tais como bibliotecas e configuraes de empacotamento do projeto. 1. Na sesso parent do pom.xml, modifique a entrada demoiselle-minimal-parent da para demoiselle-jsf-parent. 2. Na sesso packaging, modifique a entrada jar para war. 3. Na sesso dependencies, apague EclipseLink e HSQLDB, pois o servidor JEE 6 j prov dependncias equivalentes. 4. Crie a estrutura de pasta src/main/webapp/WEB-INF. 5. Crie o arquivo faces-config.xml vazio na pasta WEB-INF. 6. Crie o arquivo web.xml vazio na pasta WEB-INF. 7. Clique com o boto direito no projeto e acesse Maven / Update Project Configuration. As modificaes no pom.xml sero as seguintes:

... <packaging>war</packaging> <parent> <groupId>br.gov.frameworkdemoiselle</groupId> <artifactId>demoiselle-jsf-parent</artifactId> <version>2.2.0-RC1</version> </parent> ... <dependencies> <dependency> <groupId>br.gov.frameworkdemoiselle</groupId> <artifactId>demoiselle-jpa</artifactId> </dependency> </dependencies> ...

Nossa aplicao est ficando cada vez mais profissional. Informamos ao Maven que nosso projeto deve ser empacotado como war, ou seja, uma aplicao Java web. Ao atualizar as configuraes, o plug-in Maven modificou os artefatos especficos do Eclipse para identificar a aplicao como um projeto web. Faremos agora alguns ajustes. Defina o seguinte contedo para o arquivo de configurao do JSF, o faces-config.xml:
<?xml version="1.0"?> <faces-config version="2.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"> </faces-config>

Deixe o web.xml assim:

<?xml version="1.0"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> </web-app>

Graas s facilidades da especificao JEE 6, ambos arquivos no precisam de configuraes adicionais. Deixe-os assim mesmo: cabealhos XML definidos, porm sem contedo. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=NnKcpNNcEO0 ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-7-video-1

Ol mundo!
Que tal fazermos um Hello World para ver nossa aplicao web rodando? Vamos l! 1. Crie o arquivo index.html na pasta src/main/webapp. 2. Abra o arquivo e escreva Ol mundo!. 3. Acesse a pasta src/main/resources/META-INF. 4. Renomeie o arquivo persistence.xml para persistence.xml.backup. 5. Arraste o seu projeto para o elemento jboss-as-6 da aba Servers. 6. Clique com o boto direito em jboss-as-6 e selecione Start. 7. Aguarde o servidor iniciar. 8. Acesse o endereo http://localhost:8080/inscricao. Para aqueles que no tiveram a frase Ol Mundo! exibida no browser, veja o que h de errado. Ao invs do HTML puro, vamos utilizar recursos JSF. Crie o arquivo turma.xhtml na pasta src/main/webapp com o seguinte contedo:
<html xmlns:f="http://java.sun.com/jsf/core" xmlns:h="http://java.sun.com/jsf/html"> Ol Mundo! </html>

Acesse o endereo http://localhost:8080/inscricao/turma.jsf e veja o resultado. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=GBAk1n3-deg ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-etutoriais/tutoriais-da-versao-2/videos/modulo-7-video-2

Listagem
Criaremos agora uma tela que exibir os alunos matriculados na turma. Faa o seguinte: 1. Crie a classe TurmaMB no pacote br.gov.serpro.inscricao.view. 2. Anote-a com @ViewController. 3. Acrescente o atributo @Inject private TurmaBC bc. 4. Crie o mtodo public List<Aluno> getAlunosMatriculados() que acessa o BC e retorna os alunos matriculados. 5. O mtodo obterAlunosMatriculados() da classe TurmaBC est com private. Altere para public. 6. Acesse a pasta src/main/resources/META-INF. 7. Renomeie o arquivo persistence.xml.backup para persistence.xml. 8. Modifique o persistence.xml para obter a conexo do container JEE 6 e parametrizar o

Hibernate provido nativamente pelo JBoss AS. A classe TurmaMB ficar assim:
@ViewController public class TurmaMB { @Inject private TurmaBC bc; public List<Aluno> getAlunosMatriculados(){ return bc.obterAlunosMatriculados(); } }

E o persistence.xml ficar assim:

<persistence-unit name="inscricao-ds" transaction-type="RESOURCE_LOCAL"> <non-jta-data-source>java:/DefaultDS</non-jta-data-source> <class>br.gov.serpro.inscricao.entity.Aluno</class> <properties> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="false" /> <property name="hibernate.hbm2ddl.auto" value="create-drop" /> </properties> </persistence-unit>

Esta modificao faz com que a aplicao obtenha a conexo com o banco de dados provida pelo servidor. Caso no seja feito desta maneira, o JBoss AS acusar violao da especificao JPA. O valor create-drop definido na configurao far com que o banco seja criado no incio e destrudo na final da aplicao. Partiremos agora para a pgina. Abra o arquivo turma.xhtml e acrescente o seguinte trecho de cdigo que utiliza componentes JSF:
<html xmlns:f="http://java.sun.com/jsf/core" xmlns:h="http://java.sun.com/jsf/html"> <h:body> <h:dataTable id="lista" var="aluno" value="#{turmaMB.alunosMatriculados}"> <h:column> <h:outputText value="#{aluno.matricula}" /> </h:column> <h:column> <h:outputText value="#{aluno.nome}" /> </h:column> </h:dataTable> </h:body> </html>

Observe que cada cada elemento da listagem associado varivel aluno, que utilizada para exibir os dados cada iterao. Re-inicie o servidor e acesse o endereo http://localhost:8080/inscricao/turma.jsf. Como nenhum aluno est matriculado, nada ser listado.

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=u1ZaqmRNJWM ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-etutoriais/tutoriais-da-versao-2/videos/modulo-7-video-3

Matrcula
Como matricular o aluno? Assim: 1. Abra a classe TurmaMB. 2. Acrescente o atributo private String nomeAluno. 3. Gere os mtodos get e set para o atributo nomeAluno. 4. Crie o mtodo public void matricular() sem parmetros que acessa o BC para efetivar a matrcula do aluno. As modificaes na classe TurmaMB sero estas:
@ViewController public class TurmaMB { ... private String nomeAluno; ... public String getNomeAluno() { return nomeAluno; } public void setNomeAluno(String nomeAluno) { this.nomeAluno = nomeAluno; } public void matricular(){ bc.matricular(new Aluno(nomeAluno)); } }

Abra o arquivo turma.xhtml e acrescente o seguinte trecho de cdigo antes da tabela:

... <h:form> Nome do aluno <h:inputText id="nomeAluno" value="#{turmaMB.nomeAluno}"/> <h:commandButton value="Matricular" action="#{turmaMB.matricular}" /> </h:form> ...

Utilizamos mais alguns elementos JSF. O inputText mantm o elemento de tela sincronizado com o atributo nomeAluno da classe TurmaMB, onde os valores sero definidos e obtidos atravs dos mtodos assessores (get e set). A sincronizao ocorrer entre o acionamento do commandButton e a chamada do mtodo action.

Acesse o endereo http://localhost:8080/inscricao/turma.jsf e experimente incluir alguns registros. Veja o que ocorrer! Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=DgZa2Dq4BnQ ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-etutoriais/tutoriais-da-versao-2/videos/modulo-7-video-4

Retrospectiva
Conhecemos a camada de apresentao e vimos cada um dos elementos do MVC. Aprendemos que arquitetura em camadas no a mesma coisa que MVC. Refatoramos nosso projeto para adequar-se aos padres de uma aplicao web. Utilizamos o POM demoiselle-jsf-parent e criamos os arquivos de configurao web.xml e faces-config.xml. Construmos a classe TurmaMB: um controlador MVC integrante da camada de apresentao. Listamos na tela e matriculamos alunos. No prximo mdulo, veremos recursos do Demoiselle para manipulao de mensagens com o usurio e criaremos aplicaes web de forma rpida a partir das facilidades do Framework.

Mdulo 8
No mdulo anterior discutimos sobre o padro MVC e um pouco mais sobre arquitetura em camadas. Refatoramos nosso projeto, agora ele web! Construmos elementos da camada de apresentao e conectamos a tela lgica da aplicao. Listamos e matriculamos alunos. Neste mdulo o ltimo exploraremos a manipulao das mensagens, algumas funcionalidades da extenso JSF e facilidades para criar aplicaes web de forma rpida. Com isto finalizaremos o curso bsico do Demoiselle.

FacesMessage
Muitas vezes precisamos enviar mensagens para o usurio. No caso de aplicaes JSF, esta funcionalidade est disponvel na classe javax.faces.context.FacesContext. 1. Abra a classe TurmaMB. 2. Acrescente o atributo @Inject private FacesContext facesContext. 3. No mtodo matricular lance a mensagem Cadastro realizado com sucesso. 4. Abra o arquivo turma.xhtml e inclua a tag <h:messages /> antes do formulrio. A classe TurmaMB vai ficar assim:
... @Inject private FacesContext facesContext; ... public void matricular() { bc.matricular(new Aluno(nomeAluno)); facesContext.addMessage("sucesso", new FacesMessage("Cadastro realizado com sucesso")); } ...

E turma.xhtml assim:
<html xmlns:f="http://java.sun.com/jsf/core" xmlns:h="http://java.sun.com/jsf/html"> <h:messages /> <h:form> Nome do aluno <h:inputText id="nomeAluno" value="#{turmaMB.nomeAluno}"/> <h:commandButton value="Matricular" action="#{turmaMB.matricular}" /> </h:form> <h:body> <h:dataTable id="lista" var="aluno" value="#{turmaMB.alunosMatriculados}"> <h:column> <h:outputText value="#{aluno.matricula}" /> </h:column> <h:column> <h:outputText value="#{aluno.nome}" /> </h:column> </h:dataTable> </h:body> </html>

Como a injeo do FacesContext no suportada nativamente pelo JSF, o Demoiselle disponibiliza este recurso na extenso demoiselle-jsf. D uma olhada no pom.xml, voc no encontrar nenhuma referncia extenso. Tudo foi definido no demoiselle-jsf-parent e herdado pelo POM da nossa aplicao. Acesse http://localhost:8080/inscricao/turma.jsf, matricule um aluno e veja a mensagem na tela. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=2Dv0dSBq6Vc ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-8-video-1

Mensagem
Supondo que precisssemos disparar mensagens da camada de negcio, e no mais da apresentao, seria considerado um desvio grave na arquitetura se referencissemos o FacesContext um elemento da apresentao na classe TurmaBC. Para suprir esta necessidade, o Demoiselle disponibilizou a interface MessageContext. 1. Abra a classe TurmaBC. 2. Acrescente o atributo @Inject private MessageContext messageContext. 3. No mtodo matricular, lance para o usurio a mesma mensagem gerada no log. 4. Remova o lanamento da mensagem na classe TurmaMB. A classe TurmaBC vai ficar assim:
@Inject private MessageContext messageContext; @Transactional @RequiredPermission(resource = "turma", operation = "matricular") public void matricular(Aluno aluno) { String mensagem = bundle.getString("matricula.sucesso", aluno.getNome()); logger.info(mensagem); messageContext.add(mensagem); } ...

Como br.gov.frameworkdemoiselle.message.MessageContext independe de elementos das camadas, a arquitetura da aplicao ser preservada. As mensagens enfileiradas no MessageContext sero convertidas automaticamente em FacesMessage pela extenso JSF. Acesse http://localhost:8080/inscricao/turma.jsf, matricule um aluno e veja a mensagem na tela.

Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=1uANRAXQ11o ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-8-video-2

Excees
Outra responsabilidade da extenso JSF tratar as excees da aplicao e convert-las em mensagens. 1. Abra a classe TurmaException. 2. Sobrescreva o construtor padro com super(Erro na matrcula!). A classe TurmaException ficar assim:
@ApplicationException(rollback = true) public class TurmaException extends RuntimeException { public TurmaException() { super("Erro na matrcula!"); } }

Como TurmaException uma exceo de aplicao, pois est anotada com @ApplicationException, a extenso JSF far um tratamento especial. Acesse http://localhost:8080/inscricao/turma.jsf, exceda o limite da turma e veja o que ocorre. Terminamos por aqui os experimentos com nossa aplicao. Sinta-se vontade para refator-la, discriminar as falhas (duplicao ou de limite excedido), exibir mensagens mais intuitivas para o usurio, formatar melhor as telas, etc. Confira o vdeo de demonstrao clicando no link abaixo: http://www.youtube.com/watch?v=rS7VdkviKuw ou http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutoriaisda-versao-2/videos/modulo-8-video-3

Arqutipo
No decorrer dos mdulos criamos incrementalmente uma aplicao onde experimentamos diversas funcionalidades do Framework. No mdulo anterior convertemos nosso projeto para a plataforma web aderente s boas prticas de arquitetura em camada e ao padro MVC. No foi um caminho curto, verdade. Por isto, vamos pegar um atalho com o arqutipo demoiselle-jsf-jpa: 1. No ambiente Eclipse, acesse File / New / Project. 2. Agora v em Maven / Maven project e clique em Next duas vezes.

3. Escolha o Catalog Demoiselle. 4. Na listagem, escolha o demoiselle-jsf-jpa e clique em Next. 5. Defina o Group Id br.gov.serpro, o Artifact Id bookmark e clique em Finish. 6. Aguarde o Maven criar o seu novo projeto. Praticamente tudo o que aprendemos ao longo do curso est consolidado neste novo projeto. Ao criar projetos com o arqutipo demoiselle-jsf-jpa, voc leva de brinde um exemplo de CRUD j implementado. Trata-se do cadastro bsico de links favoritos, similar ao bookmark dos navegadores web. Os artefatos gerados serviro como guia para a criao de novas telas, classes e configuraes. Para executar a aplicao gerada pelo arqutipo, faa isso: 1. Arraste o projeto para o elemento jboss-as-6 da aba Servers. 2. Clique com o boto direito em jboss-as-6 e selecione Start. 3. Aguarde o servidor iniciar. 4. Acesse o endereo http://localhost:8080/bookmark A aplicao composta por uma tela inicial, listagem, edio e cadastro de novos de links:

Tela inicial

Tela de listagem

Tela de cadastro/edio

Tomando como base o conhecimento adquirido neste curso, analise todo o cdigo-fonte e arquivos de configurao da aplicao. Voc ser capaz de entender!

Nimble
Durante o desenvolvimento de um projeto nos deparamos com tarefas repetitivas, como criar CRUD por exemplo. Nestes casos o que fazemos copiar e colar algo existente e adapt-lo. um trabalho chato, cansativo e suscetvel a erros. Para facilitar as coisas, nasceu o Nimble: um processador automatizado que gera pginas, classes, arquivos de configurao, etc, com base em templates facilmente adaptveis.

Nos templates so definidos estruturas de pastas, arquivos e scripts de transformao utilizando linguagens como Velocity, Groovy ou FreeMarker. A transformao pode ser parametrizada com variveis previamente definidas. O Nimble prov alguns templates, que voc pode tomar como base para criar o seu. Para saber mais sobre o Demoiselle Nimble acesse http://demoiselle.sourceforge.net/tools/nimble/. L voc aprender como instalar e utilizar esta poderosa ferramenta.

Quero mais
O Demoiselle no termina por aqui. Agora que voc conhece o bsico, que tal aprofundar nos detalhes? Segue algumas indicaes para aprimorar o conhecimento: Guia de Referncia do Framework. Aprenda detalhes sobre cada uma das funcionalidades do Framework (Core + Extensions). Guia de Referncia dos Componentes. Quer conhecer melhor os componentes do Demoiselle? Este o material mais adequado. Blog do Demoiselle. Leia artigos tcnicos sem compromisso com a formalidade que tratam assuntos bem especficos. Voc tem experincias para compartilhar? Seu artigo pode parar aqui! Vdeos no YouTube. Assista aos vdeos prticos e tericos sobre o Demoiselle. Aplicao de exemplo. Baixe e aprenda com o cdigo-fonte da aplicao Contactlist que explora diversos recursos avanados. Lista de Usurios. Quer tirar dvidas e ajudar outras pessoas? Cadastre-se na lista de usurios! Bug Tracker. Descobriu algum erro? Tem sugestes de melhoria? Registre um chamado e torne o projeto cada vez melhor. Portal Institucional. Fique por dentro das notcias sobre o Demoiselle.

Retrospectiva
Neste mdulo experimentamos a funcionalidade de manipulao de mensagens do Framework. Vimos diversas facilidades que a extenso JSF oferece. Criamos uma aplicao web rapidamente utilizando o arqutipo demoiselle-jsf-jpa. Conhecemos o gerador de cdigo baseado em templates, o Demoiselle Nimble. Durante o curso experimentamos diversos recursos que o Demoiselle oferece para facilitar o desenvolvimento de aplicaes JEE 6. No pare por aqui e explore os links indicados na sesso Quero mais. Aguardamos voc na lista de usurios com dvidas e colaboraes para tornar o projeto ainda melhor!