Baixe este projeto https://github.com/gugawag/projeto-base-jsf2-rich4-jpa2-ejb3.1 e leia o arquivo LEIAME.txt.

Anúncios

H2 é o banco de dados que vem pre-configurado no JBoss 7. Ele é leve, e permite salvar seus dados tanto na memória quanto em disco.

O padrão no JBoss 7 é o H2 salvar em memória. O problema é que para boa parte das disciplinas que leciono os alunos querem salvar seus dados de testes nos sistemas que desenvolvem de forma permanente. Para isso, abaixo vou mostrar como criar um datasource H2 que salve em disco.

Configurando Datasources no JBoss 7

O JBoss 7 vem com dois modelos de start: domain e standalone. Não vou entrar em detalhes em nenhum dos dois, mas usarei o standalone (modo de start padrão para quem quer fazer aplicações para testes) como base para este post.

Para configurar um datasource no standalone, abra o arquivo */jboss-as-web-7.0.0.*/standalone/configuration/standalone.xml. Procure por H2 e você irá encontrar algo parecido com isso abaixo na área datasources:

 <datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="H2DS" enabled="true" jta="true" use-java-context="true" use-ccm="true">
<connection-url>
jdbc:h2:mem:test;DB_CLOSE_DELAY=-1
</connection-url>
<driver>h2</driver>
<pool>
 <prefill>
  false
 </prefill>
 <use-strict-min>
  false
 </use-strict-min>
 <flush-strategy>
  FailingConnectionOnly
 </flush-strategy>

</pool>
<security>
 <user-name>
  sa
 </user-name>
 <password>
  sa
 </password>
</security>
...

Perceba que esta é uma configuração do banco de dados H2 em memória, devido à connection-url ser: jdbc:h2:mem:*. A palavra mem está definindo que é um banco de dados em memória, ou seja, não serão persistidos os dados após término da aplicação/jboss. Para alterar isso:

  1. faça uma cópia de todo <datasource>…</datasource> e cole dentro da tag <datasources…> </datasources>;
  2. altere a valor da tag connection-url de jdbc:h2:mem:test para jdbc:h2:˜/test
  3. altere o jndi-name da tag <datasource para jndi-name=”java:jboss/datasources/testDS”
  4. Remova o valor da tag <password>, pois não há senha para este banco.
Para referenciar este datasource no persistence.xml de sua aplicação, basta colocar no <jta-data-source> (se você estiver usando jta):<jta-data-source>java:jboss/datasources/testDS</jta-data-source>

Perceba que se seu persistence.xml estiver referenciando o datasource com outro nome, você terá que alterar para o nome que você acabou de definir no arquivo standalone.xml.

A connection-url jdbc:h2:˜/test significa que será criado um arquivo test.h2.db (representa o banco de dados. São criados outros arquivos [test.trace.db e test.lock.db]) no home do usuário. Se você quiser especificar outro caminho, basta alterar o ~ para um outro path, tipo: jdbc:h2:/tmp/test.

Consultando o banco via SQL padrão (no browser)

Para fazer consultas ao banco de dados pelo browser (é necessário que não haja qualquer lock ao banco de dados, ou seja, precisa parar de executar o JBoss):

  • Na linha de comando, vá para pasta: {jboss-7}/modules/com/h2database/h2/main;
  • Execute a linha: java -jar h2*.jar

Será aberto o browser padrão. No campo JDBC URL, digite a connection-url configurada acima: jdbc:h2:~/test (se você configurou outra connection-url, leve em consideração a sua). Clique em conectar e faça pesquisas. Perceba que a linguagem SQL de pesquisa é a padrão, e não JPQL ou HQL.

Para configurar um banco de dados diferente do H2, vide: http://community.jboss.org/wiki/DataSourceConfigurationInAS7

Esse post tem por finalidade configurar um ambiente de desenvolvimento para o JEE 6, utilizando a tecnologias:

e mostrar ao final o desenvolvimento de um servlet.

