hibernate的Session的update方法

最新推荐文章于 2022-02-28 19:28:29 发布
最新推荐文章于 2022-02-28 19:28:29 发布
阅读量6.4k 收藏 3
点赞数 2
分类专栏： hibernate java 文章标签： hibernate session update
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011526599/article/details/51168992
版权
查看hibernate的API文档，其中Session的update方法说明如下：

 voidupdate(Object object)
          Update the persistent instance with the identifier of the given detached instance.
意思大概是detached使用update方法通过Id更新为persistent

还是通过例子来看看

1.用之前的Teacher

package com.baosight.model;

import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.SequenceGenerator;
import javax.persistence.TableGenerator;

/**
 * <p>Title: </p>
 * <p>Description:Teacher </p>
 * <p>Company: </p> 
 * @author yuan 
 * @date 2016-4-10 下午12:32:46*/
@Entity
@TableGenerator(name="tableGEN",table="table_gen",pkColumnName="pk_key",valueColumnName="pk_value",pkColumnValue="teacher",allocationSize=1)
@SequenceGenerator(name="teacherSEQ",sequenceName="teacherSEQ_DB")
//@IdClass(value=TeacherPK.class)
public class Teacher {
	private String id;
	private String name;
	private String title;
//	private TeacherPK pk;
	@Id
	@GeneratedValue//auto
//	@GeneratedValue(strategy=GenerationType.TABLE,generator="tableGEN")
//	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="teacherSEQ")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
//	@Id
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Column(updatable=false)//不参与自动更新
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
//	@EmbeddedId
//	@Id
	/*public TeacherPK getPk() {
		return pk;
	}
	public void setPk(TeacherPK pk) {
		this.pk = pk;
	}*/
	
}
2.JUnit测试类为TeacherTest.java 

package com.baosight.model;

import static org.junit.Assert.*;

import javax.persistence.Column;

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

/**
 * <p>Title:TecherTest </p>
 * <p>Description:TODO </p>
 * <p>Company: </p> 
 * @author yuan 
 * @date 2016-4-13 下午10:32:17*/
