Hibernate增删改查一些方法的区别

上一篇http://blog.youkuaiyun.com/qq_32588349/article/details/51465261

---

简单总结

• save()和persist()
  1).二者都是将瞬时态对象保存到数据库转为持久态对象，区别是save()立即执行,而persist()需要在清理缓存（flush方法或提交事务）时才执行。
  2).save()方法立即分配OID,persist()只有清理缓存(flush方法或提交事务)时才会分配OID。

• update()、saveOrUpdate()、merge()
  1).update()是将游离态对象更新到数据库变为持久态对象,若游离态对象OID在数据库不存在,会抛出异常。
  2).saveOrUpdate()是根据对象状态判断执行方法,对于瞬时态对象执行save(),对于游离态执行update()。
  3).merge()方法类似于saveOrUpdate(),区别在于不用考虑游离态对象的OID在数据库中是否存在,不存在执行save()。merge()不会改变原来对象的状态,但是会返回一个新的持久态对象。

• delete()
  1).若删除的为持久态对象,会在清理缓存的时候执行delete语句删除。
  2).若删除的为游离态对象,回先将该对象与当前Session关联,在清理缓存时执行delete语句删除。
  3).delete()方法一次只能删除一个对象。

• get()和load()
  1).懒加载开启情况下,load()只有需要获取其非OID属性时才会去查询,而get()不受懒加载影响。
  2).如果不存在于对象OID对应的记录,load()方法抛出异常,而get()方法返回null。

---

测试代码

• 使用Hibernate添加数据（save()和persist()的区别）

1.调用session.save()方法实现添加数据
    /**
     * 不开启事务且不提交事务也就是不清理缓存
     */
    public void saveEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //不开启事务
        //Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("save测试名");
        //..其余属性略
        //持久化
        session.save(emp);
        //改变持久化对象属性                   
        emp.setEname("改变后的save测试名");  
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台显示如下-并未执行update语句
    Hibernate: 
    insert 
    into
        hibernate_data.emp
        (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
    values
        (?, ?, ?, ?, ?, ?, ?)

    /**
     * 开启事务但不提交事务也就是不清理缓存
     */
    public void saveEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("save测试名");
        //..其余属性略
        //持久化
        session.save(emp);
        //改变持久化对象属性                   
        emp.setEname("改变后的save测试名");  
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台显示如下-并未执行update语句
    Hibernate: 
    insert 
    into
        hibernate_data.emp
        (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
    values
        (?, ?, ?, ?, ?, ?, ?)

    /**
     * 开启事务且提交事务清理缓存
     */
    public void saveEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("save测试名");
        //..其余属性略
        //持久化
        session.save(emp);
        //输出雇员编号
        System.out.println("雇员编号:" + emp.getEmpno());
        //改变持久化对象属性
        emp.setEname("改变后的save测试名");
        //清理缓存-与提交事务的区别在于清理缓存可以回滚事务
        //session.flush();
        //提交事务-事务提交会清理缓存
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台显示如下-执行update语句
    Hibernate: 
    insert 
    into
        hibernate_data.emp
        (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
    values
        (?, ?, ?, ?, ?, ?, ?)
    雇员编号:16    
    Hibernate: 
        update
            hibernate_data.emp 
        set
            ENAME=?,
            JOB=?,
            MGR=?,
            HIREDATE=?,
            SAL=?,
            COMM=?,
            DEPTNO=? 
        where
            EMPNO=?

//在save()之后改变属性如果不开启事务不提交事务只调用session.flush()也会计划update语句且将对象放入Session缓存中,之后如果再提交事务也会同步到数据库中。这里就不举例了。

- 当调用save()方法后,会执行以下操作
 1).无论是否开始事务或清理缓存都会将对象加入到Session的缓存中,使它进入持久化状态。
 2).无论是否开始事务或清理缓存都会根据映射文件指定的配置,为持久化对象分配唯一的OID。
 3).无论是否开启事务或清理缓存都会执行一个insert语句,比如多次
    执行save()方法后不提交事务,会发现总是输出insert语句且获得一个新的OID。
- save()方法之后又对对象的属性进行了更改且执行事务提交或清理缓存时,会额外执行一条update语句

