Spring框架下MySQL数据库的连接与操作实战-CSDN博客

本文链接：https://blog.csdn.net/weixin_42576410/article/details/150699545

简介：在Spring框架中，数据库连接和操作是开发的重要环节。本文将指导如何配置Spring与MySQL数据库进行有效连接，并使用SimpleJdbcTemplate简化数据库操作。首先，介绍添加MySQL JDBC驱动到项目，并配置数据源属性。接着，演示如何利用SimpleJdbcTemplate进行SQL查询、更新、删除和插入操作。文章还包括Spring的事务管理以及异常处理机制。通过这些步骤，开发者能够理解并应用Spring框架来管理数据库操作，提高项目的开发效率和质量。
Spring mysql数据库的配置与链接

1. Spring框架中的数据库操作

在现代Java企业级应用开发中，数据库操作是不可或缺的一部分。Spring框架以其全面的生态系统、易用性和灵活性成为处理数据库操作的首选框架之一。通过Spring提供的各种抽象和工具，开发者可以轻松实现对数据库的高效和安全操作。

1.1 Spring数据访问技术概述

Spring提供了多种数据访问技术，包括JDBC（Java Database Connectivity）、JPA（Java Persistence API）、Hibernate等。Spring通过抽象这些技术的复杂性，使得开发者可以专注于业务逻辑的实现。此外，Spring Data项目还提供了简化数据访问层开发的高级抽象，支持包括NoSQL在内的多种数据存储。

1.2 Spring数据访问模板化

为了进一步简化数据访问操作，Spring引入了模板化方法的概念。例如， JdbcTemplate 提供了对JDBC操作的模板方法，使得复杂的SQL操作更加清晰和易于管理。随后，Spring还推出了针对特定ORM技术的模板类，如 HibernateTemplate 和 SimpleJdbcTemplate 等。

1.3 从JDBC到ORM的演进

随着技术的发展，开发者越来越倾向于使用对象关系映射（ORM）工具来减少代码量并提高开发效率。Spring对主流的ORM工具如Hibernate、MyBatis等提供了良好的支持。通过Spring Data JPA和Spring Data MongoDB等项目，开发者能够以声明式的方式进行数据库访问和操作，极大地简化了代码并提升了生产力。

在下一章，我们将深入探讨MySQL JDBC驱动的配置与属性设置，这是Spring框架中进行数据库操作之前的一个重要步骤。我们会介绍如何添加MySQL JDBC驱动依赖，以及如何配置数据源信息和数据库连接属性，为深入学习Spring中的数据库操作打下坚实基础。

2. MySQL JDBC驱动配置与属性设置

2.1 MySQL JDBC驱动的配置

在Spring框架中，进行数据库操作的首要步骤是配置MySQL JDBC驱动程序，以便应用能够通过JDBC与MySQL数据库进行通信。

2.1.1 添加MySQL JDBC驱动依赖

为了使Spring项目能够使用MySQL JDBC驱动，首先需要在项目的 pom.xml 文件中添加对应的依赖。这是因为在Maven项目中，添加依赖是获取库文件最简便的方式。以下是一个示例的依赖添加代码段：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.23</version>
</dependency>

这段依赖声明会告诉Maven在构建项目时下载MySQL JDBC驱动程序的jar包，版本为8.0.23。 groupId 为 mysql 表示该依赖属于MySQL项目， artifactId 为 mysql-connector-java 则代表这是一个MySQL的Java连接器。

2.1.2 配置数据源信息

在Spring配置文件中，我们需指定数据源的信息，这包括数据库的URL、用户名和密码等。以下是一个典型的配置数据源信息的示例：

<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
    <!-- 连接池其他属性配置 -->
</bean>

这里使用了 org.apache.commons.dbcp2.BasicDataSource 作为数据源的实现，配置了驱动类名、JDBC URL、用户名和密码。此外，还可以配置连接池相关的属性，比如初始连接数、最大活跃连接数、连接的最大空闲时间等。

2.2 数据库连接属性配置

正确配置JDBC URL以及数据库连接池是保证应用性能和稳定性的关键。

2.2.1 JDBC URL格式解析

JDBC URL是连接到MySQL数据库时使用的关键参数，它遵循一定的格式规则。一个典型的JDBC URL看起来可能是这样的：

jdbc:mysql://主机名:端口/数据库名?参数名1=参数值1&参数名2=参数值2

例如：

jdbc:mysql://localhost:3306/springdb?useSSL=false&serverTimezone=UTC

这里解释一下URL中包含的几个参数：
- useSSL=false 表示不使用SSL连接到数据库。
- serverTimezone=UTC 指定了服务器时区，以避免时区相关的错误。

