服务端开发

Appearance

Spring 事务管理：为不同 Bean 配置不同的事务语义 🎯 ​

引言：为什么需要差异化的事务配置？ ​

在实际的企业级应用开发中，我们经常会遇到这样的场景：

  • 🔍 查询服务：只需要读取数据，希望设置为只读事务以提升性能
  • 💾 业务服务：需要完整的事务支持，包括增删改操作
  • 🚫 DDL 操作服务：数据库结构变更操作，不应该在事务中执行
  • 📊 报表服务：长时间运行的统计查询，需要特殊的事务隔离级别

IMPORTANT

如果所有服务都使用相同的事务配置，就像让所有车辆都走同一条车道一样，不仅效率低下，还可能造成不必要的资源浪费和性能问题。

核心概念：AOP 切点与事务通知的精准匹配 ​

Spring 通过 AOP（面向切面编程） 的方式实现声明式事务管理。其核心思想是：

基础配置：统一事务管理 ​

让我们先看看如何为一组服务配置统一的事务规则：

xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <aop:config>
        <!-- 定义切点：匹配 x.y.service 包下所有以 Service 结尾的类的所有方法 -->
        <aop:pointcut id="serviceOperation"
                expression="execution(* x.y.service..*Service.*(..))"/> // [!code highlight]

        <!-- 将事务通知应用到切点 -->
        <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/> // [!code highlight]
    </aop:config>

    <!-- 定义事务通知 -->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 查询方法设置为只读 -->
            <tx:method name="get*" read-only="true"/> // [!code highlight]
            <!-- 其他方法使用默认事务配置 -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- 这些 Bean 会被事务管理 -->
    <bean id="fooService" class="x.y.service.DefaultFooService"/>
    <bean id="barService" class="x.y.service.extras.SimpleBarService"/>

    <!-- 这些 Bean 不会被事务管理 -->
    <bean id="anotherService" class="org.xyz.SomeService"/> <!-- 不在指定包中 -->
    <bean id="barManager" class="x.y.service.SimpleBarManager"/> <!-- 不以 Service 结尾 -->

</beans>
kotlin
// 会被事务管理的服务
@Service
class DefaultFooService {
    
    fun getUserById(id: Long): User {
        // 这个方法会以只读事务执行
        return userRepository.findById(id)
    }
    
    fun saveUser(user: User): User {
        // 这个方法会以读写事务执行
        return userRepository.save(user)
    }
}

// 不会被事务管理的类（不以Service结尾）
@Component
class SimpleBarManager {
    
    fun processData() {
        // 这个方法不会有事务管理
        println("Processing data without transaction")
    }
}

TIP

切点表达式 execution(* x.y.service..*Service.*(..)) 的含义：

  • *：任意返回类型
  • x.y.service..：x.y.service 包及其子包
  • *Service：以 Service 结尾的类名
  • *(..) ：任意方法名和参数

高级配置：差异化事务语义 ​

在复杂的业务场景中，我们需要为不同的服务配置完全不同的事务行为：

xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="...">

    <aop:config>
        <!-- 普通业务服务的切点 -->
        <aop:pointcut id="defaultServiceOperation"
                expression="execution(* x.y.service.*Service.*(..))"/> // [!code highlight]

        <!-- DDL操作服务的切点 -->
        <aop:pointcut id="noTxServiceOperation"
                expression="execution(* x.y.service.ddl.DefaultDdlManager.*(..))"/> // [!code highlight]

        <!-- 为不同切点配置不同的事务通知 -->
        <aop:advisor pointcut-ref="defaultServiceOperation" advice-ref="defaultTxAdvice"/>
        <aop:advisor pointcut-ref="noTxServiceOperation" advice-ref="noTxAdvice"/> // [!code highlight]
    </aop:config>

    <!-- 标准事务配置 -->
    <tx:advice id="defaultTxAdvice">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- 禁用事务的配置 -->
    <tx:advice id="noTxAdvice"> // [!code highlight]
        <tx:attributes>
            <!-- NEVER：如果当前存在事务，则抛出异常 -->
            <tx:method name="*" propagation="NEVER"/> // [!code highlight]
        </tx:attributes>
    </tx:advice>

    <!-- 普通业务服务 -->
    <bean id="fooService" class="x.y.service.DefaultFooService"/>
    
    <!-- DDL操作服务 -->
    <bean id="ddlManager" class="x.y.service.ddl.DefaultDdlManager"/>

