Hibernate中的实体状态(二)

1． 脱管状态 (Detached)
1． １． 瞬时状态 (Transient)
由 new 命令开辟内存空间的 Java 对象，也就是平时所熟悉的普通 Java 对象。
如： Student stu = new Student();
瞬时对象特点：
(1) 不和 Session 实例关联
(2) 在数据库中没有和瞬时对象关联的记录
2． ２． 持久状态 (Persistent)
持久的实例在数据库中有对应的记录，并拥有一个持久化标识 (identifier).
持久对象总是与 Session 和 Transaction 相关联，在一个 Session 中，对持久对象的改变不会马上对数据库进行变更，而必须在 Transaction 终止，也就是执行 commit() 之后，才在数据库中真正运行 SQL 进行变更，持久对象的状态才会与数据库进行同步。在同步之前的持久对象称为脏 (dirty) 对象。
瞬时对象转为持久对象：
(1) 通过 Session 的 save() 和 saveOrUpdate() 方法把一个瞬时对象与数据库相关联，这个瞬时对象就成为持久化对象。
(2) 使用 fine(),get(),load() 和 iterater() 待方法查询到的数据对象，将成为持久化对象。
持久化对象的特点：
(1) 和 Session 实例关联
(2) 在数据库中有和持久对象关联的记录
3． ３． 脱管状态 (Detached)
与持久对象关联的 Session 被关闭后，对象就变为脱管对象。对脱管对象的引用依然有效，对象可继续被修改。
脱管对象特点：
(1) 本质上和瞬时对象相同
(2) 只是比爱瞬时对象多了一个数据库记录标识值 id.
持久对象转为脱管对象：
当执行 close() 或 clear(),evict() 之后，持久对象会变为脱管对象。
瞬时对象转为持久对象：
通过 Session 的 update(),saveOrUpdate() 和 lock() 等方法，把脱管对象变为持久对象。

（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.1.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()方法。