abr 10 2010

JPA 2.0 na Prática – Parte 3

Category: JPA 2.0Edson Gonçalves @ 6:48

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

Este artigo é o terceiro 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.

Conhecendo as anotações básicas em uma Entidade

Como pudemos perceber no artigo  JPA 2.0 na Prática – Parte 2, as entidades representam as tabelas encontradas no banco de dados. Entretanto, nem sempre refletirão exatamente o modelo da entidade relacional encontrado no banco de dados mas, com certeza, são suas representações, só que em formato de objetos – o que chamamos de O/R (Object-to-Relational).

Anotando uma classe simples

Entidades são classes Java Simples (POJOs) na JPA.  Ao fazer a Entidade Bean Categoria, em JPA 2.0 na Prática – Parte 2, adicionamos anotações que representavam certas características que deveriam ser refletidas na entidade relacional, como nome da tabela e o campo de chave primária.

A entidade Categoria é simples e possui atributos privados que  são refletidos, tais como escritos na entidade, em seu equivalente, na tabela da entidade relacional.

A classe Categoria também é formada por métodos públicos getters e setters, tais como são os JavaBeans comuns.

Para que uma classe, como no caso da Categoria criada, não seja considerada um simples JavaBean e sim uma Entidade Bean da Java Persistence, precisamos de duas anotações básicas:

javax.persistence.Entity Informa que classe é uma Entidade;

javax.persistence.Id – Informa o atributo na classe que será utilizado como chave primária;

Na ausência das demais anotações, o nome da tabela e das colunas existentes na entidade relacional, do banco de dados, são tidos pelo provedor de persistência como sendo exatamente iguais aos encontrados na Entidade Bean.

Desta forma, se mapearmos uma entidade bean como na Listagem 1, teremos uma tabela no banco de dados, procurada ou criada pelo provedor de persistência similar ao da Listagem 2.

Listagem 1 – Entidade Bean Categoria



package br.com.integrator;

import java.io.Serializable;

import java.lang.*;

import javax.persistence.*;

@Entity

public class Categoria implements Serializable {

@Id

private Long id;

private String categoria;

private String descricao;

//getters e setters omitidos

}

Listagem 2 – A tabela Categoria no banco de dados MySQL

create table Categoria(

id bigint(20) primary key not null,

categoria varchar(255),

descricao varchar(255)

);

Anotações @Table, @Column e @Id

Se necessitarmos definir o nome de uma tabela, como foi feito em JPA 2.0 na Prática – Parte 2, utilizamos a notação @Table, de javax.persistence.Table. O mesmo também pode ser feito para dar nomes a colunas, utilizando a anotação @Column, de javax.persistence.Column. Desta forma, se fizermos a modificação na classe Categoria, como na Listagem 3, teremos o resultado mostrado na Figura 1.

Listagem 3 – Utilizando as anotações @Table e @Column

@Entity

@Table(name="categorias")

public class Categoria implements Serializable {

@Id

@Column(name="categoria_id", nullable=false, columnDefinition="integer")

private Long id;

@Column(name="categoria_nome", length=30, nullable=false)

private String categoria;

@Column(columnDefinition="text")

private String descricao;

//getters e setters omitidos

}
Figura 1 – Anotações da Entidade Categoria refletida na tabela categorias no banco de dados

Figura 1 – Anotações da Entidade Categoria refletida na tabela categorias no banco de dados

A Listagem 3 exibe os atributos contidos na anotação @Column, que são úteis no mapeamento de uma tabela equivalente no banco de dados. Temos os seguintes atributos utilizados no exemplo:

name – Nome da coluna na tabela do banco de dados, recebe como valor uma String;

columnDefinition – Recebe uma String com o tipo que será usado pela coluna equivalente na tabela do banco de dados. Um exemplo é a coluna descricao que possui columnDefinition como text.

length – Alguns tipos de colunas nas tabelas dos bancos de dados possuem um valor variável de largura do campo. Um exemplo são os campos varchar(). No MySQL, se não definirmos um valor de largura para o tipo varchar, este é criado em seu tamanho máximo de caracteres, que no caso é 255. Cada banco de dados possui um limite máximo em seu determinado tipo.