2.2.2 数据库连接池的配置

数据库连接池的目的是预先创建一定数量的数据库连接，并将这些连接保存在内存中，供应用重复使用。这可以显著减少创建和销毁数据库连接所需的资源消耗。常见的连接池有Apache DBCP、HikariCP等。以HikariCP为例，其配置项如下所示：

<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
    <property name="maximumPoolSize" value="10"/>
    <property name="connectionTimeout" value="30000"/>
    <property name="idleTimeout" value="60000"/>
    <property name="maxLifetime" value="1800000"/>
</bean>

这里的 maximumPoolSize 属性定义了连接池可以拥有的最大连接数， connectionTimeout 是连接获取操作的超时时间， idleTimeout 表示连接可以保持空闲的最大时间，而 maxLifetime 则是连接在池中保持的最长时间。

在配置数据库连接属性时，需要仔细考虑应用的实际需求，以确保资源使用效率最大化，同时避免因为配置不当引起的性能问题。

通过上面的章节内容，我们可以看到，对于MySQL JDBC驱动的配置与属性设置，涉及到依赖引入、数据源配置以及连接池的优化。在后续章节中，我们将探讨如何在Spring框架中具体使用SimpleJdbcTemplate进行数据库操作。

3. Spring中SimpleJdbcTemplate的运用

3.1 SimpleJdbcTemplate的使用方法

SimpleJdbcTemplate是Spring框架提供的简化JDBC操作的一个模板类。它封装了许多传统JDBC操作的冗余代码，使得开发者能够更加专注于业务逻辑。下面是使用SimpleJdbcTemplate进行数据库操作的基本步骤。

3.1.1 创建SimpleJdbcTemplate实例

首先，你需要创建一个SimpleJdbcTemplate实例。这可以通过依赖注入（DI）来完成，通常在Spring的配置文件中配置数据源和SimpleJdbcTemplate。

// 在Spring配置文件中配置数据源
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/yourdb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

// 配置SimpleJdbcTemplate
<bean id="simpleJdbcTemplate" class="org.springframework.jdbc.core.simple.SimpleJdbcTemplate">
    <constructor-arg ref="dataSource"/>
</bean>

3.1.2 简单的CRUD操作

创建了SimpleJdbcTemplate实例后，你可以开始使用它执行各种数据库操作。以下是简单的CRUD（创建、读取、更新、删除）操作示例。

插入数据示例：

String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
Object[] params = {"John Doe", "john.doe@example.com"};
simpleJdbcTemplate.update(sql, params);

读取数据示例：

String sql = "SELECT * FROM users WHERE id = ?";
int id = 1;
Map<String, Object> map = simpleJdbcTemplate.queryForMap(sql, id);

更新数据示例：

String sql = "UPDATE users SET name = ? WHERE id = ?";
Object[] params = {"Jane Doe", 1};
simpleJdbcTemplate.update(sql, params);

删除数据示例：

String sql = "DELETE FROM users WHERE id = ?";
int id = 1;
simpleJdbcTemplate.update(sql, id);

3.2 查询操作示例

3.2.1 单条记录查询

单条记录查询通常用于获取具有唯一标识的记录，例如根据主键查询一条用户信息。

String sql = "SELECT * FROM users WHERE id = ?";
User user = simpleJdbcTemplate.queryForObject(sql, new UserMapper(), 1);

3.2.2 多条记录查询

对于多条记录的查询，SimpleJdbcTemplate提供了query方法，并且支持返回一个对象列表。

String sql = "SELECT * FROM users";
List<User> users = simpleJdbcTemplate.query(sql, new UserMapper());

表格展示：UserMapper类实现

方法	描述
mapRow	用于将查询结果集中的每一条记录转换成一个User对象
columnNames	定义了数据库表中字段与User类中属性的映射关系

代码逻辑解读与参数说明

UserMapper类代码段：

public class UserMapper implements RowMapper<User> {
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
        return user;
    }
}

逻辑解读：

该类实现了 RowMapper 接口，用于将结果集转换成Java对象。 mapRow 方法接收 ResultSet 和行号，然后读取结果集中的字段值，最后将这些值封装到一个 User 对象中。

参数说明：

ResultSet rs : 结果集对象，包含了查询返回的所有记录。
int rowNum : 行号，表示当前映射的记录在结果集中的位置。
User user : 返回的用户对象。

使用 UserMapper ，我们能够将 ResultSet 转换为 User 对象列表，这在处理多条记录查询时特别有用。

代码块解释：

