hibernate持久化对象

Hibernate框架对JDBC做了轻量级的封装，使用Hibernate对数据进行操作时，必须要写繁琐的JDBC代码，完全面向对象，通过Session接口对数据进行CRUD操作，

使用方法也非常简单

Hibernate持久化对象的流程:

1:获取session对象;

2:开启事物;

3:数据操作(操作过程中，如果抛出异常，事物回滚，然后关闭session)

4:提交事物

5:关闭session

下面是一个简单的示例：

首先是entity

public class Medicine {

    private Integer id;//

    private String medicineName;//药品名称

    private double price;//价格

    private String specifications;//规格

    private String memo;//描述

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getMedicineName() {
        return medicineName;
    }

    public void setMedicineName(String medicineName) {
        this.medicineName = medicineName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getSpecifications() {
        return specifications;
    }

    public void setSpecifications(String specifications) {
        this.specifications = specifications;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }
}

创建hibernate初始化类

Hibernate的运行离不开session,而session对象又依赖于SessionFactory对象，所以要首先创建SessionFactory对象

SessionFactory对象是非轻量级的，所以创建过程需占用大量资源，所以建议只创建一次

public class HibernateUtil {
    private static SessionFactory factory = null;//SessionFactory对象

    static {
        try {
            Configuration cfg = new Configuration().configure();//加载Hibernate配置文件
            ServiceRegistry registry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();//创建ServiceRegistry对象
            factory = cfg.buildSessionFactory(registry);
//            factory = cfg.buildSessionFactory()
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
    //创建一个本地线程副本
    private static  ThreadLocal<Session> sessionThreadLocal = new ThreadLocal<Session>();
    //获取session
    public static Session currenSession() throws HibernateException{
        Session session = sessionThreadLocal.get();
        if (session == null){
            if(factory != null){
                session = factory.openSession();
                sessionThreadLocal.set(session);
            }
        }
        return session;
    }

    //关闭SESSION
    public static  void closeSession() throws HibernateException{
        Session session = sessionThreadLocal.get();
        if(session != null)
            if(session.isOpen())
                session.close();
    }

}

添加数据的测试类

public class Save {
    public static void main(String[] args){
        Session session = null;
        try {
            session = HibernateUtil.currenSession();//获取SESSION
            session.beginTransaction();//打开事务
            Medicine medicine = new Medicine();
            medicine.setMedicineName("感康");
            medicine.setPrice(10.0);
            medicine.setSpecifications("颗");
            medicine.setMemo("感康疗效快");
            session.save(medicine);
            session.getTransaction().commit();
        }catch (HibernateException e){
            e.printStackTrace();
            session.getTransaction().rollback();//事务回滚
        }finally {
            HibernateUtil.closeSession();//关闭SESSION
        }
    }
}

当创建Medicine对象并对其属性赋值时，此时对象处于瞬时状态，没有在session的管理之中，当事务提交时，对象变成持久状态，当关闭session时，对象变为脱管状态

删除数据测试类

public class Delete {
    public static void main(String[] args){
        Session session = null;
        try {
            session = HibernateUtil.currenSession();
            session.beginTransaction();
            Medicine medicine = (Medicine) session.load(Medicine.class,new Integer(1));
            session.delete(medicine);
            session.getTransaction().commit();
        }catch (HibernateException e){
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtil.closeSession();
        }
    }
}

删除之前，先使用load加载药品对象，使其变成持久状态，然后再进行删除操作

自动更新测试类

public class AutoUpdate {
    public static void main(String[] args){
        Session session = null;
        try {
            session = HibernateUtil.currenSession();
            session.beginTransaction();
            Medicine medicine = (Medicine)session.load(Medicine.class,new Integer(2));
            System.out.println("111");
            medicine.setMedicineName("感康");
            session.getTransaction().commit();
        }catch (HibernateException e){
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtil.closeSession();
        }
    }
}

对于持久状态的对象，Hibernate在更新缓存时将对数据进行对比，当对象发生变化时，Hibernate将更新数据

手动更新测试类

public class ManualUpdate {
    public static void main(String[] args){
        Session session = null;
        try {
            session = HibernateUtil.currenSession();
            session.beginTransaction();
            Medicine medicine = new Medicine();
            medicine.setId(2);
            medicine.setMedicineName("白加黑");
            session.update(medicine);
            session.getTransaction().commit();
        }catch (HibernateException e){
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtil.closeSession();
        }
    }
}

由于手动创建了脱管状态的对象，当更新时，对于持久化对象中没有值的属性也会同步到数据库

查询方法分为get()和load()两种，get()是直接去数据库执行查询，返回实际对象，而load是先返回一个代理对象，当要使用这个对象时，才去数据库执行查询

Hibernate缓存和延迟加载

在Hibernate种包含两种缓存，分别为session的缓存和sessionFactory缓存，也成为一级缓存和二级缓存

一级缓存是session缓存，其生命周期很短，与session相对应，它并不会在session之间共享，在不同的session中，不能得到其他session的缓存的实体对象，一级缓存由

Hibernate管理，属于事务范围的缓存

当程序调用Session的load(),get(),save()等方法时，Hibernate会对实体对象进行缓存，当通过load()或get()进行查询实体对象时，首先到缓存中去找，在找不到的情况下才会

去数据库中查询，下面通过一个实例来演示一级缓存技术

第一次查询:
Hibernate: select medicine0_.id as id0_0_, medicine0_.medicine_name as medicine2_0_0_, medicine0_.price as price0_0_, medicine0_.specifications as specific4_0_0_, medicine0_.memo as memo0_0_ from medicine_tab medicine0_ where medicine0_.id=?
药品名称：白加黑
第二次查询:
药品名称：白加黑

可以看到，第一次去数据库执行查询，同时对药品对象进行一级缓存，当再次查询时，就直接从缓存中取了

二级缓存是应用级的缓存，比较复杂，留待下一篇专门介绍

延迟加载（Lazy策略）,Hibernate通过JDK代理机制对其进行实现，这意味着使用延迟加载对象，在获取对象时返回的是对象的代理，并不是对象的真正的引用，只有在对象真正被调用时，Hibernate才会对其

进行查询，返回真正的对象