fev 03 2010

JPA 2.0 na Prática – Parte 2

Category: JPA 2.0Edson Gonçalves @ 14:13

Olá, tudo bom? Como vão vocês?

Este artigo é o segundo de uma série ao qual vou ensiná-los a trabalhar com a Java Persistence API 2.0 (JPA 2.0).  Dúvidas e críticas são bem vindas.

Os primeiros passos na JPA

Com o ambiente configurado, agora podemos  configurar a JPA e dar nossos primeiros passos em sua execução, entendendo como funciona e o que podemos fazer.

Esta parte do artigo está baseada na configuração, criação da entidade e manipulação básica do banco de dados.

Caso você tenha chegado agora, a Parte 1 do artigo ensina como configurar o seu ambiente de desenvolvimento e testes.

Configurando o arquivo persistence.xml

Ao criar o projeto, também foram criados um diretório e arquivo. Note o arquivo chamado persistence.xml,  encontrado no diretório META-INF, dentro de src.

Abra o arquivo persistence.xml e verá que o Eclipse IDE possui um editor do arquivo.

Sua estrutura básica é como mostrada na Listagem 1 abaixo:
Listagem 1 – O arquivo 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>

</persistence-unit>

</persistence>

Ela pode ser visualizada no Editor do Eclipse, em Source.

Configurando a conexão com o banco de dados

No editor do Eclipse, vá na aba Connection, em persistence.xml.

Adicionando as configurações de conexão ao persistence.xml

Adicionando as configurações de conexão ao persistence.xml

Comece alterando para Resource Local em Transaction type.

Esta pequena alteração adiciona o atributo transaction-type com o valor “RESOURCE_LOCAL” em <persistence-unit/> no arquivo persistence.xml.  O atributo transaction-type está definindo que a unidade de persistência terá sua integridade gerida  através da API local (RESOURCE_LOCAL), que é o nosso caso, onde não haverá um servidor de aplicativos Java EE por enquanto envolvido para transações JTA (Java Transaction API).

Mais abaixo, em EclipseLink Connection Pool, clique em Populate from Connection.

Adicionando os parâmetros de conexão no arquivo persistence.xml

Adicionando os parâmetros de conexão no arquivo persistence.xml

Ao abrir a caixa de diálogo Connection Selection, selecione a conexão do MySQL que fez na criação do projeto e confirme.

Conexão do MySQL feita na criação do Projeto

Conexão do MySQL feita na criação do Projeto

Ao retornar ao arquivo persistence.xml, os dados pertencentes ao banco de dados estarão preenchidos.

Configurações para a conexão ao banco de dados

Configurações para a conexão ao banco de dados

Esta mudança da conexão alterou o arquivo persistence.xml da seguinte forma:

<properties>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpapratica"/>
<property name="javax.persistence.jdbc.user" value="edson"/>
<property name="javax.persistence.jdbc.password" value="integrator"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
</properties>

Na JPA 2.0, algumas propriedades foram padronizadas. As propriedades que foram adicionadas ao arquivo persistence.xml são padrões para se conectar ao banco de dados. Veja o que significa cada uma delas:

  • javax.persistence.jdbc.driver — o nome do driver da classe totalmente qualificado
  • javax.persistence.jdbc.url — URL específico do driver
  • javax.persistence.jdbc.user — usuário do banco de dados para a conexão
  • javax.persistence.jdbc.password — senha do banco de dados para a conexão

Vá agora até a aba Logging e, em Logging level, altere para All. Isso tornará visível todas as operações que fizemos, utilizando a JPA, no Console do Eclipse.

Alterando o nível de logging para ALL

Alterando o nível de logging para ALL

Infelizmente, nem todas as propriedades de persistence.xml foram padronizadas. A seguinte propriedade foi adicionada ao arquivo:

<property name=“eclipselink.logging.level” value=“ALL”/>

Ainda em persistence.xml, vá até a aba Schema Generation.  Nesta aba temos DDL generation type. Como não fizemos nenhuma tabela no banco de dados, teremos que criá-la ao executar nossa primeira entidade.

Temos três opções:

  • None – não ocorre nada;
  • Create Tables – cria as tabelas baseando-se nas informações contidas nas entidades;
  • Drop and Create Tables – exclui e cria as tabelas através das informações contidas nas entidades;

