Hibernate Collection乐观锁定

最新推荐文章于 2024-05-21 19:15:40 发布
最新推荐文章于 2024-05-21 19:15:40 发布
阅读量110 收藏
点赞数
文章标签： java 数据库 mysql hibernate python

介绍

Hibernate提供了一种乐观的锁定机制 ，即使长时间通话也可以防止丢失更新 。 结合实体存储，跨越多个用户请求（扩展的持久性上下文或分离的实体），Hibernate可以保证应用程序级的可重复读取 。

脏检查机制检测实体状态更改并增加实体版本。 尽管始终会考虑基本属性更改，但是Hibernate集合在这方面更加微妙。

拥有与反向收藏

在关系数据库中，两个记录通过外键引用关联。 在这种关系中，引用记录是父记录，而引用行（外键侧）是子记录。 非空外键只能引用现有的父记录。

在面向对象的空间中，可以在两个方向上表示这种关联。 我们可以从孩子到父母有一对多的引用，而父母也可以有一对多的孩子集合。

因为双方都有可能控制数据库外键状态，所以我们必须确保只有一方是此关联的所有者。 仅拥有方状态更改会传播到数据库。 非持有端历来称为逆侧。

接下来，我将描述对该关联进行建模的最常用方法。

单向父项拥有子项关联映射

只有父方具有@OneToMany非逆子级集合。 子实体完全不引用父实体。 

@Entity(name = "post")
public class Post {
	...
	@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
	private List<Comment> comments = new ArrayList<Comment>();
	...
}

单向父-子-子-子组件关联映射映射

子端不一定总是必须是实体，我们可以将其建模为组件类型 。 一个Embeddable对象（组件类型）可以同时包含基本类型和关联映射，但是它永远不能包含@Id。 可嵌入对象及其拥有的实体将被持久保存/删除。

父级具有@ElementCollection子级关联。 子实体只能通过不可查询的特定于 Hibernate的@Parent注释引用父实体。 

@Entity(name = "post")
public class Post {
	...
	@ElementCollection
	@JoinTable(name = "post_comments", joinColumns = @JoinColumn(name = "post_id"))
	@OrderColumn(name = "comment_index")
	private List<Comment> comments = new ArrayList<Comment>();
	...

	public void addComment(Comment comment) {
		comment.setPost(this);
		comments.add(comment);
	}
}	

@Embeddable
public class Comment {
	...
	@Parent
	private Post post;
	...
}

双向父子侧子关联映射

父级是拥有方，因此它有一个@OneToMany非逆（没有mappedBy指令）子级集合。 子实体通过@ManyToOne关联引用父实体，该关联既不可插入也不可更新： 

@Entity(name = "post")
public class Post {
	...
	@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
	private List<Comment> comments = new ArrayList<Comment>();
	...

	public void addComment(Comment comment) {
		comment.setPost(this);
		comments.add(comment);
	}
}	

@Entity(name = "comment")
public class Comment {
	...
	@ManyToOne
	@JoinColumn(name = "post_id", insertable = false, updatable = false)
	private Post post;
	...
}

双向儿童拥有侧-父母关联映射

子实体通过引用父实体@ManyToOne协会和家长有一个的mappedBy @OneToMany孩子集合。 父侧是反侧，因此仅@ManyToOne状态更改会传播到数据库。

即使只有一个拥有的一方，通过使用add / removeChild（）方法使双方保持同步始终是一个好习惯。 

@Entity(name = "post")
public class Post {
	...
	@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, mappedBy = "post")
	private List<Comment> comments = new ArrayList<Comment>();
	...

	public void addComment(Comment comment) {
		comment.setPost(this);
		comments.add(comment);
	}
}	

@Entity(name = "comment")
public class Comment {
	...
	@ManyToOne
	private Post post;	
	...
}

单向儿童拥有侧父母关系映射

子实体通过@ManyToOne关联引用父代。 父级没有@OneToMany子级集合，因此子级实体成为拥有方。 此关联映射类似于关系数据外键链接。 

@Entity(name = "comment")
public class Comment {
    ...
    @ManyToOne
    private Post post;	
    ...
}

集合版本控制

JPA 2.1规范的3.4.2部分将乐观锁定定义为：

将对象写入数据库时​​，持久性提供程序运行时会更新version属性。 所有非关系字段和适当的关系以及实体所拥有的所有关系都包含在版本检查中[35]。

