Dae gurizada!!!
Esse é um post simples para quem quer confirguar uma aplicação para usar Hibernate com Annotations.
Eu usei o Netbeans 5.5 para montar esse exemplo. Será necessário fazer o download do Hibernate Annotations, que por sua vez precisa do Hibernate Core. Para os teste utilizei o Postgresql 8.2. Segue os links: Abaixo está o link da aplicação exemplo: E só clicar nos links que irá direto para o local onde pode ser veito o download.
1º Passo: Criar o projeto
Esse artigo ainda foi feito no NetBeans 5.5. Para criar um novo projeto vá em Arquivo -> Novo Projeto. Selecione a categoria "Geral" e clique em Aplicação Java. Chamei o projeto de HibernateApp.
Crie uma pasta chamada de "lib" na raiz do seu projeto. A estrutura de diretórios vai ficar assim:
Criado o nosso projeto já criei alguns pacotes e classes. Veja:
Agora temos qu adicionar os jar necessários para a aplicação rodar. Se você notar, o hibernate tem um monte de JARs, mas nem todos são obrigatórios.
Abaixo estão quais os JARs devem estar na pasta LIB do nosso projeto. Vou separar os jars do Hibernate Core e do Hibernate Annotations, mas todos devem ser colocados na pasta LIB direto, não em subpastas.
Hibernate Core - 3.2.5GA:
- antlr.jar
- cglib.jar
- asm.jar
- asm-attrs.jars
- commons-collections.jar
- commons-logging.jar
- hibernate3.jar
- jta.jar
- dom4j.jar
- log4j.jar
Hibernate Annotations 3.3.0GA
- ejb3-persistence
- hibernate-commons-annotations
- hibernate-annotations
Postgresql 8.2
A minha pasta lib ficou assim:
Com os JARs na pasta lib ainda temos que adicionar ao projeto pelo Netbeans.
Para isso clique com o botão direito no nome do projeto e clieque em propriedades:
Depois clique em "Bibliotecas" e no botão "Adicionar Jar/Pasta" e localize os jars na pasta lib do nosso projeto:
2º Passo: Criar as classes - Entidades Persistentes.
É considerado "Entidade persistente" as classes que serão inseridas no banco de dados.
No nosso exemplo tenho duas classes que serão persistidas no banco de dados. A classe Pessoa e Endereco.
Veja com elas ficaram:
Explicação
@Entity: Toda classe persistente (POJO) deve user @Entity. Isso indica que a classe é uma entidade persistente(Entity Bean). Ou seja, existe uma tabela no banco de dados que representa essa classe. Por padrão o hibernate considera o nome da tabela igual ao nome da classe.
Caso sua classe possua um nome diferente ao nome da tabela, é necessário usar a anotaçao a seguir:
@Table: essa anotação é utiliza quando informamos o nome da tabela. Veja a classe Pessoa. O nome da classe é Pessoa, mas o nome da tabela no banco é TB_Pessoa.
@Id: Para o hibernate o ID é a forma de identificar o objeto (bem óbvio).
Os ID's podem ser gerados de várias formas dependendo do banco utilizado. O Postgresql, por exemplo, utiliza sequences. O MySQL tem um campo autoincrement e assim por diante.
Existem vários tipos de "generators". Veja esse link ou veja o meu outro post.
@Column: Essa anotação simplesmente indica qual coluna da tabela a propriedade irá referenciar. Por padrão todos os atributos da classe são pripriedades de tabelas.
@ManyToOne: esse atributo faz as relações entre as classes.
@JoinColumn: essa anotação indica qual coluna da classe Pessoa referencia a classe Endereço.
Agora um desenho para melhorar a compreensão: 
3º Passo: Classe/Arquivo de configuração:
Você deve estar se perguntando:
- Por que esse retardado colocou "'classe/arquivo de configuração" ?
Simples! Existem as duas formas de configurar o hibernate. Na verdade são 3.. heheheh
hibernate.cfg.xml ou hibernate.properties: Até chegar o annotations e jpa o hibernate era configurado através de um arquivo xml ou .properties. Neste arquivo estão as informaões de conexão com o banco e as classes que serão mapeadas. Utiliza-se esse arquivo quando vamos utilizar somente o Hibernate Core.
persistence.xml: A especificação EJB3 definiu o arquivo padrão para configuração do mapemaneto objeto relacional. Este arquivo é semelhanto ao hibernate.cfg.xml ( e tambem foi baseado nele). Utiliza-se esse arquivo quando vamos utilizar o EntityManager.
Configuração programática (classe): Uma alternativa ao antigo hibernate.cfg.xml. Todas as configurações informadas no arquivo de configuração do hibernate, podem ser setadas em tempo de execução.
Nosso hibernate.cfg.xml
Vamos ver primeiro o arquivo de configuração.
Crie um arquivo "hibernate.cfg.xml" dentro da pasta src do seu projeto.
OBS inútil: esse arquivo do hibernate pode ter outro nome. É obrigatório o arquivo conter "cfg.xml".
Ex: "qualauernome.cfg.xml"
Mas o nome mais comum é "hibernate.cfg.xml".
Veja como fica o meu projeto no netbeans:
Criado o arquivo vamos ver a maldita configuração:
Explicação
connection.driver_class: Nome da classe do driver que será utilizado. No meu caso estou utilizando o postgresql.
connection.url: URL para conexão com o banco. connection.username: nome do usuário para conexão com o banco connection.password: senha para conexão com o banco
Até aqui são configuraçoes normais que você já deve ter usado para criar conexões com o banco via JDBC dirto.
connection.pool_size: Configuração do pool de conexão. No nosso caso o hibernate manterá sempre 1 conexão com o banco.
dialect (Importantíssimo): O hibernate gera o sql dinamicamente de acordo com o banco de dados utilizado. A forma do Hibernate saber para qual banco gerar o SQL é o "dialect". Veja aqui a tabela de "dialetos" do hibernate.
cache.provider_class: O hibernate possui um podero sistema de Cahce de objetos. Eu particularmente nunca utilizei. Se alguem quiser se aprofundar veja em:
show_sql: Com o valor "true" exibe todos os comandos SQL executados pelo hibernate no console da IDE e no arquivo de LOG, caso configurado.
Ótimo para achar erros.
hbm2ddl.auto(maravilhoso): Essa cara aqui é muito bom. Esta ferramenta do hibernate gera o schema para o banco de dados, ou seja, ele cria o banco de dados com os seus relacionados, chaves primárias, etc.. a partir das classes configuradas no hibernate. Essa ferramente é executado quando criamos o SessionFactory que veremos a seguir.
Algums valores:
create-drop: Cria as tabelas do banco quando o SessionFactory é iniciado e deleta a base de dados quao termina a executação. Muito cuidado ao usar essa configração com o banco de dados de produção..hehehehe
update: Atualizar colunas e tabelas do banco de dados. Essa configuração não deleta nenuma coluna, somente insere.
OBS: É necessário já estar criado o "database".
"mapping class":
Bom esse trecho não é bem uma configuração. Aqui estamos adicionando as classes que serão mapeadas no hibernate. Todas as classe que iremos mapear no hibernate tem que ser adicionadas na configuração.
Agora que foi entendido a configuração do hibernate vamos ver como fazer essa mesma configuração na classe:
Nessa classe criamos uma instância da classe AnnotationConfiguration que é a classe do hibernate que recebe configurações iguais ao do XML.
Veja que chamei o método "setProperty" para setar as propriedades.
4º Passo: Iniciar o Hibernate.
Eu criei uma classe chamda HibernateConfig com os métodos iniciarHibernateClasse(mostrado acima) e iniciarHibernateXML, abaixo.
A lógica para istânciar um objeto SessionFactory é a mesma com o arquivo de configuação e para a classe.
1º Criar o objto AnnotationConfiguration
2º Setar as configurações.
Classe: setar as configurações a partir do método setProperty
Arquivo cfg.xml: chamar o método configure() da classe AnnotationConfiguration. Este método irá carregar as configurações do arquivo e retornar um objeto do tipo Configuration.
3º Chamar o método
Classe: chamar o método "buildSessionFactory()" da classe AnnotationConfiguration.
Arquivo: chamar o método "buildSessionFactory()" do objeto retornado do método "configure()"
Se ficiu confuso esses passos veja a classe que vai ajudar.
Bom.. mais uma vez fica aqui meu pedido de críticas e sugestões...
No mais era isso...
Abração!
