掌握hiberate核心就够了

ゝ一纸荒年。 2022-05-20 05:20 241阅读 0赞

## 掌握hiberate核心就够了 ##

*   *  掌握hiberate核心就够了
 *  前言
 *  hibernate里数据的三种状态
    
     *  概述
     *  1.TestTransient
     *  2.TestPersistent01
     *  3.TestPersistent02
     *  4.TestPersistent03
     *  5.TestPersistent04
     *  6.TestPersistent05
     *  7.TestDetached01
     *  8.TestDetached02
     *  9.TestDetached03
     *  10.TestDetached04
     *  11.TestDetached05
     *  12.TestDetached06
     *  总结
 *  级联策略
 *  策略
    
     *  例子

# 前言 #

刚接手一个hiberate做ORM的项目，由于平时使用mybatis比较多，hiberate反而不熟悉，它主要关注点在实体类操作数据库。  
交接那位小伙子功底不深，我问了一个问题，主表关联从表，假如从表没有数据，而我查主表数据能查出来吗？关联的从表对象能为null吗？他是说不可能，为什么会有这种情况呢？说了一大堆，虽然我不熟悉hiberate，但我相信肯定可以，至少数据库里有左连接，右连接概念在。  
我的意思是学习要深入概念原理，不在浮于表面，不然就会像他一样，只会配置(或者说不用配置，只会读懂别人的配置)就以为自己掌握了。

`本文大部分是内容是转载，因为别人已经写的很不错了，我只增加了一些个人的理解。`

2个知识点  
\- hiberate里数据状态  
\- hiberate里级联操作，包括增加，更新

# hibernate里数据的三种状态 #

## 概述 ##

学过hibernate的人都可能都知道hibernate有三种状态，transient(瞬时状态)，persistent(持久化状态)以及detached(离线状态)，大家伙也许也知道这三者之间的区别，比如瞬时状态就是刚new出来一个对象，还没有被保存到数据库中，持久化状态就是已经被保存到数据库中，离线状态就是数据库中有，但是session中不存在该对象。但是大家又是否对hibernate的session的那几个特殊方法一清二楚呢？或者说大家是否能够一眼就快速看出一个测试用例在反复的调用session的诸如save，update方法后会到底发出多少条SQL语句呢？本篇随笔将会给你答案，本篇随笔将会以大量的测试用例来掩饰hibernate的这三种状态的转变，相信看完本篇随笔的你会对hibernate的那三种状态有更深入的理解。

好了，废话不多说了，相信大家都知道hibernate的这三种状态的含义，那我们就通过一张图来开始我们的深入hibernate的三种状态之旅吧。  
![这里写图片描述][70]

## 1.TestTransient ##

session = HibernateUtil.openSession();
    session.beginTransaction();
    User user = new User();
    user.setUsername("aaa");
    user.setPassword("aaa");
    user.setBorn(new Date());
    /* * 以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管，即在session的 * 缓存中还不存在user这个对象，当执行完save方法后，此时user被session托管，并且数据库中存在了该对象 * user就变成了一个Persistent(持久化对象) */
    session.save(user);
    session.getTransaction().commit();

此时我们知道hibernate会发出一条insert的语句，执行完save方法后，该user对象就变成了持久化的对象了

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)

## 2.TestPersistent01 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                User user = new User();
                user.setUsername("aaa");
                user.setPassword("aaa");
                user.setBorn(new Date());
                //以上u就是Transient（瞬时状态），表示没有被session管理并且数据库中没有
                //执行save之后，被session所管理，而且，数据库中已经存在，此时就是Persistent状态
                session.save(user);
                //此时u是持久化状态，已经被session所管理，当在提交时，会把session中的对象和目前的对象进行比较
                //如果两个对象中的值不一致就会继续发出相应的sql语句
                user.setPassword("bbb");
                //此时会发出2条sql，一条用户做插入，一条用来做更新
                session.getTransaction().commit();

在调用了save方法后，此时user已经是持久化对象了，被保存在了session缓存当中，这时user又重新修改了属性值，那么在提交事务时，此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较，如果两个对象相同，则不会发送update语句，否则，如果两个对象不同，则会发出update语句。

Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_user set born=?, password=?, username=? where id=?