上述代码块中， queryForObject 和 query 方法被用来执行查询操作，而 UserMapper 类定义了如何将每条记录转换为 User 对象的过程。这些方法和类的组合构成了一个简单而强大的机制，用来执行数据库操作并处理结果。

4. 更新、删除及插入操作深入实践

4.1 更新与删除操作示例

在实际的应用开发中，更新与删除操作是数据维护不可或缺的一部分。更新（UPDATE）操作用于修改数据库中已存在的数据，而删除（DELETE）操作用于移除不再需要的数据记录。本节将通过示例代码，深入探讨如何在Spring框架中进行高效的更新与删除操作。

4.1.1 根据条件执行更新

在企业级应用中，更新操作通常伴随着复杂的业务逻辑，比如，修改用户信息、更新订单状态等。为了避免SQL注入等安全问题，同时保证代码的可读性和易维护性，推荐使用Spring的 SimpleJdbcTemplate 来执行更新操作。

假设我们需要更新某个用户的基本信息，以下是使用 SimpleJdbcTemplate 进行更新操作的示例代码：

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private SimpleJdbcTemplate simpleJdbcTemplate;

    public int updateUser(int userId, String name, String email) {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        return simpleJdbcTemplate.update(sql, name, email, userId);
    }
}

在上述代码中， updateUser 方法接受三个参数： userId 、 name 和 email 。方法内部，我们定义了一个SQL语句用于更新操作，并使用 update 方法执行它。使用 ? 作为参数占位符可以防止SQL注入。 SimpleJdbcTemplate 的 update 方法会返回受影响的行数，这对于确认更新操作是否成功执行非常有用。

4.1.2 根据条件执行删除

删除操作通常用于清除不再需要的数据，例如，删除过期的订单记录或无效的用户账户。在Spring中，使用 SimpleJdbcTemplate 进行删除操作同样简单直接。

以下是一个根据条件删除用户记录的示例：

public int deleteUser(int userId) {
    String sql = "DELETE FROM users WHERE id = ?";
    return simpleJdbcTemplate.update(sql, userId);
}

在这个示例中， deleteUser 方法仅需要一个参数 userId ，表示将要删除的用户的ID。定义的SQL语句使用了 DELETE 语句来移除符合条件的记录。 update 方法将返回被删除的记录数，这可以帮助开发者判断是否有记录被成功删除。

4.2 插入操作示例

在许多情况下，需要向数据库中插入新的数据记录。例如，添加新的订单详情、记录日志事件或创建新的用户账户。Spring提供了 SimpleJdbcTemplate 来简化插入操作的过程，并确保数据的一致性和完整性。

4.2.1 单条数据插入

当应用需要插入单条数据记录时，使用 SimpleJdbcTemplate 是一个简单且有效的方法。以下是一个插入单条用户数据的示例代码：

import java.util.HashMap;
import java.util.Map;

public int insertUser(String name, String email) {
    String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
    Map<String, Object> params = new HashMap<>();
    params.put("name", name);
    params.put("email", email);
    return simpleJdbcTemplate.update(sql, params);
}

在 insertUser 方法中，我们定义了一个插入SQL语句，并使用 Map 来存储待插入的参数。 update 方法接受SQL语句和参数映射，处理参数的绑定和语句的执行。该方法返回值表示成功插入的记录数。

4.2.2 批量数据插入

在数据量大时，单条数据插入的效率非常低。这时，批量插入就显得尤为关键。Spring通过 SimpleJdbcTemplate 也提供了批量插入的功能，从而提高数据插入的效率。

示例如下：

public int[] batchInsertUsers(List<User> users) {
    String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
    return simpleJdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
        public void setValues(PreparedStatement ps, int i) throws SQLException {
            User user = users.get(i);
            ps.setString(1, user.getName());
            ps.setString(2, user.getEmail());
        }

        public int getBatchSize() {
            return users.size();
        }
    });
}

在 batchInsertUsers 方法中，我们准备了一个批量插入的SQL语句，并通过实现 BatchPreparedStatementSetter 接口来设置每个预编译语句的参数。 batchUpdate 方法将处理整个批量插入的过程，并返回一个数组，表示每一批次插入操作影响的记录数。

批量插入通过减少与数据库的交互次数来提高整体性能，这在数据导入或大数据量处理时尤其有优势。

以上，我们通过具体的代码示例和分析，展示了在Spring中如何进行更新、删除及插入操作，并保证这些操作的效率与安全。在接下来的章节中，我们将继续深入探讨如何在Spring框架中管理事务，以及如何处理异常和保障数据一致性。

5. Spring事务管理的策略与实现

