Portal Demoiselle

Determinando o escopo do EntityManager injetado pelo Demoiselle

2013-10-17T11:59:13Z

Um dos recursos da extensão demoiselle-jpa é fornecer um produtor de instâncias de EntityManager e cuidar do ciclo de vida dessas instâncias,providenciando que permaneçam consistentes durante uma chamada de método de negócio e que sejam devidamente fechadas ao final dessa chamada. Até o momento qualquer injeção de EntityManager ficava armazenada no escopo Request, o que significa que durante uma requisição web qualquer ponto de injeção receberá a mesma instância de EntityManager.

Isso é interessante para a maior parte dos casos, mas não permite flexibilidade para contornar situações onde esse comportamento não é desejável. Exemplos de tais situações incluem:

Sistemas não web
Chamadas onde o escopo de requisição não está ativo
Situações que requerem controlar o tempo de vida do EntityManager, para evitar a famosa exceção LazyInitializationException

Começando na versão 2.4 a extensão demoiselle-jpa permitirá determinar o escopo do EntityManager. Além disso ela permitirá desligar o controle de escopo, entregando ao desenvolvedor a tarefa de controlar o ciclo de vida manualmente.

Para demonstrar essa nova funcionalidade, elaboramos um pequeno exemplo do recurso em ação. O aplicativo de exemplo está disponível no repositório do projeto no Github.

Software necessário

Para criar esse exemplo utilizamos os seguintes aplicativos:

Eclipse IDE (Kepler, versão 4.3.1) + Plugin Jboss Tools
Servidor de Aplicação JBoss AS 7.1
JDK da Oracle, versão 6 update 45

Continue lendo nosso passo-a-passo desse novo recurso.

Nosso exemplo

Criaremos um simples exemplo que nos permite evitar o LazyInitializationException ao usar JSF 2.0 e chamadas AJAX. Nosso exemplo permitirá exibir uma lista do tipo master-detail. Cada elemento da lista master possui uma coleção com seus itens detail mas essa lista é anotada para ser carregada do banco de dados apenas quando acessada (a estratégia lazy do JPA). Normalmente ao fazer uma solicitação via AJAX para detalhar um item uma exceção é lançada, pois o EntityManager que gerenciava essas entidades foi destruído com o fim doRequest. Nosso exemplo vai definir o escopo do EntityManager para o escopo de visão (ViewScoped do Demoiselle), de forma que enquanto permanecermos na mesma página, oEntityManager permanecerá ativo.

O primeiro passo é criar uma nova aplicação usando o arquétipo Bookmark. Vamos utilizar a versão 2.4.0-RC1 do framework (após o lançamento da versão 2.4.0-FINAL essa poderá ser usada normalmente). O arquétipo escolhido deve ser o demoiselle-jsf-jpa. Use o groupId “com.jpa” e o artifactId “entitymanager-scope-sample” para essa aplicação. Use o pacote java com.jpa.emscopesample como base da aplicação. Se houver dúvida em como criar um aplicativo usando o arquétipo demoiselle-jsf-jpa, consulte nossa página quickstart.

Após a criação do projeto, você já deve ter um aplicativo totalmente funcional. Teste o aplicativo em um servidor de aplicação antes de continuar. Você deve ver a tela abaixo ao acessar seu aplicativo.

Vamos agora alterar o projeto para configurar o escopo do EntityManager. O primeiro passo é abrir a classe BookmarkBC e remover a anotação @Startup.

Porque devemos fazer isso? Bem, essa anotação executa qualquer método anotado no momento da carga da aplicação. Esse método em particular usa o EntityManager e cria nossa carga inicial de dados. O problema é que vamos alterar o escopo do EntityManager para visão, um escopo que depende da existência de uma chamada à telas JSF para existir. Se deixarmos essa anotação ativa em métodos que usam um EntityManager veremos uma exceção no momento da carga e a aplicação não será iniciada.

Ao invés disso vamos abrir a classe BookmarkListMB e criar um novo método que será responsável pela nossa carga inicial. Abra essa classe e crie o método loadData.

O projeto Bookmark tem apenas uma entidade: a bookmark. Para testarmos o problema de listar dados no formato master-detail precisaremos criar uma nova entidade: a category. Faça as seguintes alterações em seu projeto:

Crie a classe Category no pacote com.jpa.emscopesample.domain.

Edite seu arquivo persistence.xml para declarar a classe Category como uma entidade JPA.

Edite a classe Bookmark para conter uma lista de categorias.

Abra a classe BookmarkBC e edite o método load para incluir pelo menos uma categoria para cada bookmark durante a carga.

Por último edite a tela bookmark_list.xhtml para transforma-la em uma lista master-detail.

Tudo pronto. Agora inicie o JBoss, acesse a aplicação e vá na lista de Bookmarks. Pressione a seta e veja o detalhe de cada bookmark. Tudo parece estar bem. Agora saia dessa tela, acesse-a novamente e tente listar os detalhes. Agora a lista de detalhes está em branco, o que aconteceu?

O primeiro acesso fez a carga inicial de nossos dados e por isso a lista de bookmarks já estava completamente preenchida, mas acessos posteriores ativam a estratégia lazy para carregar a coleção de categorias de cada bookmark. Como o EntityManager é fechado ao concluir a requisição, no momento que o componente datatable tenta usar AJAX para carregar a lista de detalhes, o provedor JPA acusa erro devido ao EntityManager estar fechado. De fato se o console do JBoss for consultado nesse momento é possível ver no log a exceçãoorg.hibernate.LazyInitializationException disparada pelo container.

Esse é o problema que tentamos resolver e a solução está a apenas uma configuração de distância. Abra o arquivo demoiselle.properties e edite/crie a propriedadeframeworkdemoiselle.persistence.entitymanager.scope com o valor view.

		
								frameworkdemoiselle.persistence.entitymanager.scope=view

Basta agora reiniciar o servidor de aplicação. Acesse agora a lista de bookmarks. Não importa quantas vezes a tela for acessada, sempre será possível detalhar um bookmark individual, pois apenas após trocar de visão (de tela) os EntityManager‘s associados àquela visão serão fechados.

Considerações importantes

A seleção de escopo para o EntityManager é um recurso experimental – é importante tomar cuidados especiais ao usar qualquer escopo diferente de request. Seguem os cuidados mais comuns a serem tomados ao usar esse recurso. Lembre-se que na dúvida é melhor deixar o comportamento padrão ativado.

Escopos serializáveis

Os escopos Session, View e Conversation são “passiváveis”, o que significa que a qualquer momento o container pode decidir serializar todos os beans armazenados nesses escopos em disco para liberar memória. De acordo com a especificação um provedor JPA não é obrigado a permitir a serialização do EntityManager e o comportamento dessa operação não é definido.

Para tentar minimizar o risco de problemas ao armazenar o EntityManager nesses escopos, tome as seguintes precauções:

Verifique a documentação de seu container para saber quando e como ele serializa esses escopos: Cheque se é possível controlar o tempo de serialização e se existe alguma forma de detectar essa situação, lhe permitindo encerrar qualquer EntityManager ainda aberto.
Não use trava em suas entidades, ou use a trava OPTIMISTIC_FORCE_INCREMENT: Ao obter uma trava pessimista (uma trava real no banco de dados) essa trava requer uma conexão aberta e acesso direto ao banco para solicitar sua abertura. No momento em que um EntityManager é serializado essa trava é perdida. Por isso se for necessário travar entidades em um sistema cujo EntityManager possa ser serializado, use a trava otimista com versão (OPTIMISTIC_FORCE_INCREMENT) pois essa trava é lógica e a trava só acontece realmente quando a entidade for ser modificada em banco. Leia a documentação da classe javax.persistence.LockModeType para entender a diferença entre as várias travas.