Tomo como padrão que se tenha instalado jdk 6 ou superior. Se você não o tem baixar aqui.

JBoss 7

Esta versão do JBoss vem por padrão com a configuração lightning, iniciando apenas os serviços básicos e fazendo com que os outros sejam executados sob demanda. O resultado disso é um startup muito rápido, em torno dos 4s, dependendo do computador. Para saber mais sobre essa versão do JBoss, clique aqui.

Para instalar o JBoss, basta baixá-lo em Servidor de Aplicação JBoss 7 versão comunidade e descompactá-lo (é independente de sistema operacional). Sugiro criar um pasta java em seu computador e descompactá-lo lá.

Para executar o JBoss pela linha de comando:

  • cd [pasta_jboss]/bin
  • standalone.bat (windows) ou ./standalone.sh (mac e linux)
Uma tela típica de início do JBoss é similar à de abaixo. Perceba que existe uma linha, ao final, informando o tempo de start do JBoss. Para ver a tela de boas vindas do JBoss no browser, digite na url: http://localhost:8080/ (se você deixou como padrão a porta 8080).
Após instalarmos o Eclipse Indigo vamos aprender a executar o JBoss por dentro dele.

Eclipse Indigo (3.7)

Baixe o Eclipse em IDE Eclipse Indigo (3.7) para desenvolvedores JEE. Escolha a versão correspondente ao sistema operacional. Execute o instalador.

JBoss Tools 3.3

Execute o Eclipse.



  • escolha na lista Work With: o JBoss Tools
  • escolha a opção All JBoss Tools 3.3

  • clique em next, aceite os termos da licença e vá clicando next até a conclusão da instalação. Dependendo da velocidade de sua rede pode demorar alguns minutos. Ao final, será preciso reiniciar o Eclipse

