DownloadsNessa vídeo-aula começaremos a desenvolver uma aplicação Java com

JPA. Já temos um ambiente de desenvolvimento pré-configurado baseado

no Java SE 7 e utilizaremos como IDE o Eclipse IDE for Java EE

Developers - todos disponíveis nos links indicados.

Além disso precisaremos os JARs do Hibernate e o driver MySQL. Você

pode baixar os JARs diretamente no site (explicado abaixo) ou já pegar

todos de uma vez nesse link: financas-libs.zip

Também segue o download para o arquivo de configuração: persistence.xml

Bibliotecas do JPA e Hibernate

Usaremos o Eclipse na versão Java EE Developers que pode ser

baixada no link indicado. O primeiro passo é criar um projeto Java que

chamaremos de financas. É um projeto Java padrão, ainda sem um

servidor web. Ao finalizar, a estrutura básica é criada com a pasta src. Além

dessa pasta, vamos criar uma outra chamada lib que conterá todas as

bibliotecas.

Vamos usar o JPA com Hibernate, ou seja, precisamos baixar os JARs no

site do Hibernate. Ao acessar hibernate.orgseguiremos o link download e

depois o link release bundles. Escolhemos a versão mais atual e

baixamos o formato ZIP.

Com o ZIP em mãos, vamos descompactar o arquivo e entrar na pasta da

distribuição. Dessa pasta vamos copiar todos os JARs obrigatórios

(required). Basta arrastá-los para pasta lib do nosso projeto. Não

podemos esquecer o JAR do JPA, já que faremos uso do Hibernate através

dele.

Como vimos, o JPA abstrai do desenvolvedor a camada SQL, mesmo assim

é preciso copiar o JAR do driver JDBC. Em nosso caso usaremos o driver

do MySQL. O JDBC Driver for MySQL (Connector/J) pode ser baixado aqui.

Todos os JARs foram copiados, agora só falta adicioná-los no classpath do

projeto: ao selecionar os JARs, botão direito:Build Path -> Add to Build

Path.

Preparação do modeloVamos preparar o modelo. Na pasta src criaremos uma nova classe Conta

dentro do pacotebr.com.caelum.financas.modelo. É essa classe que

queremos mapear para uma tabela.

Ela vai definir um atributo id que será do tipo Integer. Esse atributo

representa a chave primária. É boa prática usar chaves auxiliares e simples

a favor de chaves compostas. Isso facilita não só o trabalho com JPA, como

também simplifica o desenvolvimento Web.

Os próximos atributos serão titular, numero, banco e agencia, todos do tipo

String. Só falta gerar os getters e setters.