2.调用session.persist()方法实现添加数据
    /**
     * 不开启事务且不提交事务
     */
    public void persistEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //不开启事务
        //Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("persist测试名");
        //..其余属性略
        //持久化
        session.persist(emp);
        //输出雇员编号
        System.out.println("雇员编号：" + emp.getEmpno());
        //更改属性
        emp.setEname("更改persist测试名");
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下-未执行任何SQL语句,未获取雇员编号
    雇员编号：null

    /**
     * 不开启事务且不提交事务,但是清理缓存
     */
    public void persistEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //不开启事务
        //Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("persist测试名");
        //..其余属性略
        //持久化
        session.persist(emp);
        //输出雇员编号
        System.out.println("雇员编号：" + emp.getEmpno());
        //更改属性
        emp.setEname("更改persist测试名");
        //清理缓存
        session.flush();
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下-清理缓存前,不计划任何SQL语句,不分配OID,清理之后执行且分配.
    雇员编号：null
    Hibernate: 
        insert 
        into
            hibernate_data.emp
            (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
        values
            (?, ?, ?, ?, ?, ?, ?)
    Hibernate: 
        update
            hibernate_data.emp 
        set
            ENAME=?,
            JOB=?,
            MGR=?,
            HIREDATE=?,
            SAL=?,
            COMM=?,
            DEPTNO=? 
        where
            EMPNO=?
    雇员编号：33

    /**
     * 不开启事务且不提交事务且不清理缓存
     */
    public void persistEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个实体类对象
        Emp emp = new Emp();
        //设置值-如果主键方式为数据库自动递增或序列生成,不用设置
        emp.setEname("persist测试名");
        //..其余属性略
        //持久化
        session.persist(emp);
        //输出雇员编号
        System.out.println("雇员编号：" + emp.getEmpno());
        //更改属性
        emp.setEname("更改persist测试名");
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下-计划insert语句,分配OID,不计划update语句
    Hibernate: 
        insert 
        into
            hibernate_data.emp
            (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
        values
            (?, ?, ?, ?, ?, ?, ?)
    雇员编号：34
    雇员编号：34

- 当调用persist()方法后,会执行以下操作
 1).只有开启事务或清理缓存才会将对象加入到Session的缓存中,使它进入持久化状态。
 2).只有开启事务或清理缓存才会根据映射文件指定的配置,为持久化对象分配唯一的OID。
 3).只有开启事务或清理缓存才会执行一个insert语句。
- persist()方法之后又对对象的属性进行了更改且执行事务提交或清理缓存时,会额外执行一条update语句

• 使用Hibernate更新数据（update()和saveOrUpdate()区别）

1.调用update()方法更新数据
    /**
     * 开启事务但是不提交不清理缓存
     */
    public void updateEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个瞬时态对象
        Emp emp = new Emp();
        //设置OID变为游离态对象
        emp.setEmpno(1);
        emp.setEname("update测试名");
        //..其余属性略
        //变更为持久态对象
        session.update(emp);
        //更改属性
        emp.setEname("测试名");
        //不提交事务
        //transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输入如下-无任何输出

    /**
     * 开启事务且提交事务或清理缓存
     */
    public void updateEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个瞬时态对象
        Emp emp = new Emp();
        //设置OID变为游离态对象
        emp.setEmpno(1);
        emp.setEname("update测试名");
        //..其余属性略
        //变更为持久态对象
        session.update(emp);
        //更改属性
        emp.setEname("测试名");
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下-仅执行一条update语句
    Hibernate: 
        update
            hibernate_data.emp 
        set
            ENAME=?,
            JOB=?,
            MGR=?,
            HIREDATE=?,
            SAL=?,
            COMM=?,
            DEPTNO=? 
        where
            EMPNO=?

- 当调用update()方法后,会执行以下操作
 1).只对具备OID也就是游离态对象有效,对瞬时态(不具备OID)对象无效,将游离态转为持久态。
 2).只有提交事务或清理缓存才会将对象加入到Session的缓存中,执行一条update语句,使它进入持久化状态。
 3).无论对对象属性修改多少次,清理缓存时只执行一次update语句。

2.调用saveOrUpdate()方法更新数据

    /**
     * 更新瞬时态对象
     */
    public void saveOrUpdateEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个瞬时态对象
        Emp emp = new Emp();
        //不设置OID变为游离态对象
        //emp.setEmpno(1);
        emp.setEname("测试名");
        //..其余属性略
        session.saveOrUpdate(emp);
        //输出雇员编号
        System.out.println("雇员编号:" + emp.getEmpno());
        //更改属性
        emp.setEname("更改名");
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();

    控制台输出如下
    Hibernate: 
    insert 
    into
        hibernate_data.emp
        (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
    values
        (?, ?, ?, ?, ?, ?, ?)
    雇员编号:38
    Hibernate: 
        update
            hibernate_data.emp 
        set
            ENAME=?,
            JOB=?,
            MGR=?,
            HIREDATE=?,
            SAL=?,
            COMM=?,
            DEPTNO=? 
        where
            EMPNO=?

    /**
     * 更新游离态对象
     */
    public void saveOrUpdateEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //创建一个瞬时态对象
        Emp emp = new Emp();
        //设置OID变为游离态对象
        emp.setEmpno(1);
        emp.setEname("测试名");
        //..其余属性略
        session.saveOrUpdate(emp);
        //更改属性
        emp.setEname("更改名");
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下
    Hibernate: 
    update
        hibernate_data.emp 
    set
        ENAME=?,
        JOB=?,
        MGR=?,
        HIREDATE=?,
        SAL=?,
        COMM=?,
        DEPTNO=? 
    where
        EMPNO=?

    /**
     * 更新持久态对象
     */
    public void saveOrUpdateEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //获得持久态对象
        Emp emp = (Emp) session.get(Emp.class, 1);
        session.saveOrUpdate(emp);
        //更改属性-此属性与数据库对应数据字段数据一致
        emp.setEname("更改名");
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下-此语句为get()方法输出
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
    from
        hibernate_data.emp emp0_ 
    where
        emp0_.EMPNO=?

- 当调用saveOrUpdate()方法后,会执行以下操作
 1).对于瞬时态对象调用save()方法。
 2).对于游离态对象调用update()方法。
 3).对于持久态对象不进行任何操作直接返回,对于持久态对象,属性无改变不会执行update语句。