public class TeacherTest {
	private static SessionFactory sf = null;
	@BeforeClass
	public static void beforeClass(){
		// 读取配置文件
		Configuration cfg = new AnnotationConfiguration();
		// 得到session工厂
		sf = cfg.configure().buildSessionFactory();
	}
	@Test
	public void testSave() {
		// 教师测试类
		Teacher t = new Teacher();
		t.setName("t1");
		t.setTitle("中级");

		System.out.println("transient状态下id============="+t.getId());
		// 得到session
		Session session = sf.openSession();
		// 开启事务
		session.beginTransaction();
		// session执行save
		session.save(t);
		System.out.println("persistent状态下id============="+t.getId());
		// 事务提交
		session.getTransaction().commit();
		// 关闭session
		session.close();
		System.out.println("ditached状态下id============="+t.getId());
	}
	@Test
	public void testDelete() {
		// 教师测试类
		Teacher t = new Teacher();
		t.setName("t1");
		t.setTitle("中级");
		
		System.out.println("transient状态下id============="+t.getId());
		// 得到session
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行save
		session.save(t);
		System.out.println("persistent状态下id============="+t.getId());
		// 事务提交
		session.getTransaction().commit();
		// 关闭session
		System.out.println("ditached状态下id============="+t.getId());
		//删除
		Session session2 = sf.getCurrentSession();
		// 开启事务
		session2.beginTransaction();
		// session执行
		session2.delete(t);
		System.out.println("persistent状态下id============="+t.getId());
		// 事务提交
		session2.getTransaction().commit();
		// 关闭session
		System.out.println("ditached状态下id============="+t.getId());
	}
	@Test
	public void testDelete2() {
		// 教师测试类
		Teacher t = new Teacher();
		t.setId("24");
		
		System.out.println("transient状态下id============="+t.getId());
		//删除
		Session session2 = sf.getCurrentSession();
		// 开启事务
		session2.beginTransaction();
		// session执行
		session2.delete(t);
		System.out.println("persistent状态下id============="+t.getId());
		// 事务提交
		session2.getTransaction().commit();
		// 关闭session
		System.out.println("ditached状态下id============="+t.getId());
	}
	@Test
	public void testLoad() {
		//使用代理，只有使用到查询对象时才会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Teacher t = (Teacher) session.load(Teacher.class, "1");
		//打印代理对象名称
		System.out.println(t.getClass().getName());
//		System.out.println(t);
//		System.out.println("id============="+t.getId());
		// 事务提交
		session.getTransaction().commit();
		// 关闭session
//		System.out.println("id============="+t.getId());
	}
	@Test
	public void testGet() {
		//直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Teacher t = (Teacher) session.get(Teacher.class, "1");
		System.out.println(t.getClass().getName());
//		System.out.println(t);
//		System.out.println("id============="+t.getId());
		// 事务提交
		session.getTransaction().commit();
		// 关闭session
//		System.out.println("id============="+t.getId());
	}
	@Test
	public void testUpdate1() {
		//直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Teacher t = (Teacher) session.get(Teacher.class, "1");
		// 事务提交
		session.getTransaction().commit();
		//将detached通过update变为persistent
		//修改
		t.setName("zhangsan");
		Session session2 = sf.getCurrentSession();
		// 开启事务
		session2.beginTransaction();
		// session执行
		session2.update(t);
		// 事务提交
		session2.getTransaction().commit();
		
	}
	@Test
	public void testUpdate2() {
		// 教师测试类
		Teacher t = new Teacher();
		t.setName("zhangsan");
		//transient没有Id无法进行update操作
		//修改
		Session session2 = sf.getCurrentSession();
		// 开启事务
		session2.beginTransaction();
		// session执行
		session2.update(t);
		// 事务提交
		session2.getTransaction().commit();
		
	}
	@Test
	public void testUpdate3() {
		// 教师测试类
		Teacher t = new Teacher();
		t.setId("1");
		t.setName("lisi");
		//transient有Id可以进行update操作
		//修改
		Session session2 = sf.getCurrentSession();
		// 开启事务
		session2.beginTransaction();
		// session执行
		session2.update(t);
		// 事务提交
		session2.getTransaction().commit();
		
	}
	@Test
	public void testUpdate4() {
		// 直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Teacher t = (Teacher) session.get(Teacher.class, "1");
		//对persistent直接set也能执行
		//测试@Column(updatable=false)指定age不参与修改
		t.setName("wangwu");
		// 事务提交
		session.getTransaction().commit();
		
	}
	@Test
	public void testUpdate5() {
		// 学生测试类

		// 得到session
		Session session = sf.openSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Student s = (Student) session.get(Student.class, "1");
		//xml文件<property中update="false"指定age不参与修改
		//或者在class使用dynamic-update="true"说明只修改变化的列
		s.setName("lisi3");
		// 事务提交
		session.getTransaction().commit();
		// 关闭session
		session.close();
		
	}
	@Test
	public void testUpdate6() {
		// 直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Student s = (Student) session.get(Student.class, "1");
		// 对persistent直接set也能执行
		// 测试@Column(updatable=false)指定age不参与修改
		s.setName("lisi");
		// 事务提交
		session.getTransaction().commit();
		//detached执行save
		s.setName("zhangsan");
		// 直接从数据库查询，会打印sql
		Session session1 = sf.getCurrentSession();
		// 开启事务
		session1.beginTransaction();
		// session执行
		session1.update(s);
		// 事务提交
		session1.getTransaction().commit();
		
	}
	@Test
	public void testUpdate7() {
		// 直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		// session执行
		Student s = (Student) session.get(Student.class, "1");
		// 对persistent直接set也能执行
		// 测试@Column(updatable=false)指定age不参与修改
		s.setName("lisi");
		// 事务提交
		session.getTransaction().commit();
		//detached执行save
		s.setName("zhangsan");
		// 直接从数据库查询，会打印sql
		Session session1 = sf.getCurrentSession();
		// 开启事务
		session1.beginTransaction();
		// session执行
		session1.merge(s);
		// 事务提交
		session1.getTransaction().commit();
		
	}
	@Test
	public void testUpdate8() {
		// 直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		//通过HQl来实现特定的修改
		Query q = session.createQuery("update Student s set s.name='lisi' where s.id='1'");
		q.executeUpdate();
		// 事务提交
		session.getTransaction().commit();
		
	}
	@AfterClass
	public static void afterClass(){
		// 关闭session工厂
		sf.close();
	}
}

3.测试结果如下：

update1方法用来测试detached执行update的效果，发现是可以执行的，但是，存在修改1个字段其它字段也被修改的问题，结果如下：




update2用来测试transient执行update的问题，由于未设定Id，所以执行失败，结果如下：


update3为transient设定了Id,可以正常执行，结果如下：

update4用来测试对于persistent直接使用set属性进行修改，能够执行，结果如下：



4.从以上的测试可以发现一个问题，就是对1个属性的修改可能会影响到其他的属性，为了解决这一问题有三种方案：

一是使用annotation的@Column(updatable=false)，放在不想被自动修改的属性的get方法上面，比如上面使用在getTitle，对于使用xml的需要修改<property中update="false"指定该属性不不参与自动修改

二是对于xml使用在class使用dynamic-update="true"说明只修改变化的列