nullable – Recebe um valor booleano cujo o padrão é true, caso não declarado. Se false,  este campo é obrigatório.

A anotação @Id, mostrada pela primeira vez em JPA 2.0 na Prática – Parte 2, possui  uma anotação dependente, chamada de @javax.persistence.GeneratedValue.  Esta anotação é utilizada quando desejamos que o provedor de persistência gere as chaves para nós.

A anotação @GeneratedValue possui um atributo chamado strategy, que define a estratégia de geração de valores incrementados. A estratégia mais comum é javax.persistence.GeneratorType.AUTO, mas no exemplo visto na parte 2 dos artigos sobre JPA, utilizamos javax.persistence.GeneratorType. IDENTITY.

Entretanto, alguns gerenciadores de banco de dados, como Oracle, possuem uma estrutura predefinida para gerar valores seqüenciais. Nestes casos, utilizamos a anotação @javax.persistence.SequenceGenerator. A Listagem 4 exibe esta anotação utilizada em um banco de dados ORACLE.

Listagem 4 – Utilizando a anotação @SequenceGenerator

@Entity

@Table(name="CATEGORIAS_TABLE")

@SequenceGenerator(name="CATEGORIA_SEQUENCE", sequenceName="MINHA_SEQ", initialValue=1, allocationSize=1)

public class Categoria implements Serializable {

@Id

@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CATEGORIA_SEQUENCE")

private Long id;

@Column(length=30, nullable=false)

private String categoria;

@Column(length=3500)

private String descricao;

//getters e setters omitidos

}

A anotação @SequenceGenerator possui um atributo name do qual é referenciado em @GeneratedValue, através do atributo generator. A anotação @GeneratedValue também precisa utilizar, no atributo strategy, o valor GenerationType.SEQUENCE.

O nome da sequence gerada no Oracle, por exemplo, seria a colocada no atributo sequenceName, de @SequenceGenerator.

Também, em @SequenceGenerator temos os atributos initialValue e  allocationSize[1].  O resultado de uma sequence criada no banco de dados Oracle, com estas informações fornecidas pela entidade, através da JPA, pode ser vista na Figura 2.

Figura 2 – Sequencia gerada no Oracle XE e visualizada pelo Browser de Objetos

Figura 2 – Sequencia gerada no Oracle XE e visualizada pelo Browser de Objetos

Atenção: A forma como adicionamos a anotação @javax.persistence.Id na Entidade determina como podemos declarar as demais anotações no Bean. Se colocarmos a anotação @Id nos atributos, as demais precisam estar nos atributos. Se colocarmos no método getter, as demais precisarão estar nos métodos getters.

Na próxima parte

Na Parte 3 da série JPA 2.0 na Prática aprendemos as anotações básicas que podemos utilizar para criar uma entidade bean e tê-la refletida em uma tabela no banco de dados relacional.


[1] Sem o atributo allocationSize em 1, o Oracle, por exemplo, usando o Hibernate como provedor JPA, criará uma sequence com valor de 50 em 50.

Tags: , , , ,


mar 09 2010

JPA 2.0 na Prática com Hibernate 3.5

Category: JPA 2.0Edson Gonçalves @ 21:07

Olá, tudo bom? Como vão vocês?
Embora meus artigos sobre JPA 2.0 tenham uma sequencia, este em especial está sendo postado para sanar as dúvidas de vários leitores que me pediram para ensiná-los a usar o Hibernate 3.5, como ORM provider, para trabalhar com JPA 2.0.
Dúvidas e críticas são bem vindas.

Preparação do ambiente de trabalho

Se você olhou o artigo JPA na Prática – Parte 1, será similar no banco de dados e  na ferramenta porém, haverá uma modificação na biblioteca JPA.

A  biblioteca JPA

