Uma Introdução ao Java Persistence for

Client-Side Developers
• Conteúdo
• Quais são Persistência Java EE, Hibernate, e Hypersonic?
• Construção de seu primeiro objeto Persistable
• Criação de seu projeto
• Configuração do banco de dados
• Execução de uma consulta
• Iniciando o banco de dados dentro de sua aplicação
• Conclusão
• Recursos
A maioria das aplicações envolvem a criação, armazenamento e pesquisa de dados de alguma
forma, em outras palavras: use um banco de dados. Isso é muitas vezes chamado de CRUD, para
Create, Read, Update e Delete. Bancos de dados são partes integrantes de quase todos os sistemas
de computação. Bem, eu tenho uma confissão a fazer: eu tenho um engenheiro de software
profissional para perto de 10 anos agora e eu não sei nada sobre bancos de dados. Claro, eu posso
escrever um simples SELECT chamada, mas se você me pedir para fazer um duplo externo juntar
com chaves estrangeiras ou converter o meu esquema para forma normal 18, eu vou simplesmente
se perder e desistir. Eu não sei bases de dados. Na verdade, eu odeio bancos de dados. Eu sou um
cara do cliente. Para mim, um banco de dados é simplesmente uma caixa para armazenar o material.
Eu não sei como eles funcionam e eu não quero saber. No entanto, a triste realidade de software
cliente de hoje é que, como toda aplicação fica maior, ela eventualmente precisa de um banco de
dados. Do maior sistema de faturamento para algo tão simples como um livro de endereços, quase
todas as aplicações precisa de um banco de dados. Mas isso não muda o fato de que eu ainda odeio.
Então o que estamos desenvolvedores cliente para fazer? Aqui vai uma idéia: por que não roubar
alguns dos melhores tecnologias os caras servidor 'para tornar nossa vida mais fácil?
Com base nos novos recursos do Java SE 5 (aka Tiger), o Java Enterprise Edition Enterprise Java
Beans 3 spec (doravante conhecido pela abençoadamente mais curto "EJB3") introduziu uma nova
forma de comunicação com bancos de dados chamada Java Persistence API (JPA) . Embora
concebido essencialmente para o uso em grande, aplicações baseadas em servidor, vou mostrar
como usar JPA facilmente carregar, salvar e procurar objetos de dados em uma aplicação simples do
livro de endereços. Em um artigo de follow-up, vou cobrir mapeamento objeto avançado, herança e
busca. Mais importante, você será capaz de fazer todas as tarefas de banco de dados sem precisar
conhecer SQL, JDBC, ou qualquer outras tecnologias de banco de dados tradicional. Vamos ouvi-lo
para o lado do cliente!

Quais são Persistência Java EE, Hibernate, e Hypersonic?

Antes de chegarmos em nossa aplicação, vamos ter um momento para passar por cima de nossas
ferramentas: o Java Persistence API, Hibernate, e Hypersonic.
EJB 3 introduziu uma nova tecnologia chamada especificação do Java Persistence API, que define
um framework de persistência. Persistência é uma maneira de automaticamente mapear objetos Java
normais para um banco de dados SQL. Em outras palavras, ele carrega, pesquisas e salva seus
objetos modelo de dados. Ao invés de escrever inserir SQL pesado, atualização, e os comandos de
seleção, o quadro vai cuidar do código clichê através de algum tipo de automação. A especificação
Java Persistence codifica a vários frameworks de persistência em uma única API. Isto significa que
você pode escrever sua aplicação para a especificação e sei que ele vai trabalhar em várias
implementações, agora e no futuro.
Hibernate é uma implementação open source do Java Persistence spec. Embora precedido JPA, e de
fato influenciou o projeto final, que foi adaptada para implementar a especificação completa (junto
com algumas extensões que não vou abordar aqui). Hibernate é uma das várias implementações
disponíveis, mas eu vos escolhi este porque é completo, maduro, e livremente disponível. Muito
parecido com JDBC, se você ficar com a especificação e não usar qualquer uma das extensões do
Hibernate, você será capaz de mudar implementações conforme suas necessidades mudam no
futuro.
HSQLDB , ex-"Hypersonic," é uma fonte aberta de banco de dados SQL que armazena tudo em um
par de arquivos no disco. Tem a vantagem de ser muito pequeno, fácil de configurar, e escrito
inteiramente em Java. Estas características tornam-no ideal para incorporar diretamente dentro do
seu aplicativo: nenhum servidor de banco de dados necessário. Mais uma vez, neste artigo vamos
nos ater com as especificações do banco de dados e não usar os recursos Hypersonic específicos.
Isto significa que você pode atualizar para um servidor de banco de dados completo no futuro, se
necessário.

