`
sophia_230
  • 浏览: 120675 次
  • 性别: Icon_minigender_2
  • 来自: 上海
社区版块
存档分类
最新评论

Hibernate中的实体状态

HibernateSQLSpringiBATIS框架 
阅读更多

持久层的解决方案有许多，尤其以持久层框架的出现为持久层的开发带来福音。本章以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所示。

 


 

举个简单的例子，假如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()方法。

分享到：
| Hibernate的各种保存方式的区别
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate中的实体状态及转换

    本文将深入探讨Hibernate中的实体状态及其转换，帮助开发者更好地掌握如何有效地使用Hibernate进行数据操作。 首先，我们要了解Hibernate定义的三种实体状态： 1. **临时状态(Transient)**：当我们在程序中通过`...

    Hibernate实体层设计

    《Hibernate实体层设计》 在Java企业级应用开发中，持久化层的处理是一个至关重要的环节，而Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。本资料主要探讨的是如何利用Hibernate进行...

    hibernate操纵实体对象

    在这个主题“hibernate操纵实体对象”中，我们将探讨如何使用Hibernate来创建、更新、删除和查询数据库中的实体对象。 首先，`HibernateSessionFactory`是Hibernate的核心组件之一，它负责创建`Session`对象。`...

    hibernate中文参考手册

    在Hibernate中，核心概念包括实体（Entities）、持久化类（Persistent Classes）、会话（Sessions）、事务（Transactions）和查询（Queries）。实体是应用程序中的业务对象，它们对应数据库中的表；持久化类是包含@...

    hibernate中文参考文档pdf

    12. **实体生命周期**：阐述了Hibernate中实体的生命周期状态（瞬时、持久化、脱管和临时），以及状态转换和事件监听。 13. **性能优化**：提供了一些最佳实践和技巧，如批处理、延迟加载、缓存配置等，以提高...

    Hibernate实体对象操纵

    **Hibernate实体对象操纵** 在Java开发中，Hibernate是一款非常重要的对象关系...希望本篇文章对您在学习Hibernate实体对象操纵的过程中有所帮助，如需进一步了解，可参考提供的"02_Hibernate实体对象操纵.ppt"文档。

    Hibernate中文Api最新参考文档

    会话是Hibernate中与数据库交互的主要接口，它负责管理实体的状态。会话具有瞬时性、持久性和临时性三种状态。通过`Session`对象，我们可以进行增删改查（CRUD）操作。例如，使用`save()`或`saveOrUpdate()`方法保存...

    Hibernate 中文api 等学习资料

    7. **实体生命周期**：了解Hibernate如何处理对象的创建、更新、删除等状态变化。 8. **性能调优**：包括批处理、连接池配置、查询优化等方面的知识。 9. **拦截器和事件监听器**：学习如何自定义行为，比如在对象...

    hibernate对象三状态及OneToOne&OneToMany&ManyToMany

    本篇将详细阐述Hibernate中的对象三状态、一对一（OneToOne）、一对多（OneToMany）以及多对多（ManyToMany）关系映射。 一、Hibernate对象三状态 1. 游离态（Detached）：对象在应用程序中创建，但尚未与Session...

    Hibernate3.6中文文档.rar

    Hibernate定义了四种实体状态：瞬时态、持久态、托管态和游离态。理解这些状态有助于正确处理对象的生命周期，避免出现并发问题。 ### 九、性能优化 为了提高性能，Hibernate提供了多种策略，如延迟加载、批处理、...

    Hibernate中文文档+hibernate annotation +distribution

    1. 实体（Entity）：在Hibernate中，实体对应数据库中的表，通过@Entity注解声明。 2. 映射（Mapping）：实体和数据库表之间的关系通过XML或注解进行定义，包括字段映射、关联映射等。 3. 会话（Session）：它是持久...

    Hibernate5中文用户使用手册

    持久化上下文：这部分讲解了如何进行实体持久化、删除实体、获取实体、刷新实体状态以及使用游离态数据等操作。还讲述了如何通过natural-id获得实体以及更改实体的状态。 访问数据库：涉及如何配置和使用不同的...

    05_传智播客hibernate教程_实体对象的三种状态与saveOrUpdate方法

    在Java的持久化框架Hibernate中，实体对象的状态管理和`saveOrUpdate`方法是核心概念，对于理解和有效使用Hibernate至关重要。在本教程中，我们将深入探讨实体对象的三种状态以及`saveOrUpdate`方法的工作原理。 ...

    Hibernate 中文文档

    **实体状态** Hibernate 将实体的状态分为四种：瞬态（Transient）、持久化（Persistent）、托管（Managed）和游离（Detached）。理解这些状态对于正确管理对象非常重要。 **实体生命周期** Hibernate 管理实体的...

    Hibernate 中文开发者文档

    5. **实体状态管理**: Hibernate区分了瞬时态、持久态、脱管态和游离态，便于理解对象的生命周期。 以上内容只是Hibernate中文开发者文档的基础概述，实际文档会包含更详细的使用示例、最佳实践和解决常见问题的...

    hibernate中文开发手册

    9. **实体生命周期**：Hibernate管理对象的生命周期，包括持久化、瞬时、托管和游离状态。手册会阐述这些状态的意义，以及在不同状态下对象的行为。 10. **实用工具与扩展**：除了基本功能，Hibernate还提供了许多...

    Hibernate 中文参考文档

    在本文档中，我们将深入探讨Hibernate的核心概念、配置、实体映射、查询语言以及其他关键特性。 ### 1. Hibernate概述 Hibernate是一个开放源代码的ORM框架，它允许Java开发人员将对象模型转换为关系数据库模型，...

    hibernate_reference中文版和Hibernate中文手册

    3. 实体类和映射文件：在Hibernate中，每个Java实体类都对应着数据库中的一个表，通过XML映射文件（hbm.xml）或注解方式来定义字段与表字段的对应关系。实体类通常需要继承Hibernate的Serializable接口，并使用@...

    hibernate 3.6 中文 chm

    2. **安装与配置**：文档会详述如何在项目中集成Hibernate 3.6，包括添加必要的库依赖、配置Hibernate的主配置文件（hibernate.cfg.xml）以及实体类的映射文件（.hbm.xml）。 3. **对象关系映射**：Hibernate的核心...

Magicbox
Global site tag (gtag.js) - Google Analytics