Acrescentando o JBoss ao Eclipse

  • clique em Windows -> Show View -> Servers
  • clique com o botão direito na área dos servidores e clique em New -> Server
  • escolha a opção JBoss AS 7.0 e clique em Next
  • em Home Directory escolha a pasta de instalação do seu JBoss (se vc seguiu minha recomendação, deverá estar em c:\java\[pasta_jboss]
  • Clique em Finish
Perceba que na aba Servers haverá o jboss que você inseriu, podendo ser executado pelo botão de Run (bola verde ao lado de um besouro no canto direito [este serve para executar o JBoss em modo debug]).

Primeira aplicação Web JEE 6

Para criar um projeto web no Eclipse:

  • clique em File -> New -> Project….
  • na opção web, escolha Dynamic Web Project
  • clique em Next
  • dê um no nome ao seu projeto e clique em Finish


Para criarmos um servlet (soma entre dois números), nesta versão do JEE ficou bem mais fácil, já que foram desenvolvidas várias anotações para diminuir a quantidade de configurações no web.xml.
Como boa prática, crie um pacote na pasta src em Java Resources do seu projeto. No meu caso criarei o pacote com.gugawag.aulas.servlets. Clique com o botão direito em cima dele e clique em New -> Servlet.
  • Dê um nome à classe do servlet. Costumo dar o nome com o sufixo Servlet
  • clique em Next
  • clique no URL Mapping (como seu servlet será chamado na URL) e edite o /SomaServlet
  • mude para /soma.do (isso não muda o servlet. Apenas padroniza a forma de chamá-los. Use o prefixo da sua escolha. Uso normalmente .do)
  • clique em Next
  • dos métodos a serem sobrescritos, deixe marcado apenas o doGet
  • clique em Finish
No método doGet, insira as linhas abaixo:
int numero1 = Integer.parseInt(request.getParameter("numero1"));
 int numero2 = Integer.parseInt(request.getParameter("numero2"));

PrintWriter out = response.getWriter();

out.write("A soma desses números é: " + (numero1 + numero2));

O Servlet deve ficar como mostrado na figura abaixo. Perceba o uso da anotação @WebServlet. É nela que se define como o seu servlet será chamado na url (/soma.do), o URL Mapping como visto em passo anterior.

Para executar esse sistema, clique com o botão direito em cima do projeto -> Run as -> Run on server. Um browser interno do eclipse aparecerá. O eclipse irá implantar o sistema (.war) no JBoss. Para ver o resultado desta implantação, olhe o log da aba Console. Se o JBoss ainda não estiver executando, o eclipse fará o trabalho.

Para testar o servlet, na área de url do browser do eclipse, ou de um browser a sua escolha, digite:

http://localhost:8080/ExemplosServlets/soma.do?numero1=10&numero2=5

Troque nesta url o nome do projeto ExemplosServlets pelo nome do projeto que você escolheu. Altere os valores passados para os parâmetros numero1 e numero2 a sua escolha. Um resultado similar à imagem abaixo deve aparecer.

Neste link você pode baixar o projeto no Eclipse deste servlet.

Estive lá. Algumas fotos do ambiente. O desespero foi tão grande que alguns pensaram em pular. :/ Mas sobrevivemos.

Visual JSF no Netbeans

outubro 26, 2009

Introdução

Esse mini-tutorial tem o intuito de servir como pontapé inicial ao desenvolvimento de JSF com o plugin visual do NetBeans. Veja que não é intuito explicar JSF, e sim, e tão apenas, mostrar como usar o Visual JSF. A versão do NetBeans que estamos utilizando para esse blog é a 6.7.1.

Instalando os plugins necessários

Inicialmente, é necessário que se instale os plugins para desenvolvimento de aplicações com o Visual JSF. Para fazer isso, siga os seguintes passos:

  1. Vá em Ferramentas -> Plugins;
  2. Clique na aba Plugins Disponíveis;
  3. Coloque o cursor na área de Pesquisa no canto direito e digite Visual JSF;
  4. Escolhe, dos plugins que aparecem, o Visual JSF e Visual JSF Runtime;
  5. Clique no botão Instalar;

Configurando um projeto com o Visual JSF

Após instalados os plugins, iremos criar um projeto web com o Visual JSF. Para isto, siga os passos abaixo:

  1. Clique em Arquivo -> Novo Projeto;
  2. Em Categorias escolha Java Web e em Projetos escolha Aplicação Web;
  3. Clique no botão Seguinte (Next);
  4. Digite o nome do projeto, escolha o nome do pacote padrão e clique em Seguinte;
  5. Nos plugins disponíveis, selecione Visual Web JSF e clique em Finalizar.

Um projeto é criado com uma estrutura similar a mostrada nas figuras abaixo:

Estrutura projeto Visual JSF 1.

Estrutura projeto Visual JSF 1.

Estrutura projeto Visual JSF 2.

Estrutura projeto Visual JSF 2.

Veja que a primeira figura mostra as páginas web, neste caso a Page1, que é criada como padrão, e a segunda figura mostra a estrutura de código em Java. Veja que, também por padrão, o plugin do Visual JSF cria para você 4 backing beans (BB): um backing bean chamado Page1, representando o BB  da Page1.jsp, e os BBs ApplicationBean1, SessionBean1 e RequestBean1, representando, respectivamente, BBs de Aplicação, Sessão e Requisição. Você pode criar outros BBs e configurá-los no faces-config.xml. O plugin gera esses BBs apenas para facilitar a vida do programador, não sendo este obrigado a usá-los.

Criando Páginas Web

Para criar uma nova página, siga os passos da figura abaixo.

criandoPaginaVJsf1

Escolha o nome da página, o pacote onde o backing bean da página irá ficar e clique em finalizar. Veja que o nome do BB, por padrão, é o mesmo nome da página. Para alterar é necessário mudar no faces-config.xml.

Após criada a página a tela abaixo é mostrada.

editorVisual

Ela representa a área visual de sua página. Tudo que você colocar aí, visualmente, será mostrado na mesma posição e com as mesmas configurações escolhidas, ou seja, esse é um editor wysiwyg (What You See Is What You Get). Perceba na figura que o botão Design no canto esquerdo superior está selecionado, que é exatamente a visão de design que temos. Se quisermos visualizar o JSP (ou JSF, como queira) por trás dessa tela, clique em JSP. Se você quiser ver o BB desta página, clique em Java. Isso tudo serve para diminuir o temp0 de desenvolvimento com opções de edição integradas.

Configurando componentes em páginas web

Para adicionar componentes a uma página, basta clicar no componente JSF na paleta do lado direito do editor, quanto estiver no modo de visualização Design, e arrastar e soltar na área que se deseja da página, como pode ser visto na figura abaixo. Na paleta propriedades pode-se configurar qualquer propriedade do componente. Isso facilita a vida do programador JSF, pois não é mais necessário fazer isso em código.

Screen shot 2009-10-26 at 4.18.17 PM

Fazendo binding de componentes

Para se fazer o binding do componente com o BB, ou faz-se no próprio código JSF ou visualmente, clicando com o botão direito do mouse em cima do componente e escolhendo a opção Add Binding Attribute (traduza se seu Netbeans estiver em português), como mostrado na figura abaixo.

Acrescentando binding attribute

A partir deste momento este componente está referenciando no BB desta página (veja figura abaixo), podendo ser editado da forma que se aprover.

Screen shot 2009-10-26 at 4.26.21 PM

Trabalhando com o componente Table

Para se trabalhar com o componente Table, inicialmente clique na paleta de componentes Woodstock Basic, selecione o componente Table, arraste e solte na área que se deseja na página (Veja figura abaixo).

Screen shot 2009-10-26 at 4.27.33 PM

Para se configurar quais elementos irão ser mostrados nas colunas, é necessário configurar o layout da tabela. Para isso, clique com botão direito do mouse em cima da tabela e clique em Table Layout. Eu configurei previamente, no BB da página Page1, um atributo chamado Clientes, que nada mais é que uma lista de objetos do tipo Cliente. Assim, iremos linkar os dados da tabela à lista de clientes. Quando aparecer a tela de Table Layout, escolha a propriedade Clientes. Veja que por padrão todas as colunas serão preenchiadas com os atributos da classe Cliente, que são CPF e nome. Se desejar remover alguma coluna, basta colocá-la como disponível. Veja a figura abaixo mostrando como configurar a tabela.

Screen shot 2009-10-26 at 4.59.40 PM

Requisitando referências para backing beans (BB)

Por último, para esse primeiro post de Visual JSF, iremos ver como se pode pegar referências de qualquer BB, quer seja de Aplicação, Sessão ou Requisição. Suponha que você tenha um BB de requisição (request) chamado BBR, e um BB de application (aplicação) chamado BBAp. Para você pegar uma referência do BBAp estando dentro do BBR, basta executar o método getBean(String nomeBB). Esse método encontra-se implementado na classe AbstractPageBean que todo BB do Visual JSF herda. Assim, para o exemplo acima, a linha abaixo resolveria:

BBAp bbDeAplicacao = (BBAp) getBean(“BBApp”);

A partir daí pode-se chamar qualquer método de bbDeAplicacao.

Referências

Trabalhando com AJAX

abril 27, 2009

[Post em Rascunho]

Nesse post irei falar sobre como trabalharmos com AJAX no JSF.


<h:selectOneMenu id="mesAtual" value="#{principalBean.periodo.mesAtual}">
                               <f:selectItems value="#{principalBean.periodo.meses}"/>
                               <a4j:support ajaxSingle="false" event="onchange" reRender="tabelaHorasTrabalhadas,anoAtual,panelDados" actionListener="#{principalBean.pesquisarPeriodo}"/>
                        </h:selectOneMenu>
[/sourcecode language="xml"]



public void pesquisarPeriodo(ActionEvent event){

}

Nesse post simples pretendo discutir sobre como imprimir enviar mensagens para serem mostradas em componentes tipo <h:messages/> e como deixar as mensagens de validação em português.

Primeiramente,  vamos definir onde colocar as mensagens. Em Java, a forma mais simples de se fazer isso é configurando um arquivo de properties na sua aplicação. Chamamos isso de um message bundle.  Esse tipo de arquivo guarda informações do tipo chave=valor. Um exemplo seria:  sistemaMidias.erro.apagarMidiaInexistente=A mídia que se está tentando apagar não existe. Vamos definir esse arquivo dentro do diretório Web Pages da sua aplicação com o nome de mensagens.properties. Coloque as mensagens da forma que você quiser, lembrando que o conteúdo do lado esquerdo da vírgula sempre será a chave e o do direito o valor. É pela chave que você solicitará ao JSF para mostrar a mensagem específica.

As mensagens que definimos no arquivo mensagens.properties podem ser de dois tipos: mensagens específicas da aplicação em questão e mensagens de componentes do JSF. Quanto as mensagens desse segundo tipo, vamos conversar um pouco. Como os componentes em JSF são programados em inglês, as mensagens de erro também o são. Por exemplo, se um componente for definido como required=true, será mostrada uma mensagem em inglês dizendo “The field xyz is required”. Para deixarmos essas mensagens dos componentes JSF em inglês precisamos sobrescrevê-las em nossas aplicações. Para isso, basta colocar as chaves dessas mensagens no arquivo mensagens.properties que criamos para nossa aplicação e colocar os valores necessários. Alguns exemplos de mensagens que os componentes do JSF mostram, que poderíamos deixá-las em português, são:

javax.faces.component.UIInput.REQUIRED={0}: Preenchimento obrigatório.
javax.faces.converter.BigIntegerConverter.BIGINTEGER={0} deve ser um número de um ou mais dígitos.

javax.faces.converter.IntegerConverter.INTEGER={2}: deve ser um número de um ou mais dígitos.
javax.faces.converter.LongConverter.LONG={2}: deve ser um número de um ou mais dígitos.

Perceba que o que está entre chaves {} é o índice de um parâmetro para a mensagem. Por exemplo, para a mensgem javax.faces.component.UIInput.REQUIRED a parte do valor {0} será substituído pelo nome do componente.

Para uma lista mais completa de mensagens, clique aqui.

Definindo o arquivo mensagens.properties no faces-config.xml

Após definir as mensagens necessárias para o sistema, resta apenas configurar o arquivo faces-config.xml para referenciar esse arquivo de mensagens. Para isso, insira dentro do arquivo as seguintes tags:

<application>
 <message-bundle>mensagens</message-bundle>
 </application>

Mostrando mensagens em nossas páginas

Como foi visto acima, as mensagens que já foram definidas pelos componentes JSF, e que sobrescrevemos no arquivo mensagens.properties, serão mostradas automaticamente pelo JSF. Mas as mensagens que definimos especificamente para o nosso sistema precisamos colocar no “saco” de mensagens do JSF para que ele mostre.

Para isso, precisamos colocar um componente do tipo mensagem <h:messages/> em uma página e colocar no backing bean, no método action que se queira mostrar alguma mensagem, quer seja por erro ou algum aviso, as seguintes linhas:

FacesContext fc = FacesContext.getCurrentInstance();
 fc.addMessage("nomeComponenteDeMensages", MessageFactory.getMessage("sistemaMidias.erro.apagarMidiaInexistente",new String[]{}));

Percebeba que o primeiro parâmentro do método addMessage é o nome do componente de mensages da página JSF, p segundo é a mensagem cuja chave seja a que foi passado como parâmetro em MessageFactory.getMessage e o terceiro parâmetro são os possíveis parâmetros, em formato String, que podem ser passados para uma mensagem (com o uso de chaves {}).

Trabalhar com RichFaces e Ajax4JSF é simples. Para configurar sua aplicação, basta colocar nas bibliotecas de sua aplicaçãos os jars:

richfaces-api-*.jar; richfaces-impl-*.jar; richfaces-ui-*.jar

que podem ser baixados em: http://www.jboss.org/jbossrichfaces/downloads/

Escolha a versão mais nova, que atualmente é: richfaces-ui-3.2.2.GA-bin.zip

Depois, basta configurar o arquivo web.xml para trabalhar com Ajax e Richfaces. Para definir o skin do RichFaces:


<context-param>
<param-name>org.richfaces.SKIN</param-name>
<param-value>blueSky</param-value>
 </context-param>

e definir o filtro que trabalhará com o RichFaces:

<!-- Filtro do RichFaces -->

<filter>
 <display-name>RichFaces Filter</display-name>
 <filter-name>richfaces</filter-name>
 <filter-class>org.ajax4jsf.Filter</filter-class>
 </filter>
 <filter-mapping>
 <filter-name>richfaces</filter-name>
 <servlet-name>Faces Servlet</servlet-name>
 <dispatcher>REQUEST</dispatcher>
 <dispatcher>FORWARD</dispatcher>

<dispatcher>INCLUDE</dispatcher>

</filter-mapping>

Finalmente, em toda página JSF lembre-se de “importar” os componentes do Rich Faces assim:

<%@taglib prefix=”rich” uri=”http://richfaces.org/rich”%&gt;

Uma ótima fonte de exemplos de vários componentes do RichFaces e do Ajax4JSF é essa: http://livedemo.exadel.com/richfaces-demo/index.jsp

Configurando JBoss

Como o projeto RichFaces usa alguns componentes de outros projetos, precisamos colocar algumas bibliotecas, especificamente algumas do projeto Apache Commons, no JBoss para que suas aplicações RichFaces funcionem. As bibliotecas necessárias são: commons-digester e  commons-beanutils. Para inserir no JBoss , basta colocar na pasta lib da área de deployment de sua preferência. Por exemplo, se você usa o diretório {JBOSS_HOME}/server/default/deploy para implantar suas aplicações, você deve colocar essas bibliotecas em {JBOSS_HOME}/server/default/lib.

Essas bibliotecas podem ser encontradas aqui:

Definindo um skin para suas aplicações

Skin, ou pele, é a área onde se define as configurações de cores e tamanhos dos elementos gráficos de uma página JSF. O RichFaces, como vimos anteriormente, já vem com alguns skins preconfigurados (bluesky, classic, deepMarine, etc).

Para definir seu próprio, basta criar um arquivo <nome>.skin.properties, e colocá-lo no diretório raiz do código fonte de sua aplicação, com os valores que desejar dos atributos abaixo (os valores abaixo são do skin blueSky):


#Colors
 headerBackgroundColor=#BED6F8
 headerGradientColor=#F2F7FF
 headerTextColor=#000000
 headerWeightFont=bold

generalBackgroundColor=#FFFFFF
 generalTextColor=#000000
 generalSizeFont=11px
 generalFamilyFont=Arial, Verdana, sans-serif

controlTextColor=#000000
 controlBackgroundColor=#ffffff
 additionalBackgroundColor=#ECF4FE

shadowBackgroundColor=#000000
 shadowOpacity=1

panelBorderColor=#BED6F8
 subBorderColor=#ffffff

tabBackgroundColor=#C6DEFF
 tabDisabledTextColor=#8DB7F3

trimColor=#D6E6FB

tipBackgroundColor=#FAE6B0
 tipBorderColor=#E5973E

selectControlColor=#E79A00

generalLinkColor=#0078D0
 hoverLinkColor=#0090FF
 visitedLinkColor=#0090FF

# Fonts
 headerSizeFont=11px
 headerFamilyFont=Arial, Verdana, sans-serif

tabSizeFont=11
 tabFamilyFont=Arial, Verdana, sans-serif

buttonSizeFont=11
 buttonFamilyFont=Arial, Verdana, sans-serif

tableBackgroundColor=#FFFFFF
 tableFooterBackgroundColor=#cccccc
 tableSubfooterBackgroundColor=#f1f1f1
 tableBorderColor=#C0C0C0
 tableBorderWidth=1px

#Calendar colors
 calendarWeekBackgroundColor=#F5F5F5

calendarHolidaysBackgroundColor=#FFEBDA
 calendarHolidaysTextColor=#FF7800

calendarCurrentBackgroundColor=#FF7800
 calendarCurrentTextColor=#FFEBDA

calendarSpecBackgroundColor=#E4F5E2
 calendarSpecTextColor=#000000
 

Referências

Netbeans está se tornando cada vez mais, frente ao Eclipse, uma ferramenta comercial e de fácil uso. Apesar disso, não há uma forma simples ou clara (um botão, uma opção na lista de projetos) de gerar um projeto JPA. Nesse post eu busco, de uma forma simplista e prática, mostrar o passo-a-passo de como se deve fazer.

Tenho que dizer que esse post está levando em consideração que você já tem alguns conhecimentos básicos de JPA, e por que não dizer também de NetBeans? Mas se você quiser ter mais conhecimentos sobre esses assuntos leia na página de minha disciplina Tecnologias Web.

Bem, vamos ao que interessa. Para motivar a criação desse passo-a-passo, irei me basear num mini-projeto. Trata-se de um modeo de gerência de mensagens, tipo blogs, onde podemos ter uma mensagem com nenhum ou vários comentários. O diagrama de classes, sem muitos detalhes, seria:

Diagrama de classes de Mensagens

Diagrama de classes de Mensagens

A partir deste modelo iremos gerar nossa aplicação.

Passos para configurar um projeto JPA/EJB no Netbeans.

  1. Gere um projeto java no Netbeans:
Gerando projeto no Netbeans

2. Dê um nome ao projeto. Aqui, MensagensJPANB:

3. Com botão direito em cima do projeto -> Properties, vamos definir as bibliotecas do JBoss a serem usadas no projeto. Entre elas estarão as bibliotecas do Hibernate e do EJB.

[imagem]

4. Clique em Add Library … -> Create … e dê um nome a essa biblioteca (JBoss4.2.2). Escolha a opção Server Library e Ok.:

[imagem]

5. Acrescente todas as bibliotecas que estão em JBOSS_HOME/server/default/lib. Se precisar fazer algum cliente standalone, é necessário acrescentar também as bibliotecas de JBOSS_HOME/lib:

[imagem]

6. Acrescente a biblioteca e depois ok.

Implementando e configurando o projeto Mensagens

Agora estamos prontos para definirmos nossas classes JPA. Vamos criar as classes e logo após configurar o persistence.xml.

1. Crie uma classe chamada Mensagem, da seguinte forma: botão direito em cima do pacote -> New … -> Entity Class …

2. Dê o nome de Mensagem e defina o tipo da chave primária. Você pode clicar em Create Persistence Unit … Isso fará com que o netbeans crie o arquivo persistence.xml (arquivo que define as configurações JPA). Não faremos isso pois iremos definir nosso persistence.xml na mão. A classe Mensagem ficará da seguinte forma:


package com.gugawag.jpa.mensagens;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table (name="TB_MENSAGEM")
public class Mensagem implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer codigo;   
    private String texto;

    @OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="mensagem")
    private List<Comentario> comentarios;

    public Mensagem(Integer codigo, String texto) {
        this.codigo = codigo;
        this.texto = texto;
        comentarios = new ArrayList<Comentario>();
    }

    public Mensagem() {
        this(null, null);
    }

    public Integer getCodigo() {
        return codigo;
    }

    public void setCodigo(Integer codigo) {
        this.codigo = codigo;
    }

    public List<Comentario> getComentarios() {
        return comentarios;
    }

    public void setComentarios(List<Comentario> comentarios) {
        this.comentarios = comentarios;
    }

    public void acrescentaComentario(Comentario comentario){
        this.comentarios.add(comentario);
    }            

    public String getTexto() {
        return texto;
    }

    public void setTexto(String texto) {
        this.texto = texto;
    }    

}