Para o nosso trabalho inicial, vamos manter um ciclo de criação e exclusão,  selecionando Drop and Create Tables.

Gerando tabelas através da configuração de persistence.xml

Gerando tabelas através da configuração de persistence.xml

As últimas alterações incluíram a seguinte propriedade:

<property name=“eclipselink.ddl-generation” value=“drop-and-create-tables”/>

Com estas mudanças, temos tudo pronto para trabalhar com a JPA.

Criando sua primeira entidade

Clique com o direito do mouse sobre src, do seu projeto JPA. Selecione no menu de contexto New>Entity.

Criando uma entidade JPA no Eclipse IDE

Criando uma entidade JPA no Eclipse IDE

Na caixa de diálogo New JPA Entity, preencha Java package e Class name, no caso: br.com.integrator e Categoria, respectivamente. Mantenha Entity em Inheritance e clique no botão Next.

Criando a classe/entidade Categoria

Criando a classe/entidade Categoria

Na segunda etapa, definimos o nome da tabela que será utilizada pela entidade Categoria e seus respectivos campos/colunas.

Segunda etapa da criação da Entidade JPA

Segunda etapa da criação da Entidade JPA

O Eclipse IDE, através do seu assistente, irá manter o nome da tabela como padrão existente ao nome da entidade. Desmarque Use default e altere para categorias em Table name.

Esta pequena alteração informa que a entidade Categoria está ligada a tabela categorias do banco de dados.

Alteração do nome da tabela para o banco de dados

Alteração do nome da tabela para o banco de dados

Abaixo você vai encontrar Entity fields. Clique em Add para adicionar as os atributos que existirão na entidade Categoria e seus respectivos tipos.

Detalhe da adição de atributos na entidade Categoria

O diálogo Entity Fields possui Type para colocar o tipo ( que também é acessível com Ctrl+Space) e o nome.

Adicionando um atributo

Adicionando um atributo

Os atributos da entidade são mostrados na Figura abaixo:

Atributos da entidade Categoria

Atributos da entidade Categoria

Veja que foi marcado id como key. Isso fará com que este atributo/campo seja a chave primária.

Diálogo completamente preenchido

Diálogo completamente preenchido

Com tudo preenchido, clique no botão Finish para gerar a classe Categoria com as devidas anotações que a fará uma Entidade da JPA.

A classe/entidade Categoria possui a estrutura como mostrado na Listagem 2 após sua geração:

Listagem 2 – A entidade Categoria

package br.com.integrator;
import java.io.Serializable;
import java.lang.Long;
import java.lang.String;
import javax.persistence.*;
@Entity
@Table(name="categorias")
public class Categoria implements Serializable {
@Id
private Long id;
private String categoria;
private String descricao;
//getters e setters omitidos
}

As entidades, na especificação da JPA, são POJOS (Plain Old Java Objects ), onde podemos alocar com o operador new, assim como faríamos com qualquer outro objeto Java simples. As instâncias de uma classe do tipo entidade não se tornam persistentes até estarem associadas a um EntityManager.

No arquivo persistence.xml, verá a classe adicionada em General>Managed Classes.

Detalhe de Managed Classes em persistence.xml

Detalhe de Managed Classes em persistence.xml

No XML de persistence.xml, haverá a seguinte linha adicionada:

<class>br.com.integrator.Categoria</class>

O elemento <class/> lista explicitamente as classes que são consideradas entidades no persistence.xml.

Para finalizar, vá até a classe Categoria. Na view JPA Structure, clique em id. Marque Primary key generation na view JPA Details e selecione Identity em Strategy. Isso informa a entidade que o campo da chave primária é auto-incrementado e, portanto, gerado pela tabela do banco de dados.

Definindo a estratégia de auto-incremento no campo id da entidade

Definindo a estratégia de auto-incremento no campo id da entidade

Na classe veremos a seguinte anotação: @GeneratedValue(strategy = IDENTITY), onde IDENTITY é de javax.persistence.GenerationType.

Testando a JPA

Antes de explicar qualquer coisa, vamos fazer um teste para saber se está tudo corretamente funcionando, simplesmente chamando a persistence-unit através de uma simples classe Java com um método main().