Construção de seu primeiro objeto Persistable

Neste artigo, vamos construir uma aplicação simples livro de endereços. O coração de qualquer
aplicativo é seu modelo de dados. São estes objetos que queremos criar, salvar e pesquisa. Para um
livro de endereços, eu quero armazenar as pessoas, por isso eu criei o Person objeto abaixo:
package addressbook;
import javax.persistence.*;

@Entity
public class Person {
@Id @GeneratedValue
public Long id;
public String first;
public String middle;
public String last;
}

Como você pode ver, esta é uma classe muito simples. Ele tem três String campos para o
primeiro, nomes do meio, e por último, junto com um Long para o ID. Parece que qualquer objeto
Java normal. Na verdade, o termo mais freqüentemente usado com frameworks de persistência é
POJO, ou "Plain Old Java Object". As únicas coisas fora do comum para esse objeto são o
@Entity e @Id partes. Qualquer símbolo no início Java de código com @ é conhecida como uma
anotação. O uso de anotações é uma característica nova linguagem introduzida no Java SE 5.0 que
lhe permite adicionar metadados para seus objetos. Anotações marcar partes de seus objetos de
forma que outros sistemas podem fazer algo especial com eles. Neste artigo, vamos marcar certas
áreas e classes com anotações de persistência para que o framework de persistência saberá como
salvá-los.
No código acima, a Person classe é marcado com o @Entity anotação, o que significa que é
uma entidade EJB. Sendo marcado como uma entidade tem um monte de ramificações, mas para
nossos propósitos apenas significa que esse objeto pode ser mantida. Qualquer objeto que você
deseja coisas no banco de dados deve ser marcado com o @Entity anotação. O @Id anotação diz
que o id campo será usado como o identificador exclusivo para esse objeto. Bases de dados usar
uma coluna de tabela especial chamado uma chave primária para distinguir entre as linhas. O @Id
anotação marca o id campo como chave primária para este objeto. O @GeneratedValue
anotação informa o framework de persistência para gerar IDs para nós, o que é bom, porque nós não
nos importamos que eles são, enquanto eles são únicos. O @Id anotação tem muitos parâmetros
opcionais que permitem especificar melhor como funciona o seu chave primária, como selecionar
um nome de coluna particular ou usando vários campos. Para as nossas necessidades, o
comportamento padrão é ótimo.
Você pode notar que os outros campos - first , middle , e last - não tenho quaisquer
anotações. Isso é porque eles estão usando as anotações padrão que dizem que o campo é
persistente como um SQL VARCHAR . Como você explorar o framework de persistência Java você
vai descobrir o JSR especialista grupo fez um trabalho muito bom de definir padrões. Isto significa
que você só precisa usar valores não padrão quando você quiser fazer algo fora do comum. Esta
escolha design, parte da revisão em Java EE 5, faz a persistência muito fácil de usar para não-
servidor de desenvolvedores.

Criação de seu projeto

