spring mm 怎么回滚

Spring提供了多种方式进行事务回滚。下面将介绍几种常用的方法。

1. 使用@Transactional注解：
   在Spring中，可以使用@Transactional注解来声明事务的边界。通过在方法或类上添加该注解，可以控制方法的事务行为。当方法出现异常时，Spring会自动回滚事务。示例如下：

   @Transactional
   public void someMethod() {
       // 业务逻辑
   }
   

2. 手动回滚：
   在需要回滚事务的地方，可以通过获取TransactionStatus对象，然后调用其setRollbackOnly()方法来手动回滚事务。示例如下：

   @Autowired
   private PlatformTransactionManager transactionManager;
   
   public void someMethod() {
       TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
       try {
           // 业务逻辑
           transactionManager.commit(status);
       } catch (Exception e) {
           transactionManager.rollback(status);
       }
   }
   

3. 基于XML配置的回滚：
   Spring也支持通过XML配置方式进行事务管理。可以在XML配置文件中配置<tx:advice>元素来实现事务的回滚。示例如下：

   <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="*" rollback-for="Exception" />
       </tx:attributes>
   </tx:advice>
   
   <aop:config>
       <aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))" />
       <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods" />
   </aop:config>
   

需要注意的是，事务回滚的前提是配置了事务管理器，并且在异常情况下进行了处理，否则事务无法回滚。另外，事务的回滚只对RuntimeException及其子类的异常有效，默认情况下，Checked Exception是不会回滚事务的。如果需要让Checked Exception也回滚事务，可以在@Transactional注解或XML配置中指定rollbackFor属性。

在Spring框架中实现事务回滚是非常简单的。下面是在Spring中实现事务回滚的几种常用方法：

1. 使用@Transactional注解：在需要进行事务管理的方法上添加@Transactional注解。当方法执行的过程中发生异常时，Spring会自动回滚事务。使用@Transactional注解的方法需要包含在一个被Spring容器管理的Bean中。

示例代码：

@Transactional
public void updateData(){
    // 更新数据库操作
    // 发生异常时事务会回滚
}

2. XML配置方式：可以通过配置XML文件来管理事务。在XML文件中配置事务管理器、事务定义和事务通知。

示例代码：

<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="*" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>

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

3. 使用编程方式：通过编程方式控制事务的提交和回滚。可以使用TransactionTemplate和PlatformTransactionManager类。

示例代码：

@Autowired
private PlatformTransactionManager transactionManager;

public void updateData(){
    TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            try {
                // 更新数据库操作
                // 发生异常时手动回滚事务
                // status.setRollbackOnly();
            } catch (Exception e) {
                status.setRollbackOnly();
                throw new RuntimeException(e);
            }
        }
    });
}

4. 声明式事务管理：可以使用AspectJ风格来实现声明式事务管理。在配置文件中配置切点和通知，通过切点指定需要进行事务管理的方法，通过通知指定事务的行为（如事务的传播行为、事务的隔离级别等）。

示例代码：

@Aspect
public class TransactionAspect {
    @Autowired
    private PlatformTransactionManager transactionManager;

    @Before("execution(* com.example.service.*.*(..))")
    public void startTransaction(JoinPoint jp){
        TransactionDefinition definition = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(definition);
    }

    @AfterReturning("execution(* com.example.service.*.*(..))")
    public void commitTransaction(JoinPoint jp){
        transactionManager.commit(status);
    }

    @AfterThrowing("execution(* com.example.service.*.*(..))")
    public void rollbackTransaction(JoinPoint jp){
        transactionManager.rollback(status);
    }
}

5. 嵌套事务：Spring还支持嵌套事务，可以在一个方法中开启一个新的事务。使用嵌套事务时，内层事务被看作是外层事务的一部分，内层事务的回滚不会影响到外层事务。

示例代码：

@Transactional
public void parentMethod(){
    // do something
    childMethod();
    // do something
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void childMethod(){
    // do something
    // 发生异常时只回滚内层事务，外层事务不受影响
    // 使用NestedRuntimeException抛出异常，而不是RuntimeException
}

以上是在Spring中实现事务回滚的几种常用方法。根据具体的需求选择合适的方法来实现事务回滚。无论选择哪种方法，事务的回滚都会自动发生，无需手动处理。

Spring的事务管理机制可以帮助我们实现事务的回滚。在撰写文章之前，我们需要了解一些基础知识。Spring中的事务管理是通过代理机制实现的。Spring支持两种方式来实现事务管理：编程式事务管理和声明式事务管理。接下来，我会分别介绍这两种方式的实现方法。

一、编程式事务管理
编程式事务管理是通过在代码中显式地控制事务的起始、提交和回滚来实现的。Spring提供了TransactionTemplate类来简化编程式事务管理的操作流程。

1. 引入依赖
   首先，在pom.xml文件中引入spring-tx包的依赖，以使用TransactionTemplate类。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.3.4</version>
</dependency>

2. 配置事务管理器
   在Spring的配置文件中，配置数据库连接池和事务管理器。

<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="root"/>
    <property name="password" value=""/>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

3. 创建TransactionTemplate
   在代码中，创建TransactionTemplate对象，并通过该对象来执行事务的操作。

@Autowired
private PlatformTransactionManager transactionManager;

public void doTransaction() {
    TransactionTemplate template = new TransactionTemplate(transactionManager);
    template.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            // 事务操作
            // ...
            // 若出现异常，则手动回滚事务
            status.setRollbackOnly();
        }
    });
}

编程式事务管理的优点是灵活性较高，可以根据需要随时控制事务的状态。但是，由于需要手动控制事务，代码量较多且容易出错。

二、声明式事务管理
声明式事务管理是通过在配置文件或注解中定义事务的属性，从而实现对事务的管理。Spring提供了两种方式来实现声明式事务管理：基于XML的配置和基于注解的配置。

1. 基于XML的配置
   在Spring的配置文件中，通过tx命名空间和相应的标签来进行事务的配置。

<!-- 开启事务注解支持 -->
<tx:annotation-driven/>

<!-- 配置事务管理器 -->
<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="insert*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/>
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>

<!-- 配置事务切入点 -->
<aop:config>
    <aop:pointcut id="transactionPointcut" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>

事务配置的属性包括事务传播行为（propagation）、事务回滚规则（rollback-for）等。

2. 基于注解的配置
   在Spring的配置文件中，开启事务注解支持。

<!-- 开启事务注解支持 -->
<tx:annotation-driven/>

然后，在需要使用事务的方法上，使用@Transactional注解来配置事务的属性。

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public void doTransaction() {
    // 事务操作
    // ...
}

声明式事务管理的优点是使用简便，不需要手动控制事务，只需通过配置文件或注解来定义，可以减少代码的冗余。但是，它的灵活性相对较低，需要事先定义好事务的属性。

总结：Spring提供了编程式事务管理和声明式事务管理两种方式来实现事务的回滚。编程式事务管理需要手动控制事务的起始、提交和回滚，灵活性较高；而声明式事务管理通过配置文件或注解来定义事务的属性，使用方便，但灵活性较低。根据具体的需求，选择适合的方式来实现事务的回滚。