Crie uma classe no próprio projeto JPA , chamando-a de TesteDaJPA. Coloque em um pacote diferente do qual vem usando e marque public static void main(String[] args). Confirme a criação da classe no botão Finish.

Criação da classe de testes

Criação da classe de testes

Altere a classe TesteDaJPA conforme a Listagem 3:

Listagem 3 – A classe TesteDaJPA

package br.com.integrator.teste;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class TesteDaJPA {
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("JpaNaPratica");
EntityManager em = emf.createEntityManager();
em.close();
emf.close();
 }
}

Execute a classe através do menu Run>Run As>Java Application.

Graças à configuração que fizemos de logging no arquivo persistence.xml (em <property name=“eclipselink.logging.level” value=“ALL”/>) , possuímos uma saída bem detalhada do que ocorreu ao gerar este simples teste.

Assim que iniciada a classe, veremos a saída contendo a conexão ao banco de dados:

[EL Finest]: 2010-02-03 04:33:36.007--Thread(Thread[main,5,main])--DBPlatform: org.eclipse.persistence.platform.database.MySQLPlatform, RegularExpression: (?i)mysql.*.
[EL Fine]: 2010-02-03 04:33:36.007--Thread(Thread[main,5,main])--Detected Vendor platform: org.eclipse.persistence.platform.database.MySQLPlatform
[EL Config]: 2010-02-03 04:33:36.022--ServerSession(11025290)--Connection(29232906)--Thread(Thread[main,5,main])--connecting(DatabaseLogin(
 platform=>MySQLPlatform
 user name=> "edson"
 datasource URL=> "jdbc:mysql://localhost:3306/jpapratica"
))
[EL Config]: 2010-02-03 04:33:36.022--ServerSession(11025290)--Connection(9616314)--Thread(Thread[main,5,main])--Connected: jdbc:mysql://localhost:3306/jpapratica
 User: edson@localhost
 Database: MySQL Version: 5.1.43-community
 Driver: MySQL-AB JDBC Driver Version: mysql-connector-java-5.1.10 ( Revision: ${svn.Revision} )
[EL Config]: 2010-02-03 04:33:36.022--ServerSession(11025290)--Connection(23255990)--Thread(Thread[main,5,main])--connecting(DatabaseLogin(
 platform=>MySQLPlatform
 user name=> "edson"
 datasource URL=> "jdbc:mysql://localhost:3306/jpapratica"
))
[EL Config]: 2010-02-03 04:33:36.038--ServerSession(11025290)--Connection(16496587)--Thread(Thread[main,5,main])--Connected: jdbc:mysql://localhost:3306/jpapratica
 User: edson@localhost
 Database: MySQL Version: 5.1.43-community
 Driver: MySQL-AB JDBC Driver Version: mysql-connector-java-5.1.10 ( Revision: ${svn.Revision} )
[EL Finest]: 2010-02-03 04:33:36.069--ServerSession(11025290)--Thread(Thread[main,5,main])--sequencing connected, state is NoPreallocation_State

Entre a saída, veremos que, devido a configuração no persistence.xml (em <property name=“eclipselink.ddl-generation” value=“drop-and-create-tables”/>) , primeiro houve uma tentativa de fazer um drop table na tabela categorias. Como não existia tal tabela, veremos este erro:

Internal Exception: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown table 'categorias'
Error Code: 1051
Call: DROP TABLE categorias
Query: DataModifyQuery(sql="DROP TABLE categorias")
Em seguida veremos a criação da tabela na seguinte linha:
[EL Finest]: 2010-02-03 04:33:36.163--ServerSession(11025290)--Thread(Thread[main,5,main])--Execute query DataModifyQuery(sql="CREATE TABLE categorias (ID BIGINT AUTO_INCREMENT NOT NULL, CATEGORIA VARCHAR(255), DESCRICAO VARCHAR(255), PRIMARY KEY (ID))")

Por fim, será possível ver que ocorre a desconexão ao banco de dados.

A tabela gerada no banco de dados

Ao entrar no banco de dados, veremos que a simples classe anotada se transformou em uma tabela. Evidentemente que o POJO, sem a devida configuração no arquivo persistence.xml, antes da sua chamada pela classe executora que fizemos de teste, não teria esse poder.

A tabela gerada no MySQL

A tabela gerada no MySQL