## 3.TestPersistent02 ##

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setBorn(new Date());
                u.setUsername("zhangsan");
                u.setPassword("zhangsan");
                session.save(u);
                u.setPassword("222");
                //该条语句没有意义
                session.save(u);
                u.setPassword("zhangsan111");
                //没有意义
                session.update(u);
                u.setBorn(sdf.parse("1988-12-22"));
                //没有意义
                session.update(u);
                session.getTransaction().commit();

这个时候会发出多少sql语句呢？还是同样的道理，在调用save方法后，u此时已经是持久化对象了，记住一点：如果一个对象以及是持久化状态了，那么此时对该对象进行各种修改，或者调用多次update、save方法时，hibernate都不会发送sql语句，只有当事物提交的时候，此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较，如果不相同就发送一条update的sql语句，否则就不会发送update语句

Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_user set born=?, password=?, username=? where id=?

## 4.TestPersistent03 ##

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setBorn(sdf.parse("1976-2-3"));
                u.setUsername("zhangsan2");
                u.setPassword("zhangsan2");
                session.save(u);
                /* * 以下三条语句没有任何意义 */
                session.save(u);
                session.update(u);
                session.update(u);
                u.setUsername("zhangsan3");
                session.getTransaction().commit();

## 5.TestPersistent04 ##

session = HibernateUtil.openSession();
    session.beginTransaction();
    //此时u是Persistent
    User u = (User)session.load(User.class, 4);
    //由于u这个对象和session中的对象不一致，所以会发出sql完成更新
    u.setUsername("bbb");
    session.getTransaction().commit();

我们来看看此时会发出多少sql语句呢？同样记住一点：当session调用load、get方法时，此时如果数据库中有该对象，则该对象也变成了一个持久化对象，被session所托管。因此，这个时候如果对对象进行操作，在提交事务时同样会去与session中的持久化对象进行比较，因此这里会发送两条sql语句

Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?
    Hibernate: update t_user set born=?, password=?, username=? where id=?

## 6.TestPersistent05 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                //此时u是Persistent
                User u = (User)session.load(User.class, 4);
                u.setUsername("123");
                //清空session
                session.clear();
                session.getTransaction().commit();

再看这个例子，当我们load出user对象时，此时user是持久化的对象，在session缓存中存在该对象，此时我们在对user进行修改后，然后调用session.clear()方法，这个时候就会将session的缓存对象清空，那么session中就没有了user这个对象，这个时候在提交事务的时候，发现已经session中已经没有该对象了，所以就不会进行任何操作，因此这里只会发送一条select语句

Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?

## 7.TestDetached01 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                //此时u是一个离线对象，没有被session托管
                User u = new User();
                u.setId(4);
                u.setPassword("hahahaha");
                //当执行save的时候总是会添加一条数据，此时id就会根据Hibernate所定义的规则来生成
                session.save(u);
                session.getTransaction().commit();

我们看到，当调用了u.setId(4)时，此时u是一个离线的对象，因为数据库中存在id=4的这个对象，但是该对象又没有被session所托管，所以这个对象就是离线的对象，要使离线对象变成一个持久化的对象，应该调用什么方法呢？我们知道调用save方法，可以将一个对象变成一个持久化对象，但是，当save一执行的时候，此时hibernate会根据id的生成策略往数据库中再插入一条数据，所以如果调用save方法，此时数据库会发送一条插入的语句：

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)

所以对于离线对象，如果要使其变成持久化对象的话，我们不能使用save方法，而应该使用update方法

## 8.TestDetached02 ##

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(5);
                //完成update之后也会变成持久化状态
                session.update(u);
                u.setBorn(sdf.parse("1998-12-22"));
                u.setPassword("world");
                u.setUsername("world");
                //会发出一条sql
                session.update(u);
                session.getTransaction().commit();

此时我们看到，当调用了update方法以后，此时u已经变成了一个持久化的对象，那么如果此时对u对象进行修改操作后，在事务提交的时候，则会拿该对象和session中刚保存的持久化对象进行比较，如果不同就发一条sql语句

Hibernate: update t_user set born=?, password=?, username=? where id=?

## 9.TestDetached03 ##

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(5);
                //完成update之后也会变成持久化状态
                session.update(u);
                u.setBorn(sdf.parse("1998-12-22"));
                u.setPassword("lisi");
                u.setUsername("lisi");
                //会抛出异常
                u.setId(333);
                session.getTransaction().commit();