[35]这包括在联接表中维护的拥有的关系

注意：只有所有者方的子级集合可以更新父版本。

测试时间

让我们测试一下父子关联类型如何影响父版本。 由于我们对子级集合的脏检查感兴趣，因此将跳过单向的子级拥有方-父级关联，因为在这种情况下，父级不包含子级集合。

测试用例

以下测试用例将用于所有集合类型用例： 

protected void simulateConcurrentTransactions(final boolean shouldIncrementParentVersion) {
	final ExecutorService executorService = Executors.newSingleThreadExecutor();

	doInTransaction(new TransactionCallable<Void>() {
		@Override
		public Void execute(Session session) {
			try {
				P post = postClass.newInstance();
				post.setId(1L);
				post.setName("Hibernate training");
				session.persist(post);
				return null;
			} catch (Exception e) {
				throw new IllegalArgumentException(e);
			}
		}
	});

	doInTransaction(new TransactionCallable<Void>() {
		@Override
		public Void execute(final Session session) {
			final P post = (P) session.get(postClass, 1L);
			try {
				executorService.submit(new Callable<Void>() {
					@Override
					public Void call() throws Exception {
						return doInTransaction(new TransactionCallable<Void>() {
							@Override
							public Void execute(Session _session) {
								try {
									P otherThreadPost = (P) _session.get(postClass, 1L);
									int loadTimeVersion = otherThreadPost.getVersion();
									assertNotSame(post, otherThreadPost);
									assertEquals(0L, otherThreadPost.getVersion());
									C comment = commentClass.newInstance();
									comment.setReview("Good post!");
									otherThreadPost.addComment(comment);
									_session.flush();
									if (shouldIncrementParentVersion) {
										assertEquals(otherThreadPost.getVersion(), loadTimeVersion + 1);
									} else {
										assertEquals(otherThreadPost.getVersion(), loadTimeVersion);
									}
									return null;
								} catch (Exception e) {
									throw new IllegalArgumentException(e);
								}
							}
						});
					}
				}).get();
			} catch (Exception e) {
				throw new IllegalArgumentException(e);
			}
			post.setName("Hibernate Master Class");
			session.flush();
			return null;
		}
	});
}

单向父母所有子女的关联测试

#create tables
Query:{[create table comment (id bigint generated by default as identity (start with 1), review varchar(255), primary key (id))][]} 
Query:{[create table post (id bigint not null, name varchar(255), version integer not null, primary key (id))][]} 
Query:{[create table post_comment (post_id bigint not null, comments_id bigint not null, comment_index integer not null, primary key (post_id, comment_index))][]} 
Query:{[alter table post_comment add constraint UK_se9l149iyyao6va95afioxsrl  unique (comments_id)][]} 
Query:{[alter table post_comment add constraint FK_se9l149iyyao6va95afioxsrl foreign key (comments_id) references comment][]} 
Query:{[alter table post_comment add constraint FK_6o1igdm04v78cwqre59or1yj1 foreign key (post_id) references post][]} 

#insert post in primary transaction
Query:{[insert into post (name, version, id) values (?, ?, ?)][Hibernate training,0,1]} 

#select post in secondary transaction
Query:{[select entityopti0_.id as id1_1_0_, entityopti0_.name as name2_1_0_, entityopti0_.version as version3_1_0_ from post entityopti0_ where entityopti0_.id=?][1]} 

#insert comment in secondary transaction
#optimistic locking post version update in secondary transaction
Query:{[insert into comment (id, review) values (default, ?)][Good post!]} 
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate training,1,1,0]} 
Query:{[insert into post_comment (post_id, comment_index, comments_id) values (?, ?, ?)][1,0,1]} 

