hibernate--持久对象的生命周期介绍

持久化对象的状态

：

1、 瞬时对象(Transient Object)：使用new操作符初始化的对象不是立刻就持久的。它们的状态是瞬时的，也就是说它们没有任何跟数据库表相关联的行为，只要应用不再引用这些对象(不再被任何其它对象所引用)，它们的状态将会丢失，并由垃圾回收机制回收

2、 持久化对象(Persistent Object)：持久实例是任何具有数据库标识的实例，它有持久化管理器Session统一管理，持久实例是在事务中进行操作的----它们的状态在事务结束时同数据库进行同步。当事务提交时，通过执行SQL的INSERT、UPDATE和DELETE语句把内存中的状态同步到数据库中。

3、 游离（离线）对象(Detached Object)：Session关闭之后，持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步，它们不再受hibernate管理。

Transient对象：随时可能被垃圾回收器回收(在数据库中没有于之对应的记录，应为是new初始化)，而执行save()方法后，就变为Persistent对象(持久性对象)，没有纳入session的管理

Persistent对象：在数据库有存在的对应的记录，纳入session管理。在清理缓存(脏数据检查)的时候，会和数据库同步。

Detached对象：也可能被垃圾回收器回收掉(数据库中存在对应的记录，只是没有任何对象引用它是指session引用)，注引状态经过Persistent状态，没有纳入session的管理

package h.one.test;

import h.one.bean.User;
import h.one.utils.HibernateUtil;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

public class testSave1 {

    @Test
    public void testSave1() {
        Session session = null;
        Transaction tx = null;
        User user = null;

        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();

            // Transient状态
            user = new User();
            user.setName("李四");
            user.setPassword("123");
            user.setCreateTime(new Date());
            user.setExpireTime(new Date());

            /*
             * persistent状态 persistent状态的对象，当属性发生改变的时候，hibernate会自动和数据库同步
             */
            session.save(user);

            user.setName("王五");
            // 实际上user.setName("王五")此时已经发出一条update指令了。
            // 也可以显示的调用update指定
            // session.update(user);

            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            HibernateUtil.closeSession(session);
        }

        /*
         * 从此处开始session已经在上面关闭，这时user对象状态就变为detached状态，
         * 所有user对象已经不被session管理，但数据库中确实存在与至对应的记录(王五)。
         */
        // detached状态
        user.setName("张三");

        try {
            session = HibernateUtil.getSession();
            session.beginTransaction();
            /*
             * 此时session又对user对象进行管理 当session发出update指定后，进行更新数据为(张三。)
             */
            session.update(user);

            // update后user对象状态又变为persistent状态
            session.getTransaction().commit();
            /*
             * 此时session提交事务，发出update语句 Hibernate: update User set name=?,
             * password=?, createTime=?, expireTime=? where id=?
             */
        } catch (HibernateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }
}

Hibernate加载数据：

两种：get()、load()

一、 Session.get(Class clazz,  Serializable id)方法

* clazz:需要加载对象的类，例如：User.class

* id:查询条件(实现了序列化接口的对象)：

例"4028802c46d255740146d25576320000"字符串已经实现了序列化接口。

返回值： 此方法返回类型为Object，也就是对象，然后我们再强行转换为需要加载的对象就可以了。

如果数据不存在，则返回null;

注：执行此方法时立即发出查询SQL语句。加载User对象

加载数据库中存在的数据，代码如下

@Test
    public void testLoad() {
        Session session = null;
        Transaction tx = null;

        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();

            /*
             * Object org.hibernate.Session.get(Class arg0, Serializable arg1)
             * throws HibernateException arg0:需要加载对象的类，例如：User.class
             * arg1:查询条件(实现了序列化接口的对象
             * )：例"4028818a245fdd0301245fdd06380001"字符串已经实现了序列化接口。
             * 此方法返回类型为Object，也就是对象，然后我们再强行转换为需要加载的对象就可以了。 如果数据不存在，则返回null
             * 执行此方法时立即发出查询SQL语句。加载User对象。
             */
            User user = (User) session.get(User.class,"4028802c46d255740146d25576320000");

            // 数据加载完后的状态为persistent状态。数据将与数据库同步。
            System.out.println("user.name=" + user.getName());

            // 因为此的user为persistent状态，所以数据库进行同步为龙哥。
            user.setName("龙哥");
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
    }

一、 Object Session.load(Class clazz, Serializable id) throws HibernateException

* clazz:需要加载对象的类，例如：User.class

* id:查询条件(实现了序列化接口的对象)：例"4028802c46d255740146d25576320000"字符串已经实现了序列化接口。

* 此方法返回类型为Object，但返回的是代理对象。

* 执行此方法时不会立即发出查询SQL语句。只有在使用对象时，它才发出查询SQL语句，加载对象。

* 因为load方法实现了lazy(称为延迟加载、赖加载)

* 延迟加载：只有真正使用这个对象的时候，才加载(才发出SQL语句)

* hibernate延迟加载实现原理是代理方式。

* 采用load()方法加载数据，如果数据库中没有相应的记录，则会抛出异常对象不找到(org.hibernate.ObjectNotFoundException)

