Resumo Rápido do Hibernate

Parte I
Resumo Rápido do Hibernate
Nosso primeiro objetivo é permanecermos atualizados sobre o Hibernate o mais rápido possível. A maioria
dos capítulos desta parte é de versões atualizadas do conteúdo de Hibernate: A Developer’s Notebook
(O’Reilly), que reflete as principais mudanças que acompanharam o Hibernate 3. A amostra de código
agora funciona com as versões mais atualizadas das ferramentas nas quais confiamos para fornecer um
ambiente fácil, porém, realista para se trabalhar com o Hibernate. Também há um novo capítulo falando
sobre a capacidade de usar anotações Java 5, ao invés de arquivos de mapeamento XML, para configurar
os mapeamentos do Hibernate.
Começar e seguir os exemplos é ainda mais fácil nesta nova versão do livro, pois adotamos o Maven para
ajudar a baixar muitas das ferramentas e bibliotecas. Como esperamos que você perceba, não há desculpa
para evitar mergulhar e experimentar tudo isso sozinho!
Quando se sentir confortável com os fundamentos do Hibernate, a Parte II demonstrará como associar o
Hibernate a outros ambientes, para que eles sejam ainda mais poderosos do que são quando trabalham
sozinhos.
Muito bem, é hora de mergulhar....
CAPÍTULO 1
Instalação e Configuração
Ainda me surpreende como há tantas ferramentas JavaTM grandes, livres e de fonte aberta à disposição.
Quando precisei de um serviço de mapeamento objeto/relacional de peso leve para um projeto de
e-commerce JSP na virada do milênio, tive de construir o meu próprio. Ele evoluiu com os anos, desenvolveu
características excelentes e únicas e o temos usado em uma grande variedade de contextos diferentes. Mas,
quando descobri o Hibernate, nós o utilizamos para um novo desenvolvimento em vez de usá-lo para meu
próprio sistema, já familiar (para felizmente admitir preconceitos). Isso revela o quanto ele é irresistível!
Se estiver dando uma olhada neste livro, provavelmente está interessado em uma maneira poderosa e
conveniente para unir os mundos dos objetos Java e dos bancos de dados relacionais. O Hibernate cumpre
esse papel muito bem, sem ser tão complicado a ponto de tornar o aprendizado um desafio assombroso
por si só. Para mostrar isso, este capítulo leva você até o ponto em que poderá brincar com o Hibernate e
ver porque ele é tão cativante.
Os últimos capítulos mostrarão como usar o Hibernate como parte de ambientes mais complexos tais como
o Spring e o Stripes e também como usá-lo com outros bancos de dados. O objetivo deste primeiro capítulo
é mostrar como é fácil reunir um ambiente básico e independente em que é possível explorar o Hibernate
e fazer coisas verdadeiras com ele.
Como conseguir uma Distribuição Ant
Embora pareça surpreendente, o que você precisa, inicialmente, para colocar o Hibernate em funcionamento
não tem nada a ver com o Hibernate em si. Primeiro você deve configurar um ambiente em que os exemplos
funcionem. Ao fazer isso você obterá o agradável efeito de construir uma fundação sólida para qualquer
projeto real do qual seja responsável.
Caso ainda não utilize o Ant para gerenciar a construção, o teste, a execução e o empacotamento de seus
projetos em Java, a hora de começar é agora. Os exemplos deste livro são dirigidos para Ant, por isso você
precisará instalar Ant e tê-la em funcionamento para executá-los e experimentar com variações em seu
próprio sistema, que é a melhor maneira de aprender.
Em primeiro lugar, adquira uma Ant binária e instale-a.
Por que me preocupar?
Os exemplos utilizam Apache Ant por diversos motivos. Ele é conveniente e poderoso; é uma das ferramentas
padrão construídas para o desenvolvimento baseado em Java; é de graça e é multiplataforma. Se você
utilizar Ant, os exemplos funcionarão igualmente bem onde houver um ambiente Java, o que significa que
os leitores deste livro não ficarão frustrados ou aborrecidos. Felizmente, isso também significa que podemos
3
fazer muito mais coisas excelentes com menos esforço - especialmente agora que várias ferramentas do
Hibernate têm suporte Ant explícito, que mostrarei como dominar. (Devo notar que, hoje em dia, esses
projetos mais complexos em Java geralmente utilizam o Maven*, que acrescenta muitas outras capacidades
para o gerenciamento de projetos. Mas como foi necessário optar por um, no espírito de manter as coisas
simples e verdadeiras para aquilo que acho útil, usei Ant com esses exemplos.)
Se atualmente você usa Maven como uma ferramenta de construção, você perceberá que estamos usando
Tarefas Ant do Maven para gerenciar as dependências de nossas construções Ant. Embora o Maven
esteja ganhando força, o Ant continua sendo a ferramenta para construção mais amplamente usada em
desenvolvimento de Java. O código de exemplo de cada capítulo também possui um arquivo pom.xml
do Maven e pode ser compilado com ele. Em muitos casos, o arquivo de construção do Maven fornece a
mesma funcionalidade que o arquivo build.xml de Ant usando o plug-in Maven Hibernate 3. No capítulo
12 você encontrará orientações para construir e distribuir aplicações do Hibernate utilizando o Maven por
completo, mas a maioria dos exemplos deste livro foca Ant como uma ferramenta de construção, utilizando
as Tarefas Ant Maven para aliviar o tédio de ter que procurar e baixar as várias bibliotecas que precisamos
e as bibliotecas das quais elas, por sua vez, dependem.
Para se beneficiar de todas essas capacidades, é necessário ter o Ant instalado e funcionando em seu
sistema.
Eu me questionava porque as pessoas preferiam Ant quanto poderiam usar Make. Agora vejo
como Ant gerencia bem as construções de Java, e fico perdido sem ele.
Como eu faço isso?
Você pode baixar uma versão binária de Ant de http://ant.apache.org/bindownload.cgi. Role a página para
baixo para encontrar a versão atual de Ant e baixe o arquivo em um formato adequado para você trabalhar.
Escolha um lugar apropriado para ele e expanda o arquivo ali. O diretório no qual você expandiu o arquivo
é conhecido como ANT_HOME. Digamos que você expandiu os arquivos compactados no diretório/usr/
local/apache-ant-1.7.0; se preferir, você pode criar um link simbólico para facilitar o trabalho com ele e
evitar a necessidade de mudanças em qualquer configuração de ambiente quando você atualizar para
uma versão mais nova.
/usr/local % ln -s apache-ant-1.7.0 ant
Uma vez que o Ant foi estabelecido, você precisa fazer algumas coisas para que ele funcione corretamente.
É necessário acrescentar seu diretório bin na distribuição (neste exemplo, / usr/local/ant/bin) para o seu
caminho de comando. Também é necessário configurar a variável do ambiente ANT_HOME para o diretório
de nível superior que você instalou (neste exemplo, /usr/local/ant). Os detalhes sobre como executar esses
passos, em diferentes sistemas operacionais, podem ser encontrados no manual do Ant (http://ant.apache.
org/manual/) se precisar deles.
Verifique sua versão Java
É claro que também estou supondo que você tem um kit de desenvolvimento de software Java (SDK).
Atualmente você deve estar usando, no mínimo, Java 5 , uma vez que oferece algumas características novas
que são úteis. Se puder, opte pelo SDK estável mais recente. Tanto Java 5 quanto o Java 6 devem funcionar
com todos os exemplos deste livro. Era possível utilizar a maior parte do Hibernate 2 com Java 1.3, mas
*http://maven.apache.org/
4 Dominando Hibernate
geralmente era necessário reconstruir o arquivo Hibernate JAR usando o seu compilador 1.3. Podemos
apenas imaginar que versões mais recentes dependem ainda mais fortemente de versões atuais de Java e
Java 5 já está de lado tempo o suficiente e tem seus próprios benefícios, que nem mesmo investigaremos
a compatibilidade com JDKs anteriores. Nossos exemplos são escritos supondo que você tenha ao menos
o Java 5 – caso não tenha, sérios ajustes serão necessários:
% java – version
Java version “1.6.0_02”
Java(TM) SE Runtime Environment (build 1.6.0_02-b06)
Java HotSpot(TM) Client VM (build 1.6.0_02-b06, mixed mode, sharing)
Você também deve usar uma distribuição Java licenciada verdadeira (como as da Sun ou Apple); nossos
revisores técnicos acharam que a “semelhante” implementação GNU não executaria essas ferramentas e
exemplos adequadamente quando estávamos escrevendo este livro. Esse ambiente GNU é o Java padrão
carregado com diversas distribuições Linux. Se estiver trabalhando com uma distribuição Linux, pode ser
que precise baixar o JDK da Sun e ter certeza que é essa a versão que está chamando (executando javaversion). Agora que a Sun possui Java de fonte aberta, esperamos que isso melhore no futuro e teremos
JRE e JDK Sun por padrão, mesmo em distribuições puristas. Até lá, provavelmente será necessário fazer o
donwload da versão mais recente.
Quando este livro estava sendo escrito, as distribuições baseadas em Debian permitiam
instalar um JDK Sun utilizando seus utilitários de gerenciamento de pacotes (tanto o 5 como
o 6 estão disponíveis nas versões “Feisty Fawn” e “Gustsy Gibbon” do Ubuntu. Distribuições
derivadas do Red Hat ainda necessitam baixar Java diretamente da Sun Microsystems. Sua
quilometragem pode variar.
Quando tudo isso estiver configurado, você pode começar a aquecer o Ant executando um teste e verificar
se está tudo certo.
% ant -version
Apache Ant version 1.7.0 compiled on December 13 2006
O que aconteceu?
Bem, não muito ainda, mas agora você está em uma posição onde poderá testar os exemplos que fornecermos
mais tarde e usá-los como ponto inicial para os seus projetos reais do Hibernate.
Se o Ant é novo para você, não seria má idéia ler o manual um pouquinho para ter noção de como ele
funciona e o que ele pode fazer; isso ajudará dando sentido aos arquivos build.xml que usaremos em
nossos exemplos. Se decidir (ou já sabe) que gosta do Ant e quer ir mais a fundo, você pode ler o manual†
ou pegar o Ant: The Definitive Guide da O´Reilly (depois que terminar este livro, é claro)!
Mas e...
...o Eclipse‡, o JBuilder§, o NetBeans¦ ou qualquer outro IDE Java? Bem, é claro que você pode usá-los, mas
estará sozinho até que precisará integrar Ant no processo de construção. (Vários já utilizam Ant, então pode
ser que você inicie mais à frente; para os outros, pode ser que passem por alguns momentos difíceis.) Se
tudo falhar, use o IDE para desenvolver seu próprio código, mas chame o Ant da linha de comando quando
precisar usar um de nossos scripts de construção.
† http://www.ant.apache.org/manual/
‡ http://www.eclipse.org/
§ http://www.borland.com/jbuilder/
║ http://www.netbeans.org/
Capítulo 1: Instalação e Configuração 5
Se estiver usando o Maven, você pode gerar os arquivos do projeto Eclipse IDE executando mvn
eclipse:eclipse do diretório de exemplo de qualquer capítulo ou de diretórios de exemplo de
níveis superiores. Se executar mvn eclipse:eclipse dos diretórios de exemplo, o Maven gerará
um projeto Eclipse para cada configuração de exemplo do capítulo. No Capítulo 12 você
encontrará instruções mais detalhadas para construir os exemplos em Maven e, no Capítulo
11, uma introdução para usar as ferramentas Eclipse do Hibernate mais profundamente.
Como obter as Tarefas do Maven para Ant
Espere – eu não disse que estamos utilizando Ant nos projetos de exemplo deste livro? Sim. Mas não é só
isso. Embora o Ant permaneça como o fundamento para os exemplos deste livro, decidimos também, nessa
segunda versão, melhorar as características de gerenciamento de dependência excelente do Maven através
das Tarefas Maven para Ant. A primeira versão deste livro gastou páginas preciosas fornecendo instruções
para baixar e arrumar toda a hospedagem das bibliotecas de terceiros: tudo do Jakarta Commons Lang
para CGLIB. (E pela sua perspectiva, isso significa que você gastaria muitos minutos preciosos seguindo
as instruções com cuidado e de forma tediosa.)
Figura 1-1 Link do download para as Tarefas do Maven para Ant no site do Maven
Nesta versão declaramos as dependências de nossos projetos em nosso arquivo build.xml e deixamos o
Maven tomar conta do download e do gerenciamento de nossas dependências. Isso economiza toneladas
de passos e de tempo. Agora é hora de instalar as Tarefas do Maven para Ant.
Como eu faço isso?
Existem duas maneiras de integrar as Tarefas do Maven para Ant: a primeira é baixar o JAR requisitado
no diretório lib de Ant e a segunda é incluir a antlib através da declaração typedef em um arquivo de
construção Ant. Vamos utilizar o método anterior e baixar o maven-ant-tasks-2.0.8.jar no diretório lib de
6 Dominando Hibernate
Ant porque ele requer uma quantidade mínima de trabalho no arquivo build.xml do nosso exemplo e facilita
o compartilhamento de vários projetos. Criaremos build.xml mais tarde. Primeiro vamos baixar o arquivo
JAR necessário do site# do Maven. Na primeira página você verá um link para download das Tarefas do
Maven para Ant (veja a Figura 1-1).
Enquanto escrevia este livro, as Tarefas do Maven para Ant estavam na versão 2.0.8. Ao clicar no link Maven
Tasks for Ant 2.0.8 e escolher uma cópia, você fará o download do arquivo JAR nomeado maven-ant-tasks2.0.8.jar. Salve esse arquivo em um diretório local.
Instalar as Tarefas do Maven para Ant
Agora, copie o arquivo maven-ant-tasks-2.0.8.jar que você baixou em seu diretório ANT_HOME/lib. Se você
está seguindo este capítulo do início ao fim, você acabou de baixar e instalar o Ant. Você também deve ter
configurado a variável do ambiente ANT_HOME e deve estar familiarizado com o lugar em que instalou
o Ant. Depois que copiou maven-ant-tasks-2.0.8.jar para o seu diretório ANT_HOME/lib, qualquer arquivo
build.xml pode incluir espaço com nome apropriado para utilizar as Tarefas do Maven para Ant.
Se executar esses exemplos em uma máquina de desenvolvimento multiusuário e não tiver
direitos administrativos para colocar um arquivo JAR no diretório ANT_HOME/lib, não se
preocupe. Você pode colocar o arquivo maven-ant-tasks-2.0.8.jar no diretório ~/.ant/lib. O
Ant automaticamente procurará arquivos JAR nesse diretório.
Depois de copiar maven-ant-tasks-2.0.8.jar em seu diretório ANT_HOME/lib, você poderá executar os
seguintes comandos para ver se maven-ant-tasks-2.0.8.jar está incluído no caminho da classe em Unix:
% ant -diagnostics | grep maven | grep bytes
maven-ant-tasks-2.0.8.jar (960232 bytes)
No Windows, execute ant-diagnostics e analise o resultado para verificar a presença de maven-ant-tasks2.0.8.jar na lista de bibliotecas, no caminho da classe.
Utilizar o servidor de Banco de Dados HSQLDB
O Hibernate funciona com grandes e variados bancos de dados relacionais; as chances são de que ele
funcione com aquele que você está planejando usar em seu próximo projeto. Precisamos escolher um
para focar em nossos exemplos e, por sorte, há uma opção óbvia. O projeto livre, de fonte aberta, 100%
Java HSQLDB é poderoso o bastante para formar armazenamento complementar para os nossos projetos
de software comercial. Surpreendentemente, também é independente e de simples instalação – tão fácil,
na realidade, que podemos deixar o Maven cuidar dele para nós nesta nova versão do livro – por isso é
perfeito discuti-lo aqui. (Se você já ouviu sobre o Hypersonic-SQL, essa é a encarnação atual dele. Grande
parte da documentação do Hibernate utiliza nomes antigos.
Não entre em pânico se você se deparou com o http://hsql.sourceforge.net/, pois parece o tipo
de projeto que nunca foi terminado. Esse endereço está errado; ele fala sobre o predecessor
ao projeto atual HSQLDB. A figura 1-2 mostra a página principal correta, atual e bem viva
do projeto.
#http://maven.apache.org/
Capítulo 1: Instalação e Configuração 7
Por que me preocupar?
Os exemplos são fundamentados em um banco de dados que todos podem baixar e experimentar facilmente
de maneira que não será necessário traduzir qualquer um dos nossos dialetos SQL ou comandos de sistema
operacional para trabalhar com seus bancos de dados disponíveis (e que pode significar ainda que você
economizará um dia ou dois para aprender como baixar, instalar e configurar um dos ambientes de banco
de dados mais típicos. Finalmente, se o HSQLDB é novo para você, provavelmente ficará impressionado
e intrigado e poderá até utilizá-lo em seus próprios projetos. Conforme está na página principal do
projeto:
O HSQLDB é o servidor líder de banco de dados relacional escrito em Java. Ele possui um driver JDBC e
suporta um subsistema rico de ANSI-92 SQL (BNF em formato de árvore) mais as melhorias do SQL 99 e
2003. Ele oferece um pequeno (menos de 100 k em uma versão para miniaplicativos) e rápido servidor
de banco de dados que oferece tanto memória interna como tabelas baseadas em disco e suporta modos
embutidos e servidores. Ele também inclui ferramentas tais como um servidor mínimo para web, requisição
em memória, ferramentas de gerenciamento (podem ser executadas como miniaplicativos) e um número
de exemplos de demonstração.
Como eu faço isso?
Quando você construir os exemplos deste livro, as Tarefas Ant Maven automaticamente baixarão o HSQLDB
JARs (e quaisquer outros JARs que forem necessários) do repositório Maven em http://repo1.maven.org/
maven2/. Por isso, se quiser começar a usar imediatamente, você pode pular para a seção “Configurando
a Hierarquia de um Projeto”. Por outro lado, se preferir baixar o HSQLDB para suas próprias finalidades
ou explorar a documentação, o fórum online ou os arquivos da lista de correspondência, visite a página
do projeto em http://hsqldb.org/. Clique no link para baixar manualmente a “última versão estável” (que
é a 1.8.0.7 usada quando o livro estava sendo escrito, conforme destacado na Figura 1-2). Ela te levará a
uma página de downloads SourceForge com a versão atual selecionada. Faça uma cópia e baixe o arquivo
ZIP.
Continue, baixe o HSQLDB. Nossa, leva dois minutos, eles são pequenos!
Mas e...
... algum outro banco de dados? Não se preocupe, o Hibernate pode trabalhar com MySQL, PostgreSQL,
Oracle, DB2, Sybase, Informix, Apache Derby e outros. (Falaremos sobre como especificar “dialetos” em
diferentes bancos de dados mais tarde, no Capítulo 10 e no Apêndice C.) E, se quiser realmente, você pode
tentar compreender como trabalhar com o seu preferido desde o início, mas isso significa trabalho extra
para você ao acompanhar os exemplos e perderá uma grande oportunidade para descobrir o HSQLDB.
8 Dominando Hibernate
Figura 1-2 Link da última versão estável na página principal do HSQLDB
Usar o Hibernate Core
Esta seção não necessita de tanta motivação! Você pegou este livro porque quis aprender a usar o Hibernate.
A parte que fornece serviços do núcleo do mapeamento objeto/relacional para suas aplicações é chamada,
talvez não surpreendentemente, de Hibernate Core. Quando construir os exemplos deste livro, o Hibernate
e todas as suas dependências são baixadas automaticamente. Apesar de esta nova versão dos exemplos
do livro se preocupar em buscar o Hibernate através das Tarefas Ant Maven, você pode baixar a última
distribuição do Hibernate para explorar a fonte ou apenas visualizar a documentação online, o fórum e
outros materiais de apoio por sua conta. Se estiver pronto para os testes, você pode pular para a próxima
seção, “Configurando a Hierarquia de um Projeto”.
Como eu faço isso?
Comece na página principal do Hibernate em http://hibernate.org/ e explore a partir dali. Para conseguir
uma cópia completa da distribuição, procure o link de Download, que fica no lado esquerdo conforme
mostrado na Figura 1-3.
A seção das Versões Binárias mostrará qual versão do Hibernate Core é recomendável para ser baixada;
siga essa recomendação. (Se tiver coragem, você pode tentar uma versão em Desenvolvimento, mas a
aposta mais segura é ficar com a versão mais recente de Produção.) Depois que escolheu a versão, clique
no link para Download na linha correspondente (veja a Figura 1-4).
Capítulo 1: Instalação e Configuração 9
Figura 1-3 Link para Download na página principal do Hibernate
Você será levado para uma página de downloads SourceForge com a sua versão escolhida e a opção
de formatos de arquivos. Escolha a sua versão preferida e baixe-a. O nome do arquivo será algo do
tipo hibernate-3. x.y.tar.gz ou hibernate-3.x.y.zip. (Enquanto escrevia este livro , os nomes dos arquivos
começavam com hibernate-3.2.5.ga, uma vez que geralmente a versão disponível do Hibernate 3.2.5 é a
versão de produção atual.)
Escolha um local adequado para manter tais itens e expanda os arquivos compactados.
Na página de download do Hibernate, você pode olhar o Hibernate Tools (link de download que leva até
uma página entitulada JBossTools, mas ainda é possível encontrar o Hibernate Tools ali). Essas ferramentas
oferecem diversas capacidades úteis que não são necessárias em uma aplicação que executa o Hibernate,
mas são muito úteis para os desenvolvedores que criam tais aplicações. Logo utilizaremos uma para gerar
código em Java em nossa primeira experiência. O nome de arquivo Tools aparecerá como em hibernatetools3.x.y.zip (não haverá necessariamente a mesma versão do próprio Hibernate, pois normalmente está
disponível apenas como beta; a Matriz de Compatibilidade, logo abaixo da seção Versões Binárias da página
de download do Hibernate, exibe uma tabela mostrando quais partes do Hibernate são compatíveis).
10 Dominando Hibernate
Figura 1-4 Versões binárias do Hibernate
Novamente, baixe esse arquivo e expanda-o perto de onde você colocou o Hibernate.
Se tiver problemas com os links de download, o site pode ser alterado e você não verá os
arquivos que espera. Se isso acontecer, você pode voltar e clicar no link “Browse all Hibernate
downloads” abaixo da caixa das Versões Binárias e rolar a página até encontrar o que procura.
O projeto é tão ativo que isso acontece com mais freqüência do que você imagina.
Configurar a Hierarquia de um Projeto
Embora comecemos com pequenos arquivos nesse teste, quando começarmos a projetar estruturas de
dados e construir classes de Java e tabelas de banco de dados que as representam, junto com toda a
configuração e arquivos de controle para uni-los e fazer coisas úteis acontecer, terminaremos com muitos
arquivos. Por isso, queremos certificar que seremos muito organizados desde o início. Entre as ferramentas
que baixamos e suas bibliotecas de suporte, há ainda um número significante de arquivos para organizar.
Por sorte, as Tarefas Ant Maven baixam e gerenciam todas as dependências externas.
Por que me preocupar?
Se você construir algo legal estendendo os exemplos deste livro e quiser transformá-lo em uma aplicação
real, estará bem desde o início. Além disso, se você configurar conforme está explicado aqui, os comandos
e as instruções que dermos através dos exemplos farão sentido e funcionarão de fato; muitos exemplos
constroem-se uns nos outros por todo o livro, por isso é importante continuar no caminho certo desde o
início.
Se quiser pular para os exemplos mais à frente ou evitar a digitação de códigos de amostra mais longos
e arquivos de configuração, você pode baixar as versões “terminadas” dos exemplos do capítulo no site*
do livro. Esses downloads serão organizados conforme for descrito aqui. Recomendamos que baixe os
exemplos e os use como referência enquanto ler este livro.
*http://www.altabooks.com.br
Capítulo 1: Instalação e Configuração 11
Como eu faço isso?
Aqui está a ordem de configuração da hierarquia de um projeto vazio, se você não estiver baixando os
exemplos “terminados”:
1. Escolha um local em seu disco rígido, onde queira trabalhar com esses exemplos, e crie uma nova
pasta, que será referida a partir de agora como o seu diretório de projeto.
2. Vá nesse diretório e crie subdiretórios chamados src e data. A hierarquia de fonte Java e os
recursos relacionados estarão no diretório src. Nosso processo de construção fará a compilação em
um diretório de classes que ele criar, assim como copiará qualquer recurso do tempo de execução
ali. O diretório data é onde colocaremos o banco de dados HSQLDB.
3. As classes de exemplo que criaremos ficarão todas no pacote com.oreilly.hh (harnessing Hibernate)
e faremos com que o Hibernate gere nossos beans de dados no pacote com.oreilly.hh.data para
mantê-los separados das classes que escrevermos à mão, por isso crie esses diretórios abaixo do
diretório src. No Linux e no Mac OS X, você pode usar:
mkdir -p src/com/oreilly/hh/data
de dentro do seu diretório de projeto para realizá-lo em um passo.
Nesta altura, seu diretório de projeto deve estar estruturado como na Figura 1-5.
Está bem mais simples que no primeiro livro, onde quase não compensa mostrar o
exemplo.
Um teste rápido
Antes de ativar o Hibernate de fato para fazer qualquer trabalho útil, vale a pena verificar se as partes de
apoio estão no devido lugar e prontas para serem utilizadas. Vamos começar pelo arquivo de configuração
Ant que usaremos em todo o projeto, diga ao Ant onde foram colocados os arquivos que estamos usando
e ative a interface de banco de dados gráfica HSQLDB. Isso será prova de que as Tarefas Ant Maven são
capazes de encontrar e baixar as bibliotecas das quais os exemplos dependerão e a habilidade de acessar
a interface será útil mais tarde, quando quisermos olhar os dados reais que o Hibernate vem criando para
nós. No momento é, em primeiro lugar, um teste de racionalidade para verificar se não há erros e que
estamos prontos para seguir adiante.
Ative um editor de texto de sua escolha e crie um arquivo nomeado build.xml no nível superior, dentro do
seu diretório de projeto. Digite o conteúdo do Exemplo 1-1 no arquivo.
12 Dominando Hibernate
Figura 1-5 Conteúdo do diretório de projeto inicial
O Hibernate está fazendo as criações para nós. Por enquanto, esta é apenas uma verificação de sanidade,
para ver se não há nenhum defeito, e logo estaremos prontos para continuar. Abra o editor de texto de sua
preferência e crie um arquivo chamado build.xml no topo de seu diretório de projetos. Digite o conteúdo do
Exemplo 1-1 no arquivo.
Exemplo 1-1. Arquivo de construção Ant
<?xml version=”1.0”?> 1
<project name=”Harnessing Hibernate 3 (Developer’s Notebook Second Edition)”
default=”db” basedir=”.”
xmlns:artifact=”antlib:org.apache.maven.artifact.ant”> 2
<!-- Configure as propriedades que contêm diretórios de projeto importantes 3
-->
<property name=”source.root” value=”src”/>
<property name=”class.root” value=”classes”/>
<property name=”data.dir” value=”data”/>
<artifact:dependencies pathId=”dependency.classpath”> 4
<dependency groupId=”hsqldb” artifactId=”hsqldb” version=”1.8.0.7”/>
<dependency groupId=”org.hibernate” artifactId=”hibernate”
version=”3.2.5.ga”>
<exclusion groupId=”javax.transaction” artifactId=”jta”/>
</dependency>
<dependency groupId=”org.hibernate” artifactId=”hibernate-tools”
version=”3.2.0.beta9a”/>
<dependency groupId=”org.apache.geronimo.specs”
artifactId=”geronimo-jta_1.1_spec” version=”1.1”/>
<dependency groupId=”log4j” artifactId=”log4j” version=”1.2.14”/>
</artifact:dependencies>
<!-- Configure o caminho de classe para compilação e execução -->
<path id=”project.class.path”> 5
<!-- Inclua nossas próprias classes, é claro -->
<pathelement location=”${class.root}” /> 6
<!-- Acrescente o classpath das dependências -->
<path refid=”dependency.classpath”/> 7
</path>
<target name=”db” description=”Runs HSQLDB database management UI
against the database file--use when application is not running”> 8
<java classname=”org.hsqldb.util.DatabaseManager”
fork=”yes”>
<classpath refid=”project.class.path”/>
<arg value=”-driver”/>
<arg value=”org.hsqldb.jdbcDriver”/>
Capítulo 1: Instalação e Configuração 13
<arg
<arg
<arg
<arg
</java>
</target>
</project>
value=”-url”/>
value=”jdbc:hsqldb:${data.dir}/music”/>
value=”-user”/>
value=”sa”/>
Cuidado com a pontuação ao digitar isso e preste atenção especial nas tags XML de
autofechamento (aquelas que terminam com “/>” em vez de “>”). Se errar, será retribuído
com erros de sintaxe quando executar Ant. Novamente, você pode baixar todos esses arquivos
se não precisar digitá-los. Se estiver como um arquivo em PDF na tela, você também pode
copiar e colar o código, mas precisará editar os marcadores numerados em destaque.
Se você nunca viu um arquivo de construção Ant antes, temos uma introdução rápida para ajudar você a
orientar-se. Se quiser mais detalhes, a documentação em http://ant.apache.org/manual/index.html é muito
boa:
1
A primeira linha é simplesmente uma declaração que o tipo do arquivo é XML. Se você já trabalhou
com XML em outros contextos, está acostumado a ver isso. Se não, você o verá novamente. (Ant não
necessita disso atualmente, mas a maioria das sintaxes XML necessita, então é bom desenvolver
esse hábito.)
2
Os arquivos de construção do Ant contêm uma definição project única. O atributo default diz para Ant
qual alvo (definido mais tarde) construir, se você não especificar um comando de linha. E o atributo
basedir determina o diretório relativo para o qual todos os cálculos de caminho são feitos. Poderíamos
ter deixado isso de fora já que o padrão é tratar os caminhos como sendo relativos ao diretório
no qual o build.xml está localizado, mas não é uma boa prática ser explícito sobre configurações
fundamentais como essa. Algo importante a se notar neste elemento project é a definição do espaço
de nome xmlns:artifact para as Tarefas Ant Maven. Essa definição do espaço de nome torna as Tarefas
Ant Maven disponíveis dentro desse arquivo de construção usando o prefixo artifact: (como você
verá em uso posteriormente).
3
A próxima parte define três propriedades que podem ser usadas com nome pelo restante do arquivo em
construção. Essencialmente, estamos definindo nomes simbólicos para os diretórios importantes usados
por aspectos diferentes do projeto. Não é necessário (especialmente quando os diretórios são nomeados
de maneira simples), porém essa é outra boa prática. Primeiramente, isso significa que, se você precisar
mudar a localização de um desses diretórios, será necessário consertar apenas um lugar no arquivo em
construção em vez de conduzir uma busca tediosa e fazer a substituição.
4
O elemento artifact:dependencies faz parte das Tarefas Ant Maven, que você (e Ant) podem chamar
pelo prefixo artifact:Nesse elemento definimos uma série de dependências que o projeto necessita para
compilação e execução. Essas dependências correspondem aos arquivos JAR (ou artefatos) no Repositório
central do Maven 2 em http://repo1.maven.org/maven2. Cada artefato é unicamente identificado por
um groupId, artifactId e um número version. Nesse projeto, dependemos do Hibernate, do HSQLDB, do
Log4J e do JTA API. Quando as Tarefas Ant Maven encontram essas declarações de dependência, cada
artefato é baixado do repositório central do Maven 2, em uma base de acordo com a necessidade, em
seu repositório local do Maven 2 (in ~/.m2/repository). Não se preocupe se esta seção não fizer muito
sentido ainda; entraremos em detalhes nas próximas páginas.
14 Dominando Hibernate
Esta seção é onde você faria mudanças para usar a versão mais recente de um desses pacotes, se
quisesse (uma vez que as versões mais recentes provavelmente estarão disponíveis após a publicação
deste livro), mudando os valores de version. Mas você pode ficar tranqüilo porque os exemplos
publicados no livro continuarão a funcionar, visto que o repositório do Maven garante que as versões
que testamos em oposição continuarão disponíveis sempre que explorar os exemplos. Esse foi um
grande motivo para decidirmos adotar as Tarefas Ant Maven neste livro.
5
A seção class-path serve uma finalidade clara. Esse atributo sozinho é o motivo de eu quase nunca
começar os projetos em Java sem configurar, ao menos, uma construção Ant simples para eles. Quando
se usa muitas bibliotecas de terceiros, o que você fará em qualquer projeto sério, há muito que precisa
ir para o seu caminho de classe e você tem que ter certeza que configurou de maneira equivalente no
tempo de compilação e execução. O Ant facilita isso. Definimos um caminho, que é como se fosse uma
propriedade, mas ele sabe como analisar e selecionar arquivos e diretórios. Nosso caminho contém o
diretório classes no qual estaremos compilando nosso código Java (esse diretório não existe ainda;
acrescentaremos um passo no processo de construção para criá-lo no próximo capítulo), e também contém
todos os arquivos JAR correspondentes às dependências listadas no elemento artifact:dependencies. É
exatamente disso que precisamos para compilação e execução.
A compreensão e a manipulação de Ant nos caminhos de Java e as hierarquias de classe é
uma grande vantagem. Vale a pena aprender mais a fundo.
6
A sintaxe nessa linha parece uma complicação de pontuações, mas pode ser separada em partes
que fazem sentido. O Ant permite usar a substituição para inserir valores variáveis em suas regras.
Sempre que você vir algo do tipo “
”, isso significa “procure o valor da propriedade nomeada class.root e coloque-o aqui.” Por isso, dada
a definição da propriedade class.root antes, é como se digitassemos: <pathelementlocation=”clas
ses”/>. Então, por que fazer isso? Isso permite que você divida um valor por todo o arquivo, assim,
se precisar mudá-lo alguma vez, há apenas um lugar para se preocupar. De maneira mais ampla, em
projetos complexos, esse tipo de organização e gerenciamento é crucial.
7
O elemento artifact:dependencies, que vimos antes, junta-se a todas as dependências declaradas em um
único caminho nomeado dependency.classpath usando seu atributo pathId. Aqui, estamos anexando o
conteúdo de dependency.classpath para o project.class.path para que todas as dependências trazidas
pelo Maven estejam disponíveis na compilação e no tempo de execução.
8
Finalmente, com todo esse prólogo que não é demais, podemos definir nosso primeiro alvo. Um
alvo é simplesmente uma série de tarefas que necessita ser executada com a finalidade de cumprir
o objetivo de um projeto. Alvos típicos fazem coisas como compilar código, executar testes,
empacotar coisas para distribuição e assim por diante. As tarefas são escolhidas a partir de uma
série rica de capacidades construídas no Ant e ferramentas de terceiros, como o Hibernate, podem
estender o Ant para fornecer suas próprias tarefas úteis, como veremos no próximo capítulo. Nosso
primeiro alvo, db, executará a interface gráfica do HSQLDB para que possamos olhar em nosso
banco de dados de exemplo. Podemos alcançar isso usando a tarefa java construída de Ant, que
pode executar uma máquina virtual Java para nós, com quaisquer classe inicial, argumentos e
propriedades que queiramos.
Capítulo 1: Instalação e Configuração 15
Nesse caso, a classe que queremos invocar é org.hsqldb.util.DatabaseManager, localizada em HSQLDB
JAR que as Tarefas Ant Maven gerenciarão para nós. Ao configurar o atributo fork para yes, você diz
ao Ant para usar uma máquina virtual separada, que não é o padrão, uma vez que leva um pouco
mais de tempo e normalmente não é necessária. Nesse caso é importante, desde que queiramos
que o gerenciador de banco de dados GUI fique por perto até o dispensarmos, e isso não acontece
quando é executado o VM próprio do Ant.
Se seu banco de dados GUI abre e desaparece, verifique novamente o atributo fork da sua
tarefa java.
Você pode ver como informamos a tarefa java no caminho da classe que configuramos; essa é uma
característica comum de nossos alvos. Em seguida, fornecemos uma quantidade de argumentos ao
gerenciador do banco de dados dizendo para usar o driver HSQLDB JDBC, onde encontrar o banco
de dados e que nome de usuário utilizar. Especificamos um banco de dados chamado music no
diretório data. Atualmente, esse diretório está vazio, por isso o HSQLDB criará o banco de dados
na primeira vez que o utilizarmos. O usuário é o “administrador do sistema” padrão para novos
bancos de dados e ele é configurado para não precisar de senha inicialmente. É óbvio que, se você
planeja disponibilizar esse banco de dados na rede (o que o HSQLDB é capaz de fazer), você terá
que configurar uma senha. Não estamos fazendo nada tão especial, então podemos deixar isso de
fora por enquanto.
Certo, agora vamos tentar! Salve o arquivo e, a partir de uma orientação (comando) encapsulada executando
em seu diretório de projeto de nível superior (onde você coloca build.xml), digite o comando:
ant db
(Ou, depois que fizemos do db o alvo padrão , é possível digitar apenas ant.) Uma vez que o Ant começa
a ser executado, se tudo correr bem, você verá o produto assim:
Buildfile: build.xml
Downloading: hsqldb/hsqldb/1.8.0.7/hsqldb-1.8.0.7.pom
Transferring 0K
Downloading: org/hibernate/hibernate/3.2.5.ga/hibernate-3.2.5.ga.pom
Transferring 3K
Downloading: net/sf/ehcache/ehcache/1.2.3/ehcache-1.2.3.pom
Transferring 19K
Downloading: commons-logging/commons-logging/1.0.4/commons-logging1.0.4.pom
Transferring 5K
Downloading: commons-collections/commons-collections/2.1/commons-collections2.1
.pom
Transferring 3K
Downloading: asm/asm-attrs/1.5.3/asm-attrs-1.5.3.pom
Transferring 0K
Downloading: dom4j/dom4j/1.6.1/dom4j-1.6.1.pom
Transferring 6K
Downloading: antlr/antlr/2.7.6/antlr-2.7.6.pom
Transferring 0K
Downloading: cglib/cglib/2.1_3/cglib-2.1_3.pom
Transferring 0K
Downloading: asm/asm/1.5.3/asm-1.5.3.pom
Transferring 0K
Downloading: commons-collections/commons-collections/2.1.1/commonscollections-2
.1.1.pom
Transferring 0K
16 Dominando Hibernate
Downloading: org/hibernate/hibernate-tools/3.2.0.beta9a/hibernate-tools3.2.0.be
ta9a.pom
Transferring 1K
Downloading: org/hibernate/hibernate/3.2.0.cr5/hibernate-3.2.0.cr5.pom
Transferring 3K
Downloading: freemarker/freemarker/2.3.4/freemarker-2.3.4.pom
Transferring 0K
Downloading: org/hibernate/jtidy/r8-20060801/jtidy-r8-20060801.pom
Transferring 0K
Downloading: org/apache/geronimo/specs/geronimo-jta_1.1_spec/1.1/geronimojta_1.
1_spec-1.1.pom
Transferring 1K
Downloading: org/apache/geronimo/specs/specs/1.2/specs-1.2.pom
Transferring 2K
Downloading: org/apache/geronimo/genesis/config/project-config/1.1/projectconfi
g-1.1.pom
Transferring 14K
Downloading: org/apache/geronimo/genesis/config/config/1.1/config-1.1.pom
Downloading: org/apache/geronimo/genesis/config/config/1.1/config-1.1.pom
Downloading: org/apache/geronimo/genesis/config/config/1.1/config-1.1.pom
Transferring 0K
Downloading: org/apache/geronimo/genesis/genesis/1.1/genesis-1.1.pom
Downloading: org/apache/geronimo/genesis/genesis/1.1/genesis-1.1.pom
Downloading: org/apache/geronimo/genesis/genesis/1.1/genesis-1.1.pom
Transferring 6K
Downloading: org/apache/apache/3/apache-3.pom
Downloading: org/apache/apache/3/apache-3.pom
Downloading: org/apache/apache/3/apache-3.pom
Transferring 3K
Downloading: log4j/log4j/1.2.14/log4j-1.2.14.pom
Transferring 2K
Downloading: org/hibernate/hibernate-tools/3.2.0.beta9a/hibernate-tools3.2.0.be
ta9a.jar
Transferring 352K
Downloading: org/hibernate/jtidy/r8-20060801/jtidy-r8-20060801.jar
Transferring 243K
Downloading: commons-collections/commons-collections/2.1.1/commonscollections-2
.1.1.jar
Transferring 171K
Downloading: commons-logging/commons-logging/1.0.4/commons-logging1.0.4.jar
Transferring 37K
Downloading: antlr/antlr/2.7.6/antlr-2.7.6.jar
Transferring 433K
Downloading: org/apache/geronimo/specs/geronimo-jta_1.1_spec/1.1/geronimojta_1.
1_spec-1.1.jar
Transferring 15K
Downloading: net/sf/ehcache/ehcache/1.2.3/ehcache-1.2.3.jar
Transferring 203K
Downloading: asm/asm/1.5.3/asm-1.5.3.jar
Transferring 25K
Downloading: freemarker/freemarker/2.3.4/freemarker-2.3.4.jar
Transferring 770K
Downloading: dom4j/dom4j/1.6.1/dom4j-1.6.1.jar
Transferring 306K
Downloading: asm/asm-attrs/1.5.3/asm-attrs-1.5.3.jar
Transferring 16K
Downloading: cglib/cglib/2.1_3/cglib-2.1_3.jar
Transferring 275K
Downloading: hsqldb/hsqldb/1.8.0.7/hsqldb-1.8.0.7.jar
Transferring 628K
Downloading: log4j/log4j/1.2.14/log4j-1.2.14.jar
Capítulo 1: Instalação e Configuração 17
Transferring 358K
Downloading: org/hibernate/hibernate/3.2.5.ga/hibernate-3.2.5.ga.jar
Transferring 2202K
db:
Essa grande lista de downloads mostra as Tarefas Ant Maven realizando o seu trabalho de procurar as
partes que dissemos que precisaríamos (incluindo o HSQLDB e o Hibernate), juntamente com todas as
bibliotecas que elas, por sua vez, dependem. Isso leva um tempo para fazer (dependendo da velocidade da
sua conexão de rede, e de quanto os servidores estejam carregados), mas isso será necessário apenas uma
vez. Na próxima vez que você ativar o Ant, as Tarefas Ant Maven simplesmente avisarão que seu repositório
local já contém todas essas partes, e prosseguirá silenciosamente com o que você quiser executar.
Depois que todo o download estiver completo, o Ant mostra db: para indicar que começa executar o alvo
requisitado. Um tempo depois, você deve ver a interface gráfica do HSQLDB, que será como na Figura
1-6. Não há nada em nosso banco de dados ainda, por isso há muito coisa a ser vista, caso o comando
tenha funcionado. A exibição em árvore na parte superior esquerda é onde as diversas tabelas e colunas
em nosso banco de dados podem ser exploradas. Por enquanto, verifique apenas se a parte superior lê
jdbc:hsqldb:data/music.
Figura 1-6 Interface do gerenciador de banco de dados HSQLDB
Você pode explorar os menus um pouco se quiser, mas não mude nada no banco de dados. Quando terminar,
escolha File Exit. A janela fechará e o Ant notificará:
BUILD SUCCESSFUL
Total time: 56 seconds
A quantidade de tempo que você gastará brincando pode variar, é claro. (Lembre que o Ant fica por perto
até que o banco de dados fecha, devido ao atributo fork que acrescentamos à tarefa java.) Nesse ponto,
se você olhar no diretório de dados, vai achar que o HSQLDB criou alguns arquivos para manter o banco
de dados:
% ls data
music.log
18 Dominando Hibernate
music.properties music.script
Você pode até olhar o conteúdo desses arquivos. Diferente da maioria dos sistemas de banco de dados,
o HSQLDB armazena seus dados em um formato legível por padrão. O arquivo das propriedades contém
algumas configurações básicas e os dados por si só entram no arquivo do script, na forma de declaração
SQL. O arquivo de evento é utilizado para reconstruir o estado de um banco de dados consistente se a
aplicação travar, do contrário sai sem fechar o banco de dados com elegância. Nesse momento, tudo o que
você encontrará nesses arquivos são as definições básicas que entram por padrão, mas como começamos
a criar tabelas e a adicionar dados a elas, você poderá visualizar o arquivo novamente e ver as mudanças
aparecerem nela. Essa pode ser uma característica de depuração para verificação de sanidade e é ainda
mais rápido que ativar a interface gráfica e as queries em execução.
O fato de poder ler os arquivos do banco de dados HSQLDB é estranho, mas divertido.
O que aconteceu?
Agora que executamos o primeiro exemplo com sucesso e configuramos nosso arquivo de construção de
projeto, provavelmente é o tempo de explicar como o Ant recuperou todas as dependências necessárias
para esse projeto. Vamos examinar novamente o elemento artifact:dependencies do arquivo build.xml de
exemplo. (veja o Exemplo 1-2).
Exemplo 1-2 Nosso elemento artifact:dependencies
<artifact:dependencies pathId=”dependency.classpath”>
<dependency groupId=”hsqldb” artifactId=”hsqldb” version=”1.8.0.7”/>
<dependency groupId=”org.hibernate” artifactId=”hibernate”
version=”3.2.5.ga”>
<exclusion groupId=”javax.transaction” artifactId=”jta”/>
</dependency>
<dependency groupId=”org.hibernate” artifactId=”hibernate-tools”
version=”3.2.0.beta9a”/>
<dependency groupId=”org.apache.geronimo.specs”
artifactId=”geronimo-jta_1.1_spec” version=”1.1”/>
<dependency groupId=”log4j” artifactId=”log4j” version=”1.2.14”/>
</artifact:dependencies>
Se você nunca usou o Maven antes, isso pode parecer muito confuso. Vamos começar definindo a
terminologia. Primeiro há um artefato. Um artefato é um arquivo produzido por um projeto. Um artefato
pode ser de qualquer tipo – um WAR para uma aplicação web, um EAR para a aplicação de um projeto
ou um JAR. Para o nosso objetivo dependemos de artefatos JAR e o tipo padrão se não especificado no
elemento de dependência é jar, convenientemente suficiente.
Um artefato específico é identificado por quatro atributos: groupId, artifactId, version e type. Por exemplo,
dependemos da versão 3.2.5.ga do artefato hibernate no grupo org.hibernate e o tipo indicado é jar.
O Maven utilizará esses identificadores para localizar a dependência apropriada no repósitório central do
Maven 2 que está hospedado em http://repo1.maven.org/maven2/. Usando esses valores, o Maven tentará
localizar o JAR para o hibernate usando o seguinte padrão: <repositoryUrl>/<groupId>/<artifactId>/<v
ersion>/<artifactId>-<version>.<type>, onde os períodos no groupId são convertidos para separadores
de caminho para as URLs, usando esse padrão, seria útil colocar os JARs nas dependências do Hibernate
e do HSQLDB. Veja o Exemplo 1-3.
Example 1-3. URLs para as dependências de projeto.
http://repo1.maven.org/org/hibernate/hibernate/3.2.5.ga/hibernate-3.2.5.ga.jar
http://repo1.maven.org/hsqldb/hsqldb/1.8.0.7/hsqldb-1.8.0.7.jar
Capítulo 1: Instalação e Configuração 19
No nosso arquivo build.xml, estamos excluindo a dependência JTA da declaração de dependência do
Hibernate. Isso é necessário porque a biblioteca do Hibernate depende de um artefato JAR não livre e não
disponível no repositório público do Maven 2. Em vez de usar o padrão Sun fornecido pela JTA API JAR, esse
projeto depende de uma versão do JTA API criada pelo projeto Apache Geronimo. geronimo-jta_1.1_spec
é uma implementação livre de fonte aberta de Java Transaction API. Essa substituição é realizada usando
o elemento exclusion dentro da dependência para o Hibernate 3.2.5.ga, combinada com a dependência
explícita da especificação Geronimo JTA 1.1 mais à frente.
Certo, então temos uma percepção de como as Tarefas Ant Maven recuperam as dependências do repositório
do Maven, mas para onde elas vão uma vez que foram baixadas? As Tarefas Ant Maven baixam todas
as dependências para um repositório local do Maven. O Maven mantém um repositório local com uma
estrutura que espelha o repositório remoto. Quando necessita da verificação de um artefato, ele confere
o repositório local primeiro, antes de exigir o artefato do repositório remoto. Isso significa que se vinte
projetos referenciam a mesma versão do Hibernate, ele é baixado do repositório remoto uma vez, e todos
os vinte projetos farão referência a uma única cópia armazenada no repositório local do Maven. Então,
onde fica esse repositório local mágico do Maven? A maneira mais fácil de responder a essa perguntar é
acrescentar um alvo para o nosso arquivo build.xml. Acrescente o alvo a seguir ao final do build.xml de
Ant anterior do capítulo, conforme mostrado no Exemplo 1-4.
Exemplo 1-4. Mostrando o caminho de classe da dependência
<target name=”print-classpath” description=”Show the dependency class path”>
<property name=”class.path” refid=”dependency.classpath”/>
<echo>${class.path}</echo>
</target>
A execução desse alvo produzirá os seguintes resultados de saída:
% ant print-classpath
Buildfile: build.xml
print-classpath:
[echo] ~\.m2\repository\commons-logging\commons-logging\1.0.4\commonslogging1.0.4.jar;\
~\.m2\repository\dom4j\dom4j\1.6.1\dom4j-1.6.1.jar;\
~\.m2\repository\cglib\cglib\2.1_3\cglib-2.1_3.jar;\...
Tente executar esse alvo. O resultado terá variações, dependendo de qual sistema operacional você está
usando, mas você perceberá que o caminho de classe da dependência se refere ao seu repositório local
do Maven. Em uma máquina com Windows XP isso acontecerá provavelmente em C:\Documents and
Settings\Username\.m2\repository; no Windows Vista será em C:\Users\Username\.m2\repository e no Unix
e Macintosh será no diretório ~/.m2/repository.
Você também perceberá que existem mais dependências listadas no caminho de classe do que foi declarado
no elemento artifact:dependencies em build.xml. Essas dependências extras são chamadas de dependências
transitórias, e são dependências de suas dependências declaradas explicitamente. Por exemplo, o Hibernate
depende do CGLib, EHCache e da Commons Collections, dentre outras coisas. Embora esteja fora do escopo
deste livro, darei uma dica sobre como as Tarefas Ant Maven entendem as configurações completas das
dependências para o seu projeto. Se explorar seu repositório local depois de ter construído um dos exemplos,
você verá que perto de todo artefato JAR há um arquivo com a extensão .pom. Os arquivos Project Object
Model files (or POMs) são a fundação do sistema de construção e repositório do Maven. Cada POM
descreve um artefato e as dependências daquele artefato. As Tarefas Ant Maven usam esses metadados
para construir uma árvore de dependências transitórias. Em outras palavras, as Tarefas Ant Maven não se
preocupam apenas em baixar o Hibernate, elas baixam tudo o que o Hibernate depende.
Tudo o que você precisa saber é que funciona.
20 Dominando Hibernate
E agora?
Graças às Tarefas Ant Maven, você teve menos dificuldades para encontrar, baixar, expandir e organizar o
software do que os leitores da versão anterior deste livro. Você está no ponto ideal para começar a trabalhar
com o Hibernate e, como você verá no próximo capítulo, passaremos muito rapidamente. Você poderá ver
o código Java escrito para você! O esquema do banco de dados criados em lugar algum (ou, pelo menos,
fora da mesma tabela de mapeamento XML que produziu Java)! As tabelas reais e os dados aparecendo
na interface do gerenciador HSQLDB! (ou, pelo menos, dados de amostra falsos genuínos...)
Parece interessante? Bem, comparado com o que fizemos até aqui? Então vamos começar com tudo para
acordar o poder do Hibernate.
Por que não funcionou?
Se, por outro lado, você não viu a janela do gerenciador do banco de dados aparecer e, em vez disso, foi
recebido com mensagens de erros, tente entender se foi devido a problemas no arquivo de construção,
por diferenças na maneira que você configurou Ant ou sua hierarquia de projeto; dificuldade em acessar
a Internet para baixar as dependências do repositório do Maven ou algo mais. Verifique mais de uma vez
se todas as partes foram arrumadas e instaladas como vimos anteriormente, e considere baixar o código
de amostra se estiver tendo problemas com uma versão que você mesmo digitou.
Capítulo 1: Instalação e Configuração 21