3.使用merge()方法更新数据
    /**
     * 保存一个数据库已存在的OID对象
     */
    public void useMerge() {
        Session session = HibernateSessionFactory.getSession();
        Transaction transaction = session.beginTransaction();
        //创建一个对象
        Emp emp = new Emp();
        //设置一个数据库已经存在的OID
        emp.setEmpno(43);
        emp.setEname("merge");

        session.merge(emp);

        transaction.commit();
        HibernateSessionFactory.closeSession();
    }

    控制台输出
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
    from
        hibernate_data.emp emp0_ 
    where
        emp0_.EMPNO=?
    Hibernate: 
        update
            hibernate_data.emp 
        set
            ENAME=?,
            JOB=?,
            MGR=?,
            HIREDATE=?,
            SAL=?,
            COMM=?,
            DEPTNO=? 
        where
            EMPNO=?

    /**
     * 保存一个数据库不存在的OID对象
     */
    public void useMerge() {
        Session session = HibernateSessionFactory.getSession();
        Transaction transaction = session.beginTransaction();
        //创建一个对象
        Emp emp = new Emp();
        //设置一个数据库不存在的OID
        emp.setEmpno(1);
        emp.setEname("merge");

        session.merge(emp);

        transaction.commit();
        HibernateSessionFactory.closeSession();
    }

    控制台输出
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
    from
        hibernate_data.emp emp0_ 
    where
        emp0_.EMPNO=?
    Hibernate: 
        insert 
        into
            hibernate_data.emp
            (ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO) 
        values
            (?, ?, ?, ?, ?, ?, ?)

• 使用Hibernate删除数据（delete()方法）

    /**
     * 删除持久化对象
     */
    public void deleteEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        //获取一个持久化对象
        Emp emp = (Emp) session.get(Emp.class, 1);
        //调用delete方法将该对象有持久态转化为临时态
        session.delete(emp);
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
    from
        hibernate_data.emp emp0_ 
    where
        emp0_.EMPNO=?
    Hibernate: 
        delete 
        from
            hibernate_data.emp 
        where
            EMPNO=?

    /**
     * 删除游离态对象
     */
    public void deleteEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //开启事务
        Transaction transaction = session.beginTransaction();
        Emp emp = new Emp();
        //设置为游离态对象
        emp.setEmpno(2);
        //调用delete方法将该对象有持久态转化为临时态
        session.delete(emp);
        //提交事务
        transaction.commit();
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台输出如下
    Hibernate: 
    delete 
    from
        hibernate_data.emp 
    where
        EMPNO=?

- 当调用delete()方法后,会执行以下操作
 1).若删除的为持久态对象,会在清理缓存的时候执行delete语句删除。
 2).若删除的为游离态对象,回先将该对象与当前Session关联,在清理缓存时执行delete语句删除。
 3).delete()方法一次只能删除一个对象。

• 使用Hibernate查询数据（get()和load()区别）

<!--首先在映射文件内开启懒加载(lazy="true" 默认开启)-->
<class name="com.bc.pojo.Emp" table="emp" catalog="hibernate_data" lazy="true">

    /**
     * 使用get()获取对象
     */
    public void getEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //获取对象
        Emp emp = (Emp) session.get(Emp.class, 7);
        //分割线
        System.out.println("----------------------");
        //输出雇员姓名
        System.out.println("雇员姓名:" + emp.getEname());
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台信息
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
    from
        hibernate_data.emp emp0_ 
    where
        emp0_.EMPNO=?
    ----------------------
    雇员姓名:save测试名

    /**
     * 使用load()获取对象
     */
    public void loadEmp() {
        //获取Session
        Session session = HibernateSessionFactory.getSession();
        //获取对象
        Emp emp = (Emp) session.load(Emp.class, 7);
        //分割线
        System.out.println("----------------------");
        //输出雇员姓名
        System.out.println("雇员姓名:" + emp.getEname());
        //关闭Session
        HibernateSessionFactory.closeSession();
    }

    控制台信息
    ----------------------
    Hibernate: 
    select
        emp0_.EMPNO as EMPNO1_4_0_,
        emp0_.ENAME as ENAME2_4_0_,
        emp0_.JOB as JOB3_4_0_,
        emp0_.MGR as MGR4_4_0_,
        emp0_.HIREDATE as HIREDATE5_4_0_,
        emp0_.SAL as SAL6_4_0_,
        emp0_.COMM as COMM7_4_0_,
        emp0_.DEPTNO as DEPTNO8_4_0_ 
        from
            hibernate_data.emp emp0_ 
        where
            emp0_.EMPNO=?
    雇员姓名:save测试名

- get()方法和load()方法区别：
 1).懒加载开启情况下,load()只有需要获取其非OID属性时才会去查询,而get()不受懒加载影响。
 2).如果不存在于对象OID对应的记录,load()方法抛出异常,而get()方法返回null。