Hibernate实现乐观锁
乐观锁（Optimistic Locking）是一种并发控制机制，它允许多个事务并发地读取和修改相同的数据，但在提交时会检查数据是否被其他事务修改过。如果数据被其他事务修改过，当前事务会回滚并重新尝试。乐观锁通常通过版本号（version number）或时间戳（timestamp）来实现。
在Hibernate中，乐观锁可以通过在实体类上添加@Version注解来实现。当一个事务尝试更新数据时，Hibernate会检查版本号或时间戳是否与数据库中的值匹配。如果不匹配，则抛出OptimisticLockException。
实现步骤
- 创建实体类 并在需要使用乐观锁的字段上添加
@Version注解。 - 配置Hibernate。
- 使用Hibernate进行CRUD操作，演示乐观锁的工作原理。
示例代码
配置文件 hibernate.cfg.xml
xml
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 数据库连接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/your_database</property>
<property name="hibernate.connection.username">your_username</property>
<property name="hibernate.connection.password">your_password</property>
<!-- Hibernate 属性配置 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 映射类 -->
<mapping class="com.example.domain.Person"/>
</session-factory>
</hibernate-configuration>实体类 Person
在实体类中使用@Version注解。
java
package com.example.domain;
import javax.persistence.*;
@Entity
@Table(name = "person")
public class Person {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name")
private String name;
@Column(name = "age")
private int age;
@Version
@Column(name = "version")
private int version;
public Person() {}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// getters 和 setters
public Long getId() {
return id;
}
public void setId(Long 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 int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
}使用Hibernate进行CRUD操作
HibernateUtil类
java
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
// 从配置文件创建SessionFactory
sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
} catch (Throwable ex) {
// 记录启动失败的错误
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}乐观锁使用示例
java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.exception.OptimisticLockException;
public class HibernateOptimisticLockExample {
public static void main(String[] args) {
// 获取SessionFactory
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
// 创建示例数据
createPerson(sessionFactory);
// 模拟两个并发事务进行更新操作
simulateConcurrentUpdates(sessionFactory);
// 关闭SessionFactory
sessionFactory.close();
}
private static void createPerson(SessionFactory sessionFactory) {
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
try {
Person person = new Person("John Doe", 30);
session.save(person);
transaction.commit();
System.out.println("Inserted Person: " + person.getName());
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}
}
private static void simulateConcurrentUpdates(SessionFactory sessionFactory) {
// 第一个事务
Thread thread1 = new Thread(() -> updatePerson(sessionFactory, 1L, "John Doe 1", 31));
// 第二个事务
Thread thread2 = new Thread(() -> updatePerson(sessionFactory, 1L, "John Doe 2", 32));
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static void updatePerson(SessionFactory sessionFactory, Long personId, String newName, int newAge) {
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
try {
// 获取Person实体
Person person = session.get(Person.class, personId);
if (person != null) {
// 更新Person实体字段
person.setName(newName);
person.setAge(newAge);
// 提交事务前会检查版本号
session.update(person);
transaction.commit();
System.out.println("Updated Person: " + person.getName() + ", Age: " + person.getAge());
} else {
System.out.println("No Person found with ID: " + personId);
}
} catch (OptimisticLockException e) {
if (transaction != null) {
transaction.rollback();
}
System.err.println("Optimistic lock exception encountered for Person ID: " + personId);
e.printStackTrace();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
e.printStackTrace();
} finally {
if (session != null) {
session.close();
}
}
}
}详细解释
-
配置文件
hibernate.cfg.xml：定义数据库连接信息、Hibernate属性配置以及实体类映射配置。xml<mapping class="com.example.domain.Person"/> -
实体类
Person：使用@Version注解定义版本字段。@Version：表示版本字段，用于乐观锁的实现。每次更新时，Hibernate会检查版本号是否匹配。
java@Version @Column(name = "version") private int version; -
HibernateUtil类：创建并管理SessionFactory。
javapublic class HibernateUtil { // 创建SessionFactory的代码 } -
CRUD操作类：演示了如何使用Hibernate进行插入操作和模拟并发更新操作。
javapublic class HibernateOptimisticLockExample { // CRUD操作方法 } -
模拟并发更新：使用两个线程来模拟并发更新同一个实体，从而展示乐观锁的工作原理。
javaprivate static void simulateConcurrentUpdates(SessionFactory sessionFactory) { // 第一个事务 Thread thread1 = new Thread(() -> updatePerson(sessionFactory, 1L, "John Doe 1", 31)); // 第二个事务 Thread thread2 = new Thread(() -> updatePerson(sessionFactory, 1L, "John Doe 2", 32)); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } }
总结
通过在实体类中添加@Version注解，Hibernate可以实现乐观锁。当多个事务并发地修改同一实体时，乐观锁确保了只有版本号匹配的事务才能成功提交，从而避免数据不一致的问题。通过模拟并发更新操作，可以清楚地看到乐观锁的工作原理和效果。