Graças a anotação @Table, pudemos dar o nome da tabela que seria gerada, através do atributo name.

Atributos convertidos em colunas

Observe que cada atributo da classe se transformou em uma coluna na tabela. A coluna chave, tida por ID, foi gerada graças à anotação @Id. Além disso, o MySQL considerou esta coluna como auto-incrementada, ou seja, ela possui um modificador que incrementa em um toda vez que uma informação é inserida na tabela. Isso é automático e gerenciado pelo banco de dados. A anotação @GeneratedValue foi a responsável pela geração do auto-increment do MySQL.

Os tipos de cada coluna são gerados pelo similar em Java. Logo, Long se transformou em bigint e String em varchar. Cada tipo de coluna, na tabela do banco de dados, possui também um tamanho definido na sua criação. Como não especificamos isso na classe Categoria, através de anotações, a tabela foi gerada utilizando o tamanho máximo obtido pelo tipo, isso no banco de dados em questão. Logo, Long se transformou em bigint(20) e String em varchar(255).

Na próxima parte

Na Parte 2 da série JPA 2.0 na Prática finalmente fizemos a configuração da JPA, possibilitando a conexão ao banco de dados. Também foi possível gerar uma tabela baseada em uma entidade da JPA através de um pequeno teste de utilização.

Em JPA 2.0 na Prática – Parte 3, começaremos a compreender a Entidade em questão, suas várias anotações e implicações no banco de dados.

As entidades, na especificação da JPA, são POJOS (Plain Old Java Objects ), onde podemos alocar com o operador new, assim como faríamos com qualquer outro objeto Java simples. As instâncias de uma classe do tipo entidade não se tornam persistentes até estarem associadas a um EntityManager.

No arquivo persistence.xml, verá a classe adicionada em General>Managed Classes.

Tags: , , , , ,


jan 18 2010

JavaServer Faces 2.0 na Prática – Parte 1

Category: JSF 2.0Edson Gonçalves @ 1:06

Olá, tudo bom? Como vão vocês?
Este artigo é o primeiro de uma série ao qual vou ensiná-los a trabalhar com o JavaServer Faces 2.0. Dúvidas e críticas são bem vindas.

Como Rodar o JSF 2.0 na sua máquina

A forma mais rápida de executar um aplicativo em JSF 2.0 é através do NetBeans IDE 6.8.  A versão que você deve baixar é a que possui o Sun GlassFish Enterprise Server v3 que, não por acaso, possui suporte ao Java Web e EE.

JavaServer Faces no NetBeans IDE – Criando um Projeto JSF 2.0

O NetBeans IDE, graças ao GlassFish v3, possui as bibliotecas necessárias para desenvolver uma aplicação JavaServer Faces.

Para criar um projeto com JavaServer Faces, siga os seguintes passos:

1. Vá ao menu File e clique no item New Project.

File > New Project

Figura 1. Criando um novo projeto no NetBeans IDE

2. Na caixa de diálogo New Project selecione o item  Web em Categories e Web Application em Projects. Clique no botão Next.

Caixa de Diálogo New Project

Figura 2. Criando um projeto Web no NetBeans IDE

3. Na segunda etapa você define o nome do projeto, em Project Name, e a localização, em Project Location. Digite PrimProjJSF (uma abreviação de Primeiro Projeto JavaServer Faces, como sugestão no nome do projeto). Fique atento a localização dos arquivos em sua máquina. Se desejar mudar a localização de onde se encontra o projeto, clique no botão Browse e selecione um novo local. Clique no botão Next.

Nome do Projeto e Localização na Criação do Projeto no NetBeans IDE

Figura 3. Nome do Projeto e Localização

3. Na terceira etapa você vai manter o GlassFish v3 em Server, assim como manter o mesmo nome do projeto em Context Path. Clique no botão Next.

Seleção do Servidor de Aplicativos

Figura 4. Seleção do Servidor de Aplicativos

4. A última etapa é onde você escolhe o framework  JavaServer Faces. Na parte inferior, após selecionar o framework, surgirá duas abas: Libraries e Configuration. Em Libraries mantenha Use default library which comes with Server (JSF 2.0) .

Selecionando o Framework JSF 2.0

Figura 5. Selecionando o Framework JSF 2.0