public class Conta {

private Integer id;

private String titular;

private String banco;

private String agencia;

private String numero;

// getters e setters

A primeira EntidadePara mapear a classe Conta é preciso anotá-la com @Entity do pacote

javax.persistence. Entidades (ou Entities) são as classes que tem uma

tabela associada. Além disso, é obrigatório declarar o atributo que

representa a chave primária com@Id. A anotação @GeneratedValue é

opcional, mas é muito comum usar com chaves auxiliares. Com ela

indicamos que o banco deve atribuir o valor da chave, e não a aplicação. Ao

inserir uma conta no banco, automaticamente será alocada umaID.

import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;

@Entitypublic class Conta {

@Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Integer id; private String titular; private String numero; private String banco; private String agencia;

Como usaremos MySQL deixamos a estratégia como Identity, com outros

bancos, por exemplo Postgre e Oracle, poderíamos usar sequências.

Por exemplo, para mapear uma sequência com Postgres podemos usar:

@Entity@SequenceGenerator(name = "SEQ_CONTAS", sequenceName = "SEQ_CONTAS", initialValue = 1)public class Conta {

@Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_CONTAS") private Integer id; private String titular; private String banco; private String agencia; private String numero;

Configuração no persistence.xml

Para definir os dados de conexão, o JPA possui um arquivo de

configuração, o persistence.xml. Pela especificação esse arquivo deve ficar

dentro da pasta META-INF. Vamos criar essa pasta dentro do src e copiar

um persistence.xml já pré-configurado que estará disponível para download

aqui.

No persistence.xml toda configuração fica dentro de um elemento

persistence-unit. Uma unidade de persistência possui um nome e dentro

do mesmo persistence.xml poderiam ter várias unidades, por exemplo, para

bancos de dados diferentes:

<persistence ...> <persistence-unit name="financas-mysql"> <!-- configurações para mysql --> </persistence-unit> <persistence-unit name="financas-postgre"> <!-- configurações para postgreSQL --> </persistence-unit>

</persistence>

Dentro da unidade de persistênia, logo em seu início, está a definição do

provedor JPA (JPA Provider), no nosso treinamento o Hibernate; e também

o nome da nossa entidade, Conta com seu endereço completo. Além disso,

declaramos as propriedades de conexão como o driver, URL, login e senha,

como também algumas propriedades específicas do Hibernate. Repare que

definimos um dialeto para MySQL. Através dessa classe o Hibernate será

capaz de gerar o SQL específico para nosso banco. Ou seja, há dialetos

para os diversos bancos e suas versões. É importante sempre procurar o

dialeto mais específico.

A propriedade hbm2ddl é muito útil para ambientes de testes e provoca a

criação e atualização automática das tabelas e colunas no banco de dados.

Com essa configuração habilitada o Hibernate gerará uma tabela com o

mesmo nome da entidade. O Hibernate gera SQL e podemos pedir que ele

o mostre antes de executar. Assim fica mais fácil de entender o trabalho do

JPA.<persistence 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" version="2.0"> <!-- unidade de persistencia com o nome financas --> <persistence-unit name="financas"> <!-- Implementação do JPA, no nosso caso Hibernate --> <provider>org.hibernate.ejb.HibernatePersistence</provider> <!-- Aqui são listadas todas as entidades --> <class>br.com.caelum.financas.modelo.Conta</class> <properties> <!-- Propriedades JDBC --> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />

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

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

<!-- Configurações específicas do Hibernate --> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />

<property name="hibernate.hbm2ddl.auto" value="update" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> </properties> </persistence-unit></persistence>

Preparação do banco e a geração do esquema

Antes de testar o JPA, não podemos esquecer de criar o banco no MySQL. O Hibernate gera as tabelas e colunas, mas não o banco em si. Vamos abrir um terminal e conectar com o MySQL. No prompt criaremos o banco: CREATE DATABASE financas;

Para testar, vamos selecionar o banco, ou seja executar: USE financas; e

depois mostrar que não há nenhuma tabela ainda pelo comando

SHOW TABLES.

Inicialização do JPA e Hibernate

Chegou a hora de testar o JPA. Para isso criaremos uma classe auxiliar

chamada TesteJPA, no pacote financas.teste, com um simples método

main.

public class TesteJPA {

public static void main(String[] args) {

}

}

A primeira coisa a fazer é carregar a configuração, aquele arquivo

persistence.xml. O JPA possui uma classe com o mesmo nome:

Persistence. Usaremos ela para criar uma EntityManagerFactory

baseada na unidade de persistência financas, chamando o método

createEntityManagerFactory(...). A fábrica por sua vez cria um

EntityManager. Também já vamos fechar o EntityManager através do

método close().

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

public class TesteJPA {

public static void main(String[] args) {

EntityManagerFactory entityManagerFactory = Persistence .createEntityManagerFactory("financas");

EntityManager manager = entityManagerFactory.createEntityManager();

manager.close(); }}

O EntityManager possui os principais métodos do JPA e será estudado

detalhadamente nos próximos capítulos. Através do EntityManager

podemos, por exemplo, persistir uma entidade. O método que possui essa

responsabilidade se chamapersist().

Para o código compilar falta instanciar um objeto da classe Conta. Vamos

preencher os atributos titular, banco, numero e agencia. Repare que não

preenchemos o atributo da chave, o id pois ela vem do banco de dados.

public class TesteJPA { public static void main(String[] args) {

Conta conta = new Conta(); conta.setTitular("Joao Ferreira"); conta.setBanco("HSBC"); conta.setNumero("123345"); conta.setAgencia("321");

EntityManagerFactory entityManagerFactory = Persistence .createEntityManagerFactory("financas"); EntityManager manager = entityManagerFactory.createEntityManager(); manager.persist(conta); manager.close(); }}

Gerenciamento da Transação

Por último, é preciso cuidar da transação. O EntityManager possui o

método getTransaction(), que devolve um objeto que representa a

transação. Com ele em mãos vamos iniciar e comitar a transação.

em.getTransaction().begin();

em.persist(conta);

em.getTransaction().commit();

Persistindo entidades

Tudo pronto para testar. Basta rodar a aplicação e o Hibernate vai gerar a tabela e inserir a conta. Podemos ver no console abaixo que o comando SQL foi gerado.

Vamos também verificar a tabela no terminal. A tabela Conta foi criada e ao

selecionar todos os dados, aparece o registro:

mysql> show tables;+--------------------+| Tables_in_financas |+--------------------+| Conta |+--------------------+1 row in set (0.00 sec)mysql> select * from Conta;+----+---------+-------+--------+---------------+| id | agencia | banco | numero | titular |+----+---------+-------+--------+---------------+| 1 | 321 | Bradesco | 123345 | Joao Ferreira |+----+---------+-------+--------+---------------+1 row in set (0.02 sec)