O escopo especial “noscope”

É possível definir o valor da propriedade frameworkdemoiselle.persistence.entitymanager.scope para noscope. Isso significa que o controle do ciclo de vida do EntityManager, uma vez injetado, é de inteira responsabilidade do desenvolvedor. Esse EntityManager não vai participar de transações iniciadas a partir da anotação @Transactional (a não ser que a estratégia JTA seja usada) nem será fechado ao fim do request. Mais: se o desenvolvedor injetar um EntityManager em mais de um ponto de injeção durante um request, cada ponto de injeção gerará uma instância diferente de EntityManager. Use esse recurso com cuidado, seu objetivo é dar maior controle ao ciclo de vida de um EntityManager e seu uso deve ser considerado.

Conclusão

Alterar o escopo do EntityManager é um recurso poderoso – é necessário planejar bem a arquitetura da aplicação que se fará dele. Verifique se um dos problemas listados nesse artigo aparecem em sua aplicação e realize testes para escolher o melhor escopo para configurar seu EntityManager. Consulte a documentação da API e teste o recurso em seu aplicativo. Não esqueça de reportar qualquer dúvida ou problema na lista de discussão e no tracker oficial do projeto.

Autor: Dancovich

Configuração do Framework Java Demoiselle 2.3.1 com Eclipse Indigo sr2 3.7, edição Java Developers (64bits para Mac), JBoss 7.1.1.Final e Postgres 9.2

2013-07-18T18:52:33Z

O projeto Demoiselle-Infra não está disponível para Mac e, por isso, usuários dessa plataforma precisam configurar o ambiente manualmente.

Referências:

Wilson Elias Guimarães Neto -
http://pensandoalgo.wordpress.com/2011/10/19/preparando-o-eclipse-indigo-para-o-demoiselle-2/

Emerson Saito -
http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutorial-da-versao-2-2-3-0/

Emerson Saito -
http://frameworkdemoiselle.wordpress.com/2012/11/13/usando-datasources-conexao-com-base-de-dados-no-jboss-as-7-1-2/

Cleverson Sacramento – http://cleversonsacramento.com/2011/09/10/tela-cheia-no-eclipse-com-lion/

1) Download do Eclipse

URL: http://www.eclipse.org/downloads/packages/release/indigo/sr2

2) Instalação de software e updates do Eclipse

2.1) Clique em “Help” → “Eclipse Marketplace”.

2.2) No Marketplace, pesquise pelas palavras chaves “jboss tools” e instale o plugin para a versão Indigo

2.3) Instalação do Maven:

Seguindo as dicas do Wilson Elias Guimarães Neto, o jeito mais prático é acessar
“File” → “Import”. Pesquise pelo termo “maven” e selecione a opção “Checkout Maven Projects from SCM”. A tela abaixo será exibida. Clique no link “m2e Marketplace”.

Ao clicar no link “m2e Marketplace”, será exibida a tela com as opções disponíveis para instalação. Marque as opções, conforme imagem abaixo, e prossiga.

3) Criação do projeto:

Acesse “File” →”New” → “Project” e selecione a opção “Maven” → “Maven Project”.

Ou, ainda melhor, use os atalhos para evitar “cliques”. Pressione <⌘> + N, digite “maven”, navegue com a seta para baixo até a opção “Maven Project” e pressione a tecla <Enter>.

Avance até chegar na tela abaixo, na qual você deverá clicar no botão “Configure…” para adicionar o repositório de arquétipos maven do demoiselle.

Na tela de configuração de repositórios, adiciona o repositório remoto http://demoiselle.sourceforge.net/repository/archetype-catalog.xml. Pode nomear o repositório como “Demoiselle”, por exemplo.

Uma vez configurado o repositório, selecione o recém incluído catálogo “Demoiselle”, marque a opção “demoiselle-minimal”, conforme figura abaixo, e prossiga.

Informe os dados do projeto. Daqui em diante, pode usar o projeto “Inscrição”, seguindo o tutorial da versão 2.3.1.

A figura abaixo mostra o projeto recém criado. Rode os testes do Hello World e certifique-se de que está tudo certo (o resultado será verde).

4) Instalação do Jboss

Em determinado ponto do tutorial citado acima, você precisará rodar a aplicação no servidor de aplicações JBoss. Se tivéssemos usado o Demoiselle-Infra, já estaria tudo pronto. Porém, teremos que instalar manualmente. Baixe a versão 7.1.1.Final aqui (eu extraí o pacote em /usr/bin/).

Caso ainda não esteja aberta a visualização de servidores, acesse “Window” → “Show View” → “Other”, digite “server” e selecione a opção “servers”, conforme abaixo.

Na visualização de servidores, clique no link “new server wizard”.

Em seguida, deixe selecionada a opção JBoss 7.1, avance à próxima tela e você verá a tela abaixo. Já que o Jboss foi extraído em /usr/bin, então o caminho será /usr/bin/jboss-as-7.1.1.Final. Se você fez tudo certo, basta clicar no botão “Finish”, e seu JBoss 7 estará configurado.

Para usar o console de administração do JBoss 7.1, basta criar usuários com o script add_user.sh. Para isso, digite os seguintes comandos no Terminal:

cd /usr/bin/jboss-as-7.1.1.Final/bin

./add_user.sh

Siga as instruções no prompt de comando.

A figura abaixo ilustra todo o procedimento de criação do usuário.

5) Instalação e configuração do Postgres 9.2

Se você configurou tudo até agora e seguiu o tutorial do Demoiselle, percebeu que os dados não persistem de fato (o banco de dados é recriado a cada execução da aplicação).

O JBoss 7.1 já vem com um DataSource configurado (ExampleDS). E esse DS é referenciado no arquétipo demoiselle-jsf-jpa, por exemplo.

Se você ainda não tem o PostgreSQL instalado, baixe aqui. Recomendo o “One Click Installer”.

Depois, siga o tutorial do Saito, que está bem completo. Apesar de ser referente ao PostgreSQL 9.1, não vi nenhuma diferença com relação à configuração do meu ambiente, com o 9.2. Ele também explica como criar usuário no JBoss, citado no tópico (4) acima.

Segue um resumo do tutorial:

Baixe o driver;

Copie o arquivo para o diretório de deploys do JBoss. No meu caso executei o comando

sudo mv ~/Downloads/postgresql-9.2-1002.jdbc4.jar /usr/bin/jboss-as-7.1.1.Final/standalone/deployments/

Inicie seu servidor JBoss pelo Eclipse

Procure as linhas abaixo no console:

INFO [org.jboss.as.server.deployment] (MSC service thread 1-5) JBAS015876: Starting deployment of “postgresql-9.2-1002.jdbc4.jar”

…

INFO [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-1) JBAS010404: Deploying non-JDBC-compliant driver class org.postgresql.Driver (version 9.2)

Significa que o driver do PostgreSQL foi registrado.

Crie o DataSource java:jboss/datasources/PostgreSqlDS no console de administração web do JBoss, configurando a URL de conexão, que será algo como jdbc:postgresql://localhost:5432/<nome_do_banco_de_dados>. Também será necessário informar um nome de usuário do banco e senha.