@Test
    public void testLoad() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();

            User user = (User) session.load(User.class,
                    "4028802c46d255740146d25576320000");

            // 只有在使用对象时，它才发出查询SQL语句，加载对象。
            System.out.println("user.name=" + user.getName());

            // 因为此的user为persistent状态，所以数据库进行同步为龙哥。
            user.setName("发哥");

            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
    }

Hbernate两种加载数据方式的区别：

get()方法默认不支持lazy(延迟加载)功能，而load支持延迟加载

get()方法在查询不到数据时，返回null,而load因为支持延迟加载，只有在使用对象时才加载，所以如果数据库中不在数据load会抛出异常(org.hibernate.ObjectNotFoundException)。

get()和load()只根据主键查询，不能根据其它字段查询，如果想根据非主键查询，可以使用HQL

hibernate更新数据：

建立使用hibernate进行更新数据时，先加载数据，然后再修改后更新。

否则一些字段可以会被null替换。

@Test
    public void testDelete() {
        Session session = null;
        Transaction tx = null;

        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();

            User user = (User) session.load(User.class,
                    "4028802c46d255740146d25576320000");
            session.delete(user);

            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            if (session != null) {
                if (session.isOpen()) {
                    session.close();
                }
            }
        }
        // transistent状态(数据库中没有配区的数据记录。)
    }

query接口初步

Query session.createQuery(String hql)方法;

* hibernate的session.createQuery()方法是使用HQL(hibernate的查询语句)语句查询对象的。

* hql：是查询对象的，例如："from User"，其中from不区分大小写，而User是区分大小写，因为它是对象。是User类

* 返回Query对象。

* 执行这条语句后，Hibernate会根据配置文件中所配置的数据库适配器自动生成相应数据库的SQL语句。如：

ibernate: select user0_.id as id0_, user0_.name as name0_, user0_.password as password0_, 
user0_.createTime as createTime0_, user0_.expireTime as expireTime0_ from User user0_

Query的分页查询：

@Test
    public void testQuery1() {
        Session session = null;
        try {
            session = HibernateUtil.getSession();
            session.beginTransaction();
            Query query = session.createQuery("from User");
            // 分页查询
            query.setFirstResult(0);// 从哪一条记录开始查询，是从0开始计算
            query.setMaxResults(2);// 分页每页显示多少条记录。
            /*
             * Query对象中有一个list()方式，将所有查询来的对象自动生成list对象返回。
             */
            List userList = query.list();
            // 然后我们就可以显示数据了。
            for (Iterator iter = userList.iterator(); iter.hasNext();) {
                User user = (User) iter.next();
                System.out.print(user.getId() + "   ");
                System.out.println(user.getName());
            }
            session.getTransaction().commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateUtil.closeSession(session);
        }
    }

总结：

Hibernate是一个O/R映射框架(也称为ORM)

从ORM词来看，O---Object(对象模型)；R--- Relational(关联模型)，可以做对象和关联的一种映射，当然这只是部分功能，一个完善ORM框架应该具有更多的功能：如HQL相关的查询语句、提供缓存机制(一级缓存、二级缓存)。

Java开发数据库时，使用JDBC，但是需要编写大量相同的代码，这样不便提高生产效率，而hibernate可以让你不能编写大量的相同的代码。从而提高生产效率。另一方面，hibernate可以让我们更面对象化开发，还有一个移植性hibernate只需要更改配置文件(数据库适配器)的选项，就可以非常方便的移植到不同的数据库，而不需要重新编写不同数据库厂家所对应的JDBC、SQL语句了。还有hibernate可以解决阻抗不匹配(Java类中有继承关系，而关系型数据库中没有这个功能(目前数据库还不是面向对象，都是关系型数据库)),使用hibernate框架，侵入性比较好(因此hibernate称为轻量级框架)

O/R映射框架和使用环境：在程序中添加→修改→保存；查询可以批量，但是修改不可为批量性；程序中有大量的数据只读，这样就可以一次性读取到缓存中；对象间存在自然的关系；不需要数据库SQL特定的语句优化。

O/R映射框架不适合环境：聚集性操作：批量性添加、修改。批量的统计查询。

Configuration对象：读取hibernate配置文件(hibernate.cfg.xml或hiberante.properties)的. new Configuration()默认是读取hibernate.properties, 所以使用new Configuration().configure();来读取hibernate.cfg.xml配置文件

SessionFactory：是一个重量级对象，它的创建是耗时的。因为它对应一个数据库里所有配置，包括一些缓存机制都由SessionFactory来维护，它与二级缓存是绑定的。通常只创建一次，但它是线程安全的。

Session:是非线程安全的，它是通过SessionFactory来创建的。不要多个线程同时访问同一个Session，否则会出现一些未知问题。通常是一个请求对应一个Session,请求完成要关闭Session

Transaction:hibernate默认不是自动开启事务的，所以要手动开启事务、手动提交事务、手动回滚事务、手动关闭事务。当然可以通过配置文件配置成自动。一般使用手动。

Hibernate正常的开发思路：考虑对象模型这一块，把对象模型建立起来，把对象图建立起来，对象之间的关系建立起来、然后再编写映射文件(hbm),然后根据映射文件生成数据库表。数据库对我来说是透明的，我们只操作对象不用关心数据库。

——————————————————————————————————————————————————————————————————————————————

原文链接：http://www.cnblogs.com/sunhan/p/3808680.html