O Hibernate é um ORM como o EclipseLink, muito utilizado no desenvolvimento Web com Java,  cujo a versão 3.5 possui suporte a Java Persistence API 2.0.  Você pode baixá-la clicando aqui. Clique em Download, no menu lateral esquerdo.

A versão, no momento em que escrevo, é a 3.5.0-CR-2 (ainda em desenvolvimento).

Os arquivos que terá de baixar serão:

  • Hibernate Core
  • Hibernate JPAModelGen

Ao baixar os arquivos, descompacte-os.  Você precisará das seguintes bibliotecas:

  • hibernate3.jar
  • antlr-2.7.6.jar
  • commons-collections-3.1.jar
  • dom4j-1.6.1.jar
  • javassist-3.9.0.GA.jar
  • jta-1.1.jar
  • slf4j-api-1.5.8.jar
  • hibernate-jpa-2.0-api-1.0.0-CR-1.jar

Além destes arquivos, será necessário utilizar as bibliotecas da Simple Logging Facade for Java, SLF4J. Baixe o arquivo com todas as bibliotecas da SLF4J aqui.

Descompacte o arquivo após baixá-lo.  Você precisará das seguintes bibliotecas:

  • slf4j-jdk14-1.5.11.jar
  • slf4j-log4j12-1.5.11.jar

O Projeto

O projeto para este pequeno tutorial é o mesmo do criado no artigo JPA na Prática – Parte 1, portanto não será explicado novamente como fazê-lo.

As bibliotecas no projeto

Podemos tanto criar uma biblioteca de usuário, contendo todas elas ou, simplesmente, adicionar todas ao seu projeto.

Figura 1 – Bibliotecas do Hibernate 3.5 e SLF4J adicionadas ao projeto

Figura 1 – Bibliotecas do Hibernate 3.5 e SLF4J adicionadas ao projeto

Configurando o arquivo persistence.xml

Similar ao mostrado na JPA 2.0 na Prática – Parte 2, no arquivo persistence.xml, altere-o conforme a 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 name="JpaNaPratica" transaction-type="RESOURCE_LOCAL">

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

<properties>

<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpapratica"></property>

<property name="javax.persistence.jdbc.user" value="edson"></property>

<property name="javax.persistence.jdbc.password" value="integrator"></property>

<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"></property>

<property name="hibernate.show_sql" value="true" />

<property name="hibernate.format_sql" value="true" />

<property name="hibernate.hbm2ddl.auto" value="create"/>

</properties>

</persistence-unit>

</persistence>

Infelizmente, nem todas as propriedades de persistence.xml são padronizadas, conforme já dito no artigo JPA na Prática – Parte 2. Para exibir a saída das instruções SQL geradas, assim como outras informações, as seguintes propriedades foram  adicionadas ao arquivo persistence.xml:

<property name="hibernate.show_sql" value="true" />

<property name="hibernate.format_sql" value="true" />

Para criar a tabela, utilizamos a seguinte adição:

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

Testando o Projeto

Similar ao mostrado na JPA 2.0 na Prática – Parte 2, execute a classe com o método main() e veja os resultados refletidos no banco de dados.

Hibernate ou EclipseLink?

Muitos me perguntam isso, querendo saber qual é o melhor. O ideal, como sempre, é conhecer ambos e tirar as suas próprias conclusões. Em JPA 2.0, ao menos por enquanto, no que foi mostrado, não há diferença.

Abraço a todos e até o próximo artigo.

Tags: , , , , ,


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

JPA 2.0 na Prática – Parte 1

Category: JPA 2.0Edson Gonçalves @ 2:59

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

Este artigo é o primeiro 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.

Preparando o ambiente

Se você tem experiência com instruções SQL, JPA é  fácil de entender. A JPA trabalha com objetos diretamente e converte as suas instruções para SQL através da JDBC, de modo a executar no banco de dados.

JPA na prática começará com um ambiente de trabalho simples, onde teremos as execuções fora do ambiente Java EE.

O banco de dados

O banco de dados utilizado será o MySQL. Você pode baixar a versão 5.1, utilizada no artigo, aqui.

Preparando o banco de dados do exemplo

