如果B出错，请回滚A。Spring Boot，jdbctemplate

Question

我有一个方法，数据库变化，它以迭代的方式调用2个操作：A，B。第一个，最后一个。'A'

让我们说，

'a'更新表用户属性zip中的记录，其中id=1。

“B”在表中插入记录。

场景：数据库更改方法被调用，'A'操作并更新记录。'B'操作并尝试插入一条记录，发生了一些事情，抛出了一个异常，异常正在冒泡到数据库更改方法。

预期：“A”和“B”没有改变任何东西。“A”执行的更新将被回滚。”B'没有改变什么，嗯。。。有一个例外。

实际：“更新似乎未回滚。”B'没有改变什么，嗯。。。有一个例外。

一些代码

如果我有连接，我会做如下事情：

private void databaseChanges(Connection conn) {
   try {
          conn.setAutoCommit(false);
          A(); //update.
          B(); //insert
          conn.commit();
   } catch (Exception e) { 
        try {
              conn.rollback();
        } catch (Exception ei) {
                    //logs...
        }
   } finally {
          conn.setAutoCommit(true);
   }
}

问题：我没有连接（请参阅随问题发布的标签）

我试图：

@Service
public class SomeService implements ISomeService {
    @Autowired
    private NamedParameterJdbcTemplate jdbcTemplate;
    @Autowired
    private NamedParameterJdbcTemplate npjt;

    @Transactional
    private void databaseChanges() throws Exception {   
        A(); //update.
        B(); //insert
    }
}

我的AppConfig类：

import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

@Configuration
public class AppConfig {    
    @Autowired
    private DataSource dataSource;

    @Bean
    public NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
        return new NamedParameterJdbcTemplate(dataSource);
    }   
}

'A'进行更新.从'B'抛出异常。A所做的更新没有被回滚。

从我阅读的内容中，我了解到我没有正确使用@Transactional。我阅读并尝试了几篇博客文章和stackverflow Q

有什么建议吗？

编辑

有一个方法调用databaseChanges（）方法

public void changes() throws Exception {
    someLogicBefore();
    databaseChanges();
    someLogicAfter();
}

哪个方法应该用@Transactional注释，

变化（）？数据库更改

Answer 1

您呈现的第一个代码是用于UserTransaction的，即应用程序必须执行事务管理。通常，您希望容器处理这些问题，并使用@Transactional注释。我认为在你的情况下，问题可能是，你有一个私有方法的注释。我会把注释移到班级级别

@Transactional
public class MyFacade {

public void databaseChanges() throws Exception {   
    A(); //update.
    B(); //insert
}

然后它应该正确地回滚。您可以在这里找到更多详细信息Spring@Transactional属性是否在私有方法上工作？

Answer 2

任何RuntimeException都会触发回滚，而任何选中的异常都不会触发回滚。

这是所有Spring事务API的常见行为。默认情况下，如果从事务代码中抛出运行时异常，则事务将回滚。如果抛出选中的异常（即不是运行时异常），则事务将不会回滚。

这取决于您在数据库更改函数中获得的异常。因此，为了捕获所有异常，您需要做的就是添加rollback For=Exception.class

应该对服务类进行更改，代码如下：

@Service
public class SomeService implements ISomeService {
    @Autowired
    private NamedParameterJdbcTemplate jdbcTemplate;
    @Autowired
    private NamedParameterJdbcTemplate npjt;

    @Transactional(rollbackFor = Exception.class)
    private void databaseChanges() throws Exception {   
        A(); //update
        B(); //insert
    }
}

此外，你可以用它做一些好事，所以不是所有的时间，你将不得不写rollback For=Exception.class。您可以通过编写自己的自定义注释来实现这一点：

@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional(rollbackFor = Exception.class)
@Documented
public @interface CustomTransactional {  
}

最终代码如下所示：

@Service
public class SomeService implements ISomeService {
    @Autowired
    private NamedParameterJdbcTemplate jdbcTemplate;
    @Autowired
    private NamedParameterJdbcTemplate npjt;

    @CustomTransactional
    private void databaseChanges() throws Exception {   
        A(); //update
        B(); //insert
    }
}

Answer 3

spring中的@Transactional注释通过将对象包装在代理中来工作，代理又将使用@Transactional注释的方法包装在事务中。因为这个注释在私有方法上不起作用（如您的示例中），因为私有方法不能被继承=

下面是关于@Transactionalspring magic如何工作的基本解释。

你写道：

class A {
    @Transactional
    public void method() {
    }
}

但这是你注射豆子时实际得到的：

class ProxiedA extends A {
   private final A a;

   public ProxiedA(A a) {
       this.a = a;
   }

   @Override
   public void method() {
       try {
           // open transaction ...
           a.method();
           // commit transaction
       } catch (RuntimeException e) {
           // rollback transaction
       } catch (Exception e) {
           // commit transaction
       }
   }
} 

这有局限性。它们不使用@PostConstruct方法，因为它们是在代理对象之前调用的。即使您正确配置了所有事务，默认情况下，事务也只在未检查的异常上回滚。如果您需要回滚某些已检查的异常，请使用@Transactional（rollboor={CustomCheckedException.class}）。

我知道另一个经常遇到的警告：

@Transactional方法只有在您将其称为“从外部”时才有效，在下面的示例中，b（）将不会包装在事务中：

class X {
   public void a() {
      b();
   }

   @Transactional
   public void b() {
   }
}

这也是因为@Transactional通过代理对象来工作。在上面的示例中，a（）将调用X. b（）而不是增强的Spring代理方法b（），因此不会有事务。作为一种解决方案，你必须从另一个bean调用b（）。

当您遇到这些警告中的任何一个并且不能使用建议的解决方案（使方法非私有或从另一个bean调用b（））时，您可以使用TransactionTem板而不是声明性事务：

public class A {
    @Autowired
    TransactionTemplate transactionTemplate;

    public void method() {
        transactionTemplate.execute(status -> {
            A();
            B();
            return null;
        });
    }

...
} 

使现代化

使用上述信息回答OP更新的问题。

哪个方法应该被注释为@Transactional：更改（）？数据库更改

@Transactional(rollbackFor={Exception.class})
public void changes() throws Exception {
    someLogicBefore();
    databaseChanges();
    someLogicAfter();
}

确保changes（）是从bean的“外部”调用的，而不是从类本身以及在实例化上下文之后调用的（例如，这不是afterPropertieSet（）或@PostConstruct带注释的方法）。了解spring在默认情况下仅对未检查的异常回滚事务（请尝试在rollbackFor checked exceptions列表中更加具体）。