Hibernate中的实体状态

1  怎样理解实体状态

程序员M在使用Hibernate时总是有些惊奇，原因在于Hiberate中对各个实体的状态有着不可思议的控制魔力。比如：有时候在更改实体的属性时，与数据库中对应的列值也会被更改，而有时候又无法对应更新起来。想要更新的时候无法更新，不想更新的却更新了。

这就引发了程序员M的问题：在什么情况下这个实体是持久化一致的，什么时候又不一致呢？在Hibernate中实体有三个状态：瞬时、持久化和脱管。要想解决持久化一致性的问题，就必须了解各个状态各代表了什么，而且在什么操作后这些状态会发生变化。

2  实体状态的定义

Hibernate中实体有三个状态：瞬时、持久化和脱管。下面先来看看Hibernate对这三个状态是怎么定义的。

（1）瞬时：一个实体通过new操作符创建后，没有和Hibernate的Session建立关系，也没有手动赋值过该实体的持久化标识（持久化标识可以认为映射表的主键）。此时该实体中的任何属性的更新都不会反映到数据库表中。

（2）持久化：当一个实体和Hibernate的Session创建了关系，并获取了持久化标识，而且在Hibernate的Session生命周期内存在。此时针对该实体任何属性的更改都会直接影响到数据库表中一条记录对应字段的更新，也即与对应数据库表保持同步。

（3）脱管：当一个实体和Hibernate的Session创建了关系，并获取了持久化标识，而此时Hibernate的Session的生命周期结束，实体的持久化标识没有被改动过。针对该实体的任何属性的修改都不会及时反映到数据库表中。

这三种状态有两个很重要的点需要掌握：Hibernate的Session和持久化标识。通过这两个条件就可以判断出究竟是3种状态中的哪一个。3种不同状态通过Hibernate的Session和持久化标识可以互相之间进行转换，如图6.1所示。

 

图6.1  3个状态的转化

举个简单的例子，假如Room实体的属性id表示持久化标识，那么：

（1）创建的Room实例为瞬时状态，将表中对应的主键手动设置到id属性，此时就是脱管状态。

（2）创建的Room实例为瞬时状态，不设置id或设置的id在表中找不到对应，此时调用Hibernate Session的持久化方法，将成为持久化状态。

（3）Room实体在持久化状态下关闭Hibernate Session，此时就是脱管状态。

（4）Room实体在脱管状态下调用Hibernate Session的持久化方法，此时就是持久化状态。

（5）Room实体在持久化状态下关闭Hibernate Session，随后清除id属性的值，此时就是瞬时状态。

3  实体状态的代码实现：瞬时—持久化

从瞬时状态到持久化状态，Hibernate提供了如下的实现，见例6.1（以下代码省略了配置映射文件的部分）。