Alterar as configurações da aplicação no persistence.xml para usar o novo DataSource criado. Não esqueça também de alterar a propriedade hibernate.hbm2ddl.auto para update.

6) Aplicação de exemplo usando arquétipo demoiselle-vaadin-jpa

Para arrematar, criei uma aplicação de exemplo usando o vaadin. Criei uma validação adicional em CategoryBC antes de salvar novas categorias, criei uma nova Entity chamada Author e adicionei o atributo Author, com o tipoi @ManyToOne, na entitade Bookmark. Super simples e muito legal.

Imagens abaixo:

7) Conclusões

Considerando:

Tudo o que foi descrito acima (pode-se dizer que foi bastante fácil fazer esse aplicativo simples, mesmo no ambiente OS X, bastante distinto do utilizado no Serpro);
A quantidade de material disponível na web sobre o assunto (apesar de ter encontrado bastante material on-line, considero que isso ainda pode melhorar um bocadinho em relação a outros framework, como Django e Rails, principalmente no quesito documentaçao de API contendo exemplos de uso dos métodos das classes do framework);
O fato de que a estrutura de banco é gerada e/ou atualizadas automaticamente de acordo com as entidades da aplicação e conforme são alteradas;
A alta estabilidade observada durante a construção da aplicação de exemplo e execução dos testes, sendo que não foi identificado nenhum erro ou travamento;
A possibilidade de escolher dentre as diferentes implementações disponíveis para as especificações utilizadas pelo framework;

Podemos afirmar, sem medo, que o Demoiselle 2.3.1 é um dos melhores frameworks para construção de aplicativos Web disponíveis no mercado (e estou falando de comparação com Rails e Django que, na minha opinião, são dois dos melhores).

Detalhe: nem cheguei a usar Nimble.

Portanto, framework recomendadíssimo e parabéns à equipe!!!

Autor: arturtupiassu

Usando DataSources (conexão com base de dados) no JBoss AS 7.1.

2013-07-18T18:54:58Z

No post anterior, sobre este mesmo assunto, fizemos um exemplo de uso para configurações de “DataSources “(que são as conexões com bancos de dados gerenciadas pelo servidor de aplicações), usando a versão 6.1 do JBoss-AS com PostgreSQL.

Como muitos já sabem, a evolução do JBoss-AS da versã0 6.x para 7.x é bastante evidente e além das melhorias esperadas, foi necessário mudanças na forma como outros recursos funcionam e por consequência também na forma de configuração tanto dos Datasources como de outras funcionalidades. Mas neste post ficaremos concentrados no DataSource.

Apesar de muito simples e com apoio da interface visual do próprio servidor de aplicações, vamos seguir na linha a mesma linha anterior para apoio ao usuário e demonstrar essa configuração com base em uma aplicação Demoiselle. Desde a versão 2.3.0-Beta1 é possível utilizar o Demoiselle com a versão 7 do JBoss-AS. Mas sempre recomendamos que utilize a versão estável que no caso será a 2.3.0. Versões Beta e RC podem mudar e só devem ser usadas para casos de testes e estudos.

Pré-requistos:

Softwares:

Para este exemplo, foi usada a versão 7.1 do JBoss-AS, em conjunto com a IDE-Eclipse na versão 3.7 (Indigo) com os plugins M2Eclipse e JBoss-Tools correspondentes à esta versão. Recomendamos sempre que seja utililizado o projeto Demoiselle-Infra (http://demoiselle.sourceforge.net/infra/site/install.html) para criação do ambiente de desenvolvimento, pois as configurações já estarão prontas e não serão abordadas neste texto. O Eclipse será utilizado tanto para criação e configuração da aplicação como também para controlar (iniciar/parar) o JBoss-AS.

Também usaremos como exemplo o PostgreSQL como servidor de banco de dados, e neste caso foi usada a versão 9.1. Não abordaremos a configuração e instalação do banco de dados, essa informação pode ser vista neste link: http://wiki.postgresql.org.br/Parte1_Instalando_e_Configurando_o_PostgreSQL

O ambiente operacional usado foi o GNU-Linux Ubuntu, onde não foi necessário nenhuma outra configuração além das descritas na instalação do Demoiselle-Infra.

Configuração do Servidor:

Primeiro faremos a configuração no servidor de aplicações. Uma das tarefas é acessar a aplicação de administração do JBoss 7. Existe uma forma de acessar via terminal e linha de comando, mas neste exemplo usaremos a interface gráfica. Para acessar essa aplicação é preciso de um usuário administrativo, e por “default” o JBoss não traz nenhum pré-configurado por questões de segurança. Para criar esse usuário siga os passos abaixo:

- Abra um terminal de linha de comando (Crtl+Alt+T)

- Acesse a pasta bin da instalação do JBoss:

cd /opt/demoiselle/server/jboss-7.1/bin/

-Execute o comando:

./add-user.sh

- Serão apresentadas as perguntas abaixo:

What type of user do you wish to add?
a) Management User (mgmt-users.properties)
b) Application User (application-users.properties)
(a): [pressione a tecla ENTER para selecionar a opção defalut ]

Enter the details of the new user to add.
Realm (ManagementRealm) : [pressione a tecla ENTER para selecionar a opção defalut ]
Username : admin
Password : [nova senha]
Re-enter Password : [repita nova senha]
The username ‘admin’ is easy to guess
Are you sure you want to add user ‘admin’ yes/no? yes
About to add user ‘admin’ for realm ‘ManagementRealm’
Is this correct yes/no? yes
Added user ‘admin’ to file ‘../../jboss-as-7.1.1.Final/standalone/configuration/mgmt-users.properties’
Added user ‘admin’ to file ‘../../jboss-as-7.1.1.Final/domain/configuration/mgmt-users.properties’

Com isso já temos a configuração de um novo usuário para administrar o servidor.

Será necessário também o driver de conexão (JDBC), que no nosso exemplo é o PostgreSQL: http://jdbc.postgresql.org/download.html

Se for usar outro servidor ou versão do PostgreSQl certifique-se que o driver é padrão JDBC4. Outro tipo não funcionará com o JBoss 7.1.

Coloque este arquivo (.jar) no diretório /opt/demoiselle/server/jboss-7.1/standalone/deployments/ (se estiver usando o Demoiselle-Infra)

Criação de uma aplicação para testes:

Faremos a criação de uma aplicação utilizando um arquétipo do Demoiselle, neste exemplo usamos o demoiselle-jsf-jpa na versão 2.3.0, lembrando novamente que somente a partir da versão 2.3.0 é que o projeto funcionará bem no JBoss-AS 7. Caso tenha alguma dúvida ou dificuldade para criar o projeto veja no primeiro módulo do tutorialhttp://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutorial-da-versao-2-2-3-0/

Abra o Eclipse e execute a criação do projeto: File -> New -> Project -> Maven Project. Selecione o arquétipo conforme mostrado na figura abaixo:

Selecionando arquétipo demoiselle-jsf-jpa versão 2.3.0

Por enquanto, basta criar a aplicação.

Mais à frente faremos as alterações necessárias.

Configurando o Datasource no JBoss7.

Usando o Eclipse, abra a janela Servers onde deverá aparecer o ícone para o JBoss-7.1. Ative o servidor usando o botão “start“, conforme mostra a figura abaixo:

Ativando o servidor JBoss 7.1