Combinando JPA, Hibernate, e Hypersonic requer muita. Frascos. Se você quer construir seu
próprio espaço de trabalho, você deve primeiro ir para o Hibernate site e baixar o Hibernate Core,
Hibernate Annotations e Hibernate gerenciador de entidades. arquivos zip. Certifique-se de baixar a
versão 3.2cr2 ou mais recente do arquivo Hibernate Core, porque as versões mais antigas não
funcionam com anotações. Descompactá-los e colocar todos os jars. Em seu classpath (Eu
normalmente colocá-los em um subdiretório lib).
Há um monte de. Frascos e nem todos eles são necessários, dependendo do que você está fazendo,
então eu recomendo usá-los todos durante o desenvolvimento e removendo os que você não precisa,
quando você começa a implantação. O único que você deve precisar na sua classpath em tempo de
compilação é ejb3-persistence.jar. O resto são para uso em tempo de execução. Hibernate contém
um arquivo lib / README.txt com mais detalhes sobre os requisitos biblioteca. Você também vai
precisar do banco de dados HSQLDB na forma do arquivo hsqldb.jar.
Uma breve nota sobre versões de bibliotecas: o Hibernate Persistence implementação tem vindo a
sofrer alterações conforme a especificação EJB 3 se move para a ratificação final. Devido a essas
alterações, algumas versões do Hibernate Core. Frascos não funcionam com algumas versões do
Anotações e gerenciador de entidades. Frascos. Ao escrever esta série de artigos, eu encontrei
alguns ocasionais NoSuchMethodError s, indicando uma incompatibilidade de versão. Eu
recomendo baixar todas as versões dos módulos que foram liberados no mesmo dia. Para este artigo
usei a versões lançadas em 27 de março de 2006. Estes são Hibernate Core v 3.2.0.cr1, Anotações v
3.1beta9 e Entidade Gestor v 3.1beta7. Até que as mudanças se acalmar, eu recomendo ficar com
essas versões. Eu encontrei-os a trabalhar na perfeição.
Agora que você tem um objeto persistente, a grande questão é: como você persistir isso? Aqui é
onde o EntityManager vem dentro Cada implementação da API Persistence terá sua própria
maneira de se conectar a um banco de dados e gerenciamento de objetos, mas contanto que você
não usar qualquer implementação de extensões específicas, você pode furar o oficial interfaces. O
EntityManager mantém o controle de seus objetos e permite que você salvar, carregar e busca-
los à vontade. Como muitas APIs Java, Persistência usa um padrão de fábrica, de modo que é onde
iremos começar. Aqui está um aplicativo de teste típico:
package addressbook;
import javax.persistence.*;

public class Main {

EntityManagerFactory factory;
EntityManager manager;

public void init() {

factory = Persistence.createEntityManagerFactory("sample");
manager = factory.createEntityManager();
}

Para usar persistência, você deve primeiro criar um EntityManagerFactory usando o static
Persistence.createEntityManagerFactory() método. Observe a seqüência de
"sample" passado para o método. Esta é a unidade de persistência você estará usando, o que
deve coincidir com a configuração no arquivo persistence.xml que vamos chegar à tarde. Depois de
ter uma fábrica, você pode obter um EntityManager com o createEntityManager()
método. Em geral, você deve ter uma fábrica por aplicação e um gerente por usuário, geralmente
entregue e gerenciado por seu container de aplicação. Isso ocorre porque a fábrica é thread-safe e do
gerente não é. No entanto, essas restrições foram concebidos com aplicativos de servidor web em
mente. Para uma aplicação desktop, onde só há uma pessoa a usá-lo você pode simplesmente salvar
as referências e usá-los como você precisa. Basta lembrar que o EntityManager não é thread-
safe, isso não deixe de fazer tudo de sua persistência no mesmo segmento ou de uso múltiplo
EntityManager s.
Depois de ter terminado suas operações de persistência você pode desligar o gerente de fábrica e
com os respectivos métodos de perto.
private void shutdown() {
manager.close();
factory.close();
}

public static void main(String[] args) {

// TODO code application logic here
Main main = new Main();
main.init();
try {
// do some persistence stuff
} catch (RuntimeException ex) {
ex.printStackTrace();
} finally {
main.shutdown();
}
}
}

Acima, você pode ver o main() método que cria um Main objeto, inicializa o
sistema de persistência, faz algum trabalho, e então chama shutdown() em uma
finally bloco. Esta simples Main classe encapsula o ciclo de vida típico de um
aplicativo que usa a persistência.

Agora que o sistema de persistência é criado, nós podemos finalmente persistir alguns objetos! Você
só precisa criar uma transação, criar seus objetos, e depois salvá-los.
private void create() {
System.out.println("creating two people");
EntityTransaction tx = manager.getTransaction();
tx.begin();
try {
Person person = new Person();
person.first = "Joshua";
person.middle = "Michael";
person.last = "Marinacci";
manager.persist(person);

Person sister = new Person();

sister.first = "Rachel";
sister.middle = "Suzanne";
sister.last = "Hill";
manager.persist(sister);
tx.commit();
} catch (Exception ex) {
tx.rollback();
}
System.out.println("created two people");
}

