<think>我们当前的问题是在Java JDK 1
.8、Spring Boot
2.2.6版本下，使用
Druid数据源连接
MySQL，实现SQL执行回滚的方式。
注意：用户提到了使用
Druid数据源，因此我们需要在原有Spring Boot事务管理的基础上，
整合Druid。
实现回滚的核心仍然是Spring的事务管理。在Spring Boot中，无论使用哪种数据源（包括
Druid），事务管理的方式都是统一的，即通过`@Transactional`注解或编程式事务。
步骤：
1
. 添加必要的依赖（包括Spring Boot Starter JDBC、MyBatis-Spring-Boot-Starter、
Druid Starter等）
2. 配置数据源（
Druid）
和事务管理器
3. 在Service层使用`@Transactional`注解
具体步骤如下：
### 1
. 环境准备与依赖配置
根据用户要求，使用JDK 1
.8，Spring Boot
2.2.6
.RELEASE。
在`pom
.xml`中添加依赖：
```xml
<dependencies>
<!-- Spring Boot Starter JDBC -->
<dependency>
<groupId>org
.springframework
.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- MyBatis Spring Boot Starter -->
<dependency>
<groupId>org
.mybatis
.spring
.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>
2.1
.4</version> <!-- 此版本与Spring Boot
2.2.6兼容 -->
</dependency>
<!--
Druid Starter -->
<dependency>
<groupId>com
.alibaba</groupId>
<artifactId>
druid-spring-boot-starter</artifactId>
<version>1
.1
.22</version> <!-- 兼容Spring Boot
2.2.x -->
</dependency>
<!--
MySQL驱动 -->
<dependency>
<groupId>
mysql</groupId>
<artifactId>
mysql-connector-java</artifactId>
<version>
8.0.19</version> <!-- 根据实际
MySQL版本调整 -->
</dependency>
</dependencies>
```
注意：版本兼容性，上述版本都是支持Spring Boot
2.2.6的。
###
2. 配置数据源
和连接池
在`application
.yml`（或`application
.properties`）中配置
Druid数据源：
```yaml
spring:
datasource:
url: jdbc:
mysql://localhost:
3306/test_db?useUnicode=true&characterEncoding=utf
8&serverTimezone=UTC
username: root
password: yourpassword
driver-class-name: com
.mysql.cj
.jdbc
.Driver
type: com
.alibaba
.druid.pool
.DruidDataSource
druid:
# 连接池配置
initial-size: 5
min-idle: 5
max-active:
20
max-wait: 6
0000
# 监控配置（可选）
stat-view-servlet:
enabled: true
url-pattern: /
druid/*
login-username: admin
login-password: admin
filter:
stat:
enabled: true
```
###
3. 事务管理配置
Spring Boot会自动配置
一个`DataSourceTransactionManager`，我们无需额外配置，只要在需要事务的方法上添加`@Transactional`注解即可。
示例Service代码：
```java
import org
.springframework
.beans
.factory
.annotation
.Autowired;
import org
.springframework
.stereotype
.Service;
import org
.springframework
.transaction
.annotation
.Transactional;
import org
.springframework
.jdbc
.core
.JdbcTemplate;
@Service
public class AccountService {
@Autowired
private JdbcTemplate jdbcTemplate;
// 使用@Transactional注解实现事务
@Transactional(rollbackFor = Exception
.class)
public void transfer(int fromId, int toId, int amount) {
// 扣减转出账户余额
jdbcTemplate
.update("UPDATE account SET balance = balance - ? WHERE id = ?", amount, fromId);
// 增加转入账户余额
jdbcTemplate
.update("UPDATE account SET balance = balance + ? WHERE id = ?", amount, toId);
// 模拟业务异常，测试回滚
if (amount <
0) {
throw new RuntimeException("转账金额不能为负数");
}
}
}
```
说明：
- `@Transactional`注解可以加在类或方法上，加在类上表示所有public方法都开启事务。
- `rollbackFor = Exception
.class`表示遇到所有异常（包括受检异常）都回滚。默认只回滚运行时异常
和错误（即继承自`RuntimeException`或`Error`的异常）。
- 使用JdbcTemplate只是为了示例，实际中可以使用MyBatis的Mapper。
### 4
. 使用MyBatis时的示例
如果使用MyBatis，通常我们会注入Mapper接口：
```java
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
@Transactional(rollbackFor = Exception
.class)
public void updateUser(User user1, User user
2) {
userMapper
.update(user1);
// 模拟异常
if (user
2 == null) {
throw new RuntimeException("user
2 cannot be null");
}
userMapper
.update(user
2);
}
}
```
### 5
. 测试事务回滚
编写测试类：
```java
import org
.junit
.jupiter
.api
.Test;
import org
.springframework
.beans
.factory
.annotation
.Autowired;
import org
.springframework
.boot
.test
.context
.SpringBootTest;
@
SpringBootTest
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransferRollback() {
// 传入负数的金额触发异常，观察是否回滚
assertThrows(RuntimeException
.class, () -> {
accountService
.transfer(1,
2, -1
00);
});
}
}
```
### 注意事项
1
. **异常捕获**：在事务方法中，如果捕获了异常但没有重新抛出，事务不会回滚。因此，需要确保异常能传播到事务管理器。
2. **方法可见性**：`@Transactional`只能用于public方法。如果用在非public方法上，事务不会生效（但不会报错）。
3. **事务管理器**：如果项目中有多个数据源，需要配置多个事务管理器，并通过`@Transactional`的`value`属性指定。
4
. **
Druid监控**：配置了
Druid的监控后，可以通过`/
druid`路径访问监控信息，帮助分析数据库操作。
### 高级：编程式事务
除了声明式事务（@Transactional），还可以使用编程式事务：
```java
@Autowired
private PlatformTransactionManager transactionManager;
public void transferWithProgrammaticTransaction(int fromId, int toId, int amount) {
TransactionDefinition def = new DefaultTransactionDefinition();
TransactionStatus status = transactionManager
.getTransaction(def);
try {
// 业务代码
jdbcTemplate
.update("UPDATE account SET balance = balance - ? WHERE id = ?", amount, fromId);
jdbcTemplate
.update("UPDATE account SET balance = balance + ? WHERE id = ?", amount, toId);
if (amount <
0) {
throw new RuntimeException("转账金额不能为负数");
}
transactionManager
.commit(status);
} catch (RuntimeException e) {
transactionManager
.rollback(status);
throw e;
}
}
```
但通常声明式事务更简洁。
通过以上步骤，即可在Spring Boot
2.2.6、
Druid数据源
和MySQL环境下实现SQL回滚。
§§相关问题§§
1
. 在Spring Boot中如何配置多数据源并实现分布式事务？
2. 使用
Druid数据源时如何进行SQL监控
和性能分析？
3. 在事务方法中调用同
一个类的其他方法时，事务传播行为是怎样的？
4
. 如何设置事务的超时时间？
5
. 在Spring Boot中如何集成Seata实现分布式事务？
</think>### Java JDK 1
.8 + Spring Boot
2.2.6 +
Druid +
MySQL 实现SQL回滚方案
#### 1
. **环境配置与依赖**
**核心依赖**（`pom
.xml`）：
```xml
<dependencies>
<!-- Spring Boot Starter -->
<dependency>
<groupId>org
.springframework
.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>
2.2.6
.RELEASE</version>
</dependency>
<!-- MyBatis
整合 -->
<dependency>
<groupId>org
.mybatis
.spring
.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>
2.1
.4</version> <!-- 兼容Spring Boot
2.2.x -->
</dependency>
<!--
Druid数据源 -->
<dependency>
<groupId>com
.alibaba</groupId>
<artifactId>
druid-spring-boot-starter</artifactId>
<version>1
.1
.22</version> <!-- 适配JDK 1
.8 -->
</dependency>
<!--
MySQL驱动 -->
<dependency>
<groupId>
mysql</groupId>
<artifactId>
mysql-connector-java</artifactId>
<version>
8.0.19</version>
</dependency>
</dependencies>
```
**数据源配置**（`application
.yml`）：
```yaml
spring:
datasource:
url: jdbc:
mysql://localhost:
3306/test_db?useSSL=false&serverTimezone=UTC
username: root
password: yourpassword
driver-class-name: com
.mysql.cj
.jdbc
.Driver
type: com
.alibaba
.druid.pool
.DruidDataSource # 指定
Druid
druid:
initial-size: 5
min-idle: 5
max-active:
20
validation-query: SELECT 1 #
MySQL连接校验
```
####
2. **声明式事务管理（推荐）**
通过 `@Transactional` 注解实现自动回滚：
```java
import org
.springframework
.stereotype
.Service;
import org
.springframework
.transaction
.annotation
.Transactional;
import org
.springframework
.beans
.factory
.annotation
.Autowired;
@Service
public class AccountService {
@Autowired
private AccountMapper accountMapper; // MyBatis Mapper接口
/**
* 转账操作（任何异常触发回滚）
* @Transactional 注解关键参数：
* - rollbackFor: 指定触发回滚的异常类型
* - isolation: 事务隔离级别（默认ISOLATION_DEFAULT）
*/
@Transactional(rollbackFor = Exception
.class) // 所有异常都回滚
public void transferMoney(int fromId, int toId, double amount) {
// 扣减转出账户
accountMapper
.deductBalance(fromId, amount);
// 模拟异常场景（测试回滚）
if (amount <
0) {
throw new IllegalArgumentException("转账金额不能为负数");
}
// 增加接收账户
accountMapper
.addBalance(toId, amount);
}
}
```
**关键点
说明**：
1
. **异常触发回滚**：默认对 `RuntimeException` 回滚，通过 `rollbackFor` 可扩展
2. **
Druid连接池**：自动由Spring Boot集成，无需额外配置事务管理器
3. **事务传播**：默认 `Propagation
.REQUIRED`（当前存在事务则加入）
####
3. **编程式事务管理（精细控制）**
手动控制事务边界：
```java
import org
.springframework
.jdbc
.datasource
.DataSourceTransactionManager;
import org
.springframework
.transaction
.TransactionStatus;
import org
.springframework
.transaction
.support
.DefaultTransactionDefinition;
@Service
public class ManualTransactionService {
@Autowired
private DataSourceTransactionManager transactionManager;
@Autowired
private AccountMapper accountMapper;
public void batchUpdateWithRollback() {
// 定义事务属性
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def
.setIsolationLevel(TransactionDefinition
.ISOLATION_READ_COMMITTED);
// 启动事务
TransactionStatus status = transactionManager
.getTransaction(def);
try {
// 批量SQL操作
accountMapper
.updateOperation1(
...);
accountMapper
.updateOperation
2(
...);
// 提交事务
transactionManager
.commit(status);
} catch (Exception ex) {
// 回滚事务
transactionManager
.rollback(status);
throw new BusinessException("操作失败", ex);
}
}
}
```
#### 4
. **
Druid事务监控配置**
在 `application
.yml` 中启用事务监控：
```yaml
spring:
datasource:
druid:
filter:
stat:
enabled: true
log-slow-sql: true
slow-sql-millis: 1
000 # 慢SQL阈值
web-stat-filter:
enabled: true
stat-view-servlet:
enabled: true
url-pattern: /
druid/*
login-username: admin
login-password: admin
```
访问 `http://localhost:
8080/
druid` 查看：
- 实时SQL执行情况
- 事务回滚统计
- 慢SQL监控
#### 5
. **回滚验证测试**
使用JUnit测试事务回滚：
```java
import org
.junit
.jupiter
.api
.Test;
import org
.springframework
.boot
.test
.context
.SpringBootTest;
import org
.springframework
.test
.annotation
.Rollback;
import org
.springframework
.transaction
.annotation
.Transactional;
@
SpringBootTest
@Transactional // 测试后自动回滚
@Rollback(true)
class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
void testTransferRollback() {
// 触发非法金额异常
assertThrows(IllegalArgumentException
.class, () -> {
accountService
.transferMoney(1,
2, -1
00.0);
});
// 验证数据未变更（回滚生效）
assertEquals(1
000.0, accountService
.getBalance(1));
}
}
```
#### 6
. **常见问题排查**
| 问题现象 | 解决方案 |
|-------------------------|------------------------------------------|
| 事务未回滚 | 1
. 检查方法是否为`public`<br>
2. 确认异常类型匹配`rollbackFor` |
|
Druid连接泄露 | 启用`removeAbandoned: true`配置 |
| 跨数据源事务失效 | 使用分布式事务框架（如Seata） |
| 嵌套事务未回滚 | 调整`@Transactional(propagation = Propagation
.REQUIRES_NEW)` |
> **性能提示**：
Druid的事务监控对性能影响<
3%，生产环境可开启[^1]。
超级会员免费看
订阅专栏 解锁全文
扫一扫
4614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