在当今的软件开发中，事务管理是保证数据一致性和业务完整性的核心功能之一。特别是在涉及多个数据源、复杂业务逻辑或关键业务操作的系统中，事务管理显得尤为重要。Spring框架提供了强大而灵活的事务管理解决方案，无论是编程式事务管理还是声明式事务管理，Spring都能提供有效的支持。

5.1 事务管理的基本概念

事务管理是数据库操作的一个重要组成部分，它确保了一组操作要么全部成功，要么全部失败。Spring框架通过抽象出的事务管理API，使得开发者可以不关心底层实现细节，只需要遵循框架提供的规则即可。

5.1.1 事务的ACID属性

事务管理依赖于数据库事务的四大基本属性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），简称为ACID。

原子性 ：指的是事务中的所有操作要么全部完成，要么全部不完成。如果事务执行过程中发生错误，系统将回滚到事务开始之前的状态。
一致性 ：事务必须将数据库从一个一致性状态转换到另一个一致性状态。
隔离性 ：在并发环境中，事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的。
持久性 ：事务一旦提交，其所做的修改就会永久保存在数据库中。

5.1.2 Spring中的事务抽象

Spring框架对事务管理提供了丰富的抽象，允许开发者以声明式的方式管理事务，这样可以将事务管理代码从业务逻辑代码中分离出来，使得应用的业务逻辑更加清晰。Spring提供了编程式和声明式两种事务管理方式：

编程式事务管理 ：通过编程方式管理事务，这种方式更加灵活，但是代码侵入性较高，维护起来比较复杂。
声明式事务管理 ：通过注解或XML配置来管理事务，这种方式更加简洁，符合AOP（面向切面编程）原则，能够将事务管理代码从业务代码中解耦。

5.2 配置事务管理器

Spring通过 PlatformTransactionManager 接口为不同的事务类型提供了不同的实现，例如 DataSourceTransactionManager 用于单数据源事务， JtaTransactionManager 用于分布式事务等。

5.2.1 使用注解配置事务

使用注解是声明式事务管理中一种非常流行的方式。通过在服务层方法上添加 @Transactional 注解，可以轻松地控制事务边界。

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class MyBusinessService {

    @Transactional
    public void doSomeBusinessStuff() {
        // 处理业务逻辑
    }
}

在上述代码中， @Transactional 注解表示 doSomeBusinessStuff 方法需要在事务的上下文中运行。Spring默认情况下会回滚事务，如果方法抛出运行时异常或错误。

5.2.2 XML配置事务管理器

在Spring的早期版本中，使用XML配置事务管理器非常普遍。在XML中配置事务管理器涉及定义事务管理器的bean以及事务属性。

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="get*" read-only="true"/>
        <tx:method name="add*" propagation="REQUIRED"/>
        <tx:method name="update*" propagation="REQUIRED"/>
        <tx:method name="delete*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="serviceOperation" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>
</aop:config>

在这个配置示例中，首先定义了一个 DataSourceTransactionManager 的bean，然后创建了一个事务通知（ txAdvice ），其中定义了事务属性。最后，通过 aop:config 将事务通知应用到业务服务层的所有操作上。

通过以上两种配置方式，Spring为开发者提供了灵活的事务管理策略选择，无论是通过注解还是XML，都能保证事务的正确执行和业务逻辑的完整性。

6. 异常处理及数据一致性保障

6.1 异常处理机制

6.1.1 数据访问异常处理

在数据库操作中，异常处理是保证程序健壮性的重要部分。Spring框架通过提供统一的异常处理机制，可以有效地对数据访问层的异常进行处理。当使用Spring的JdbcTemplate或SimpleJdbcTemplate执行数据库操作时，常见的数据库访问异常可以分为两类：checked exceptions和runtime exceptions。

Checked Exceptions ：这些异常通常与数据库连接问题、SQL语法错误或数据类型转换错误有关。例如，当执行一条SQL语句时，如果该语句中存在语法错误，Spring将会抛出 BadSqlGrammarException 异常。
Runtime Exceptions ：与checked exceptions不同的是，runtime exceptions通常表示那些我们无法预知的问题，比如数据约束违反（如 DataIntegrityViolationException ），这可能会发生在尝试插入重复主键的记录时。

代码逻辑解读

在Spring中，我们可以通过在方法上使用 @Transactional 注解来管理事务，并利用其回滚机制来处理异常。当发生异常时，Spring的事务管理器会自动回滚事务。下面是一个简单的例子：

@Service
public class MyService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void addData(String data) {
        // 此处省略一些业务逻辑代码
        jdbcTemplate.update("INSERT INTO table_name (column) VALUES (?)", data);
    }
}

