Hibernate配置及持久化操作(CRUD)

hibernate.cfg.xml文件

Hibernate中最核心的配置文件

功能：

数据库方言的配置
数据库连接参数的配置
数据库连接池的配置
加载对象关系映射文件

Hibernate映射主要是通过关系对象映射文件来实现

作用：将实体类映射到关系文件数据库表中。

Session缓存和持久化生命周期

Session缓存称为一级缓存

原理：

当应用程序调用Session的CRUD方法，以及调用查询接口的list(),iterate()或filter()方法时，如果在Session缓存中不存在相应的对象,Hibernate就会把该对象加入到第一级缓存中
当清理缓存时，Hibernate会根据缓存中对象状态的变化来同步更新数据库

作用：

减少访问数据库的频率
保证缓存中的对象与数据库中的数据同步
当缓存中的持久化对象之间存在循环关联关系时，Session会保证不出现访问对象图的死循环，以及由死循环引起的JVM堆栈溢出异常
应用：
当应用程序调用Transaction的commit方法时，commit()方法会清理缓存，然后再向数据库提交事务

<span style="font-size:18px;"> public void get() {
Configuration configuration=new Configuration().configure();
StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
ServiceRegistry registry = builder.build();
SessionFactory factory = configuration.buildSessionFactory(registry);
Session session=factory.openSession();
Transaction transaction=session.beginTransaction();

try{
Student student=(Student) session.get(Student.class,1);
student.setName("hello");//从数据库中获取该对象，对其修改后会自动保存到数据库中
transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}</span>

当应用程序调用Session的flush方法时，通过Session的setFushMode(FlushMode mode)方法来设定清除缓存的时间点   
FlushMode_ALWAYS,FlushMode_AUTO,FlushMode_COMMIT,FlushMode_MANUAL

持久化对象的生命周期：
瞬时状态，持久化状态，脱管状态，移除状态



Save()方法：使一个瞬时状态的对象转变成为持久化对象

get()和load()方法：根据给定的OID，加载一个持久化的对象

特点：

根据给定的OID从缓存中（一级，二级）中获取，存在就是直接返回

get方法：执行SQL从数据库返回

load方法：返回一个代理对象（延迟加载，懒加载）

如果数据库不存在对应的记录，get方法则返回一个null对象，load方法抛出一个ObjectNotFoundException异常。

delete()方法：使一个持久化对象变成移除状态，从数据库中移除它的持久化状态

update()方法：使一个脱管对象重附到新的session对象中，成为持久化对象

merge()方法：将给定实例的状态复制到具有相同标识符的持久化实例上，并返回这个持久化实例，常用来代理update和saveOrUpdate方法，存在就更新，不存在就创建

操作实例

<span style="font-size:18px;">package action;

import entity.Student;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;

/**
* Created by lenovo on 2016/3/27.
*/
public class HandleSession
{
public Session getSession(){
Configuration configuration=new Configuration().configure();
StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
ServiceRegistry registry = builder.build();
SessionFactory factory = configuration.buildSessionFactory(registry);

Session session=factory.openSession();
return session;
}
@Test
public void createTable(){
Configuration configuration=new Configuration().configure();
SchemaExport schemaExport=new SchemaExport(configuration);
schemaExport.create(true,true);
}
@Test
public void add() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
Student student=new Student();
student.setName("wo");
student.setAge(22);
session.save(student);
//调用save方法后对该对象进行修改，Hibernate会把session缓存中的更改执行到数据库中，因此
//更改会被同步到数据库中
student.setAge(23);
transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
@Test
public void get() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
Student student=(Student) session.get(Student.class,1);
System.out.println(student.getName());

transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
@Test
public void load() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
//此处的Student可视为代理对象，在关闭Session，也就是脱离Session管理后对其操作会
//抛出懒加载对象的初始化异常
Student student=(Student) session.load(Student.class,1);
//对通过load查询的对象执行访问非对象标识符（id）的操作时不会执行数据库查询，直接返回id
//因此是延迟加载懒加载
System.out.println(student.getId());
//若对该对象调用除非对象标识符（id）外的其他方法，则会执行相应的数据库查询
System.out.println(student.getId());
transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
@Test
public void delete() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
Student student=(Student)session.get(Student.class,2);
session.delete(student);

transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
@Test
public void update() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
Student student=(Student)session.get(Student.class,3);
student.setName("haha");
student.setAge(12);
/*
在执行update方法时，如果操作的对象是一个脱管对象，则会将其转化成持久化对象

*/
session.update(student);

transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
@Test
public void merge() {
Session session=getSession();
Transaction transaction=session.beginTransaction();

try{
/* 对于瞬时状态对象，merge会在数据库中创建这个对象
Student student=new Student();
student.setName("haha");
student.setAge(12);*/

/*
操作永久对象时，merge方法会更新这个对象
*/
Student student=(Student)session.get(Student.class,1);
student.setName("good");
session.merge(student);

transaction.commit();
}catch (Exception e){
transaction.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
}
</span>