e a classe Comentario, que você deve fazer clicando botão direito em cima do pacote -> New … -> Java Class … ficará assim:


package com.gugawag.jpa.mensagens;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Comentario implements Serializable{

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer codigo;
    private String texto;

    @ManyToOne
    private Mensagem mensagem;

    public Integer getCodigo() {
        return codigo;
    }

    public void setCodigo(Integer codigo) {
        this.codigo = codigo;
    }

    public Mensagem getMensagem() {
        return mensagem;
    }

    public void setMensagem(Mensagem mensagem) {
        this.mensagem = mensagem;
    }

    public String getTexto() {
        return texto;
    }

    public void setTexto(String texto) {
        this.texto = texto;
    }

}

3. Crie uma pasta em Source Packages com o nome META-INF. É nessa pasta que ficará o arquivo persistence.xml.

4. Crie um arquivo chamado persistence.xml nessa pasta e coloque o seguinte código, que define uma unidade de persistência de nome MensagensPU:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.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_1_0.xsd">
<persistence-unit name="MensagensPU" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
<property name="hibernate.connection.url" value="jdbc:hsqldb:/Users/gugawag/jboss/server/default/data/hypersonic/localdb "/>
<property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/>
<property name="hibernate.connection.password" value=""/>
<property name="hibernate.connection.username" value="sa"/>
<property name="hibernate.cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
<property name="hibernate.hbm2ddl.auto" value="create-drop"/>      
    </properties>
  </persistence-unit>