#optimistic locking exception in primary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate Master Class,1,1,0]}
org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect) : [com.vladmihalcea.hibernate.masterclass.laboratory.concurrency.EntityOptimisticLockingOnUnidirectionalCollectionTest$Post#1]

单向父子侧子组件关联测试

#create tables
Query:{[create table post (id bigint not null, name varchar(255), version integer not null, primary key (id))][]} 
Query:{[create table post_comments (post_id bigint not null, review varchar(255), comment_index integer not null, primary key (post_id, comment_index))][]} 
Query:{[alter table post_comments add constraint FK_gh9apqeduab8cs0ohcq1dgukp foreign key (post_id) references post][]} 

#insert post in primary transaction
Query:{[insert into post (name, version, id) values (?, ?, ?)][Hibernate training,0,1]} 

#select post in secondary transaction
Query:{[select entityopti0_.id as id1_0_0_, entityopti0_.name as name2_0_0_, entityopti0_.version as version3_0_0_ from post entityopti0_ where entityopti0_.id=?][1]} 
Query:{[select comments0_.post_id as post_id1_0_0_, comments0_.review as review2_1_0_, comments0_.comment_index as comment_3_0_ from post_comments comments0_ where comments0_.post_id=?][1]} 

#insert comment in secondary transaction
#optimistic locking post version update in secondary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate training,1,1,0]} 
Query:{[insert into post_comments (post_id, comment_index, review) values (?, ?, ?)][1,0,Good post!]} 

#optimistic locking exception in primary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate Master Class,1,1,0]} 
org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect) : [com.vladmihalcea.hibernate.masterclass.laboratory.concurrency.EntityOptimisticLockingOnComponentCollectionTest$Post#1]

双向父母拥有-子-孩子关联测试

#create tables
Query:{[create table comment (id bigint generated by default as identity (start with 1), review varchar(255), post_id bigint, primary key (id))][]} 
Query:{[create table post (id bigint not null, name varchar(255), version integer not null, primary key (id))][]} 
Query:{[create table post_comment (post_id bigint not null, comments_id bigint not null)][]} 
Query:{[alter table post_comment add constraint UK_se9l149iyyao6va95afioxsrl  unique (comments_id)][]} 
Query:{[alter table comment add constraint FK_f1sl0xkd2lucs7bve3ktt3tu5 foreign key (post_id) references post][]} 
Query:{[alter table post_comment add constraint FK_se9l149iyyao6va95afioxsrl foreign key (comments_id) references comment][]} 
Query:{[alter table post_comment add constraint FK_6o1igdm04v78cwqre59or1yj1 foreign key (post_id) references post][]} 

#insert post in primary transaction
Query:{[insert into post (name, version, id) values (?, ?, ?)][Hibernate training,0,1]} 

#select post in secondary transaction
Query:{[select entityopti0_.id as id1_1_0_, entityopti0_.name as name2_1_0_, entityopti0_.version as version3_1_0_ from post entityopti0_ where entityopti0_.id=?][1]} 
Query:{[select comments0_.post_id as post_id1_1_0_, comments0_.comments_id as comments2_2_0_, entityopti1_.id as id1_0_1_, entityopti1_.post_id as post_id3_0_1_, entityopti1_.review as review2_0_1_, entityopti2_.id as id1_1_2_, entityopti2_.name as name2_1_2_, entityopti2_.version as version3_1_2_ from post_comment comments0_ inner join comment entityopti1_ on comments0_.comments_id=entityopti1_.id left outer join post entityopti2_ on entityopti1_.post_id=entityopti2_.id where comments0_.post_id=?][1]} 

#insert comment in secondary transaction
#optimistic locking post version update in secondary transaction
Query:{[insert into comment (id, review) values (default, ?)][Good post!]} 
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate training,1,1,0]} 
Query:{[insert into post_comment (post_id, comments_id) values (?, ?)][1,1]} 

