Tutorial de Hibernate

package br.com.curso.entidade;
 
import java.io.Serializable;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
 
@Entity
public class Aluno implements Serializable{
	private static final long serialVersionUID = -309513637403441918L;
 
	@Id
	@GeneratedValue
	private Long matricula;
 
	private String nome;
 
	private String telefone;
 
	public Long getMatricula() {
		return matricula;
	}
 
	public void setMatricula(Long matricula) {
		this.matricula = matricula;
	}
 
	public String getNome() {
		return nome;
	}
 
	public void setNome(String nome) {
		this.nome = nome;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	@Override
	public String toString() {
		return "Aluno [matricula=" + matricula + ", nome=" + nome
				+ ", telefone=" + telefone + "]";
	}
 
}

package br.com.curso.dao;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.hibernate.tool.hbm2ddl.SchemaExport;
 
public class HibernateUtil {
 
	private static SessionFactory sessionFactory = null;
	private static ServiceRegistry serviceRegistry;
 
	static {
		try {
			sessionFactory = getSessionFactory();
		} catch (Throwable ex) {
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}
 
	public static SessionFactory getSessionFactory() {
		if (sessionFactory == null) {
			Configuration configuration = new Configuration();
			configuration.configure();
			serviceRegistry = new ServiceRegistryBuilder().applySettings(
					configuration.getProperties()).buildServiceRegistry();
			sessionFactory = configuration.buildSessionFactory(serviceRegistry);
			sessionFactory.openSession();
			return sessionFactory;
		}
		return sessionFactory;
	}
 
	public static Session getSession() {
		return sessionFactory.openSession();
	}
 
	public static void gerarBanco() {
		// Carrega as configurações do arquivo
		// hibernate.cfg.xml
		Configuration conf = new Configuration();
		conf.configure();
		SchemaExport se2 = new SchemaExport(conf);
		// Executa a operação da criação do Banco de Dados
		se2.create(true, true);
	}
 
}

package br.com.curso.dao;
 
import java.util.ArrayList;
import java.util.List;
 
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
 
import br.com.curso.entidade.Aluno;
 
public class AlunoDAO {
 
	private Session session;
 
	public void incluir(Aluno aluno) {
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			session.save(aluno);
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
 
	public void alterar(Aluno aluno) {
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			session.merge(aluno);
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
 
	public void excluir(Aluno aluno) {
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			session.delete(aluno);
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
	}
 
	public Aluno consultar(int codigo) {
		Aluno retorno = new Aluno();
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			retorno = (Aluno) session.get(Aluno.class, codigo);
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return retorno;
	}
 
	@SuppressWarnings("unchecked")
	public List<Aluno> listar() {
		List<Aluno> lista = new ArrayList<Aluno>();
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			lista = (List<Aluno>) session.createCriteria(Aluno.class).list();
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return lista;
	}
 
	@SuppressWarnings("unchecked")
	public List<Aluno> listar(Aluno aluno) {
		Criteria c = session.createCriteria(Aluno.class);
		if (aluno.getNome().length() > 0) {
			c.add(Restrictions.like("nome", aluno.getNome() + "%"));
		}
		c.addOrder(Order.asc("nome"));
		return (List<Aluno>) c.list();
	}
}

 
package br.com.curso.teste;
 
import java.util.List;
 
import br.com.curso.dao.AlunoDAO;
import br.com.curso.entidade.Aluno;
 
public class AlunoTeste {
 
	public static void main(String[] args) {
		new AlunoTeste().incluirAluno();
	}
 
 
 
	public void incluirAluno() {
		System.out.println(this.getClass() + "Inicio");
 
		try {
			// Cria a instância de um classe de acesso a Dados
			AlunoDAO dao = new AlunoDAO();
 
 
			//Cria um objeto aluno informando apenas o nome
			Aluno aluno1 = new Aluno();
			aluno1.setNome("Jose da Silva");
 
			//Cria um objeto aluno informando apenas o nome
			Aluno aluno2 = new Aluno();
			aluno2.setNome("Maria da Silva");
 
			//Realiza a inclusão de um aluno
			dao.incluir(aluno1);
 
			//Realiza a inclusão de um aluno
			dao.incluir(aluno2);
 
 
			// Consulta a lista de usuários cadastrados no Banco
			List<Aluno> listaAluno = dao.listar();
 
 
 
			// Realiza um loop para exibir todos os registro existentes no Banco de dados
			System.out.println("==================  Alunos Cadastrados ============================");
			for (Aluno a : listaAluno) {
				System.out.println(a);
			}
 
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(this.getClass() + "Fim");
	}
}

 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- dados de Conexão com o Banco -->
		<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
		<property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/BDAcademicNet</property>
		<property name="hibernate.connection.username">postgres</property>
		<property name="hibernate.connection.password">teco01</property>
 
 
		<!-- Quando Banco de dados será utilizado (PostgreSQL, MySQL, SQLServer, Oracle) -->
		<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		<property name="hibernate.jdbc.batch_size">20</property>
 
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 
		Ações que podem ser executadas:
		validate: Apenas valida se as tabelas estão conforme o modelo de entidades 
		update: Atualiza as tabelas conforme estão as entidades
		create: Cria as tabelas que não existem
		create-drop: Apaga todas as tabelas e recria		
		 -->		
 
		<!-- Lista das entidades que serão persistidas no Banco de Dados-->		
		<mapping class="br.com.curso.entidade.Aluno" />				
	</session-factory>
</hibernate-configuration>

 
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
insert
into
Aluno
(nome, telefone, matricula)
values (?, ?, ?)
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
insert
into
Aluno
(nome, telefone, matricula)
values
(?, ?, ?)
Hibernate:
select
this_.matricula as matricul1_0_0_,
this_.nome as nome2_0_0_,
this_.telefone as telefone3_0_0_
from
Aluno this_
================== Alunos Cadastrados ============================
Aluno [matricula=1, nome=Jose da Silva, telefone=null]
Aluno [matricula=2, nome=Maria da Silva, telefone=null]
class br.com.curso.teste.AlunoTesteFim