问题：Hibernate中的实体状态

最新推荐文章于 2024-08-25 21:18:14 发布
最新推荐文章于 2024-08-25 21:18:14 发布
阅读量602 收藏
点赞数
文章标签： hibernate session 数据库 sql object 持久层框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxexplorer/article/details/1912769
版权
持久层的解决方案有许多，尤其以持久层框架的出现为持久层的开发带来福音。本章以Hibernate和Spring两个最流行的框架来讨论持久层问题，包括Hibernate实体状态、Hibernate关联关系、Hibernate连接表、Spring与JDBC、Spring与Hibernate、Spring与IBatis.
6.1  问题：Hibernate中的实体状态
6.1.1  怎样理解实体状态
程序员M在使用Hibernate时总是有些惊奇，原因在于Hinberate中对各个实体的状态有着不可思议的控制魔力。比如：有时候在更改实体的属性时，与数据库中对应的列值也会被更改，而有时候又无法对应更新起来。想要更新的时候无法更新，不想更新的却更新了。
这就引发了程序员M的问题：在什么情况下这个实体是持久化一致的，什么时候又不一致呢？在Hibernate中实体有三个状态：瞬时、持久化和脱管。要想解决持久化一致性的问题，就必须了解各个状态各代表了什么，而且在什么操作后这些状态会发生变化。
6.1.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属性的值，此时就是瞬时状态。
6.1.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同步数据库。
6.1.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实例，因此将从脱管状态转变为持久化状态，同步数据库。
6.1.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.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()方法。
 
