《Hibernate学习笔记五》Session 的update方法详解

最新推荐文章于 2020-05-24 12:40:27 发布

jiruirui213

最新推荐文章于 2020-05-24 12:40:27 发布

阅读量390

点赞数

分类专栏： hibernate 文章标签： hibernate

hibernate 专栏收录该内容

14 篇文章

订阅专栏

《Hibernate学习笔记五》Session 的update方法详解

在前面的学习中，我们用到了Session的save方法，将对象从tansient状态转化为persistent状态。下面我们就来学习Session的update方法。

在hibernate api文档中，Session接口提供了两种重载了update方法，分别如下：

1、void update(Object object) ：Update the persistent instance with the identifier of the given detached instance.

此方法文档中的意思就是：根据唯一的标识将一个detached状态的对象更新为persistent状态。

第一个例子：detached状态的对象可以update

这个例子就是先new了一个对象，用session的save方法进行持久化，持久化后，对象进入到detached状态，之后我们进行更新操作，这样是可以更新的。

package com.hibernate.mode;

    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    import org.junit.AfterClass;
    import org.junit.BeforeClass;
    import org.junit.Test;

    import com.hibernate.model.Teacher;

    public class TeacherTest {
    private static SessionFactory sessionFactory;
    @BeforeClass
    public static void beforeClass(){
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }
    @Test
    public void testUpdate1() {
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        //新new的对象处于transient状态
        Teacher t=new Teacher();
        t.setName("wuranghao");
        t.setTitle("professior");
        session.save(t);
        session.getTransaction().commit();
        //commit之后，对象t就进入detached状态,下面我们用update方法对其进行更新
        Session session2=sessionFactory.getCurrentSession();
        session2.beginTransaction();
        t.setName("haohao");
        session2.update(t);
        session2.getTransaction().commit();
    }
    @AfterClass
    public static void afterClass(){
        sessionFactory.close();
    }

    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

运行后在数据库中查询的结果如下，从结果可以看出，对象是更新成功了的。

第二个例子：transient状态没有设唯一标识符的对象是不能够update的

@Test
    public void testUpdate2() {
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Teacher t=new Teacher();
        t.setName("wuranghao");
        t.setTitle("professior");
        //新new的对象t此时是transient状态,看是否能够对其update
        session.update(t);
        session.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9
10
11

transient 状态没有设唯一标识符ID的对象是不能够update的。

第三个例子：transient状态设有唯一标识符的对象且对应数据库表中没有设置这个Id的记录也是不能够update的

@Test
    public void testUpdate3() {     
        Teacher t=new Teacher();
        t.setId(2);
        t.setName("wuranghao");
        t.setTitle("professior");
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        //新new的对象t此时是transient状态,看是否能够对其update
        session.update(t);
        session.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12

第四个例子：transient状态设有唯一标识符的对象且数据库中有对象设置的对应Id的记录是能够update的

上面这句话可能不太好理解，意思就是说，如果数据库中有一条id=0的记录，然后我们就可以将transient状态的对象+此对象setId(0)，则此对象是可以被update的。

在测试下面这个方法前，数据库的内容如下：

@Test
    public void testUpdate3() {     
        Teacher t=new Teacher();
        t.setId(0);
        t.setName("wuranghao");
        t.setTitle("professior");
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        //新new的对象t此时是transient状态,看是否能够对其update
        session.update(t);
        session.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12

测试代码运行后，数据库的结果如下：

第五个例子：对persistent状态的对象的属性内容进行更改会自动的update到数据库

下面的例子是利用了Session的get方法从数据库中导出一个相应Id的记录并转化为Teacher对象实例，此时的对象是处于persistent状态。

@Test
    public void testUpdate4() {     
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Teacher t=session.get(Teacher.class, 0);//从数据库中提取id=0的记录并转化为Teacher对象实例。
        //get出来的对象是persistent状态，对persistent状态的对象进行更改，则一定回自动的update
        t.setName("wuwu");
        session.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9

这样就会自动触发update语句，但是，如果更改前后的内容完成一样，则不会触发update语句。只有对象在缓存中的内容和数据库的记录不一样时，才会触发update语句进行更新。

关于Session的update方法总结

1、用来更新detached对象，更新完成后转为persistent状态。

2、更新transient对象会报错

3、更新自己设定的唯一标识符(例如：Id)的transient对象且数据库有对应记录的可以update。

4、处于persistent状态的对象，对这个对象的属性内容进行更改后当commit时会自动触发Session update方法。有一点需要注意的是如果更改前后的内容完成一样，则不会触发update语句。只有对象在缓存中的内容和数据库的记录不一样时，才会触发update语句进行更新。

上面的update有一个问题，问题是：无论我们更改了对象的几个属性，当持久化的时候，都会更新所有的记录，这显然是不好的。

下面就来介绍下，如果只更新修改了的字段。

更新部分更改的字段

更新部分更改的字段，有以下三种方法。

1、xml设定property标签的update属性，annotation设定@Column的updatable属性

这种方式不灵活，因此很少用。下面不再进行详细介绍。

2、使用xml中的dynamic-update

注意，在XXX.hbm.xml文件中的设置dynamic-update=”true” 这样就可以实现部分只进行了更改字段的更新。

<class name="Teacher" table="teacher" dynamic-update="true">
    </class>
 
 1
2

完整配置文件内容如下：

<?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.hibernate.model">
    <class name="Teacher" table="teacher" dynamic-update="true">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <property name="title"/>
    </class>
    </hibernate-mapping>
 
 1
2
3
4
5
6
7
8
9
10
11
12
13

但是这种方法不能跨Session。在一个Session中，当我们在XXX.hbm.xml文件中加上了dynamic-update=”true”,则就只会更新我们修改的字段。看下面的例子：

    @Test
    public void testUpdate4() {     
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Teacher t=session.get(Teacher.class, 0);//从数据库中提取id=0的记录并转化为Teacher对象实例。
        //get出来的对象是persistent状态，对persistent状态的对象进行更改，则一定回自动的update
        t.setName("wuwuwuwu");
        session.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9

当我们运行这个Test的时候，Hibernate发出了如下的MySQL语句,从该语句可以看出，只更新了name字段，这就是我们想要的结果；

但是，当我们跨Session后，即使我们在XXX.hbm.xml文件中加上了dynamic-update=”true”,则就在第二次更新的时候就并不是只更新我们修改的字段了。

看如下的例子：

    @Test
    public void testUpdate5() {     
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        Teacher t=session.get(Teacher.class, 0);//从数据库中提取id=0的记录并转化为Teacher对象实例。
        //get出来的对象是persistent状态，对persistent状态的对象进行更改，则一定回自动的update
        t.setName("xiao");
        session.getTransaction().commit();
        //另外一个Session
        Session session2=sessionFactory.getCurrentSession();
        session2.beginTransaction();
        t.setName("xiaoxiao");
        session2.update(t);
        session2.getTransaction().commit();
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果如下：

在上面这个例子中Teacher.hbm.xml文件中加上了dynamic-update=”true” ,而测试函数有两个Session，在第二个Session中，我们修改了处于detached状态下的对象的name属性，当调用update方法时，并不是只更新name字段，而是更新了这条记录的所有字段。

如果我们既想采用这种方法(即在XXX.hbm.xml文件中添加dynamic-update=”true”)来实现只更新我们修改的字段，又想跨Session，则解决方法就是:在第二个以之后的Session 中我们不使用session2.update(t)来更新，而是采用session2.merge(t)来进行合并更新。

所以这种方法我们也不推荐。

3、使用HQL(EJBQL) ,建议使用这种方法。

例子程序如下：

利用 Query来进行字段的更新。

    @Test
    public void testUpdate6() {     
        Session session=sessionFactory.getCurrentSession();
        session.beginTransaction();
        //org.hibernate.Query     
    //语句的Teacher指的是类，不是数据库的表名
        Query q=session.createQuery("update Teacher t set t.name='wuranghao' where t.id=0");
        q.executeUpdate();
        session.getTransaction().commit();
    }from: http://blog.youkuaiyun.com/u010412719/article/details/51283926