#optimistic locking exception in primary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate Master Class,1,1,0]} 
org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect) : [com.vladmihalcea.hibernate.masterclass.laboratory.concurrency.EntityOptimisticLockingOnBidirectionalParentOwningCollectionTest$Post#1]

双向儿童拥有侧-父母关联测试

#create tables
Query:{[create table comment (id bigint generated by default as identity (start with 1), review varchar(255), post_id bigint, primary key (id))][]} 
Query:{[create table post (id bigint not null, name varchar(255), version integer not null, primary key (id))][]} 
Query:{[alter table comment add constraint FK_f1sl0xkd2lucs7bve3ktt3tu5 foreign key (post_id) references post][]} 

#insert post in primary transaction
Query:{[insert into post (name, version, id) values (?, ?, ?)][Hibernate training,0,1]} 

#select post in secondary transaction
Query:{[select entityopti0_.id as id1_1_0_, entityopti0_.name as name2_1_0_, entityopti0_.version as version3_1_0_ from post entityopti0_ where entityopti0_.id=?][1]} 

#insert comment in secondary transaction
#post version is not incremented in secondary transaction
Query:{[insert into comment (id, post_id, review) values (default, ?, ?)][1,Good post!]} 
Query:{[select count(id) from comment where post_id =?][1]} 

#update works in primary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate Master Class,1,1,0]}

否决默认集合版本控制

如果默认的拥有方集合版本控制不适合您的用例，则始终可以使用Hibernate @OptimisticLock注释来取代它。

让我们废除双向parent-owning-side-child关联的默认父版本更新机制： 

@Entity(name = "post")
public class Post {
	...
	@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
	@OptimisticLock(excluded = true)
	private List<Comment> comments = new ArrayList<Comment>();
	...

	public void addComment(Comment comment) {
		comment.setPost(this);
		comments.add(comment);
	}
}	

@Entity(name = "comment")
public class Comment {
	...
	@ManyToOne
	@JoinColumn(name = "post_id", insertable = false, updatable = false)
	private Post post;
	...
}

这次，子级集合更改不会触发父版本更新： 

#create tables
Query:{[create table comment (id bigint generated by default as identity (start with 1), review varchar(255), post_id bigint, primary key (id))][]} 
Query:{[create table post (id bigint not null, name varchar(255), version integer not null, primary key (id))][]} 
Query:{[create table post_comment (post_id bigint not null, comments_id bigint not null)][]} 
Query:{[alter table post_comment add constraint UK_se9l149iyyao6va95afioxsrl  unique (comments_id)][]} 
Query:{[alter table comment add constraint FK_f1sl0xkd2lucs7bve3ktt3tu5 foreign key (post_id) references post][]} 
Query:{[alter table post_comment add constraint FK_se9l149iyyao6va95afioxsrl foreign key (comments_id) references comment][]} 
Query:{[alter table post_comment add constraint FK_6o1igdm04v78cwqre59or1yj1 foreign key (post_id) references post][]} 

#insert post in primary transaction
Query:{[insert into post (name, version, id) values (?, ?, ?)][Hibernate training,0,1]} 

#select post in secondary transaction
Query:{[select entityopti0_.id as id1_1_0_, entityopti0_.name as name2_1_0_, entityopti0_.version as version3_1_0_ from post entityopti0_ where entityopti0_.id=?][1]} 
Query:{[select comments0_.post_id as post_id1_1_0_, comments0_.comments_id as comments2_2_0_, entityopti1_.id as id1_0_1_, entityopti1_.post_id as post_id3_0_1_, entityopti1_.review as review2_0_1_, entityopti2_.id as id1_1_2_, entityopti2_.name as name2_1_2_, entityopti2_.version as version3_1_2_ from post_comment comments0_ inner join comment entityopti1_ on comments0_.comments_id=entityopti1_.id left outer join post entityopti2_ on entityopti1_.post_id=entityopti2_.id where comments0_.post_id=?][1]} 

#insert comment in secondary transaction
Query:{[insert into comment (id, review) values (default, ?)][Good post!]} 
Query:{[insert into post_comment (post_id, comments_id) values (?, ?)][1,1]} 

#update works in primary transaction
Query:{[update post set name=?, version=? where id=? and version=?][Hibernate Master Class,1,1,0]}

结论

了解各种建模结构如何影响并发模式非常重要。 递增父版本号时，将考虑拥有方集合的更改，您始终可以使用@OptimisticLock批注来绕过它。

翻译自: https://www.javacodegeeks.com/2014/11/hibernate-collections-optimistic-locking.html

dnc8371
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
出现 DB2 SQL Error: SQLCODE = -798, SQLSTATE = 428C9 错误的原因及解决方法
CG国斌的博客
11-11 2万+
1 错误描述在通过「DbVisualizer」执行 SQL 语句插入数据的时候，报出如下错误：2 错误原因通过观察上述标记出来的错误描述： DB2 SQL Error: SQLCODE = -798, SQLSTATE = 428C9, SQLERRMC = ID 然后，查询「史上最全的 DB2 错误代码大全」可知，此错误的原因为： -798 428C9 不能把一个值插入到用 GENERAT
hibernate乐观锁_Hibernate Collection乐观锁定
最佳 Java 编程
06-18 254
hibernate乐观锁 介绍 Hibernate提供了一种乐观的锁定机制 ，即使长时间通话也可以防止更新丢失 。 结合实体存储，跨越多个用户请求（扩展的持久性上下文或分离的实体），Hibernate可以保证应用程序级的可重复读取 。 脏检查机制检测实体状态更改并增加实体版本。 尽管始终考虑基本属性更改，但是Hibernate集合在这方面更加微妙。 拥有与反向收藏 在关系数据库中，两个...
Hibernate 乐观锁（Optimistic Locking）
weixin_34219944的博客
01-08 128
　　1、hibernate基于数据版本（Version）记录机制实现。为数据增加一个版本标识，一般是通过为数据库表增加一个“version”字段来实现。 读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据 版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。 　　2、 1 //$Id: Co...
hibernate 控制并发访问
爱.NET
11-01 158
在标准SQL规范中，定义了4个事务隔离级别，不同的隔离级别对事务的处理不同: ◆未授权读取（Read Uncommitted）：允许脏读取，但不允许更新丢失。如果一个事务已经开始写数据，则另外一个数据则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。 ◆授权读取（Read Committed）：允许不可重复读取，但不允许脏读取。这可以通过“瞬间共享读锁”和“...
hibernate,jpa锁机制
TONG哥的专栏
02-21 1374
在高并发的计算机群组成的负载均衡环境中，经常会碰到多个节点更新同一条数据，从而引起数据不一致的问题！ 场景 有 A ,B 2台WEB服务器，负载均衡处理请求， C为数据库服务器， 有订单Order, 订单初始的金额为 300 如果 A B同时调整订单金额 减少100元，将会存在如下情况。 A -> Order.amount(200) -100 = 200 B -> Order.amount(200
最全Hibernate 参考文档
08-29
11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 长生命周期session和自动版本化 11.3.3. 脱管对象(deatched object)和自动版本化 ...
HibernateAPI中文版.chm
10-07
11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 扩展周期的session和自动版本化 11.3.3. 脱管对象(deatched object)和自动版本化 ...
Hibernate+中文文档
02-22
11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 扩展周期的session和自动版本化 11.3.3. 脱管对象(deatched object)和自动版本化 ...
Hibernate教程
04-29
12.3. 乐观并发控制(Optimistic concurrency control) 12.3.1. 应用程序级别的版本检查(Application version checking) 12.3.2. 长生命周期session和自动版本化 12.3.3. 脱管对象(deatched object)和自动版本化 ...
hibernate 教程
07-17
乐观并发控制（Optimistic concurrency control） 10.4.1. 使用长生命周期带有自动版本化的会话 10.4.2. 使用带有自动版本化的多个会话 10.4.3. 应用程序自己进行版本检查 10.5. 会话断开连接（Session...
Hibernate事务并发问题处理（乐观锁与悲观锁）
Vern的专栏
10-07 2292
使用悲观锁解决事务并发问题 　　悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。 　　一个典型的依赖数据库
Hibernate锁机制
05-29 1241
Hibernate支持两种锁机制：  悲观锁(Pessimistic Locking):当数据被外界修改时保持原始状态，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁大多数情况下依靠数据库的锁机制实现。  乐观锁(Optimistic Locking):主要由Hibernate提供的版本控制功能实现。Hibernate的主要锁定模式：(1) LockMode.NONE:无锁机制，这是默认的...
Hibernate中的Collection小谈
编程人生
06-05 225
记得我们在以前例子中一对多中用到的Set，还有印象么，如果没有赶快去查一下资料，回顾一下。今天我们就围绕着这些Collection来进行学习。 还是不废话了，我们直接进入正题。 1）首先我们来学习一下Set。大家都知道JAVA util包里面也有一个Set，那么hibernate里面的set和java的set和什么区别和联系呢？我们打开hibernate的API，找到Set，可以看到。 ...
hibernate配置用户名密码加密
u014173568的专栏
07-02 2569
1 我使用的数据库连接池是c3p0, 即hibernate的配置为： hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider 2 hibernate配置文件中添加两个配置：代表密文 hibernate.connection.passwordSec RhxglVY1
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 316
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 758
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 403
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
hibernate乐观锁报错
06-06
当使用 Hibernate 实现乐观锁时，如果在更新过程中发现数据版本号不一致，就会抛出 OptimisticLockException 异常。这个异常是 Hibernate 提供的，它表示在操作时出现了并发冲突，即有其他线程修改了数据。此时需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值