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才会对其

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