Tutorial Hibernate para Iniciantes

Bem-vindo ao tutorial do Hibernate para iniciantes. O Hibernate é uma das ferramentas Java ORM mais amplamente utilizadas. A maioria das aplicações utiliza bancos de dados relacionais para armazenar informações da aplicação e, em um nível mais baixo, utilizamos a API JDBC para conectar-se aos bancos de dados e realizar operações CRUD.

Tutorial do Hibernate para iniciantes

Se você olhar para o código JDBC, há muito código repetitivo e há chances de vazamento de recursos e inconsistência de dados, pois todo o trabalho precisa ser feito pelo desenvolvedor. É aqui que uma ferramenta ORM se torna útil. Mapeamento objeto-relacional ou ORM é a técnica de programação para mapear objetos do modelo de domínio da aplicação para tabelas de banco de dados relacionais. O Hibernate é uma ferramenta ORM baseada em Java que fornece um framework para mapear objetos do modelo de domínio da aplicação para tabelas de banco de dados relacionais e vice-versa. Alguns dos benefícios de usar o Hibernate como ferramenta ORM são:

1. O Hibernate suporta o mapeamento de classes Java para tabelas de banco de dados e vice-versa. Ele fornece recursos para realizar operações CRUD em todos os principais bancos de dados relacionais.
2. Hibernate elimina todo o código repetitivo associado ao JDBC e cuida da gestão de recursos, permitindo-nos concentrar nos casos de uso de negócios, em vez de garantir que as operações do banco de dados não estejam causando vazamentos de recursos.
3. O Hibernate oferece suporte à gestão de transações e garante que não haja dados inconsistentes no sistema.
4. Como usamos XML, arquivos de propriedades ou anotações para mapear classes Java para tabelas de banco de dados, ele fornece uma camada de abstração entre a aplicação e o banco de dados.
5. O Hibernate nos ajuda a mapear junções, coleções, objetos de herança e podemos visualizar facilmente como nossas classes de modelo estão representando tabelas de banco de dados.
6. O Hibernate fornece uma linguagem de consulta poderosa (HQL) semelhante ao SQL. No entanto, o HQL é totalmente orientado a objetos e compreende conceitos como herança, polimorfismo e associação.
7. O Hibernate também oferece integração com alguns módulos externos. Por exemplo, o Hibernate Validator é a implementação de referência da Validação de Beans (JSR 303).
8. O Hibernate é um projeto de código aberto da comunidade Red Hat e é usado em todo o mundo. Isso o torna uma escolha melhor do que outros porque a curva de aprendizado é pequena e há muita documentação online, com ajuda facilmente disponível em fóruns.
9. O Hibernate é fácil de integrar com outros frameworks Java EE, sendo tão popular que o Spring Framework oferece suporte integrado para a integração do Hibernate com aplicativos Spring.

I hope all the above benefits will convince you that Hibernate is the best choice for your application object-relational mapping requirements. Let’s look at the Hibernate Framework architecture now and then we will jump into sample project where we will look into different ways to configure Hibernate in standalone java application and use it.

Arquitetura do Hibernate

A imagem abaixo mostra a arquitetura do Hibernate e como ele funciona como uma camada de abstração entre as classes da aplicação e as APIs JDBC/JTA para operações de banco de dados. Fica claro que o Hibernate é construído sobre as APIs JDBC e JTA. Vamos analisar os componentes principais da arquitetura do Hibernate um por um.