Transações são muito necessárias com persistência, porque você está conversando com um debaixo
do banco de dados. Normalmente você vai criar uma transação com
manager.getTransaction() , chame tx.begin() , e depois fazer tudo do seu trabalho. O
código acima chama manager.persist() para salvar os novos objetos, mas isso pode ser
facilmente chamadas para carregar, pesquisar ou atualizar objetos também. Uma vez terminado,
você deve chamar tx.commit() para fazer as alterações permanentes. Repare que as chamadas
são embrulhados em try / catch blocos. Isso é para que você possa reverter a transação, se
alguma coisa der errado, deixando seu banco de dados em um estado consistente.

Configuração do banco de dados

Há uma peça final do quebra-cabeça antes de começar a salvar os objetos. A pilha de persistência
inteiro está configurado com um arquivo persistence.xml. Este arquivo lista as classes que você
deseja persistir, a conexão com o banco, e todas as propriedades que são específicas para a
implementação de persistência (Hibernate, neste caso). Uma vez que você está configurado, este
arquivo XML será a única coisa que você precisa modificar se você mudar ou mover o banco de
dados. Este recurso está subjacente o poder do Java Persistence API e faz a transição do banco de
dados desenvolvedor grande servidor Oracle bastante fácil. Aqui está o que o arquivo
persistence.xml se parece com:
<?xml version="1.0" encoding="UTF-8"?>
<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_1_0.xsd"
version="1.0">

<persistence-unit name="sample" transaction-type="RESOURCE_LOCAL">

<class>addressbook.Person</class>

<properties>
<property name="hibernate.connection.driver_class"
value="org.hsqldb.jdbcDriver"/>
<property name="hibernate.connection.username"
value="sa"/>
<property name="hibernate.connection.password"
value=""/>
<property name="hibernate.connection.url"
value="jdbc:hsqldb:hsql://localhost"/>
<property name="hibernate.dialect"
value="org.hibernate.dialect.HSQLDialect"/>
<property name="hibernate.hbm2ddl.auto"
value="update"/>
</properties>

</persistence-unit>
</persistence>

No arquivo acima, a primeira coisa que você deve observar é o name atributo do persistence-
unit elemento. Não importa o que este nome é, desde que ele corresponda a string passada para o
Persistence.createEntityManagerFactory() método. Mais uma vez, essa API foi
concebido para apoiar usos avançados, como lojas de persistência e bancos de dados. Uma vez que
este é incomum para aplicativos de desktop, eu recomendo usar apenas um nome e nunca alterá-lo.
O arquivo persistence.xml deve estar no diretório META-INF do seu jar da aplicação.. Se você
estiver usando o NetBeans, você pode colocá-lo em um diretório META-INF do seu diretório src e
deixe NetBeans copiá-lo para o lugar certo durante a compilação.
Finalmente estamos prontos para pôr em marcha acima o banco de dados e começar a salvar os
objetos. Hypersonic está contida em um frasco único., Hsqldb.jar, e você pode iniciá-lo com todas
as configurações padrão direito a partir da linha de comando.
java -classpath lib/hsqldb.jar org.hsqldb.Server
Isso irá iniciar uma instância do Hypersonic em sua porta padrão com o banco de dados armazenado
no teste .* arquivos colocados no diretório de trabalho atual. Usando os padrões é conveniente para
o teste porque você pode remover os dados por apenas apagar o teste criado .* arquivos quando
você está feito.
Se você compilar e executar o Main classe, e ter o banco de dados começou em outra janela, então
você deve ter um monte de saída do Hibernate seguido pelas duas linhas:
creating two people
created two people

Parabéns! Você acabou de persistiu seus objetos em primeiro lugar. Depois que você começa a
configuração inicial feito, você vai descobrir como é fácil para armazenar e recuperar seus objetos.
Você nunca mais vai precisar escrever SQL novamente.

Execução de uma consulta

Agora que podemos salvar nossos objetos seria bom para carregá-los de volta. Você pode fazer isso
com uma sintaxe SQL-ish simplificado chamado EJB3-QL. Ele permite que você execute consultas
simples para o armazenamento de persistência, bem como SQL, só que ao invés de retornar
ResultSet s, ele irá retornar List s de seus objetos de dados. Abaixo está uma função de
pesquisa simples.
private void search() {
EntityTransaction tx = manager.getTransaction();
tx.begin();
System.out.println("searching for people");
Query query = manager.createQuery("select p from Person p");
List<Person> results = (List<Person>)query.getResultList();
for(Person p : results) {
System.out.println("got a person: " + p.first + " " + p.last);
}
System.out.println("done searching for people");
tx.commit();
}