例6.1：瞬时—持久化的实现

     public void run() {

          //创建瞬时状态的UserInf实例

          UserInfo userInfo = new UserInfo();

          //设置UserInfo属性，持久化标识id属性在映射中为自增长，不用设置

          userInfo.setName("RW");

          userInfo.setSex("M");

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

          //瞬时—持久化的实现，保存UserInfo代表的一条记录到数据库

          ①session.save(userInfo);

          //打印结果

          System.out.println("---Id:" + userInfo.getId());

          System.out.println("---Name:" + userInfo.getName());

          System.out.println("---Sex:" + userInfo.getSex());

          //对持久化的UserInfo进行属性的更新，此时将同步数据库

          ②userInfo.setName("RW2");

          userInfo.setSex("F");

          //不用调用update方法，持久化状态的UserInfo会自动同步数据库

          //打印结果

          System.out.println("---Id:" + userInfo.getId());

          System.out.println("---Name:" + userInfo.getName());

          System.out.println("---Sex:" + userInfo.getSex());

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.save(userInfo);的动作 */

 insert

        into

            userinfo

            (NAME, SEX, roomid, id)

        values

            (?, ?, ?, ?)

Hibernate:

/* ②userInfo.setName("RW2");

userInfo.setSex("F"); 的动作*/

 update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

当瞬时状态转变为持久化状态时，需要自行调用持久化方法（如：session.save()）来执行SQL。而在持久化状态时，Hibernate控制器会自动侦测到改动，执行SQL同步数据库。

4  实体状态的代码实现：脱管-持久化、持久化-脱管

从脱管状态和持久化状态双重转变，Hibernate提供了如下的实现，见例6.2（以下代码省略了配置映射文件的部分）。

例6.2：脱管状态和持久化状态双重转变

     public void run() {

          //创建UserInfo实例

          UserInfo userInfo = new UserInfo();

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

          //得到持久化UserInfo，此时UserInfo为持久化状态

          //与数据库中主键为11117的记录同步

          ①session.load(userInfo,new Long(11117));

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

          //关闭Hibernate Session后UserInfo的状态为脱管状态

          //此时依然能够得到数据库在持久化状态时的数据

          System.out.println("---Id:" + userInfo.getId());

          System.out.println("---Name:" + userInfo.getName());

          System.out.println("---Sex:" + userInfo.getSex());

          //对userInfo实体的属性的操作将不影响数据库中主键为11117的记录

          ②userInfo.setName("RW3");

          userInfo.setSex("M");

          //启动Session

          session = HibernateSessionFactory.currentSession();

          //启动事务

          tx = session.beginTransaction();

          //从脱管状态到持久化状态的转变，此时将更新数据库中对应主键为11117的记录

          ③session.update(userInfo);

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.load(userInfo,new Long(11117))的动作 */

select

        userinfo0_.id as id0_0_,

        userinfo0_.NAME as NAME0_0_,

        userinfo0_.SEX as SEX0_0_,

        userinfo0_.roomid as roomid0_0_

    from

        userinfo userinfo0_

    where

        userinfo0_.id=?

Hibernate:

/* ③session.update(userInfo)的动作 */

 update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

可以看到②userInfo.setName("RW3")这一部分的代码没有直接同步数据库的表，因为此时 Hibernate Session已经关闭了，此时是脱管状态。而直到再次打开Hibernate Session并调用③session.update(userInfo)，此时由于持久化标识存在于UserInfo实例，因此将从脱管状态转变为持久 化状态，同步数据库。

5  持久化方法对状态的影响

在Hibernate中定义了多个持久化方法，这些方法的调用对实体状态是有影响的。注意，并不是每一个持久 化方法都会将实体状态变为持久化状态。在之前的代码中，已经使用到的持久化方法为session.save()、session.load()、 session.update()。下面是另外一些持久化方法的调用方式。

（1）session.delete()方法

该方法将已经存在的表记录删除，其所影响的状态是从持久化、脱管状态转变为瞬时状态，见例6.3。

例6.3：session.delete()方法对状态的变化

     public void run() {

          //创建UserInfo实例

          UserInfo userInfo = new UserInfo();

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

          //得到持久化UserInfo，此时UserInfo为持久化状态

          //与数据库中主键为11117的记录同步

          ①session.load(userInfo,new Long(11117));

          //删除持久化状态的UserInfo实体，此时UserInfo实体为瞬时状态

          ②session.delete(userInfo);

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

          //由于执行了session.delete因此UserInfo实体为瞬时状态，在数据库中找不到主键为11117的数据

          //此时依然能够显示该实体的属性

          System.out.println("---Id:" + userInfo.getId());

          System.out.println("---Name:" + userInfo.getName());

          System.out.println("---Sex:" + userInfo.getSex());

          //更新UserInfo实体的持久化标识，使其成为脱管状态

          ③userInfo.setId(11116);

          //启动Session

          session = HibernateSessionFactory.currentSession();

          //启动事务

          tx = session.beginTransaction();

          //调用delete方法将脱管状态的UserInfo实体转变为瞬时状态

          ④session.delete(userInfo);

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.load(userInfo,new Long(11117))的动作 */

select

        userinfo0_.id as id0_0_,

        userinfo0_.NAME as NAME0_0_,

        userinfo0_.SEX as SEX0_0_,

        userinfo0_.roomid as roomid0_0_

    from

        userinfo userinfo0_

    where

        userinfo0_.id=?

Hibernate:

/* ②session.delete(userInfo)的动作 */

delete

        from

            userinfo

        where

            id=?

Hibernate:

/* ④session.delete(userInfo)的动作 */

delete

        from

            userinfo

        where

            id=?

可以看到，两句delete语句分别对应了持久化状态的UserInfo和脱管状态的UserInfo的删除动作。之后两种状态的UserInfo都会成为瞬时状态。

（2）session.merge ()方法

该方法将修改表中记录，其所需要的实体状态为脱管状态，但是注意，它并不影响调用方法前后的状态，也即该实体依然是脱管状，见例6.4。

例6.4：session.merge ()方法对状态的变化

     public void run() {

          //创建UserInfo实例

          UserInfo userInfo = new UserInfo();

          //使之成为脱管状态

          userInfo.setId(11112);

          userInfo.setName("RW3");

          userInfo.setSex("M");

          //创建UserInfo实例

          UserInfo userInfo2 = new UserInfo();

          //使之成为脱管状态

          userInfo2.setId(11112);

          userInfo2.setName("RW4");

          userInfo2.setSex("F");

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

          //调用merge方法，此时UserInfo实体状态并没有被持久化

          session.merge(userInfo);

          //调用merge方法，此时UserInfo实体状态并没有被持久化

          //但是数据库中的记录被更新了

          ①session.merge(userInfo2);

          //merge方法与update方法的差别在于针对同样的操作update方法会报错

          //原因在于update方法使得实体状态成为了持久化状态，而Session中不允许两个持久化实体有同样的持久化标识

          ②//session.update(userInfo);

          //session.update(userInfo2);

         //以下两句不会发送SQL，因为userInfo2不是持久化状态的实体

         ③userInfo2.setName("RW5");

          userInfo2.setSex("M");

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.merge(userInfo2)的动作 */

 select

        userinfo0_.id as id0_0_,

        userinfo0_.NAME as NAME0_0_,

        userinfo0_.SEX as SEX0_0_,

        userinfo0_.roomid as roomid0_0_

    from

        userinfo userinfo0_

    where

        userinfo0_.id=?

Hibernate:

/* ①session.merge(userInfo2)的动作 */

 update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

session.merge()方法会首先发送一句select语句，去数据库端获取UserInfo持久化 标识所对应的表记录；然后自动生成一个持久化状态的UserInfo实体，与脱管状态的UserInfo实体做比较是否有所改变；一旦发生了改变，才会发 送update语句执行更新。而按执行顺序，若两句session.merge()方法针对同一个脱管状态的UserInfo实体，那其结果只会执行最后 一个session.merge()方法所发出的update语句。即使执行了session.merge()方法，UserInfo实体依然是脱管状 态，因此③userInfo2. setName("RW5")的语句不会同步数据库中的表。

（3）session.lock()方法

他为了解决事务处理而使用，它会将实体从脱管状态转变为持久化状态。但是值得注意的是，调用 session.lock()方法后，脱管状态的实体信息不会同步到数据库，而是会从数据库中返回该持久化状态。即使在脱管状态对实体属性进行了修改，一 旦调用了session.lock()方法，这种修改就成了无效，见例6.5。

例6.5：session.lock()方法对状态的变化

     public void run() {

          //创建UserInfo实例

          UserInfo userInfo = new UserInfo();

          //使之成为脱管状态

          userInfo.setId(11112);

          userInfo.setName("RW3");

          userInfo.setSex("M");

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

         //发送select获取数据库中的当前记录（执行的SQL根据LockMode不同有不同的方式）

         //UserInfo实体将从脱管状态转变为持久化状态

          ①session.lock(userInfo,LockMode.UPGRADE_NOWAIT);

          //对当前UserInfo实体进行更新将同步数据库中的记录

          ②userInfo.setName("RW8");

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.lock(userInfo,LockMode.UPGRADE_NOWAIT)的动作 */

select

        id

    from

        userinfo

    where

        id =? for update

            nowait

Hibernate:

/*②userInfo.setName("RW8")的动作 */

update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

session.lock()方法并不是为了将脱管状态的对象转变为持久化状态，而是为了事务处理。

（4）session.saveOrUpdate()方法

它是Hibernate提供的既可以新增也可以更新的方法，该方法使实体状态从脱管或瞬时直接变成持久化。 session.saveOrUpdate()方法对实体的持久化标识非常敏感。当实体持久化标识存在，就会发送update SQL，当持久化标识不存在，就会发送insert SQL，见例6.6。

例6.6：session.saveOrUpdate()方法对状态的变化

     public void run() {

          //创建UserInfo实例

          UserInfo userInfo = new UserInfo();

          //使之成为脱管状态

          userInfo.setId(11112);

          userInfo.setName("RW3");

          userInfo.setSex("M");

          //创建UserInfo实例,其为瞬时状态

          UserInfo userInfo2 = new UserInfo();

          userInfo2.setName("RW3");

          userInfo2.setSex("M");

          //启动Session

          Session session = HibernateSessionFactory.currentSession();

          //启动事务

          Transaction tx = session.beginTransaction();

          //UserInfo存在持久化标识，因此为新增，从瞬时状态成为持久化状态

          ①session.saveOrUpdate(userInfo2);

          //同步数据库表记录

          ②userInfo2.setName("RW9");

          //UserInfo存在持久化标识，因此为修改，从脱管状态成为持久化状态

          ③session.saveOrUpdate(userInfo);

          //同步数据库表记录

          ④userInfo.setName("RW10");

          //提交事务

          tx.commit();

          //关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* ①session.saveOrUpdate(userInfo2)的动作 */

insert

        into

            userinfo

            (NAME, SEX, roomid, id)

        values

            (?, ?, ?, ?)

Hibernate:

/* ②session.saveOrUpdate(userInfo)的动作 */

update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

Hibernate:

/* ③session.saveOrUpdate(userInfo)的动作 */

 update

            userinfo

        set

            NAME=?,

            SEX=?,

            roomid=?

        where

            id=?

根据代码的执行，对同一持久化UserInfo属性需要改变多次，那只会以最后的属性为准，因此 ③session.saveOrUpdate(userInfo)和④userInfo.setName("RW10")虽然从理论上需要发送两句 update SQL到数据库，但其实只会产生一句。

（5）session.createQuery()方法

它为HQL语句调用，HQL（HibernateQusery Language）是Hibernate框架自定义的一种面向对象的语言，类似SQL语言，用以与数据库进行交互。Hibernate将HQL解析成 SQL语句与数据库交互。HQL被执行后，其所关系到的实体对象将从瞬时状态转变为脱管状态，见例6.7。

例6.7：session.createQuery()方法对状态的变化

//一个内部类，作为SQL查询的参数传递

     class RoomDTO {

          Long id;

          public Long getId() {

               return id;

          }

          public void setId(Long id) {

               this.id = id;

          }

     }

 

     public void run() {

          // 创建一个JavaBean作为参数传递

          RoomDTO roomDTO = new RoomDTO();

          //设置id属性的值

          roomDTO.setId(1L);

          // 启动Session

          Session session = HibernateSessionFactory.currentSession();

          // 启动事务

          Transaction tx = session.beginTransaction();

          //session.createQuery方法作为HQL查询的执行

          //其中setProperties方法作为":id"的参数传递，要求roomDTO实例中必须包含id

          //属性和getId、setId方法

          //由于SQL中包含有3个实体：room、room.id、userinfo，因此返回的结果将是对象数组

          ①Iterator i = session

                    .createQuery(

                              "select room, room.id, userinfo from Room room, UserInfo userinfo where room.id = userinfo.room.id and room.id = :id")

                    .setProperties(roomDTO).iterate();

          //通过迭代将3个实体对象转型，得到最终结果

          //其中Room实体和UserInfo实体对应的实体状态为脱管，roomid则为一个Long类型

          while (i.hasNext()) {

               //获取对象数组转型

               Object[] object = (Object[]) i.next();

               //获取脱管状态的Room实体

               ②Room roomr = (Room) object[0];

               System.out.println(roomr.getName());

               System.out.println(roomr.getRoomnumber());

               //获取roomid

               ③Long roomid = (Long) object[1];

               System.out.println(roomid);

               //获取脱管状态的UserInfo实体

               ④UserInfo userinfor = (UserInfo) object[2];

               System.out.println(userinfor.getName());

               System.out.println(userinfor.getSex());

          }

          // 提交事务

          tx.commit();

          // 关闭Hibernate Session

          HibernateSessionFactory.closeSession();

     }

针对该段代码将执行如下SQL语句：

Hibernate:

/* 执行

①select

        room,

        room.id,

        userinfo

    from

        Room room,

        UserInfo userinfo

    where

        room.id = userinfo.room.id

        and room.id = :id

的HQL语句 */

select

            room0_.id as col_0_0_,

            room0_.id as col_1_0_,

            userinfo1_.id as col_2_0_

        from

            room room0_,

            userinfo userinfo1_

        where

            room0_.id=userinfo1_.roomid

            and room0_.id=?

Hibernate:

/* ②Room roomr = (Room) object[0]的动作（数据库中有一条记录，取第一条） */

select

        room0_.id as id1_0_,

        room0_.NAME as NAME1_0_,

        room0_.roomnumber as roomnumber1_0_

    from

        room room0_

    where

        room0_.id=?

Hibernate:

/* ④UserInfo userinfor = (UserInfo) object[2]的动作（数据库中有两条记录，取第一条） */

select

        userinfo0_.id as id0_0_,

        userinfo0_.NAME as NAME0_0_,

        userinfo0_.SEX as SEX0_0_,

        userinfo0_.roomid as roomid0_0_

    from

        userinfo userinfo0_

    where

        userinfo0_.id=?

Hibernate:

/* ④UserInfo userinfor=(UserInfo)object[2]的动作（数据库中有两条记录，取第二条）*/

 select

        userinfo0_.id as id0_0_,

        userinfo0_.NAME as NAME0_0_,

        userinfo0_.SEX as SEX0_0_,

        userinfo0_.roomid as roomid0_0_

    from

        userinfo userinfo0_

    where

        userinfo0_.id=?

可以看到，Hibernate在执行这段代码的HQL时，并不会一次性把所有的room表和userinfo 表的字段都捞取出来，而是先获取其主键。在之后真正要使用这两个表所对应的实体对象（Room和UserInfo）时，才会调用select语句去获取其 所有字段，这是“延时求值”的机制在起作用。session.createQuery()方法不会使实体成为持久化状态，因此对Room和 UserInfo的实体属性进行改变不会同步数据库。

调用createQuery()方法执行HQL时，有多种方式可以传递参数，本例提供了一种常见的方式——setProperties()。

说明  除了createQuery()方法外，Hibernate还提供了外置命名查询（getNameQuery()方法）、结果集过滤 （createFilter()方法）、条件查询（createCriteria()方法）、原生SQL查询（createSQLQuery()方法）来 实现抓取数据。

6  结语

对Hibernate中的持久化方法做一个总结，也作为本问题的结语。

（1）瞬时—脱管状态的方法有以下几种。

·  直接将实体的持久化标识进行改变。

·  调用session.createQuery()方法。

·  调用session.getNameQuery()方法。

·  调用session.createFilter()方法。

·  调用session.createCriteria()方法。

·  调用session.createSQLQuery()方法。

（2）瞬时—持久化状态的方法有以下几种。

·  调用session.save()方法。

·  调用session.saveOrUpdate()方法。

（3）脱管—持久化状态的方法有以下几种。

·  调用session.load()方法。

·  调用session.lock()方法。

·  调用session.update()方法。

·  调用session.saveOrUpdate()方法。

（4）脱管—瞬时状态的方法有以下几种。

·  直接将实体的持久化标识清除。

·  调用session.delete()方法。

（5）持久化—脱管状态的方法：关闭Hibernate Session。

（6）持久化—瞬时状态的方法。调用session.delete()方法。

（7）脱管状态-脱管状态但影响数据库记录的方法：调用session.merger()方法。