我们看这个例子，前面的操作一样，调用update方法后，user变成了一个持久化对象，在对user进行一些修改后，此时又通过 u.setId(333)方法设置了u的ID，那么这个时候，hibernate会报错，因为我们的u当前已经是一个持久化对象，如果试图修改一个持久化对象的ID的值的话，就会抛出异常，这点要特别注意

org.hibernate.HibernateException: identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333

## 10.TestDetached04 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(5);
                //现在u就是transient对象
                session.delete(u);
                //此时u已经是瞬时对象，不会被session和数据库所管理
                u.setPassword("wangwu");
                session.getTransaction().commit();

接着我们来看这个例子，这里在调用了session.delete()方法以后，此时后u就会变成一个瞬时对象，因为此时数据库中已经不存在该对象了，既然u已经是一个瞬时对象了，那么对u再进行各种修改操作的话，hibernate也不会发送任何的修改语句，因此这里只会 有一条 delete的语句发生：

Hibernate: delete from t_user where id=?

## 11.TestDetached05 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(4);
                u.setPassword("zhaoliu");
                //如果u是离线状态就执行update操作，如果是瞬时状态就执行Save操作
                //但是注意：该方法并不常用
                session.saveOrUpdate(u);
                session.getTransaction().commit();

这里我们来看看 saveOrUpdate这个方法，这个方法其实是一个”偷懒”的方法，如果对象是一个离线对象，那么在执行这个方法后，其实是调用了update方法，如果对象是一个瞬时对象，则会调用save方法，记住：如果对象设置了ID值，例如u.setId(4)，那么该对象会被假设当作一个离线对象，此时就会执行update操作。

Hibernate: update t_user set born=?, password=?, username=? where id=?

如果此时我将u.setId(4)这句话注释掉，那么此时u就是一个瞬时的对象，那么此时就会执行save操作，就会发送一条insert语句

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)

## 12.TestDetached06 ##

session = HibernateUtil.openSession();
                session.beginTransaction();
                //u1已经是持久化状态
                User u1 = (User)session.load(User.class, 3);
                System.out.println(u1.getUsername());
                //u2是离线状态
                User u2 = new User();
                u2.setId(3);
                u2.setPassword("123456789");
                //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常
                session.saveOrUpdate(u2);

