Tutorial do Hibernate para Iniciantes

Tutoriais
Hibernate

Bem-vindo ao tutorial do Hibernate para iniciantes. O Hibernate é uma das ferramentas de Java ORM mais amplamente utilizadas. A maioria das aplicações usa bancos de dados relacionais para armazenar informações do aplicativo e, em um nível mais baixo, usamos 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 porque 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 do aplicativo 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 do aplicativo 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 boilerplate associado ao JDBC e cuida da gestão de recursos, permitindo que nos concentremos nos casos de uso de negócios, em vez de garantir que as operações de banco de dados não estejam causando vazamentos de recursos.
  3. O Hibernate suporta o gerenciamento de transações e garante a ausência de dados inconsistentes no sistema.
  4. Como utilizamos 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 oferece uma linguagem de consulta poderosa (HQL) semelhante ao SQL. No entanto, a HQL é totalmente orientada 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 do Bean Validation (JSR 303).
  8. O Hibernate é um projeto de código aberto da comunidade Red Hat e é utilizado em todo o mundo. Isso o torna uma escolha melhor do que outros, pois a curva de aprendizado é pequena e há uma abundância de 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 aplicações 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 de 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 de uma única thread que representa uma conversa entre a aplicação e o armazenamento 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 de uma única thread que contêm estado persistente e função de negócios. Eles podem ser JavaBeans/POJOs comuns e estão associados exatamente a uma org.hibernate.Session.
  • Objetos Transientes: Objetos transientes são instâncias de classes persistentes que atualmente não estão 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): Transação é um objeto de curta duração e de thread única 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 o 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 implementação da Java Persistence API, assim podemos utilizar as anotações JPA com beans de modelo e o Hibernate cuidará de configurá-lo para ser utilizado em operações CRUD. Vamos explorar isso com um exemplo de anotações.

Exemplo do Hibernate

Ao desenvolver aplicações com 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 utilizar configurações baseadas em XML ou propriedades para configurações relacionadas à conexão com o banco de dados. Podemos utilizar configurações baseadas em XML ou anotações para fornecer mapeamentos entre classes de modelo e tabelas de banco de dados. Vamos usar as anotações JPA de javax.persistence para mapeamentos baseados em anotações. Nosso projeto final terá a aparência da imagem abaixo. Crie um projeto Maven no Eclipse ou no seu IDE favorito, você pode escolher qualquer nome. Antes de avançarmos para os diferentes componentes do projeto, precisamos 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 é usado 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>

O artefato hibernate-core contém todas as classes principais do Hibernate, então teremos todos os recursos necessários incluindo-o no projeto. Observe que estou usando a versão mais recente do Hibernate (4.3.5.Final) para o meu projeto de exemplo, e o Hibernate ainda está evoluindo; percebi que muitas classes principais mudam 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 usa o log do JBoss, mas versões mais antigas usam o slf4j para fins de log, 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 conectar-se a bancos de dados MySQL. Se estiver usando outro banco de dados, adicione o artefato do driver correspondente.

Classes do Modelo de Domínio

Como você pode ver na imagem acima, temos duas classes de modelo, Employee e Employee1. Employee é uma classe Java Bean simples e usaremos a configuração baseada em XML para fornecer os detalhes de mapeamento. Employee1 é um 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 é um Java Bean simples, 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 Java 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 as restrições exclusivas 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 “id” gerado seja mapeado para o Java Bean e possa ser recuperado no programa Java. javax.persistence.Column é usado para mapear o campo com a coluna da tabela, também podemos especificar comprimento, nulidade e singularidade para as propriedades do bean.

Configuração XML de Mapeamento do Hibernate

Conforme mencionado acima, usaremos uma configuração baseada em XML para o mapeamento da classe Employee. Podemos escolher qualquer nome, mas é bom escolher um que tenha clareza em relação à tabela ou ao nome do bean Java. 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

Vamos criar dois arquivos de configuração xml do Hibernate – um para configuração baseada em XML e outro para 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 às configurações do banco de dados, outros detalhes das propriedades são fornecidos em comentários. Note a configuração para o arquivo de mapeamento do Hibernate, podemos definir vários arquivos de mapeamento do Hibernate e configurá-los aqui. Note também 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 que a configuração baseada em XML, a única diferença é a configuração de mapeamento. Podemos fornecer configuração de mapeamento para classes, bem como 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 {
            // Crie 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 {
            // Crie 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();
		
		//Crie Propriedades, também pode ser lido de arquivos de propriedade
		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 arquivo de mapeamento ou classe com anotação
		//addClass(Employee1.class) irá procurar recurso
		// com/journaldev/hibernate/model/Employee1.hbm.xml (não é bom)
		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;
    }
	
}

Criar SessionFactory para configuração baseada em XML é o mesmo, quer o mapeamento seja baseado em XML ou baseado em anotações. Para baseada em propriedades, precisamos definir as propriedades no objeto Configuration e adicionar classes de anotação antes de criar a SessionFactory. No geral, criar uma SessionFactory inclui os seguintes passos:

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

Nosso aplicativo está quase pronto agora, vamos escrever alguns programas de teste e executá-los.

Teste de Configuração XML do Hibernate

Nosso programa de teste parece o seguinte.

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 do 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 do 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 da configuração baseada 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 está definido com o valor padrão 20.

Teste de Configuração do Hibernate em Java

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 do 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();
	}

}

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 começar. Vamos explorar diferentes recursos do framework Hibernate em tutoriais futuros. Baixe o projeto completo no link abaixo e brinque com ele para aprender mais.

Baixe o Projeto Inicial do Hibernate

Source:
https://www.digitalocean.com/community/tutorials/hibernate-tutorial-for-beginners