MyBatis事务原理与实战深入解析

<!-- mybatis核心依赖 -->
<dependency>
    <groupid>org.mybatis</groupid>
    <artifactid>mybatis</artifactid>
    <version>3.5.13</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
    <groupid>com.mysql</groupid>
    <artifactid>mysql-connector-j</artifactid>
    <version>8.0.33</version>
</dependency>
<!-- 数据源（c3p0） -->
<dependency>
    <groupid>com.mchange</groupid>
    <artifactid>c3p0</artifactid>
    <version>0.9.5.5</version>
</dependency>

<configuration>
    <!-- 环境配置：配置事务工厂和数据源 -->
    <environments default="development">
        <environment id="development">
            <!-- 事务工厂：使用jdbc事务工厂 -->
            <transactionmanager type="jdbc"/>
            <!-- 数据源：c3p0连接池 -->
            <datasource type="pooled">
                <property name="driver" value="com.mysql.cj.jdbc.driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test_mybatis?usessl=false&servertimezone=asia/shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
                <property name="poolmaximumactiveconnections" value="10"/>
            </datasource>
        </environment>
    </environments>
    <!-- 映射器扫描 -->
    <mappers>
        <mapper resource="mapper/ordermapper.xml"/>
        <mapper resource="mapper/productmapper.xml"/>
    </mappers>
</configuration>

public interface ordermapper {
    int insertorder(order order);
}

public interface productmapper {
    int decreasestock(@param("productid") long productid, @param("num") integer num);
}

<mapper namespace="com.example.mapper.ordermapper">
    <insert id="insertorder" parametertype="com.example.entity.order">
        insert into `order`(order_no, product_id, num, create_time)
        values(#{orderno}, #{productid}, #{num}, now())
    </insert>
</mapper>

<mapper namespace="com.example.mapper.productmapper">
    <update id="decreasestock">
        update product set stock = stock - #{num} where id = #{productid} and stock >= #{num}
    </update>
</mapper>

public class transactiondemo {
    public static void main(string[] args) {
        // 1. 加载mybatis配置，创建sqlsessionfactory
        string resource = "mybatis-config.xml";
        try (inputstream inputstream = resources.getresourceasstream(resource)) {
            sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
            // 2. 开启sqlsession，关闭自动提交（false表示手动控制事务）
            sqlsession sqlsession = sqlsessionfactory.opensession(false);
            try {
                // 3. 获取mapper接口
                ordermapper ordermapper = sqlsession.getmapper(ordermapper.class);
                productmapper productmapper = sqlsession.getmapper(productmapper.class);
                // 4. 模拟下单流程：① 插入订单；② 扣减库存
                order order = new order();
                order.setorderno(uuid.randomuuid().tostring());
                order.setproductid(1l);
                order.setnum(2);
                ordermapper.insertorder(order); // 第一步：插入订单
                int rows = productmapper.decreasestock(1l, 2); // 第二步：扣减库存
                if (rows == 0) {
                    throw new runtimeexception("库存不足，扣减失败");
                }
                // 5. 所有操作成功，提交事务
                sqlsession.commit();
                system.out.println("事务提交成功：下单流程完成");
            } catch (exception e) {
                // 6. 发生异常，回滚事务
                sqlsession.rollback();
                system.out.println("事务回滚：" + e.getmessage());
            } finally {
                // 7. 关闭sqlsession，释放连接
                sqlsession.close();
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

<parent>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-parent</artifactid>
    <version>2.7.10</version>
</parent>
<dependencies>
    <!-- spring web -->
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-web</artifactid>
    </dependency>
    <!-- mybatis + spring boot整合依赖 -->
    <dependency>
        <groupid>org.mybatis.spring.boot</groupid>
        <artifactid>mybatis-spring-boot-starter</artifactid>
        <version>2.3.1</version>
    </dependency>
    <!-- mysql驱动 -->
    <dependency>
        <groupid>com.mysql</groupid>
        <artifactid>mysql-connector-j</artifactid>
        <scope>runtime</scope>
    </dependency>
    <!-- lombok -->
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <optional>true</optional>
    </dependency>
</dependencies>

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.driver
    url: jdbc:mysql://localhost:3306/test_mybatis?usessl=false&servertimezone=asia/shanghai
    username: root
    password: 123456
  # spring事务配置（可选，默认已配置datasourcetransactionmanager）
  transaction:
    rollback-on-commit-failure: true # 提交失败时回滚
mybatis:
  mapper-locations: classpath:mapper/**/*.xml
  type-aliases-package: com.example.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.stdoutimpl # 打印sql，便于调试

@service
public class orderservice {
    @autowired
    private ordermapper ordermapper;
    @autowired
    private productmapper productmapper;
    /**
     * 下单流程：插入订单 + 扣减库存
     * @transactional：声明式事务，默认 runtimeexception 触发回滚
     */
    @transactional(
            rollbackfor = exception.class, // 所有异常都回滚（默认仅runtimeexception回滚）
            propagation = propagation.required, // 事务传播行为：默认，当前无事务则创建新事务
            isolation = isolation.default // 隔离级别：默认，使用数据库默认隔离级别
    )
    public void createorder(order order) {
        // 1. 插入订单
        ordermapper.insertorder(order);
        // 2. 扣减库存
        int rows = productmapper.decreasestock(order.getproductid(), order.getnum());
        if (rows == 0) {
            throw new runtimeexception("库存不足，下单失败");
        }
        // 3. 模拟其他业务操作（如记录日志）
        system.out.println("下单成功，订单号：" + order.getorderno());
    }
}

@restcontroller
@requestmapping("/api/orders")
public class ordercontroller {
    @autowired
    private orderservice orderservice;
    @postmapping
    public responseentity<string> createorder(@requestbody order order) {
        try {
            order.setorderno(uuid.randomuuid().tostring());
            orderservice.createorder(order);
            return responseentity.ok("下单成功");
        } catch (exception e) {
            return responseentity.status(httpstatus.bad_request).body("下单失败：" + e.getmessage());
        }
    }
}

// 纯查询方法，设置readonly=true优化性能
@transactional(readonly = true, propagation = propagation.supports)
public list<order> getorderbyuserid(long userid) {
    return ordermapper.selectbyuserid(userid);
}

// 转账业务：扣减付款方余额 + 增加收款方余额，要求强一致性
@transactional(
        rollbackfor = exception.class,
        isolation = isolation.read_committed,
        timeout = 30
)
public void transfer(long fromuserid, long touserid, bigdecimal amount) {
    // 扣减付款方余额
    useraccountmapper.decreasebalance(fromuserid, amount);
    // 增加收款方余额
    useraccountmapper.increasebalance(touserid, amount);
}

// 主事务：创建订单
@transactional(rollbackfor = exception.class)
public void createorder(order order) {
    ordermapper.insertorder(order);
    // 调用子事务方法（创建订单日志，独立事务，即使失败不影响主事务）
    logservice.recordorderlog(order.getid());
}
// 子事务：记录订单日志（独立事务）
@transactional(propagation = propagation.requires_new, rollbackfor = exception.class)
public void recordorderlog(long orderid) {
    orderlog log = new orderlog();
    log.setorderid(orderid);
    log.setoperatetime(localdatetime.now());
    orderlogmapper.insert(log);
}