我们再来看一下这个例子，此时我们的u1已经是持久化的对象了，保存在session缓存中，u2通过调用saveOrUpdate方法后也变成了一个持久化的对象，此时也会保存在session缓存中，这个时候session缓存中就存在了一个持久化对象有两个引用拷贝了，这个时候hibernate就会报错

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [com.xiaoluo.bean.User#3]

一个session中不能存在对一个持久化对象的双重copy的，要解决这个方法，我们这里又要介绍session的另一个方法 merge方法，这个方法的作用就是解决一个持久化对象两分拷贝的问题，这个方法会将两个对象合并在一起成为一个对象。

session = HibernateUtil.openSession();
     session.beginTransaction();
     //u1已经是持久化状态
     User u1 = (User)session.load(User.class, 3);
     System.out.println(u1.getUsername());
     //u2是离线状态
     User u2 = new User();
     u2.setId(3);
     u2.setPassword("123456789");
     //此时u2将会变成持久化状态，在session的缓存中就存在了两份同样的对象,在session中不能存在两份拷贝，否则会抛出异常
    //            session.saveOrUpdate(u2);
     //merge方法会判断session中是否已经存在同一个对象，如果存在就将两个对象合并
     session.merge(u2);
     //最佳实践：merge一般不用
     session.getTransaction().commit();

我们看到通过调用了merge方法以后，此时会将session中的两个持久化对象合并为一个对象，但是merge方法不建议被使用

Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?
    zhangsan
    Hibernate: update t_user set born=?, password=?, username=? where id=?

终于写完了本篇随笔，本篇随笔可能概念性的内容比较少，基本都是通过测试用例来分析hibernate的三种状态可能会出现的各种情况。

## 总结 ##

最后总结一下：

*  对于刚创建的一个对象，如果session中和数据库中都不存在该对象，那么该对象就是瞬时对象(Transient)
 *  瞬时对象调用save方法，或者离线对象调用update方法可以使该对象变成持久化对象，如果对象是持久化对象时，那么对该对象的任何修改，都会在提交事务时才会与之进行比较，如果不同，则发送一条update语句，否则就不会发送语句
 *  离线对象就是，数据库存在该对象，但是该对象又没有被session所托管

# 级联策略 #

先抛个问题，新手常犯的错

object references an unsaved transient instance - save the transient instance before

# 策略 #

当Hibernate持久化一个临时对象时，在默认情下，他不会自动持久化所关联的其他临时对象，如果希望当持久化对象时把他所关联的所有临时对象进行持久化的话：可以把 的cascade属性设置为”save-update” ,cascade的默认属性值为none。

*  save-update ：表示当保存和更新当前对象(即insert和update语句时)，会级联保存和更新与他关联的对象。 `org.hibernate.annotations.CascadeType.SAVE_UPDATE`
 *  all ：表示任何情况下都会进行级联操作，即对一个对象进行操作，也会对和他关联的其他对象进行同样的操作。 `org.hibernate.annotations.CascadeType.ALL`
 *  delete ：表示在执行delete时，进行级联操作，删除和他关联的对象。`org.hibernate.annotations.CascadeType.REMOVE`
 *  none ：表示任何情况下，都不会进行级联操作。`默认，不填即可。`

## 例子 ##

import java.util.*;
    
    import javax.persistence.*;
    @Entity
    @Table(name="person_inf")
    public class Person { 
        // 标识属性
        @Id @Column(name="person_id")
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id;
        private String name;
        private int age;
        // 定义该Person实体关联的Address实体
        @OneToOne(targetEntity=Address.class,cascade=CascadeType.ALL)
        // 映射名为address_id的外键列，参照关联实体对应表的addres_id主键列
        @JoinColumn(name="address_id"
            , referencedColumnName="address_id" , unique=true)
        private Address address;
        //省略所有set get方法
    }

注意上面代码中@OneToOne(cascade=CascadeType.All)这条，它就代表着将所有的持久化操作都级联到关联体中，意思就是系统会自动级联插入主表记录（address\_inf表），再插入从表记录(person\_inf)，而不用担心该关联体是否已经保存为持久化状态

import java.util.ArrayList;
    import java.util.List;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name="address_inf")
    public class Address { 
    
        @Id
        @Column(name="address_id")
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private int addressId;
        private  String addressDetail;
        public Address() {
    
        }
        public Address(String addressDetail) {
            this.addressDetail = addressDetail;
        }
        //省略set get方法

主程序代码

Person person=new Person();
    person.setName("VipMao");
    person.setAge(24);
    //创建一个瞬态 的Adress对象
    Address address=new Address("山东曲阜");
    //设置Person和Adress之间的关联关系
    person.setAddress(address);
    //persist方法并不是立刻将标识符填入到实例化中 这是与save方法的区别
    session.persist(person);
    tx.commit();

设置了`@OneToOne(cascade=CascadeType.All)`，这就说明当程序执行到session.persist(person)的时候，会先执行插入address\_inf表记录，再执行插入person\_inf表记录。

回头解决开头的问题

object references an unsaved transient instance - save the transient instance before

上面的代码由于使用`cascade=CascadeType.ALL`指定所有操作都会级联操作，所以不会出现这个问题，如果把该设置去掉。这时候由于person对象引用了address对象，在保存person时默认不会级联保存address，address虽然处于瞬间状态，但因为person做的save操作的关系，address是`unsaved`的，这时候由于2者的引用关系，如果在当前事务里有对`address表`做相关操作，都会报`object references an unsaved transient instance`错误。如果将`person.setAddress(null);`,那么2都不存在引用关系，在保存person后，address还是处于瞬间状态，不会`unsaved`报错误。

**所以有2种解决方法**  
\- 使用cascad：`cascade=CascadeType.ALL`或`cascade=CascadeType.SAVE_UPDATE`。  
\- 解除引用关系，引用对象设为null。

参考文章  
[Hibernate中的级联策略][Hibernate]  
[Hibernate级联保存和更新][Hibernate 1]

[70]: /images/20220520/a3c532d16ed4480ab1ac9f0828a1e43d.png
[Hibernate]: https://blog.csdn.net/vipmao/article/details/51378237
[Hibernate 1]: https://blog.csdn.net/liumm1983/article/details/1541592