</beans>

让我们用 Kotlin 代码来展示这种差异化配置的实际应用：

kotlin
@Service
class DefaultFooService(
    private val userRepository: UserRepository,
    private val orderRepository: OrderRepository
) {
    
    // 只读事务：优化查询性能
    fun getUserWithOrders(userId: Long): UserWithOrders {
        val user = userRepository.findById(userId)
        val orders = orderRepository.findByUserId(userId)
        return UserWithOrders(user, orders)
    }
    
    // 读写事务：保证数据一致性
    fun createOrder(userId: Long, orderData: OrderData): Order {
        val user = userRepository.findById(userId)
            ?: throw UserNotFoundException("User not found: $userId")
        
        val order = Order(
            userId = userId,
            amount = orderData.amount,
            status = OrderStatus.PENDING
        )
        
        return orderRepository.save(order)
    }
}
kotlin
@Service
class DefaultDdlManager(
    private val jdbcTemplate: JdbcTemplate
) {
    
    // 不使用事务：DDL操作通常不支持事务
    fun createTable(tableName: String, columns: List<ColumnDefinition>) {
        val sql = buildCreateTableSql(tableName, columns)
        
        try {
            jdbcTemplate.execute(sql) 
            logger.info("Table $tableName created successfully")
        } catch (e: Exception) {
            logger.error("Failed to create table $tableName", e) 
            throw DdlOperationException("Table creation failed", e)
        }
    }
    
    // 不使用事务：索引创建操作
    fun createIndex(tableName: String, indexName: String, columns: List<String>) {
        val sql = "CREATE INDEX $indexName ON $tableName (${columns.joinToString(", ")})"
        
        jdbcTemplate.execute(sql)
        logger.info("Index $indexName created on table $tableName")
    }
    
    private fun buildCreateTableSql(tableName: String, columns: List<ColumnDefinition>): String {
        val columnDefinitions = columns.joinToString(", ") { 
            "${it.name} ${it.type}${if (it.nullable) "" else " NOT NULL"}"
        }
        return "CREATE TABLE $tableName ($columnDefinitions)"
    }
}

data class ColumnDefinition(
    val name: String,
    val type: String,
    val nullable: Boolean = true
)

现代化配置：使用注解方式 ​

虽然 XML 配置很强大，但在现代 Spring Boot 应用中，我们更倾向于使用注解：

kotlin
@Configuration
@EnableTransactionManagement
class TransactionConfig {
    
    @Bean
    fun transactionManager(dataSource: DataSource): PlatformTransactionManager {
        return DataSourceTransactionManager(dataSource)
    }
}

@Service
class UserService(private val userRepository: UserRepository) {
    
    @Transactional(readOnly = true) 
    fun findUser(id: Long): User? {
        return userRepository.findById(id)
    }
    
    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.READ_COMMITTED,
        rollbackFor = [Exception::class]
    ) 
    fun saveUser(user: User): User {
        return userRepository.save(user)
    }
}

@Service
class DdlService(private val jdbcTemplate: JdbcTemplate) {
    
    @Transactional(propagation = Propagation.NEVER) 
    fun executeSchema(sql: String) {
        jdbcTemplate.execute(sql)
    }
}

实战场景：电商系统的事务配置 ​

让我们通过一个电商系统的例子来看看如何在实际项目中应用差异化事务配置：

完整的电商系统事务配置示例
kotlin
// 订单服务：标准事务配置
@Service
class OrderService(
    private val orderRepository: OrderRepository,
    private val inventoryService: InventoryService
) {
    
    @Transactional(readOnly = true)
    fun getOrderHistory(userId: Long): List<Order> {
        return orderRepository.findByUserIdOrderByCreatedAtDesc(userId)
    }
    
    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.READ_COMMITTED,
        rollbackFor = [Exception::class]
    )
    fun createOrder(orderRequest: OrderRequest): Order {
        // 检查库存
        inventoryService.checkAndReserveStock(orderRequest.items)
        
        // 创建订单
        val order = Order(
            userId = orderRequest.userId,
            items = orderRequest.items,
            totalAmount = orderRequest.calculateTotal(),
            status = OrderStatus.PENDING
        )
        
        return orderRepository.save(order)
    }
}

