Hibernate中乐观锁的实现示例_Java

hibernate的乐观锁（optimistic locking）是一种并发控制机制，用于防止在多个事务并发访问相同数据时出现数据冲突。乐观锁的基本思想是，每次读取数据时不进行实际的加锁操作，而是在提交更新时检查数据是否已经被其他事务修改。如果数据在此期间被其他事务修改，则当前事务会回滚并重新尝试。

乐观锁的实现

乐观锁通常通过版本号（version）字段实现。每次更新数据时，都会检查版本号是否一致，并将版本号加1。

示例代码

下面是一个完整的示例，展示如何在hibernate中使用乐观锁。

配置文件hibernate.cfg.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.student"/>
    </session-factory>
</hibernate-configuration>

hibernateutil 类

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;
    }
}

实体类 student

package com.example.domain;

import javax.persistence.entity;
import javax.persistence.generatedvalue;
import javax.persistence.generationtype;
import javax.persistence.id;
import javax.persistence.version;

@entity
public class student {
    @id
    @generatedvalue(strategy = generationtype.identity)
    private long id;
    
    private string name;
    private int age;

    @version
    private int version;

    public student() {}

    public student(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;
    }
}

乐观锁示例代码

下面的示例展示了如何在并发环境中使用乐观锁。

import org.hibernate.session;
import org.hibernate.sessionfactory;
import org.hibernate.transaction;

public class hibernateoptimisticlockingexample {
    public static void main(string[] args) {
        // 获取sessionfactory
        sessionfactory sessionfactory = hibernateutil.getsessionfactory();
        
        // 第一个会话
        session session1 = sessionfactory.opensession();
        transaction transaction1 = session1.begintransaction();
        
        // 第二个会话
        session session2 = sessionfactory.opensession();
        transaction transaction2 = session2.begintransaction();

        try {
            // 在第一个会话中获取对象
            student student1 = session1.get(student.class, 1l);
            system.out.println("session1 - student: " + student1.getname() + ", age: " + student1.getage() + ", version: " + student1.getversion());

            // 在第二个会话中获取相同的对象
            student student2 = session2.get(student.class, 1l);
            system.out.println("session2 - student: " + student2.getname() + ", age: " + student2.getage() + ", version: " + student2.getversion());

            // 修改并更新对象
            student1.setage(21);
            session1.update(student1);
            transaction1.commit();
            system.out.println("session1 - updated student: " + student1.getname() + ", age: " + student1.getage() + ", version: " + student1.getversion());

            // 尝试在第二个会话中提交修改
            student2.setage(22);
            session2.update(student2);
            transaction2.commit(); // 这里会抛出异常，因为版本号不一致

        } catch (exception e) {
            if (transaction2 != null) {
                transaction2.rollback();
            }
            e.printstacktrace();
        } finally {
            if (session1 != null) {
                session1.close();
            }
            if (session2 != null) {
                session2.close();
            }
        }

        // 关闭sessionfactory
        sessionfactory.close();
    }
}

详细解释

配置乐观锁：在实体类中添加一个@version注解的字段，通常为整数类型。
```
@version
private int version;
```
示例场景：
- 在第一个会话中获取同一个student对象，修改其属性并提交更新。
- 在第二个会话中获取同一个student对象，也修改其属性并试图提交更新。
- 由于版本号不一致，第二个会话在提交更新时会抛出异常（org.hibernate.staleobjectstateexception）。
事务管理：在事务中进行数据操作，并在操作完成后提交事务。如果操作失败，则回滚事务以确保数据一致性。