wxexplorer
关注
Hibernate -----实体的状态（三种状态讲解）
qq_32659773的博客
04-11 321
状态介绍 实体Entity有三种状态，瞬时状态、持久状态、脱管状态 瞬时状态：transient, session没有缓存，数据库也没有记录，oid没有值 持久状态：persistent, session有缓存，数据库也有记录,oid有值 脱管状态/游离状态：detached，session没有缓存，数据库有记录,oid有值 1.2、瞬时 转 持久 新创建的一个对象，经过sav...
Hibernate实体状态
article的专栏
11-27 286
6.1 问题：Hibernate中的实体状态 6.1.1 怎样理解实体状态 程序员M在使用Hibernate时总是有些惊奇，原因在于Hinberate中对各个实体的状态有着不可思议的控制魔力。比如：有时候在更改实体的属性时，与数据库中对应的列值也会被更改，而有时候又无法对应更新起来。想要更新的时候无法更新，不想更新的却更新了。 这就引发了程序员M的问题：在什么情况下这个实体是持久...
瞬时、持久化和脱管
神#儿童
07-01 211
持久层的解决方案有许多，尤其以持久层框架的出现为持久层的开发带来福音。本章以Hibernate和Spring两个最流行的框架来讨论持久层问题，包括Hibernate实体状态、Hibernate关联关系、Hibernate连接表、Spring与JDBC、Spring与Hibernate、Spring与IBatis.6.1 问题：Hibernate中的实体状态6.1.1 怎样理解实体状态程序员M在使用...
hibernate中的实体状态
11-08 115
hibernate中的实体3种状态： （1）瞬时：只是new出来时候，也就是说与数据库中的数据没有任何的关联即，该实体从未与任何持久化上下文联系过，没有持久化标识（相当与主键）。  与数据库中的记录没有任何关联，也就是没有与其相关联的数据库记录 与Session没有任何关系，也就是没有通过Session对象的实例对其进行任何持久化的操作。 （2）持久：指该实体对象处于Hibernate框架所...
hibernate之使用脱管对象(合并脱管对象的状态)
fhd001的专栏
10-03 939
hibernate之使用脱管对象(合并脱管对象的状态)
HiberNate实体
01-08
一、Hibernate实体的状态管理 1. **瞬时状态（Transient）**： 当对象通过`new`关键字创建，但尚未与Session关联时，对象处于瞬时状态。这些对象在内存中存在，但不会被持久化到数据库中，也没有持久化标识。对...
hibernate:Hibernate示例
04-19
1. **实体类**：在Hibernate中，实体类代表数据库中的表，类中的属性对应于表中的列。例如，我们可以创建一个名为`User`的实体类，包含`id`、`username`和`password`等属性，并使用`@Entity`注解标识该类为数据库表...
Hibernate:Hibernate 回顾
07-03
7. **持久化类和 ID 映射**：每个实体类都有一个唯一的标识符（ID），Hibernate 使用这个 ID 来跟踪和管理对象的状态。 **MySQL 与 Hibernate 的结合** MySQL 是一款广泛使用的开源关系型数据库管理系统，与 ...
hibernate-search：Hibernate搜索：全文搜索域模型
02-11
通过Hibernate ORM会话修改的实体进行，以始终使索引保持最新状态。 ，可轻松构建全文本搜索查询并以Hibernate ORM实体的形式检索匹配。 以及更多： Search DSL中的许多不同和， 。 搜索查询返回的是而不是实体，...
hibernate:Hibernate练习
06-20
【描述】：在Java开发中，Hibernate是一个强大的对象关系映射（ORM）框架，它极大地简化了数据库操作。这个“Hibernate练习”可能包含一系列的示例和项目，用于帮助开发者更好地理解和掌握Hibernate的核心概念、API...
hibernate之使用脱管对象(重附被修改的脱管实例)
fhd001的专栏
10-02 794
hibernate之使用脱管对象(重附被修改的脱管实例)
Hibernate中的实体状态【转】
xinjiXJZ的专栏
05-12 610
（2）session.merge ()方法 该方法将修改表中记录，其所需要的实体状态为脱管状态，但是注意，它并不影响调用方法前后的状态， 也即该实体依然是脱管状，见例6.4。 例6.4：session.merge ()方法对状态的变化      public void run() {           //创建UserInfo实例           UserInfo userInf
Hibernate实体对象四大状态
abguorui0928的专栏
06-24 5697
首先声明，在Hibernate中，实体对象存在四种状态，而不是三种（相关源码如下，见org.hibernate.event.def.AbstractSaveEventListener.java）。网上流传的hibernate对象三大状态，大概是因为hibernate官方文档没有更新，然后一个接着一个的copy吧，你懂的。
Hibernate三种实体状态(五)
两个蝴蝶飞
10-20 5707
感谢Jie’ blog http://ilog.vip/ ,谢谢他让我有了继续写下去的信念。愿一起坚持，在路上… 上一章简单介绍了Hibernate简单注解开发和事务处理(四),如果没有看过，请观看上一章 一.Hibernate 的三种实体状态 Hibernate有三种实体状态，有瞬时态(transiant),持久态(persistent),游离态(detached)。 简单理解就是,瞬时态指的是...
Hibernate对象状态&三种查询操作
weixin_30763397的博客
01-13 170
hibernate对象状态 public class Test { public static void main(String[] args) { Configuration configuration= new Configuration().configure(); SessionFactory sessionFactory = co...
深入hibernate的三种状态
weixin_33894640的博客
10-21 211
学过hibernate的人都可能都知道hibernate有三种状态，transient(瞬时状态)，persistent(持久化状态)以及detached(离线状态)，大家伙也许也知道这三者之间的区别，比如瞬时状态就是刚new出来一个对象，还没有被保存到数据库中，持久化状态就是已经被保存到数据库中，离线状态就是数据库中有，但是session中不存在该对象。但是大家又是否对hibernate的ses...
Hibernate实体对象的三种状态以及困惑
aty
04-16 2439
Hibernate官方文档manaul中提到，hibernate实体有三种状态：Transient、Persistent、Detached。本文参考了官网手册和http://blog.csdn.net/hgd250/article/details/2775943这篇博客。 1、Transient状态     An object is transient if it has just
hibernate 实体对象的三种状态以及转换关系。
weixin_30339457的博客
02-25 196
最新的Hibernate文档中为Hibernate对象定义了四种状态（原来是三种状态，面试的时候基本上问的也是三种状态），分别是：瞬时态（new, or transient）、持久态（managed, or persistent）、游离态（detached）和移除态（removed，以前Hibernate文档中定义的三种状态中没有移除态），如下图所示，就以前的Hibernate文档中移除态被视为是...
Web安全：SQL注入实战测试.（扫描 + 测试）
最新发布
网络安全领域___专研者.
08-25 1079
SQL注入就是 有些恶意用户在提交查询请求的过程中 将SQL语句插入到请求内容中，同时程序的本身对用户输入的内容过于相信，没有对用户插入的SQL语句进行任何的过滤，从而直接被SQL语句直接被服务端执行，导致数据库的原有信息泄露，篡改，甚至被删除等风险。
理解Hibernate：实体对象的三种状态详解
"这篇文档主要介绍了Hibernate框架中实体对象的三种状态：Transient（自由状态）、Persistent（持久状态）和Detached（游离状态），并提到了Hibernate的基本使用、配置文件、对象关系映射以及与Spring框架的结合。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值