// 支付服务：高隔离级别事务
@Service
class PaymentService(
    private val paymentRepository: PaymentRepository,
    private val accountService: AccountService
) {
    
    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.SERIALIZABLE, // 最高隔离级别
        timeout = 30 // 30秒超时
    )
    fun processPayment(paymentRequest: PaymentRequest): Payment {
        // 扣减账户余额
        accountService.deductBalance(
            paymentRequest.userId, 
            paymentRequest.amount
        )
        
        // 记录支付信息
        val payment = Payment(
            orderId = paymentRequest.orderId,
            amount = paymentRequest.amount,
            status = PaymentStatus.SUCCESS
        )
        
        return paymentRepository.save(payment)
    }
}

// 报表服务：只读长事务
@Service
class ReportService(
    private val jdbcTemplate: JdbcTemplate
) {
    
    @Transactional(
        readOnly = true,
        timeout = 300, // 5分钟超时
        isolation = Isolation.READ_UNCOMMITTED // 允许脏读以提高性能
    )
    fun generateSalesReport(startDate: LocalDate, endDate: LocalDate): SalesReport {
        val sql = """
            SELECT 
                DATE(created_at) as sale_date,
                COUNT(*) as order_count,
                SUM(total_amount) as total_sales
            FROM orders 
            WHERE created_at BETWEEN ? AND ?
            GROUP BY DATE(created_at)
            ORDER BY sale_date
        """.trimIndent()
        
        val results = jdbcTemplate.query(sql, { rs, _ ->
            SalesData(
                date = rs.getDate("sale_date").toLocalDate(),
                orderCount = rs.getInt("order_count"),
                totalSales = rs.getBigDecimal("total_sales")
            )
        }, startDate, endDate)
        
        return SalesReport(results)
    }
}

// DDL服务：无事务操作
@Service
class DatabaseMaintenanceService(
    private val jdbcTemplate: JdbcTemplate
) {
    
    @Transactional(propagation = Propagation.NEVER)
    fun createPartitionTable(tableName: String, partitionColumn: String) {
        val sql = """
            CREATE TABLE ${tableName}_partition (
                LIKE $tableName INCLUDING ALL
            ) PARTITION BY RANGE ($partitionColumn)
        """.trimIndent()
        
        jdbcTemplate.execute(sql)
        logger.info("Partition table created: ${tableName}_partition")
    }
    
    @Transactional(propagation = Propagation.NEVER)
    fun rebuildIndex(indexName: String) {
        val sql = "REINDEX INDEX $indexName"
        jdbcTemplate.execute(sql)
        logger.info("Index rebuilt: $indexName")
    }
}

最佳实践与注意事项 ​

✅ 推荐做法 ​

事务配置的黄金法则

  1. 查询操作：使用 readOnly = true 优化性能
  2. 业务操作：使用适当的隔离级别和传播行为
  3. DDL操作：使用 NEVER 传播行为
  4. 长时间操作：设置合理的超时时间

⚠️ 常见陷阱 ​

需要特别注意的问题

  • 切点表达式过于宽泛：可能意外地给不需要事务的方法添加事务
  • 事务传播行为冲突：不同的事务配置可能产生意外的交互
  • 性能影响：过度使用事务会影响系统性能

🚫 避免的错误 ​

这些做法可能导致严重问题

kotlin
// ❌ 错误：DDL操作使用事务
@Transactional
fun createTable() {
    jdbcTemplate.execute("CREATE TABLE ...") 
}

// ✅ 正确：DDL操作禁用事务
@Transactional(propagation = Propagation.NEVER)
fun createTable() {
    jdbcTemplate.execute("CREATE TABLE ...") 
}

总结 ​

差异化的事务配置是企业级应用的重要特性，它让我们能够：

  1. 🎯 精确控制：为不同类型的操作配置最合适的事务行为
  2. ⚡ 性能优化：通过只读事务、合适的隔离级别等提升性能
  3. 🛡️ 数据安全：通过合理的事务配置保证数据一致性
  4. 🔧 运维友好：DDL操作等特殊场景的正确处理

IMPORTANT

记住：事务配置不是一劳永逸的，需要根据具体的业务场景和性能要求进行调整。在设计时要充分考虑业务逻辑的特点，选择最合适的事务策略。

通过合理的事务配置，我们可以构建出既高效又可靠的企业级应用系统！ 🚀