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
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
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
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
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
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
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
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
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
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
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
Os atributos da entidade são mostrados na Figura abaixo:
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
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
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
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
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
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.