A própria consulta é gerado pelo manager.createQuery("select p from Person

p") chamada. Esta é a consulta mais simples possível. Ele irá retornar todas as instâncias da
Person classe. Você poderia qualificar totalmente o Person classe como
addressbook.Person , mas isso não é necessário porque o motor de persistência irá usar o
nome da classe não qualificado por padrão. Depois de ter criado uma consulta, você pode executá-
lo com query.getResultList() . O código acima coloca a consulta dentro de uma transação,
assim como o create() método fez anteriormente neste artigo.
A linguagem EJB3-QL é case-insensitive, exceto para os nomes da classe Java e método, por isso
select é equivalente a SeLeCt . Ele suporta a maioria dos habituais SQL select recursos,
como where cláusulas. Por exemplo, se eu quisesse procurar apenas Person s com o primeiro
nome de Joshua eu poderia usar a consulta: select p from Person p where
p.first='Joshua' . A linguagem EJB3-QL é poderoso o suficiente para executar a maioria
das coisas complicadas que você poderia fazer com o SQL real, como interior e exterior junta, mas
eu acho que para ser desnecessários para a maioria das aplicações cliente. Eu prefiro fazer simples
where as buscas e, em seguida, fazer qualquer requinte extra em código Java.
Iniciando o banco de dados dentro de sua aplicação
Agora que o programa pode carregar e salvar objetos, seria bom ter o banco de dados fornecido com
o aplicativo. Não podemos esperar que nossos usuários iniciar manualmente Hypersonic em outra
janela. Felizmente Hypersonic foi projetado para rodar em processo, de modo que este é bastante
fácil.
Antes de criar o EntityManager você deve começar Hypersonic pela obtenção de um banco de
dados Connection objeto como este:
public static void main(String[] args) throws Exception {
// start hypersonic
Class.forName("org.hsqldb.jdbcDriver").newInstance();
Connection c = DriverManager.getConnection(
"jdbc:hsqldb:file:test", "sa", "");
// start persistence
Main main = new Main();
main.init();
// rest of the program....

Então, pouco antes de seu programa termina, você deve desligar Hypersonic SQL com um
SHUTDOWN comando como este:
// shutdown hypersonic
Statement stmt = c.createStatement();
stmt.execute("SHUTDOWN");
c.close();
} // end main() method

Além disso, desde que você já mudou a configuração do banco de dados, você precisa atualizar o
seu persistence.xml arquivo, especificamente alterando a propriedade URL de conexão
desse:
<property name="hibernate.connection.url" value="jdbc:hsqldb:hsql://localhost"/>

a esta:

<property name="hibernate.connection.url" value="jdbc:hsqldb:test"/>

Com essas poucas mudanças, o banco de dados será iniciado dentro de sua aplicação, salve todos os
dados para o test.* arquivos e desligar quando o aplicativo termina. Hypersonic é uma maneira
simples e compacto para armazenar todos os seus aplicativos em um banco de dados real, sem
nunca saber seus usuários.

Conclusão
A Java Persistence API foi concebido como uma maneira simples de carregar e salvar seus objetos
de dados sem usar qualquer SQL em tudo. Uma vez que também foi projetado para ser
independente de implementação, você pode alterar o seu banco de dados ou provedor de
persistência como suas necessidades mudam e não se preocupar com quebrar nada. Apesar de Java
Persistence foi originalmente concebido para tarefas de servidor, ele executa muito bem em
aplicativos cliente, permitindo que os desenvolvedores do lado do cliente gastar menos tempo de
armazenamento e mais tempo do que eles são bons em: assassino de construção de GUIs.
Junte-me em algumas semanas um artigo de acompanhamento em que explorar os recursos
avançados, como a persistência restrições, propriedades personalizadas, subclasses e gerenciamento
de objetos gráficos toda de uma vez.
Recursos
• Código fonte para este artigo
• O Java EE 5 Tutorial : ver Capítulo 25: "Introdução ao Java Persistence"
• O Java (EJB / JDO) Persistência FAQ
• Hibernate: Persistência Relacional para Java e NET.
• HSQLDB (Hypersonic)