Observe também a aba “console”, onde deverão aparecer algumas linhas informando o registro do driver.

INFO [org.jboss.as.server.deployment.scanner] (MSC service thread 1-3) JBAS015012: Started FileSystemDeploymentService for directory /opt/demoiselle/server/jboss-7.1/standalone/deployments
INFO [org.jboss.as] (Controller Boot Thread) JBAS015874: JBoss AS 7.1.0.Final “Thunder” started in 3192ms – Started 135 of 206 services (70 services are passive or on-demand)
INFO [org.jboss.as.server.deployment] (MSC service thread 1-2) JBAS015876: Starting deployment of “postgresql-9.2-1001.jdbc4.jar”
INFO [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-2) JBAS010404: Deploying non-JDBC-compliant driver class org.postgresql.Driver (version 9.2)
INFO [org.jboss.as.server] (DeploymentScanner-threads – 2) JBAS018559: Deployed “postgresql-9.2-1001.jdbc4.jar”

Isso indica que o servidor está ativo e o driver pode ser configurado.

Abra então seu Navegador WEB, e acesse o endereço do servidor JBoss se for local será: http://localhost:8080

Em seguida clique no link “Administration Console“

Acessando console de Administração

Logo na sequência aparecerá a tela para autenticação, lembre-se do usuário e senha que foram criados nos pré-requisitos -> configuração do servidor.

Jboss7 autenticação

Assim, acessamos a parte administrativa do Servidor, nesta página (confirme mostrado na figura abaixo), clique na opção “Datasources” no menu esquerdo. Depois clique no perfil “Profile“, para habilitar as alterações.

Console de Administração do JBoss 7

Com as opções de alteração habilitadas, veremos que já existe um DataSource habilitado que é o famoso ExampleDS que usamos nos arquétipos do Demoiselle. Como já sabemos este é um conector para o HslqDB. Vamos então clicar no botão “Adicionar” ou “Add” caso sua console esteja em inglês.

Interface Administrativa habilitada para criação de um novo DataSource.

Na próxima tela apresentada definiremos o nome do DataSource (ex: PostgreSqlDS) e o JNDI Name (ex: java:jboss/datasources/PostgreSqlDS ). A informação mais importante aqui é o JNDI Name que usaremos depois na configuração da aplicação.

Clique então no botão “Next :>>“

Criando e nomeando o Datasource

A tela seguinte escolheremos o driver para o DataSource, devemos selecionar o que foi incluído para o PostgreSQL quando fizemos o download e colocamos na pasta /deployments, selecione clicando sobre o nome, e depois no botão “Next >>“

Escolhendo driver JDBC4

No próximo passo as informações dependerão do configuração que foi definida para o PostgreSQL, caso o servidor de banco de dados estiver em outra máquina é preciso certificar-se que há permissões de acesso para o usuário a ser usado. E o usuário deverá ter direitos de criação de tabela para nosso exemplo funcionar. No exemplo abaixo, criamos um usuário chamado Demoiselle e um banco de dados com o mesmo nome. Clique no botão “Done“.

Configurações da Conexão

Deverá então aparecer na tela o Datasource que acabamos de configurar, veja na coluna “enabled?” que está mostrando um símbolo que significa que não está habilitado, selecione (clicando sobre a linha do nome) o datasource criado que deverá mostrar o botão “Enable“, conforme destacado na figura abaixo, clique neste para habilitar o serviço.

Datasource criado e selecionado

Será apresentada uma tela de confirmação, basta clicar no botão “Confirm“.

Confirmação da ativação do serviço

Feito isso o ícone na coluna “Enabled?” deverá mudar indicando que o serviço está pronto para ser usado.

Veja que há mais opções de configuração, como por exemplo o Pool de conexões, mas neste exemplo não faremos nenhuma configuração além dessas. Caso se interesse pode trocar idéias na lista de usuários sobre essas características que são importantes para o desempenho da aplicação. Na aba “Connection” é possível executar um teste de conexão para validar as informações antes de configurar a aplicação.

Configurando e executando a aplicação de Exemplo.

Retornemos então ao Eclipse onde temos nossa aplicação de exemplo criada e o servidor já iniciado.

Abra para edição o arquivo: /src/main/resources/META-INF/persistence.xml e encontre a tag abaixo:

<non-jta-data-source>java:jboss/datasources/ExampleDS</non-jta-data-source>

Modifique-a com a informação que foi configurada nos passos anteriores:

<non-jta-data-source>java:jboss/datasources/PostgreSqlDS</non-jta-data-source>

Isso é o que basta para a aplicação usar a conexão recém criada.

Publique a aplicação no servidor JBoss-7.1: basta arrastar o projeto até o item na pasta servers.

No próprio console do Eclipse deverá ser mostrado as informações que identificam que o banco foi criado.

