Upload
valber-santana
View
8
Download
1
Embed Size (px)
Citation preview
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)