三是通过HQl来实现特定的修改

5.使用annotation的@Column(updatable=false)

修改Teacher的getTitle，使用注解

@Column(updatable=false)
	public String getTitle() {
		return title;
	}
重新执行update4，结果如下：

6.对于使用xml的需要修改<property中update="false"指定该属性不不参与自动修改

使用之前的Student

package com.baosight.model;

import javax.persistence.Column;

/**
 * <p>Title: </p>
 * <p>Description:Student </p>
 * <p>Company: </p> 
 * @author yuan 
 * @date 2016-4-10 下午12:32:46*/
public class Student {
	private String id;
	private String name;
//	private StudentPK pk;
	private int age;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
/*	public StudentPK getPk() {
		return pk;
	}
	public void setPk(StudentPK pk) {
		this.pk = pk;
	}*/
	
}
修改Student.hbm.xml，使用<property中update="false" 

<?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.baosight.model">
<class name="Student" dynamic-update="true">
<id name="id" >
<generator class="uuid"></generator>
</id>
<!-- <composite-id name="pk" class="StudentPK">
<key-property name="id"></key-property>
<key-property name="name"></key-property>
</composite-id> -->
<property name="name"></property>
<property name="age"></property>
<!-- <property name="age" update="false"></property> -->
</class>
</hibernate-mapping>
运行update5，结果如下：

7.对于xml使用在class使用dynamic-update="true"说明只修改变化的列，xml见上面

运行update5，结果如下：



8.通过HQL来实现特定的修改

直接通过执行特定的HQL来实现特定的修改

比如本例中的update8，方法如下：

@Test
	public void testUpdate8() {
		// 直接从数据库查询，会打印sql
		Session session = sf.getCurrentSession();
		// 开启事务
		session.beginTransaction();
		//通过HQl来实现特定的修改
		Query q = session.createQuery("update Student s set s.name='lisi' where s.id='1'");
		q.executeUpdate();
		// 事务提交
		session.getTransaction().commit();
		
	}
执行结果如下：

9.执行update6，结果如下：

发现persistent的update只修改变化的属性，而detached则可能修改其他属性，针对这一情况，可以考虑使用merge

10.merge的使用

hibernate的API文档中对Session的merge方法的描述：

 Objectmerge(Object object)
          Copy the state of the given object onto the persistent object with the same identifier.

将给定对象的状态复制到具有相同标识符的持久对象上。会先做查询再做修改，类似于persistent的update

执行update7，结果如下：


以上即为hibernate的Session的update相关内容，值得一提的是，对于上面提到的防止修改其他属性的3种方法，在实际的使用中多采用第三种方法，即使用HQL实现特定的修改，当然可能还会结合HQL查询等。