Abra o terminal do MySQL com seu usuário e senha ROOT (aquela que você configurou na instalação).

Crie o banco de dados executando o seguinte comando:

create database jpapratica;

Baixando e descompactando o driver JDBC

No mesmo local onde baixamos o MySQL, existe a versão atual do driver JDBC, chamado de Connector/J 5.1. Baixe o arquivo e o descompacte.  O arquivo JAR do qual iremos precisar será:

mysql-connector-java-5.1.10-bin.jar

O ambiente de trabalho

Os exemplos desenvolvidos serão criados no Eclipse IDE 3.6 M4, ao qual teremos uma breve explicação de como criar projetos JPA.

Baixando o Eclipse

No momento em que este artigo é criado, o Eclipse IDE 3.6 ainda está em desenvolvimento. Esta versão foi escolhida por possuir suporte a JPA 2.0. O pacote que vamos usar é o Eclipse IDE for Java EE Developers.

Download Eclipse IDE 3.6

Figura 1. Download do pacote Eclipse IDE 3.6 para Java EE

A  biblioteca JPA

O EclipseLink é a biblioteca oficial da Java Persistence API 2.0.  Você pode baixá-la clicando aqui. O arquivo baixado para o exemplo é o EclipseLink 2.0.0 Installer Zip.

Ao baixar o arquivo, descompacte-o. Você precisará das seguintes bibliotecas:

  • eclipselink.jar
  • javax.persistence_2.0.0.v200911271158.jar

Criando o projeto

No Eclipse, na view Project Explorer, clique com o direito e selecione New>JPA Project.

Criando um projeto JPA

Figura 2. Criando um projeto JPA no Eclipse

Na caixa de diálogo New JPA Project, digite o nome do projeto em Project name. No exemplo que usaremos será chamado de JpaNaPratica. Em Configuration, mantenha em Minimal JPA 2.0 Configuration. Clique no botão Next para prosseguir.

Primeira etapa do projeto

Figura 3. Primeira etapa da criação do projeto

A segunda etapa mantenha como está, prosseguindo com o botão Next.

Segunda etapa da criação do Projeto

Figura 4. Segunda etapa da criação do projeto

As bibliotecas do EclipseLink no projeto

Na terceira etapa, você vai configurar o EclipseLink 2.0. Para isso, clique no ícone Manage libraries.

Terceira etapa da criação do projeto

Figura 5. Terceira etapa da criação do projeto - Clicando no ícone Manage libraries

Na caixa de diálogo Preferences, clique no botão New.

Caixa de diálogo Preferences

Figura 6. Caixa de diálogo Preferences - Botão New

Na caixa de diálogo New User Library digite EclipseLink e confirme no botão OK.

Caixa de diálogo New User Library

Figura 7. Caixa de diálogo New User Library

Ao retornar a caixa de diálogo Preferences, clique no botão Add JARs e selecione as bibliotecas do EclipseLink.

Caixa de diálogo Preferences - botão Add JARs

Figura 8. Caixa de diálogo Preferences - botão Add JARs

Após selecioná-las, confirme a caixa de diálogo no botão OK.

Biblioteca EclipseLink com os JARs adicionados

Figura 9. Biblioteca EclipseLink com os JARs adicionados

Ao retornar ao diálogo de criação do seu projeto, marque a biblioteca EclipseLink que agora está lá.

Biblioteca EclipseLink adicionada na criação do projeto

Figura 10. Biblioteca EclipseLink adicionada na criação do projeto

A conexão no Eclipse e a biblioteca do banco de dados no projeto

Abaixo, em Connection, clique em Add connection.

Detalhe em Add Connection na criação do projeto

Figura 11. Detalhe em Add Connection na criação do projeto

Na caixa de diálogo New Connection Profile, selecione o MySQL e dê o nome da sua conexão em Name. Prossiga clicando no botão Next.

Caixa de diálogo New Connection Profile

Figura 12. Caixa de diálogo New Connection Profile

Na próxima etapa, você precisa adicionar definir o driver JDBC do banco de dados MySQL. Clique no ícone (New Driver Definition).