• SessionFactory (org.hibernate.SessionFactory): SessionFactory é um cache imutável e seguro para threads com mapeamentos compilados para um único banco de dados. Podemos obter uma instância de org.hibernate.Session usando SessionFactory.
• Session (org.hibernate.Session): Session é um objeto de curta duração e monofilar que representa uma conversa entre a aplicação e a loja persistente. Ele encapsula java.sql.Connection do JDBC e funciona como uma fábrica para org.hibernate.Transaction.
• Objetos persistentes: Objetos persistentes são objetos de curta duração e monofilar que contêm estado persistente e função de negócios. Podem ser JavaBeans/POJOs comuns. Eles estão associados exatamente a uma org.hibernate.Session.
• Objetos Transitórios: Objetos transitórios são instâncias de classes persistentes que não estão atualmente associadas a uma org.hibernate.Session. Eles podem ter sido instanciados pela aplicação e ainda não persistidos, ou podem ter sido instanciados por uma org.hibernate.Session fechada.
• Transação (org.hibernate.Transaction): A transação é um objeto de curta duração e de única thread usado pela aplicação para especificar unidades atômicas de trabalho. Ela abstrai a aplicação da transação JDBC ou JTA subjacente. Uma org.hibernate.Session pode abranger múltiplas org.hibernate.Transaction em alguns casos.
• ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider é uma fábrica de conexões JDBC. Ele fornece abstração entre a aplicação e a javax.sql.DataSource ou java.sql.DriverManager subjacente. Não é exposto à aplicação, mas pode ser estendido pelo desenvolvedor.
• TransactionFactory (org.hibernate.TransactionFactory): Uma fábrica para instâncias de org.hibernate.Transaction.

Hibernate e Java Persistence API (JPA)

Hibernate fornece uma implementação da API de Persistência Java, então podemos usar anotações JPA com beans de modelo e o Hibernate se encarregará de configurá-lo para ser usado em operações CRUD. Vamos analisar isso com um exemplo de anotações.

Exemplo do Hibernate

Ao desenvolver aplicações Hibernate, precisamos fornecer dois conjuntos de configurações. O primeiro conjunto de configurações contém propriedades específicas do banco de dados que serão usadas para criar conexão com o banco de dados e objetos de Sessão. O segundo conjunto de configurações contém o mapeamento entre as classes de modelo e as tabelas do banco de dados. Podemos usar configurações baseadas em XML ou em propriedades para configurações relacionadas à conexão com o banco de dados. Podemos usar configurações baseadas em XML ou em anotações para fornecer classes de modelo e mapeamento de tabelas do banco de dados. Vamos usar as anotações JPA do javax.persistence para mapeamentos baseados em anotações. Nosso projeto final parecerá com a imagem abaixo. Crie um projeto Maven no Eclipse ou em seu IDE favorito, você pode escolher qualquer nome de sua preferência. Antes de avançarmos para os diferentes componentes do projeto, precisaremos configurar o banco de dados.

Configuração da Tabela do Banco de Dados

Para o meu exemplo, estou usando o banco de dados MySQL e o script abaixo é utilizado para criar a tabela necessária.

