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

hibernate.cfg.xml文件

Hibernate中最核心的配置文件

功能：

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

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

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

Session缓存和持久化生命周期

Session缓存称为一级缓存

原理：

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

作用：

1. 减少访问数据库的频率
2. 保证缓存中的对象与数据库中的数据同步
3. 当缓存中的持久化对象之间存在循环关联关系时，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>