faraway2004
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 使用Hibernate事务管理：update等操作无效果问题
2401_83641443的博客
04-18 573
我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习已经将知识体系整理好（源码，笔记，PPT，学习视频）《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-eANFjTrl-1713397022471)]《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Spring测试Hibernate执行update方法之后数据库未更新的原因
weixin_41641941的博客
06-17 2602
昨天在写Dao层之后进行测试，用Junit执行session.save()方法的时候可以持久化到数据库，但是测试执行session.update()的时候却显示执行成功但是数据库却没有变化，网上的回答说是事务没有开启，但我的Hibernate事务都是交给Spring来管理的 <!-- 事务配置 声明式事务 --> <bean id="transactionManager" ...
hibernate 关于session的update方法
曼曼的博客
05-24 464
hibernate 关于session的update方法
hibernate update 错误解决
自由程式--FC
10-06 205
update时候出现如下错误 org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: 解决方法： 根据id得到缓存里的pojo对象，修改该对象，更新该对象 [code="java"] ...
hibernate update 操作
qq_47959958的博客
02-28 1081
涉及到三层结构 Controller（控制逻辑）层：它是负责在页面和程序之间传输数据的，还有作用是做页面跳转。 页面由用户填写表单数据，点击提交按钮，页面的表单数据由传入Service层。 DAO层（数据库操作层）：负责对数据向数据库增删改查的操作。 Service层（业务逻辑层）：负责的是对数据的处理。如果没有数据处理任务的话，此层只做单纯的数据传递作用，而后又到了DAO层。 参考了https://blog.csdn.net/qq_38881474/article/details/96447
使用hibernate执行原生update更新数据（只更新部分字段）
湖面上的一叶扁舟的博客
01-12 5396
事务根据实际情况进行添加，这里不特殊说明 1、使用update执行更新部分字段 String sql = " update  A set  a.grade= :grade,a.gradeType = :gradeType where a.number in ( select number from B where b.createTime > to_char('2020-02-02','yyy
Hibernate三种状态和Session常用的方法
08-31
Hibernate三种状态和Session常用的方法 Hibernate 作为一个流行的 Java 持久层框架，提供了对数据库的操作能力，其中Session 是 Hibernate 中最核心的接口，负责管理对象的生命周期。为了更好地理解 Hibernate 的...
hibernate更新数据方法小结
01-08
Session session=HibernateSessionFactory.getSession(); String sql=”from Usertable as user where user.username=?”; Query q=session.createQuery(sql); q.setString(0,username); List l=q.list(); Iterator...
Hibernate管理Session和批量操作分析
09-04
1. **通过Session**：使用`Session`的`save()`和`update()`方法。但需要注意，频繁调用可能导致内存压力，因此建议在适当的时候调用`flush()`和`clear()`。 2. **通过HQL（Hibernate Query Language）**：利用HQL...
hibernate和session学习
12-01
`Session`的常用方法包括：`save()`, `update()`, `delete()`, `get()`, `load()`, `query()`等。 1. `save()` 和 `update()`: `save()`用于将新对象持久化到数据库，如果对象已经存在，可以使用`update()`来更新其...
Hibernate_11session
05-30
Session提供了各种操作数据库的方法，如`save()`, `update()`, `delete()`, `load()`, `get()`等，它们都是事务性的。比如，`save()`方法用于保存一个新的对象到数据库，`update()`用于更新已存在的对象，而`delete...
01. Session 常用方法：save、update、saveOrUpdate
远方水木
06-12 3886
Session 常用方法：save、update、saveOrUpdate save方法 该方法传入的参数是临时对象 //启动事务1 trans=session.beginTransaction(); /*临时对象*/ Student student=new Student(); student.setId("2017"); student.setName("Vin"); stud...
【Hibernate框架开发之五】Hibernate对象的三种状态&&Session的常用方法
李华明Himi
05-25 2589
本站文章均为 李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/hibernate/814.html　　　　　　　　　　☞ 点击订阅 ☜ 本博客最新动态!及时将最新博文通知您！ 1. Hibernate对象的三种状态：（图解如下：） 如图所示，Hibernate对象有三种状态，1.Transient  2.Pe
在使用hibernate更新操作时出现org.hibernate.StaleStateException
weixin_30500663的博客
04-02 222
org.hibernate.StaleStateException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1 错误原因： 使用hibernate的saveOrUpdate方法保存实例。saveOrUpdate方法要求ID为null时才执行SAV...
Hibernate更新某些字段的几种update方法
nikerlover的专栏
07-13 498
Hibernate 中如果直接使用Session.update(Object o);会把这个表中的所有字段更新一遍。比如：view plaincopy to clipboardprint?public class TeacherTest {      @Test    publi
精通Hibernate——Session的保存、更新、删除和查询
路漫漫，水迢迢
08-20 1982
session的save方法 使一个临时对象变为持久化对象。 session的save方法完成以下操作： 1、把customer对象加入到缓存中，使他变为持久化对象 2、选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。Customer.hbm.xml文件中id元素的 子元素指定标识符生成器：<generator> <id name="id" column="ID" >
Hibernate中Update的使用
慕小怡的专栏
05-28 600
关键句：Confinfo oconf = (Confinfo)ConnectionDB.getSession().load(Confinfo.class, ofconf.getConfInfoId());以获得类的实例。public void UpdateConfById(Confinfo ofconf) { // TODO Auto-generated method stub
Hibernate中save和update的区别
零怀念的博客
01-10 2180
public class Main { public static void main(String[] args) { SessionFactory sf = new Configuration().configure().buildSessionFactory(); Session session=sf.getCurrentSession(); ...
hibernate的session有哪些方法
最新发布
06-01
Hibernate 的 Session 对象提供了许多方法，用于执行持久化操作和查询操作。常用的 Hibernate Session 方法包括： 1. save(Object entity)：将一个实体对象保存到数据库中。 2. update(Object entity)：更新数据库中的一个实体对象。 3. delete(Object entity)：删除数据库中的一个实体对象。 4. get(Class<?> clazz, Serializable id)：根据实体类和主键查询一个实体对象。 5. load(Class<?> clazz, Serializable id)：根据实体类和主键查询一个实体对象，返回一个代理对象。 6. createQuery(String queryString)：创建一个 HQL 查询对象。 7. createSQLQuery(String queryString)：创建一个 SQL 查询对象。 8. beginTransaction()：开启一个事务。 9. commit()：提交一个事务。 10. rollback()：回滚一个事务。 11. close()：关闭 Session 对象。 除了以上常用的方法之外，Session 对象还提供了很多其他的方法，用于执行各种类型的持久化操作和查询操作。需要根据具体的业务需求选择合适的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值