Para testar, basta abrir a aplicação e entrar na página de listagem. ( ex: http://localhost:8080/teste/bookmark_list.jsf)

Como nosso exemplo é usando o PostgreSQL, usamos a ferramenta PGAdmin (http://www.pgadmin.org/) que é bastante útil para verificar a base de dados. Veja na figura abaixo que mostra a tabela da aplicação de exemplo que foi criada.

Visualização do banco PostgreSQL com PGAdmin

Como podemos verificar, é bastante simples a criação de conexões de bancos de dados usando o JBoss-AS 7.

Em caso de dúvidas, procure auxilio na lista de usuários.

Autor: Emerson Sachio Saito

Configuração de conexão com base de dados (DataSources) no JBoss AS.

2013-07-18T18:33:35Z

Percebemos que esta é uma dúvida comum para os desenvolvedores que usam o Demoiselle e que vamos esclarecer um pouco agora.

Como já é bem conhecido, a partir da versão 2 do Demoiselle o padrão para interfaceamento com base de dados é a especificação JPA2. O desenvolvedor quando faz uso do Demoiselle 2 percebe que a recomendação e padrão para a configuração de conexão com banco de dados no arquivo persistence.xml (JPA), têm sido através do uso do recurso do Servidor de aplicações (no caso o JBoss) conhecido como DataSource. Um “DataSource” é um mecanismo com o qual o servidor de aplicações, gerencia o acesso a uma conexão com o banco de dados. Se a aplicação utilizará um servidor de aplicações como o JBoss, nada é mais prático e seguro que usar o recurso que já está disponível e otimizado para esse ambiente. Além disso alguns outros recursos como por exemplo um pool de conexões, são bem mais simples de se configurar. Além disso, em organizações departamentalizadas, onde os ambientes de desenvolvimento, homologação e produção são separados, as configurações de conexão de bancos de dados ficam a cargo de cada um dos setores, o que é positivo para questões como segurança por exemplo.

Mas enfim, o objetivo do post não é justificar ou embasar o uso do recurso, e sim mostra como isso pode ser feito.

Antes de mais nada, partimos do pressuposto que estamos trabalhando como uma aplicação criada pelo arquétipo demoiselle-jsf-jpa (http://demoiselle.sourceforge.net/repository/archetype-catalog.xml). Outra premissa é que a versão do JBoss-AS seja no máximo a 6.1(http://community.jboss.org/wiki/AS610FinalReleaseNotes) pois a partir da versão 7.0 a configuração é um pouco diferente e será tópico de outro post.

Após criada a aplicação na IDE Eclipse (veja como fazer isso em http://demoiselle.sourceforge.net/docs/quickstart/2.0.4/html/ ), devemos localizar o arquivo src/main/resources/META-INF/persistence.xml.

Listando o arquivo persistence.xml, podemos verificar os trechos:

<!– If you are using jboss6 with non JTA transaction then use this persistence-unit –>

<!–

–>

<persistence-unit name=“bookmark-ds” transaction-type=“RESOURCE_LOCAL”>

<non-jta-data-source>java:/DefaultDS</non-jta-data-source>

<class>br.org.frameworkdemoiselle.bookmark.domain.Bookmark</class>

<properties>

<property name=“hibernate.show_sql” value=“true” />

<property name=“hibernate.format_sql” value=“false” />

<property name=“hibernate.hbm2ddl.auto” value=“create-drop” />

<property name=“hibernate.transaction.manager_lookup_class” value=“org.hibernate.transaction.JBossTransactionManagerLookup” />

</properties>

</persistence-unit>

<persistence-unit name=“bookmark-ds” transaction-type=“JTA”>

<jta-data-source>java:/DefaultDS</jta-data-source>

<class>br.org.frameworkdemoiselle.bookmark.domain.Bookmark</class>

<properties>

<property name=“hibernate.show_sql” value=“true” />

<property name=“hibernate.format_sql” value=“false” />

<property name=“hibernate.hbm2ddl.auto” value=“update” />

<property name=“hibernate.transaction.manager_lookup_class” value=“org.hibernate.transaction.JBossTransactionManagerLookup” />

</properties>

</persistence-unit>

As linhas que nos interessam agora são:

<non-jta-data-source>java:/DefaultDS</non-jta-data-source>

<jta-data-source>java:/DefaultDS</jta-data-source>

Neste post não comentaremos sobre a JTA (http://www.oracle.com/technetwork/java/javaee/jta/index.html), mas resumindo a instrução das tag em poucas palavras: non-jta-data-source significa que as transações NÃO serão gerenciadas pelo servidor de aplicações, mas as configurações de conexão serão tratadas (ex: usuário, senha, endereço do servidor de banco de dados) conforme o DataSource. Já a jta-data-source todo o gerenciamento será feito pelo servidor de aplicações. Note que há uma instrução: java:/DefaultDS, isso tem relação com o que está configurado diretamente no servidor de aplicações. Obviamente só podemos definir um tipo de conexão JTA no arquivo de configuração persistence.xml. Para o nosso exemplo a escolha será a jta-data-source.

Dentro da aplicação, isso é tudo que precisamos saber. Sobre as outras tags do persistence.xml você encontrará informações na especificação JPA ou na documentação dos provedores de implementação (ex: Hibernate, EclipseLink). No caso do nosso exemplo, estão sendo utilizadas tags para o Hibernate que é a implementação padrão que já vem com o servidor JBoss.

Agora podemos explorar a configuração no servidor.

Neste exemplo, estamos usando o JBoss 6, mas as configurações e locais são os mesmos para as versões anteriores. Encontre o diretório de Deploy do servidor, para quem utiliza os pacotes do projeto Infra será por exemplo: /opt/demoiselle/server/jboss-6.0/server/default/deploy/ ou para quem está usando cluster: /opt/demoiselle/server/jboss-6.0/server/all/deploy

Neste diretório encontraremos o arquivo hsqldb-ds.xml.

O conteúdo do arquivo descreve uma configuração para o banco de dados Hsqldb (http://hsqldb.org/), que contém a localização do banco, o usuário, senha de acesso e outras informações importantes para a conexão. A informação que nos interessa é a tag:

<jndi-name>DefaultDS</jndi-name>

Essa tag é que está relacionada à instrução que encontramos na aplicação que foi criada anteriormente:

<jta-data-source>java:/DefaultDS</jta-data-source>

Essa relação é estabelecida por Java Naming and Directory Interface (JNDI http://www.oracle.com/technetwork/java/jndi/index.html ), portanto é esse “nome” (no exemplo: DefaultDS) que relaciona a configuração da aplicação à do servidor de aplicações. Quando o servidor de aplicações encontra esse tipo de arquivo faz automaticamente essa conexão. Especificamente no JBoss, podemos ver a instrução na console quando o servidor é iniciado:

INFO [ConnectionFactoryBindingService] Bound ConnectionManager ‘jboss.jca:service=DataSourceBinding,name=DefaultDS’ to JNDI name ‘java:DefaultDS’

Assim, a aplicação gerada pelo arquétipo Demoiselle, faz somente a relação com uma configuração que já é provida por padrão pelo servidor JBoss. Não sendo portanto necessário nenhuma intervenção do desenvolvedor para utilizar essa conexão na aplicação.

Com isso, desvendamos a forma como a aplicação de exemplo do arquétipo Demoiselle utiliza-se do recurso JTA pré-definido no servidor JBoss.

Na prática, não será tão comum utilizar essa configuração padrão, pois é mais habitual que o gerenciador de bando de dados esteja em outro equipamento ou em uma arquitetura mais complexa como um cluster por exemplo. E também há vários gerenciadores de bancos de dados disponíveis no mercado.

Como última dica deste texto, vamos exemplificar a configuração da aplicação para um banco de dados PostgreSQL.

Vamos considerar que o servidor de banco de dados já exista, assim como um usuário de testes.

Para nos ajudar, o JBoss-AS nos oferece um conjunto de exemplos pré-configurados para uma lista de servidores de banco de dados conhecidos no mercado. Estes arquivos podem ser encontrados no diretório de documentos da instalação (/docs/jca). No nosso exemplo usaremos o: /opt/demoiselle/server/jboss-6.0/docs/examples/jca/postgres-ds.xml. Listado abaixo:

<?xml version=“1.0″ encoding=“UTF-8″?>

<!– ===================================================================== –>

<!– –>

<!– JBoss Server Configuration –>

<!– –>

<!– ===================================================================== –>

<!– See http://www.jboss.org/community/wiki/Multiple1PC for information about local-tx-datasource –>

<!– $Id: postgres-ds.xml 97536 2009-12-08 14:05:07Z jesper.pedersen $ –>

<!– ==================================================================== –>

<!– Datasource config for Postgres –>

<!– ==================================================================== –>

<datasources>

<local-tx-datasource>

<jndi-name>PostgresDS</jndi-name>

<connection-url>jdbc:postgresql://[servername]:[port]/[database name]</connection-url>

<driver-class>org.postgresql.Driver</driver-class>

<user-name>x</user-name>

<password>y</password>

<!– sql to call when connection is created. Can be anything, select 1 is valid for PostgreSQL

<new-connection-sql>select 1</new-connection-sql>

–>

<!– sql to call on an existing pooled connection when it is obtained from pool. Can be anything, select 1 is valid for PostgreSQL

<check-valid-connection-sql>select 1</check-valid-connection-sql>

–>

<!– corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) –>

<metadata>

<type-mapping>PostgreSQL 7.2</type-mapping>

</metadata>

</local-tx-datasource>

</datasources>

Aproveitando esse arquivo base, podemos definir e alterar o arquivo para o seguinte exemplo:

<?xml version=“1.0″ encoding=“UTF-8″?>

<datasources>

<local-tx-datasource>

<jndi-name>bookmarkPostgresqlDS</jndi-name>

<connection-url>jdbc:postgresql://10.0.0.1:5432/bookmark</connection-url>

<driver-class>org.postgresql.Driver</driver-class>

<user-name>bookmark</user-name>

<password>bookmark</password>

<min-pool-size>5</min-pool-size>

<max-pool-size>30</max-pool-size>

<idle-timeout-minutes>0</idle-timeout-minutes>

<track-statements/>

<prepared-statement-cache-size>32</prepared-statement-cache-size>

<new-connection-sql>select 1</new-connection-sql>

<check-valid-connection-sql>select 1</check-valid-connection-sql>

<metadata>

<type-mapping>PostgreSQL 8.0</type-mapping>

</metadata>

</local-tx-datasource>

</datasources>

Esse arquivo deverá ser armazenado no mesmo diretório de Deploy onde localizamos o arquivo hsqldb-ds.xml.

Em seguinda devemos alterar a configuração no arquivo para se referenciar a nova configuração persistence.xml para:

<jta-data-source>java:/BookmarkPostgresqlDS</jta-data-source>

Outra coisa ser conferida é o arquivo beans.xml (em /src/main/resources/),

É provável que esteja assim:

<alternatives>
<class>br.gov.frameworkdemoiselle.transaction.JPATransaction</class>

<!–
<class>br.gov.frameworkdemoiselle.transaction.JTATransaction</class>
–>
</alternatives>

Certifique-se que a classe ativa seja a JTATransaction, ficando assim:

<alternatives>
<class>br.gov.frameworkdemoiselle.transaction.JTATransaction</class>
</alternatives>

A última providência, é a lib do driver do banco de dados que estamos utilizando, neste link estão os drivers do PostgreSQL:

http://jdbc.postgresql.org/download.html

Para que a estratégia JTA funcione corretamente, o driver deverá ser incluído diretamente no servidor, assim como é com o datasource, no seguinte diretório:

/opt/demoiselle/server/jboss-6.1/lib/

Com estas alterações a aplicação passará a utilizar o PostgreSQL ao invés do Hsqldb.

Poderíamos utilizar o mesmo nome JNDI: DefaultDS, no lugar de BookmarkPostgresqlDS, e dessa forma não precisar alterar a configuração na aplicação. Mas neste caso teríamos que excluir o arquivo hsqldb-ds.xml, ou alterar a tag <jndi-name> para outro nome. Pois não é possível ter o mesmo JNDI-Name.

Obviamente que cada Gerenciador de Banco de Dados pode ter alguma particularidade com relação à configuração do DataSource, mas geralmente é tarefa do Administrador de Banco de dados ou a área de produção. E mesmo que tudo esteja por conta do desenvolvedor, ainda assim é mais simples do que manter toda a configuração na aplicação.

Autor: Emerson Sachio Saito

Demoiselle 2 com Netbeans e Tomcat

2013-07-18T18:27:43Z

O Demoiselle Framework é construído a partir do conceito de framework integrador, integrando diversas ferramentas utilizadas no mercado Java. Tem como objetivo facilitar o desenvolvimento de aplicações, privando o desenvolvedor de perder tempo escolhendo os frameworksespecialistas que serão usados no seu projeto, resultando grande aumento da produtividade, e facilita a manutenção dos sistemas. Possui mecanismos facilitadores voltados à resolução dos problemas mais comum em uma aplicação, entre eles estão arquitetura, segurança e configuração.

O framework contém uma estrutura não monolítica, ou seja, as funcionalidades estão separadas do núcleo principal, esta forma de organização permite que aplicações específicas não necessitem compor dependências que não serão usadas.

A estrutura do Demoiselle é dividida em Core, que contém as funcionalidades que são comuns a todas aplicações, é a base, o núcleo propriamente dito. Extensões por sua vez são funcionalidades extras extremamente ligadas ao núcleo, porém específicas a um domínio, como é o caso de JPA e JSF, pois algumas aplicações não fazem uso de persistência, não fazendo sentido estar no núcleo. Por fim os Componentes, que são artefatos independentes do núcleo, não precisam estender as funcionalidades do core, têm ciclo de vida próprio, não precisa necessariamente fazer uso do Demoiselle.

Para o gerenciar o projeto é utilizado o Apache Maven, não estando preso a este. Porém uma das vantagens de usar o Maven é a possibilidade de usar os arquétipos, que são modelos de aplicações.

A execução do projeto foi feita utilizando a IDE Netbeans 7.0, justamente pelo maior suporte ao Maven, que nas versões anteriores não é tão completo. Pode ser que funcione com versões anteriores, mas os recursos do maven serão mais precários.

Nosso projeto usará um arquetipo de uma aplicação JSF com JPA. Este arquétipo contém uma aplicação simples de bookmark (links favoritos). A partir desta simples aplicação é possível entender os principais conceitos do Demoiselle.

Agora vamos ao que interessa!!! No Netbeans clique em Novo Projeto, na Categoria Maven selecione Projeto do Arquetipo. Clicando em próximo você visualizará uma tela com vários arquetipos que estão disponíveis nos repositórios do Maven. o Arquetipo do demoiselle não está nestes repositórios. Clique em Adicionar para inserir um arquetipo externo. Os arquétipos disponibilizados pela aquipe do demoiselle estão disponíveis aqui. Os dados abaixo são referentes ao arquetipo demoiselle-jsf-jpa.

groupId: br.gov.frameworkdemoiselle.archetypes
artifactId: demoiselle-jsf-jpa
version: 2.1.2
repository: http://demoiselle.sourceforge.net/repository/release

Selecione o arquétipo criado e clique em próximo. Após informar os dados do projeto clique em Finalizar. Nesta etapa o maven irá indexar os repositórios e baixará as dependências necessárias para o projeto. Pegue um café, pois este processo demora certo tempo.

Após criar o projeto e baixar as dependências, são necessárias algumas configurações para que seja possível rodar o projeto no Tomcat. Para este tutorial foi usado o Tomcat 7 pois é a versão mais nova e que atende maior quantidade de recursos do JEE 6. Podendo não funcionar em versões anteriores.

Primeiramente devemos escolher a configuração do projeto no netbeans, selecione tomcat7 no checkbox que está localizado próximo ao botão executar na barra de ferramentas .

Após isso habilitaremos o listener do Weld (framework para CDI) no arquivo web.xml, devendo ser adicionado o seguinte conteúdo:

		
								<listener>

								    <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>

								</listener>

Provavelmente este trecho apenas estará comentado, bastando apenas remover os comentários.

O próximo arquivo a ser alterado é o persistence.xml, que está localizado na pasta Outros códigos-fonte, em META-INF. Novamente nossa Persistence Unit (Unidade de persistência JPA) estará comentada, descomente a Persistence unit que está localizada abaixo do seguinte comentário: <!–If you are using tomcat6/tomcat7 then use this persistence-unit–>. Esta é a única persistence unit que deve estar neste arquivo.

O arquivo deve ficar com o seguinte conteúdo:

		
								<persistence-unit name="bookmark-ds" transaction-type="RESOURCE_LOCAL">

								    <class>com.mycompany.teste.domain.Bookmark</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:hsql:." />

								        <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>

Na mesma pasta devemos alterar o arquivo beans.xml, para ativar a estratégia de transação JPA do Demoiselle. Deixe apenas uma linha contendo a seguinte entrada:

		
								<alternatives>

								    <class>br.gov.frameworkdemoiselle.transaction.JPATransaction</class>

								</alternatives>

Após estas configurações o projeto estará apto a rodar, o arquétipo vem configurado com uma base de dados padrão que é iniciada com o projeto. O banco de dados utilizado é o HSQLDB.

Para compilar o projeto execute Shift+F11 ou Limpar e Construir, após finalizado este processo você verá no final do console a saída ‘BUILD SUCCESS’. Agora você pode executar seu projeto usando F6 ou Executar. Quando for clicado em executar aparecerá uma mensagem pedindo o servidor onde será executado o projeto. Selecione o Tomcat 7, e marque em lembrar permanentemente.

Sempre que você executar o projeto é indicado que você pare o servidor Tomcat. Pois quando o projeto é compilado, o maven altera alguns arquivos que estão em uso pelo servidor. Gerando um erro de compilação.

Para alterar a base de dados é possível alterar o persistence.xml com as configurações que desejadas e adicionar a dependência do driver JDBC que você quer usar.

Caso haja interesse de interagir com a comunidade demoiselle, acesse o site, onde você pode se inscrever na lista de discussão, o pessoal do demoiselle está sempre ajudando os iniciantes através deste meio. O Demoiselle e sua comunidade estão de parabéns.

Fontes:
Framework Demoiselle 2.0: Guia de Referência: <http://demoiselle.sourceforge.net/docs/reference/2.0-v6/pdf/demoiselle-reference.pdf>

Este artigo foi publicado também no meu blog que pode ser acessado aqui.

Autor: Robson Gian Perassoli

Pretty URL com JSF 2 e Demoiselle 2

2013-07-30T16:42:35Z

http://ocpsoft.com/prettyfaces

Quem aí sabe o que é pretty url, também conhecido como simple url? Há quem chame de url rewrite. Tanto faz! O que importa mesmo é para que serve. Se você não sabe, não deixe de ler este post completo. Se você sabe do que se trata, vou mostrar como implementar na sua aplicação web com JSF 2 e Demoiselle 2.

Recentemente precisei utilizar pretty urls em um projeto com JSF 2 e Demoiselle 2. Então comecei mais uma longa jornada de experimentar diversas soluções do mercado. Achei uma muito prática e simples de usar. Ops… vamos com calma! Que diacho é pretty url?

Ao acessar o Twitter você está usando pretty urls, olha só: http://twitter.com/zyc. Ao escrever “/zyc”, você vai diretamente para a página do usuário “zyc”. Olha outro exemplo: http://americanas.com.br/produto/7107451. Agora que você sabe o que é, vai perceber que é muito comum na Internet. Quer fazer isto na sua aplicação?!

No exemplo utilizei o framework Demoiselle 2 para facilitar minha vida, mas funcionaria em qualquer aplicação com JSF puro também. Criei a aplicação com base no post Iniciando com o Demoiselle 2.0. Com o Maven gerei o projeto a partir do arquétipo demoiselle-jsf-jpa (versão 2.1.0).

Utilizando o arquétipo demoiselle-jsf-jpa

Ao final do processo, minha aplicação estava pronta. O Demoiselle criou o projeto contendo um caso de uso modelo: o bookmark. Trata-se de uma listagem básica e edição dos registros. Ao acessar a página de listagem, a url no navegador finaliza assim: /bookmark_list.jsf. Mas eu gostaria que fosse simplesmente assim: /bookmark. A tela de edição está assim: /bookmark_edit.jsf?id=1. Quero que fique assim: /bookmark/1.

É óbvio que não implementei na mão! Pesquisei e achei várias soluções. As que mais gostei foram: Url Rewrite Filter e PrettyFaces. Optei pela PrettyFaces por quatro motivos: (1) adocumentação está muito bem elaborada; (2) o código-fonte está hospedado no GitHub, o que facilita a evolução do projeto; (3) está mais bem integrado com o Maven e; (4) funciona redondamente com JSF.

Abri o arquivo pom.xml do meu projeto e inclui a seguinte dependência:

		
								<dependency>

								    <groupId>com.ocpsoft</groupId>

								    <artifactId>prettyfaces-jsf2</artifactId>

								    <version>3.3.0</version>

								</dependency>

No web.xml declarei o filtro (opcional para JSF 2):

		
								<filter>

								    <filter-name>Pretty Filter</filter-name>

								    <filter-class>com.ocpsoft.pretty.PrettyFilter</filter-class>

								</filter>

								<filter-mapping>

								    <filter-name>Pretty Filter</filter-name>

								    <url-pattern>/*</url-pattern>

								    <dispatcher>FORWARD</dispatcher>

								    <dispatcher>REQUEST</dispatcher>

								    <dispatcher>ERROR</dispatcher>

								</filter-mapping>

Criei o arquivo pretty-config.xml na pasta WEB-INF com o seguinte conteúdo:

								<pretty-config xmlns="http://ocpsoft.com/prettyfaces/3.3.0"

								    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

								    xsi:schemaLocation="http://ocpsoft.com/prettyfaces/3.3.0 http://ocpsoft.com/xml/ns/prettyfaces/ocpsoft-pretty-faces-3.3.0.xsd">

								    <rewrite match="^/(.*)/$" substitute="/$1" redirect="301" />

								    <url-mapping id="index">

								        <pattern value="/" />

								        <view-id value="/index.jsf" />

								    </url-mapping>

								    <url-mapping id="bookmark-list">

								        <pattern value="/bookmark" />

								        <view-id value="/bookmark_list.jsf" />

								    </url-mapping>

								    <url-mapping id="bookmark-new">

								        <pattern value="/bookmark/new" />

								        <view-id value="/bookmark_edit.jsf" />

								    </url-mapping>

								    <url-mapping id="bookmark-edit">

								        <pattern value="/bookmark/#{id}" />

								        <view-id value="/bookmark_edit.jsf" />

								    </url-mapping>

								</pretty-config>

Utilizei a tag <rewrite> para remover as barras no final da url, caso exista. O primeiro mapeamento define que ao acessar a raiz, a página index.jsf atenderá a requisição. O segundo define a tela de listagem. O terceiro a edição.

Removi o arquivo index.html do projeto e fiz as seguintes modificações no bookmark_list.xhtml:

		
								<!--

								<p:commandButton title="#{messages['button.new']}" image="ui-icon-document" action="#{bookmarkListMB.getNextView}"

								    actionListener="#{bookmarkListMB.clear}" ajax="false" />

								-->

								<p:commandButton title="#{messages['button.new']}" image="ui-icon-document" action="pretty:bookmark-new"

								    actionListener="#{bookmarkListMB.clear}" ajax="false" />

Ainda no bookmark_list.xhtml, substituí a tag <h:commandLink> por <h:link> para possibilitar a passagem do parâmetro id através de query string:

		
								<!--

								<h:commandLink action="#{bookmarkListMB.getNextView}" actionListener="#{bookmarkListMB.clear}">

								    <h:outputText value="#{bean.description}" />

								    <f:param name="id" value="#{bean.id}" />

								</h:commandLink>

								-->

								<h:link outcome="#{bookmarkListMB.nextView}" value="#{bean.description}">

								    <f:param name="id" value="#{bean.id}" />

								</h:link>

Modifiquei as anotações da classe BookmarkListMB para retornar o padrão bonito:

		
								@ViewController

								//@NextView("/bookmark_edit.xhtml")

								//@PreviousView("/bookmark_list.xhtml")

								@NextView("pretty:bookmark-edit")

								@PreviousView("pretty:bookmark-list")

								public class BookmarkListMB extends AbstractListPageBean {

								    ...

								}

E o mesmo para o controlador BookmarkEditMB da tela de edição:

		
								@ViewController

								//@PreviousView("/bookmark_list.xhtml")

								@PreviousView("pretty:bookmark-list")

								public class BookmarkEditMB extends AbstractEditPageBean {

								    ...

								}

Por fim, fiz deploy no JBoss AS 6. A tela de listagem ficou assim:

Listagem de bookmark

A edição assim:

Edição de bookmark

E inclusão:

Inclusão de bookmark

Se quiser dar uma olhada no código-fonte, está disponível no meu repositório GitHub. Se quiser contribuir, faça fork, modifique e depois faça pull request. Toda ajuda será bem vinda

A ferramenta PrettyFaces oferece muitos outros recursos avançados. Para quem se interessou, vale à pena aprofundar nela. O que você achou? Conhece outra ferramenta melhor? Compartilhe sua opinião!

Autor: Cleverson Sacramento

Demoiselle 2 + two-phase commit no Tomcat 6

2013-07-30T16:42:19Z

Olá a todos, meu nome é Danilo Viana, trabalho no Serpro-SSA e este é meu primeiro post contribuindo para o Demoiselle. No momento estou participando de um projeto utilizando Demoiselle 2, Hibernate e two-phase commit, ou seja, precisariamos sincronizar acesso a dois bancos de dados em uma única transação.

Surgiu a possibilidade de nosso projeto não poder utilizar JBoss 6, que possui suporte nativo a two-phase commit através da API XATransaction. Ao invés disso o projeto passaria a executar em Tomcat 6, sem o mesmo suporte nativo. Com o projeto já bastante adiantado e sem possibilidade de voltar atrás em nossa decisão de tecnologia, foi necessário configurar o Tomcat 6 para ter suporte ao Demoiselle 2 utilizando JTA e two-phase commit.

Suporte a JSF 2

O primeiro problema que encontramos foi a implementação da Expression Language utilizada pelo Tomcat 6. No JSF 2 as expressões em EL suportam chamada de métodos com parâmetros mas esse suporte não está presente na biblioteca do Tomcat. Testamos a versão utilizada no Glassfish (disponível no repositório Maven http://download.java.net/maven/glassfish sob o group-id “el-impl”) que funcionou sem problemas.

Baixe via Maven ou acessando o repositório no browser, os arquivos “el-api.jar” e “el-impl.jar”, acesse a pasta [TOMCAT 6]\lib e copie estes arquivos lá, substituindo o arquivo el-api.jar já existente (faça um backup do arquivo original).

Além disso é necessário ensinar o Tomcat a fabricar o objeto que processa instruções EL. Para isso no arquivo “web.xml” do seu projeto web adicione o parâmetro abaixo:

		
								<context-param>

								    <param-name>com.sun.faces.expressionFactory</param-name>

								    <param-value>com.sun.el.ExpressionFactoryImpl</param-value>

								</context-param>

Habilitando two-phase commit

O Tomcat não tem suporte nativo a api XATransaction, que provê suporte a two-phase commit. Para ter este suporte vamos utilizar o framework Atomikos (http://www.atomikos.com), que é livre e está sob licença Apache 2.0

O Atomikos está no repositório geral Maven, então basta acrescentar em seu projeto a dependência à biblioteca “transactions-hibernate3″, que está no group-id “com.atomikos” e seu projeto já poderá utilizar two-phase commit no JPA com Hibernate como persistence provider.

É necessário copiar em seu projeto uma classe que substitui o ObjectFactory original do Tomcat 6, do contrário seu projeto não será capaz de obter instâncias de UserTransaction já que o Tomcat 6 não tem suporte a fornecer objetos dessa classe. Acesse este link do site do Atomikos e copie a classe ou o jar disponibilizado para seu projeto.

Agora para configurar o acesso à conexão. Este é um exemplo de criação de recurso JNDI no arquivo “context.xml”, onde criamos tanto o recurso de acesso à conexões quanto o recurso de acesso à transações via UserTransaction. Note o parâmetro “factory”, que referencia a classe copiada no passo anterior. Note também que estamos utilizando o PostgreSQL como exemplo, pois esse SGBP suporta transações XA, verifique se seu SGBD oferece este suporte.

		
								<Context>

								    <Resource

								        name="jdbc/nome_datasource"

								        auth="Container"

								        type="com.atomikos.jdbc.AtomikosDataSourceBean"

								        factory="com.atomikos.tomcat.BeanFactory"

								        uniqueResourceName="jdbc/nome_datasource"

								        xaDataSourceClassName="org.postgresql.xa.PGXADataSource"

								        xaProperties.databaseName="base_principal"

								        xaProperties.serverName="ip_servidor_banco_principal"

								        xaProperties.user="****"

								        xaProperties.password="****"

								        maxPoolSize="20"

								    />

								    <Resource

								        name="UserTransaction" auth="Container"

								        type="javax.transaction.UserTransaction"

								        factory="com.atomikos.icatch.jta.UserTransactionFactory"

								    />

								</Context>

Utilizando JTA e Hibernate como persistence provider, é necessário incluir os seguintes parâmetros no arquivo “persistence.xml”:

		
								<persistence-unit name="unidade_persistencia">

								    <jta-data-source>java:comp/env/jdbc/nome_datasource</jta-data-source>

								    <properties>

								        <!--...-->

								        <property name="hibernate.transaction.manager_lookup_class" value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" />

								        <!--...-->

								    </properties>

								</persistence-unit>

Caso esteja utilizando Hibernate nativo, sem o JTA, estas configurações devem estar presentes em seu arquivo “hibernate.cfg.xml”:

		
								<property name="hibernate.connection.datasource">java:comp/env/jdbc/nome_datasource</property>

								<property name="hibernate.transaction.manager_lookup_class">com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup</property>

								<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JTATransactionFactory</property>

								<property name="jta.UserTransaction">java:comp/env/UserTransaction</property>

Por último, o Demoiselle 2 não está preparado para produzir instâncias de UserTransaction para Tomcat 6, então por ora é necessário acrescentar ao seu projeto um produtor deUserTransaction através da anotação @Produces.

Crie a classe abaixo em seu projeto, o pacote não é importante, mas note a anotação @Produces, ela vai indicar ao CDI que esta classe é responsável por produzir instâncias deUserTransaction.

		
								package com.tomcat6.usertransactionsupport;

								import javax.enterprise.inject.Produces;

								import javax.naming.Context;

								import javax.naming.InitialContext;

								import javax.naming.NamingException;

								import javax.transaction.UserTransaction;

								/**

								* Classe responsável por produzir UserTransactions no Tomcat 6, pois

								* o Demoiselle 2 não produz estas classes normalmente em um ambiente Tomcat.

								*/

								public class TomcatUserTransactionProducer {

								@Produces

								public UserTransaction create() {

								UserTransaction transaction = null;

								try {

								Context context = new InitialContext();

								transaction = (UserTransaction) context.lookup("java:comp/env/UserTransaction");

								} catch (NamingException e) {

								e.printStackTrace();

								}

								return transaction;

								}

								}

Conclusão

Com esses passos você será capaz de utilizar JSF 2 e two-phase commit no Tomcat 6. Se você está desenvolvendo um sistema com estes requisitos mas não pode utilizar um container com suporte nativo a estas funcionalidades, ou acredita que o JBoss é muito pesado e seu projeto simples não necessita de tanto, esta solução pode ser o que você procura.

Autor: Dancovich