5. Na aba Configuration, em  Servlet URL Pattern, mantenha como /faces/*, assim como deixe Facelets em Preferred Page Language (veremos sobre isso em outra parte). Clique no botão Finish para concluir.

Mapeando o Faces Servlet no Projeto

Figura 6. Mapeando o Faces Servlet no arquivo web.xml

O NetBeans IDE abrirá automaticamente uma página em JSF criada pelo assistente através do template existente.

Um primeiro contato com JavaServer Faces

Se você não tem base de conhecimento no JavaServer Faces, aqui será o seu princípio.  A idéia é modificar os arquivos configurados pelo NetBeans IDE.

Uma página simples

A primeira página de um projeto Web costuma ser chamada de index. No JSF 2.0, quando utilizamos o padrão de Facelets, esta página possui a extensão .xhtml, ficando  index.xhtml. No NetBeans basta substituir o conteúdo da página index.xhtml pelo mostrado na  Listagem 1.

Listagem 1 – A página index.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Uma simples página JSF</title>
</h:head>
<h:body>
<h:form>
<h:outputText value="Exemplo Simples" />
</h:form>
</h:body>
</html>

O diretório WEB-INF

No diretório WEB-INF encontramos o arquivo web.xml (deployment descriptor) padrão, contendo as adições mostradas na Listagem 2.

Listagem 2 – O arquivo web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
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-app_3_0.xsd">
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>faces/index.xhtml</welcome-file>
</welcome-file-list>
</web-app>

O elemento <servlet-class /> declara javax.faces.webapp.FacesServlet fazendo com que este seja carregado inicialmente. O Servlet é mapeado no contexto pelo elemento <url-pattern /> para que as páginas da aplicação tenham o prefixo /faces/.

Nota: Embora na versão com Eclipse apareça o arquivo faces-config.xml, utilizado até a versão 1.2, na versão do JSF 2.0 não é obrigatório.

Você também pode configurar, para um aplicativo JSF, alguns parâmetros específicos no elemento <context-param />, como no trecho a seguir:

<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>client</param-value>
</context-param>
<context-param>
<param-name>javax.faces.PROJECT_STAGE</param-name>
<param-value>Production</param-value>
</context-param>

A seguir você tem a Tabela 1 com alguns parâmetros e sua explicação:

Tabela 1 – Parâmetros de configurações de um projeto JSF no web.xml

Parâmetro Descrição
javax.faces.CONFIG_FILES Define uma lista delimitada por vírgulas com caminhos relativos de  contextos de configurações JSF em que a aplicação  irá procurar.
javax.faces.DEFAULT_SUFFIX Permite definir uma lista de sufixos (ex.: .xhtml, .jsf) que serão utilizadas pelo framework para ler páginas com conteúdo JSF.
javax.faces.LIFECYCLE_ID Identifica a instância do ciclo de vida a ser utilizado durante o processamento de  requisições JSF.
javax.faces.STATE_SAVING_METHOD Define a localização em que o estado é salvo.  Neste caso temos dois: server (padrão) que tipicamente salva em HttpSession e client que salva como campos ocultos na subsequente submissão do formulário.
javax.faces.PROJECT_STAGE Descreve como a aplicação JSF está em seu ciclo de vida no desenvolvimento de software, podendo conter os seguintes valores:  Development, UnitTest, SystemTest ou Production. Esta informação poderá ser usada por uma implementação JSF cachear recursos de modo que haja uma melhora no desempenho em produção, por exemplo.
javax.faces.DISABLE_FACELET_JSF_VIEWHANDLER Desabilita o Facelets (padrão) como Linguagem de Declaração de Página (Page Declaration Language – PDL) se colocado como true em seu valor.
javax.faces.LIBRARIES Interpreta cada arquivo encontrado na lista, separada por vírgula, de caminhos como uma biblioteca de tags Facelets.

Executando o projeto de exemplo

No NetBeans é mais simples, pois o projeto considerado principal (main) já está ativo, sendo necessário apenas ir ao menu Run>Run Main Project.

Executando o Projeto

Figura 7. Executando o Projeto no NetBeans IDE

Resultado é uma página JSF renderizada no Browser como mostrado na Figura abaixo.

Resultado da página JSF renderizada

Figura 8. Resultado da página JSF renderizada no Browser

Tags: , , ,


« Página anterior