CREATE TABLE `Employee` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `role` varchar(20) DEFAULT NULL,
  `insert_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;

Observe que a coluna “id” da tabela Employee é gerada automaticamente pelo MySQL, então não precisamos inseri-la.

Dependências do Projeto Hibernate

O nosso arquivo pom.xml final fica assim.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.journaldev.hibernate</groupId>
  <artifactId>HibernateExample</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>HibernateExample</name>
  
  <dependencies>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-core</artifactId>
  		<version>4.3.5.Final</version>
  	</dependency>
  	<!-- Hibernate 4 uses Jboss logging, but older versions slf4j for logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
        	<groupId>mysql</groupId>
        	<artifactId>mysql-connector-java</artifactId>
        	<version>5.0.5</version>
        </dependency>
  </dependencies>
  
  <build>
  	<finalName>${project.artifactId}</finalName>
  </build>
</project>

hibernate-core contém todas as classes principais do Hibernate, portanto, obteremos todos os recursos necessários incluindo-o no projeto. Note que estou usando a versão mais recente do Hibernate (4.3.5.Final) para o meu projeto de exemplo, e o Hibernate está em constante evolução. Já vi muitas mudanças nas classes principais a cada grande lançamento. Portanto, se estiver usando outra versão, há uma pequena chance de que seja necessário modificar as configurações do Hibernate para que funcione. No entanto, tenho certeza de que funcionará bem para todas as versões 4.x.x. O Hibernate 4 utiliza o JBoss logging, mas as versões mais antigas utilizam o slf4j para fins de registro, então incluí slf4j-simple em meu projeto, embora não seja necessário porque estou usando o Hibernate 4. mysql-connector-java é o driver MySQL para conexão com bancos de dados MySQL. Se estiver usando outro banco de dados, adicione o driver correspondente.

Classes de Modelo de Domínio

Como você pode ver na imagem acima, temos duas classes de modelo, Employee e Employee1. Employee é uma simples classe Java Bean e usaremos configuração baseada em XML para fornecer os detalhes de mapeamento. Employee1 é uma classe Java Bean onde os campos são anotados com anotações JPA, para que não seja necessário fornecer o mapeamento em um arquivo XML separado.

package com.journaldev.hibernate.model;

import java.util.Date;

public class Employee {

	private int id;
	private String name;
	private String role;
	private Date insertTime;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public Date getInsertTime() {
		return insertTime;
	}
	public void setInsertTime(Date insertTime) {
		this.insertTime = insertTime;
	}
	
}

A classe Employee é uma simples classe Java Bean, não há nada específico para discutir aqui.

package com.journaldev.hibernate.model;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity
@Table(name="Employee", 
	   uniqueConstraints={@UniqueConstraint(columnNames={"ID"})})
public class Employee1 {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="ID", nullable=false, unique=true, length=11)
	private int id;
	
	@Column(name="NAME", length=20, nullable=true)
	private String name;
	
	@Column(name="ROLE", length=20, nullable=true)
	private String role;
	
	@Column(name="insert_time", nullable=true)
	private Date insertTime;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public Date getInsertTime() {
		return insertTime;
	}
	public void setInsertTime(Date insertTime) {
		this.insertTime = insertTime;
	}
}

A anotação javax.persistence.Entity é usada para marcar uma classe como um bean de Entidade que pode ser persistido pelo Hibernate, já que o Hibernate fornece a implementação JPA. A anotação javax.persistence.Table é usada para definir o mapeamento da tabela e restrições únicas para as colunas. A anotação javax.persistence.Id é usada para definir a chave primária da tabela. javax.persistence.GeneratedValue é usado para definir que o campo será auto-gerado e a estratégia GenerationType.IDENTITY é usada para que o valor gerado “id” seja mapeado para o bean e possa ser recuperado no programa Java. A anotação javax.persistence.Column é usada para mapear o campo com a coluna da tabela, onde também podemos especificar o comprimento, a possibilidade de nulo e a singularidade das propriedades do bean.

Configuração XML de Mapeamento do Hibernate

Conforme mencionado anteriormente, usaremos uma configuração baseada em XML para o mapeamento da classe Employee. Podemos escolher qualquer nome, mas é bom escolher um relacionado ao nome da tabela ou do bean Java para maior clareza. Nosso arquivo de mapeamento do Hibernate para o bean Employee parece o seguinte. employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
	<class name="com.journaldev.hibernate.model.Employee" table="EMPLOYEE">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="increment" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="role" type="java.lang.String">
            <column name="ROLE" />
        </property>
        <property name="insertTime" type="timestamp">
        	<column name="insert_time" />
        </property>
    </class>
</hibernate-mapping>

A configuração XML é simples e faz a mesma coisa que a configuração baseada em anotações.

Arquivos de Configuração do Hibernate

Iremos criar dois arquivos de configuração XML do Hibernate – um para a configuração baseada em XML e outro para a configuração baseada em anotações. hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- Database connection properties - Driver, URL, user, password -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
		<property name="hibernate.connection.username">pankaj</property>
		<property name="hibernate.connection.password">pankaj123</property>
		<!-- Connection Pool Size -->
		<property name="hibernate.connection.pool_size">1</property>
		
		<!-- org.hibernate.HibernateException: No CurrentSessionContext configured! -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- Outputs the SQL queries, should be disabled in Production -->
		<property name="hibernate.show_sql">true</property>
		
		<!-- Dialect is required to let Hibernate know the Database Type, MySQL, Oracle etc
			Hibernate 4 automatically figure out Dialect from Database Connection Metadata -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 

		<!-- mapping file, we can use Bean annotations too --> 
		<mapping resource="employee.hbm.xml" />
	</session-factory>
</hibernate-configuration>

A maioria das propriedades está relacionada à configuração do banco de dados; outros detalhes de propriedades são fornecidos em comentários. Observe a configuração para o arquivo de mapeamento do Hibernate, onde podemos definir vários arquivos de mapeamento do Hibernate e configurá-los aqui. Também observe que o mapeamento é específico para a fábrica de sessões. hibernate-annotation.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- Database connection properties - Driver, URL, user, password -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
		<property name="hibernate.connection.username">pankaj</property>
		<property name="hibernate.connection.password">pankaj123</property>
		
		<!-- org.hibernate.HibernateException: No CurrentSessionContext configured! -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- Mapping with model class containing annotations -->
		<mapping class="com.journaldev.hibernate.model.Employee1"/>
	</session-factory>
</hibernate-configuration>

A maioria da configuração é a mesma da configuração baseada em XML, a única diferença é a configuração de mapeamento. Podemos fornecer a configuração de mapeamento para classes, bem como para pacotes.

SessionFactory do Hibernate

I have created a utility class where I am creating SessionFactory from XML based configuration as well as property based configuration. For property based configuration, we could have a property file and read it in the class, but for simplicity I am creating Properties instance in the class itself.

package com.journaldev.hibernate.util;

import java.util.Properties;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

import com.journaldev.hibernate.model.Employee1;

public class HibernateUtil {

	//Configuração baseada em XML
	private static SessionFactory sessionFactory;
	
	//Configuração baseada em anotações
	private static SessionFactory sessionAnnotationFactory;
	
	//Configuração baseada em propriedades
	private static SessionFactory sessionJavaConfigFactory;

    private static SessionFactory buildSessionFactory() {
        try {
            // Criar a SessionFactory a partir do hibernate.cfg.xml
        	Configuration configuration = new Configuration();
        	configuration.configure("hibernate.cfg.xml");
        	System.out.println("Hibernate Configuration loaded");
        	
        	ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
        	System.out.println("Hibernate serviceRegistry created");
        	
        	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        	
            return sessionFactory;
        }
        catch (Throwable ex) {
            // Certifique-se de registrar a exceção, pois ela pode ser ignorada
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    private static SessionFactory buildSessionAnnotationFactory() {
    	try {
            // Criar a SessionFactory a partir do hibernate.cfg.xml
        	Configuration configuration = new Configuration();
        	configuration.configure("hibernate-annotation.cfg.xml");
        	System.out.println("Hibernate Annotation Configuration loaded");
        	
        	ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
        	System.out.println("Hibernate Annotation serviceRegistry created");
        	
        	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        	
            return sessionFactory;
        }
        catch (Throwable ex) {
            // Certifique-se de registrar a exceção, pois ela pode ser ignorada
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
	}

    private static SessionFactory buildSessionJavaConfigFactory() {
    	try {
    	Configuration configuration = new Configuration();
		
		//Criar propriedades, que podem ser lidas de arquivos de propriedades também
		Properties props = new Properties();
		props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
		props.put("hibernate.connection.url", "jdbc:mysql://localhost/TestDB");
		props.put("hibernate.connection.username", "pankaj");
		props.put("hibernate.connection.password", "pankaj123");
		props.put("hibernate.current_session_context_class", "thread");
		
		configuration.setProperties(props);
		
		//Podemos definir o arquivo de mapeamento ou a classe com anotações
		//addClass(Employee1.class) procurará o recurso
		// com/journaldev/hibernate/model/Employee1.hbm.xml (não é recomendado)
		configuration.addAnnotatedClass(Employee1.class);
		
		ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
    	System.out.println("Hibernate Java Config serviceRegistry created");
    	
    	SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
    	
        return sessionFactory;
    	}
        catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
	}
    
	public static SessionFactory getSessionFactory() {
		if(sessionFactory == null) sessionFactory = buildSessionFactory();
        return sessionFactory;
    }
	
	public static SessionFactory getSessionAnnotationFactory() {
		if(sessionAnnotationFactory == null) sessionAnnotationFactory = buildSessionAnnotationFactory();
        return sessionAnnotationFactory;
    }
	
	public static SessionFactory getSessionJavaConfigFactory() {
		if(sessionJavaConfigFactory == null) sessionJavaConfigFactory = buildSessionJavaConfigFactory();
        return sessionJavaConfigFactory;
    }
	
}

A criação da SessionFactory para configuração baseada em XML é a mesma, quer o mapeamento seja baseado em XML ou em anotações. Para configuração baseada em propriedades, precisamos definir as propriedades no objeto Configuration e adicionar classes de anotação antes de criar a SessionFactory. Em geral, a criação da SessionFactory inclui as seguintes etapas:

1. Criar o objeto Configuration e configurá-lo
2. Criar o objeto ServiceRegistry e aplicar as configurações de configuração.
3. Usar configuration.buildSessionFactory() passando o objeto ServiceRegistry como argumento para obter o objeto SessionFactory.

Nossa aplicação está quase pronta agora, vamos escrever alguns programas de teste e executá-los.

Teste de Configuração XML do Hibernate

Nosso programa de teste se parece com o abaixo.

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;

import com.journaldev.hibernate.model.Employee;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateMain {

	public static void main(String[] args) {
		Employee emp = new Employee();
		emp.setName("Pankaj");
		emp.setRole("CEO");
		emp.setInsertTime(new Date());
		
		// Obter Sessão
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		// iniciar transação
		session.beginTransaction();
		// Salvar o objeto Modelo
		session.save(emp);
		// Confirmar transação
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Encerrar a fábrica de sessões, caso contrário o programa não terminará
		HibernateUtil.getSessionFactory().close();
	}

}

O programa é autoexplicativo, quando executamos o programa de teste, obtemos a seguinte saída.

May 06, 2014 12:40:06 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:40:06 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate.cfg.xml
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate.cfg.xml
May 06, 2014 12:40:07 AM org.hibernate.cfg.Configuration addResource
INFO: HHH000221: Reading mappings from resource: employee.hbm.xml
May 06, 2014 12:40:08 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Configuration loaded
Hibernate serviceRegistry created
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 1 (min=1)
May 06, 2014 12:40:08 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:40:08 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:40:08 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Hibernate: select max(ID) from EMPLOYEE
Hibernate: insert into EMPLOYEE (NAME, ROLE, insert_time, ID) values (?, ?, ?, ?)
Employee ID=19
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

Observe que está imprimindo o ID do funcionário gerado, você pode verificar a tabela do banco de dados para confirmar.

Teste de Configuração de Anotação do Hibernate

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.journaldev.hibernate.model.Employee1;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateAnnotationMain {

	public static void main(String[] args) {
		Employee1 emp = new Employee1();
		emp.setName("David");
		emp.setRole("Developer");
		emp.setInsertTime(new Date());
		
		// Obter Sessão
		SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
		Session session = sessionFactory.getCurrentSession();
		// iniciar transação
		session.beginTransaction();
		// Salvar o objeto Modelo
		session.save(emp);
		// Confirmar transação
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		// Encerrar a fábrica de sessões, caso contrário o programa não terminará
		sessionFactory.close();
	}

}

Ao executarmos o programa acima, obtemos a seguinte saída.

May 06, 2014 12:42:22 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:42:22 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:23 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:42:23 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:42:23 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:42:23 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=20
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

Dê uma olhada na saída e compare-a com a saída do arquivo de configuração baseado em XML; você notará algumas diferenças. Por exemplo, não estamos definindo o tamanho do pool de conexões para a configuração baseada em anotações, então ele é configurado com o valor padrão 20.

Teste de Configuração Java do Hibernate

package com.journaldev.hibernate.main;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.journaldev.hibernate.model.Employee1;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateJavaConfigMain {

	public static void main(String[] args) {
		Employee1 emp = new Employee1();
		emp.setName("Lisa");
		emp.setRole("Manager");
		emp.setInsertTime(new Date());
		
		//Obter Sessão
		SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
		Session session = sessionFactory.getCurrentSession();
		//iniciar transação
		session.beginTransaction();
		//Salvar o objeto Modelo
		session.save(emp);
		//Confirmar transação
		session.getTransaction().commit();
		System.out.println("Employee ID="+emp.getId());
		
		//encerrar a fábrica de sessões, caso contrário, o programa não será encerrado
		sessionFactory.close();
	}

}

A saída do programa de teste acima é:

May 06, 2014 12:45:09 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:45:09 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
Hibernate Java Config serviceRegistry created
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:45:10 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:45:10 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:45:10 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=21
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]

Isso é tudo para o tutorial do Hibernate para iniciantes, espero que seja suficiente para você começar. Vamos explorar diferentes recursos do framework Hibernate em tutoriais futuros. Baixe o projeto completo no link abaixo e experimente para aprender mais.

Baixar Projeto Iniciante do Hibernate