在上述代码中，如果在插入操作过程中发生异常（例如，违反了唯一性约束）， @Transactional 注解会触发事务回滚。当然，我们也可以自定义一个异常处理器来捕获特定的异常，并进行相应的处理。

6.1.2 自定义异常处理

在实际的应用开发中，可能需要根据业务需求来处理特定的异常情况。Spring提供了多种方式来自定义异常处理，比如通过声明 @ControllerAdvice 类和使用 @ExceptionHandler 注解来捕获并处理异常。

代码逻辑解读

以下是一个自定义异常处理器的示例代码，它展示了如何捕获 DataIntegrityViolationException 异常：

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(DataIntegrityViolationException.class)
    @ResponseBody
    public ResponseEntity<Object> handleDataIntegrityViolationException(DataIntegrityViolationException ex) {
        // 自定义异常处理逻辑
        // 可以记录日志，或者返回特定的错误信息给前端
        String errorMessage = "数据库操作失败，可能是因为违反了数据完整性约束。";
        return new ResponseEntity<>(errorMessage, HttpStatus.BAD_REQUEST);
    }
}

在该 GlobalExceptionHandler 类中，我们使用了 @ExceptionHandler 注解来指定处理 DataIntegrityViolationException 的逻辑。当此类异常被捕获时，会返回一个HTTP状态码为 BAD_REQUEST 的响应给客户端，同时附带一个自定义的错误信息。

6.2 数据一致性的保障

6.2.1 事务隔离级别的理解

为了确保数据的一致性，我们还需要理解事务的隔离级别。Spring使用的是数据库的事务隔离级别，而数据库事务隔离级别定义了一个事务可能受其他并发事务影响的程度。具体来说，有四种隔离级别：

Read Uncommitted（读未提交） ：最低的隔离级别，允许读取尚未提交的数据变更，会导致脏读、不可重复读和幻读。
Read Committed（读已提交） ：保证一个事务只能读取另一个事务已经提交的数据，避免脏读，但不可重复读和幻读问题仍然存在。
Repeatable Read（可重复读） ：保证在同一个事务中多次读取同样数据的结果是一致的，避免了脏读和不可重复读，但是幻读问题仍然存在。
Serializable（可串行化） ：最高的隔离级别，完全服从ACID的隔离级别，确保所有事务串行化执行，避免了脏读、不可重复读和幻读。但这种级别效率低下，一般情况下不使用。

代码逻辑解读

在Spring中，可以通过 @Transactional 注解来设置事务的隔离级别，如下所示：

@Transactional(isolation = Isolation.REPEATABLE_READ)
public void someBusinessMethod() {
    // 业务逻辑代码
}

在这个例子中，我们设置了事务的隔离级别为 REPEATABLE_READ ，这可以有效避免不可重复读和脏读的问题，但在某些情况下可能会导致幻读。

6.2.2 应用级锁与乐观锁的使用

为了进一步保证数据的一致性，我们可以使用锁机制。Spring支持两种锁机制：应用级锁和乐观锁。

应用级锁 ：通常是在代码中直接实现的，比如使用 synchronized 关键字或者 Lock 接口。它适用于需要在多线程环境下保护共享资源的场景。
乐观锁 ：不同于悲观锁，乐观锁假设多个事务在处理数据时不会发生冲突，只有在最后提交事务时才进行检测。如果检测到冲突，事务将会被回滚。乐观锁通常通过在数据库表中增加一个版本号字段来实现。

代码逻辑解读

下面是一个使用乐观锁的简单例子：

@Entity
public class EntityWithOptimisticLock {
    @Id
    private Long id;
    private Integer version;

    @Version
    public Integer getVersion() {
        return version;
    }

    public void setVersion(Integer version) {
        this.version = version;
    }
    // 其他字段和业务逻辑代码
}

@Service
public class OptimisticLockService {

    @Autowired
    private EntityManager entityManager;

    public void updateEntityWithOptimisticLock(Long id, String newData) {
        EntityWithOptimisticLock entity = entityManager.find(EntityWithOptimisticLock.class, id);
        entity.setSomeField(newData);
        entityManager.merge(entity);
    }
}

在这个例子中， @Version 注解告诉Hibernate框架，当我们更新 EntityWithOptimisticLock 实体时，需要检查版本号。如果版本号在加载数据和提交更新之间发生了变化（即其他事务已经修改了该实体），则会抛出 OptimisticLockException 异常。在捕获该异常后，我们通常会处理冲突，例如提示用户重新更新数据。