无需Spring框架，JUnit测试用例后能否实现数据库回滚？

当然可以！不用Spring框架也能实现JUnit测试用例执行后数据库回滚的需求，毕竟Spring的事务管理也是基于底层JDBC或JTA实现的。下面给你几个实用的方案，都是不依赖Spring的：

1. 手动管理JDBC事务（最基础直接） #

javax的@Transactional之所以没生效，是因为这个注解需要容器（比如Spring、Java EE容器）来做代理拦截，自动帮你管理事务。非Spring环境下没有这个容器支持，所以得手动控制事务。

你可以用JUnit的@BeforeEach和@AfterEach注解，在每个测试前开启事务（关闭自动提交），测试完成后强制回滚：

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class MultiTableUpdateTest {
    private Connection connection;

    @BeforeEach
    void setUpDatabase() throws Exception {
        // 初始化数据库连接，关闭自动提交（相当于开启事务）
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test_db", "root", "password");
        connection.setAutoCommit(false);
    }

    @AfterEach
    void rollbackAndClose() throws Exception {
        if (connection != null && !connection.isClosed()) {
            // 不管测试成功还是失败，都回滚事务
            connection.rollback();
            connection.close();
        }
    }

    @Test
    void testMultiTableUpdate() throws Exception {
        // 执行你的多表更新操作
        try (PreparedStatement stmt1 = connection.prepareStatement("UPDATE table1 SET ...")) {
            stmt1.executeUpdate();
        }
        try (PreparedStatement stmt2 = connection.prepareStatement("UPDATE table2 SET ...")) {
            stmt2.executeUpdate();
        }
        // 这里不要调用commit！测试完成后会自动回滚
    }
}

要点：

• 手动控制Connection的autoCommit为false，相当于开启了一个事务
• 测试用例里不要调用commit()，否则数据会永久写入
• 不管测试成功还是失败，@AfterEach里都执行rollback()，保证数据回到初始状态

2. 封装JUnit 5扩展（复用性更强） #

如果有多个测试类都需要事务回滚，手动写重复代码太麻烦，可以用JUnit 5的Extension机制封装事务管理逻辑，然后在测试类上引用即可：

首先写一个自定义Extension：

import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import java.sql.Connection;
import java.sql.DriverManager;
import java.lang.reflect.Field;

public class TransactionalTestExtension implements BeforeEachCallback, AfterEachCallback {
    // 用ThreadLocal保存连接，避免多线程测试冲突
    private final ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();

    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        // 创建连接并关闭自动提交
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test_db", "root", "password");
        conn.setAutoCommit(false);
        connectionHolder.set(conn);

        // 把连接注入到测试类的指定字段（比如测试类里有private Connection connection;）
        context.getTestInstance().ifPresent(testInstance -> {
            try {
                Field connectionField = testInstance.getClass().getDeclaredField("connection");
                connectionField.setAccessible(true);
                connectionField.set(testInstance, conn);
            } catch (Exception e) {
                throw new RuntimeException("Failed to inject database connection", e);
            }
        });
    }

    @Override
    public void afterEach(ExtensionContext context) throws Exception {
        Connection conn = connectionHolder.get();
        if (conn != null && !conn.isClosed()) {
            conn.rollback();
            conn.close();
            connectionHolder.remove();
        }
    }
}

然后在测试类里引用这个Extension：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import java.sql.Connection;
import java.sql.PreparedStatement;

@ExtendWith(TransactionalTestExtension.class)
public class AnotherMultiTableTest {
    // 会被Extension自动注入连接
    private Connection connection;

    @Test
    void testAnotherUpdate() throws Exception {
        // 直接用connection执行操作即可，不用管事务管理
        try (PreparedStatement stmt = connection.prepareStatement("UPDATE table3 SET ...")) {
            stmt.executeUpdate();
        }
    }
}

要点：

• 把事务逻辑封装在Extension里，所有测试类只要加@ExtendWith就能复用
• 用ThreadLocal保存连接，避免多线程并行测试时的连接冲突
• 通过反射把连接注入到测试类字段，不用每个测试类都写连接初始化代码

3. 用Testcontainers创建临时数据库（彻底隔离） #

如果你的测试环境支持Docker，还可以用Testcontainers启动一个临时的数据库容器，每个测试用例都使用全新的数据库实例，根本不需要回滚——测试结束后直接销毁容器即可：

import org.junit.jupiter.api.Test;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

@Testcontainers
public class IsolatedDatabaseTest {
    // 启动一个临时MySQL容器
    @Container
    private static final MySQLContainer<?> mysqlContainer = new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("temp_test_db")
            .withUsername("test_user")
            .withPassword("test_pass");

    @Test
    void testMultiTableUpdate() throws Exception {
        // 从容器获取JDBC连接
        try (Connection conn = DriverManager.getConnection(
                mysqlContainer.getJdbcUrl(),
                mysqlContainer.getUsername(),
                mysqlContainer.getPassword()
        )) {
            // 先初始化表结构（可以执行SQL脚本）
            // 然后执行测试更新操作
            try (PreparedStatement stmt = conn.prepareStatement("UPDATE table1 SET ...")) {
                stmt.executeUpdate();
            }
        }
    }
}

要点：

• 每个测试用例都拿到干净的数据库，完全隔离，不用担心测试之间的污染
• 不需要管理事务回滚，测试结束后Testcontainers会自动停止并销毁容器
• 缺点是需要Docker环境，启动容器会增加一点测试时间，但隔离性最好

为什么javax的@Transactional没生效？ #

最后补充一下：javax的@Transactional属于JTA（Java Transaction API）规范的一部分，它本身只是一个标记注解，需要有支持JTA的容器来实现事务的拦截和管理——比如Spring的事务管理器、Java EE的应用服务器（如TomEE、WildFly）。在非Spring非EE的普通Java项目里，没有这样的容器来处理这个注解，所以自然不会生效。

内容的提问来源于stack exchange，提问作者Luka