Detalhe da localização do ícone New Driver Definition

Figura 13. Detalhe da localização do ícone New Driver Definition

Na caixa de diálogo New Driver Definition, você possui três abas:

Name/Type – Aqui definimos qual a versão do driver JDBC iremos usar. Neste caso, MySQL JDBC Driver.

Selecionando o driver JDBC do MySQL

Figura 14. Selecionando o driver JDBC do MySQL

Jar List – O local onde se encontra o arquivo JAR. Neste caso, remova o atual, clicando em Remove JAR/Zip e adicione o que foi baixado em Add JAR/Zip.

Adicionando o path para o arquivo JDBC do MySQL

Figura 15. Adicionando o path para o arquivo JDBC do MySQL

Properties – Podemos configurar a conexão ao banco de dados. Coloque os dados do seu banco de dados utilizado no exemplo deste artigo.

Propriedades da conexão ao banco de dados do exemplo

Figura 16. Propriedades da conexão ao banco de dados do exemplo

Após configurar o seu driver e conexão com o banco de dados, confirme no botão OK.

Retornando ao diálogo New Connection Profile, agora com as configurações do seu banco de dados preenchidas, marque Save password.

Dados para a conexão preenchidos

Figura 17. Dados para a conexão preenchidos

Clique no botão Test Connection e, se estiver com tudo funcionando perfeitamente, verá uma mensagem de sucesso.

Conexão executada com sucesso

Figura 18. Conexão executada com sucesso

Terminadas estas configurações, seu perfil de conexão está pronto. Pode finalizar o diálogo clicando em Finish.

Caixa de diálogo New Connection Profile com dados da conexão

Figura 19. Caixa de diálogo New Connection Profile com dados da conexão

Retornando a criação do projeto, em New JPA Project, agora você possui todas as informações necessárias para criar o projeto JPA. Clique no botão Finish para gerar o projeto.

Etapa final do diálogo New JPA Project com tudo preenchido

Figura 20. Etapa final do diálogo New JPA Project com tudo preenchido

O Eclipse desejará colocar a perspectiva associada ao tipo de projeto. Basta confirmar em Yes.

Autorizando a mudança de perspectiva

Figura 21. Autorizando a mudança de perspectiva

O projeto gerado é mostrado na Figura a seguir:

Projeto JPA gerado

Figura 22. Projeto JPA gerado

Adicionando a biblioteca JDBC no projeto

Embora, para configurar o projeto JPA, você criou uma conexão com o MySQL, esta apenas funciona no Eclipse IDE. Para adicionar no seu projeto a biblioteca JDBC, clique com o direito do mouse sobre ele e selecione Properties no menu de contexto.

Na caixa de diálogo Properties, vá em Java Build Path, na aba Libraries e clique em Add Library.

Caixa de diálogo Properties, em Java Build Path, na aba Libraries

Figura 23. Caixa de diálogo Properties, em Java Build Path, na aba Libraries

Na caixa de diálogo Add Library, selecione Connectivity Driver Definition e clique no botão Next.

Caixa de diálogo Add Library, em Connectivity Driver Definition

Figura 24. Caixa de diálogo Add Library, em Connectivity Driver Definition

Na segunda etapa, selecione a configuração do MySQL que fez para o Eclipse, em Available Driver Definitions e confirme no botão Finish.

Seleção da configuração do MySQL em Available Driver Definitions

Figura 25. Seleção da configuração do MySQL em Available Driver Definitions

Agora você possui a biblioteca JDBC também em seu projeto. Agora confirme a caixa de diálogo e seu projeto estará pronto para trabalhar com a JPA 2.0.

Detalhe da biblioteca JDBC do MySQL adicionada ao projeto

Figura 26. Detalhe da biblioteca JDBC do MySQL adicionada ao projeto

Em JPA 2.0 na Prática – Parte 2, vocês verão como configurar, criar entidades e executar operações em JPA que serão refletidas no banco de dados do MySQL.

Bons Códigos!

Tags: , , , , ,