</persistence>

Criando novas mensagens

Há várias formas de se comunicar com o EntityManager do JPA para criar novas Mensagens e Comentários. Uma delas é usando JSF. Como esse post não trata disto, iremos fazer um programa que criar novas mensagens e iremos ver o resultado nas tabelas do Hypersonic.

1. Crie uma classe chamada ClienteMensagens com um método main. Ela deve ficar assim:


package com.gugawag.jpa.mensagens;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.EntityManager;

public class ClienteMensagens {
    public static void main(String args[]){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("MensagensPU");
        EntityManager em = emf.createEntityManager();

        Mensagem mensagem = new Mensagem();
        mensagem.setTexto("Olá mundo!");

        em.persist(mensagem);
        em.close();
    }

}

2.Crie um arquivo chamado jndi.properties na raiz do Source Packages. Esse arquivo define onde encontrar o serviço JNDI do JBoss, onde está definido o datasource DefaultDS do Hypersonic (pré-definido pelo JBoss no arquivo JBOSS_HOME/server/default/deploy/hsqldb-ds.xml. Ela deverá ficar assim:


java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost

3.Inicie o JBoss.

4. Exporte o arquivo .jar do seu projeto MensagensJPANB para o diretório JBOSS_HOME/server/default/deploy/ da seguinte forma: botão direito em cima do projeto -> Properties -> Build -> Packaging dê o nome do arquivo jar file  MensagensJPANB.jar. Você pode já dizer nesse momento onde ele será salvo (de preferência no diretório JBOSS_HOME/server/default/deploy/MensagensJPANB.jar) ou depois você copia esse arquivo.

5. Dê um Clean and Build no projeto.

6. Execute a classe ClienteMensagens

Visualizando os resultados no banco

1. Vá para o diretório JBOSS_HOME/server/default/lib e execute o comando:

java -cp hsqldb.jar org.hsqldb.util.DatabaseManager

2. Escolha em Type: HSQL Database Engine Standalone e na url coloque jdbc:hsqldb:file:/JBOSS_HOME/server/default/data/hypersonic/localdb. Lembre-se de trocar o JBOSS_HOME pelo diretório onde foi instalado o seu JBoss.

[imagem]

3. Clique em ok.

4. Na área de consulta digite select * from TB_MENSAGEM e clique em execute:

[imagem]


xxx. Para que não hava dúvidas de onde os arquivos devem estar, veja a imagem abaixo:

[imagem árvore projeto]