java - 在新的事务范围内更新对象

Question

我有一个与事务边界有关的问题，我无法弄清楚出了什么问题。

@Transactional( propagation = Propagation.REQUIRED )
Class A {
void methodA() {
     try {
     new B().callMethodB(obj)
     } catch(Exception e) {
           updateSomeProperty(obj1)
     }
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
void updateSomeProperty(Object obj1) {
     obj1.setProperty(1);
     obj1.save();       
}
        }

 Class B {

   public void callMethodB(Object obj) throws Exception {
    throws new Exception();  
 }

 }

问题是抛出错误时我的对象没有更新。我还尝试从该方法中触发 SQL 代码，updateSomeProperty但这也不起作用。

基本上我想更新对象的属性，不管是否抛出异常。
有任何想法吗？？

score 3 · Accepted Answer

它不应该工作。因为您从该类的另一个方法调用 updateSomeProperty(obj1) 并尝试更改默认事务行为（从 REQUIRED 到 REQUIRED_NEW）。但它不会起作用。这就是为什么发生异常时所有更改都将回滚的原因。

默认情况下，Spring 为接口创建代理，@Transactional 注释应该只用于公共方法。并且应该从“外部”调用此方法。如果您将从类中的另一个方法调用它们，则 @Transactional 注释将不起作用。

您还可以更改 xml 中事务的默认设置（查看属性 proxy-target-class 和 mode）。但我从未改变过这一点，也不记得它应该如何工作。

<tx:annotation-driven transaction-manager="txManager" mode="..." proxy-target-class="..."/>

编辑：

顺便一提。这是一篇关于交易陷阱的非常好的文章。它对我帮助很大。还有一些关于交易的其他非常有趣的文章。

编辑2：

再次问好。我认为我找到了解决您问题的方法。至少我对此进行了测试，它对我很有效。我建议您将事务模式更改为“AspectJ”，并为项目使用 AspectJ 编译时间。这将使您有可能从一个类中的另一个方法调用私有事务方法，并更改事务行为（对于已启动的嵌套事务）。在这种情况下，您可以在嵌套事务中提交一些更改，而外部事务将被回滚。为此，您需要执行以下步骤：

1）在事务定义中更改事务模式： - 如果您使用 xml 配置，则：

<tx:annotation-driven transaction-manager="txManager" mode="aspectj"/>

如果您使用 java 配置，那么：

@EnableTransactionManagement(mode=AdviceMode.ASPECTJ, proxyTargetClass=false)

2）在pom中添加aspectj依赖：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>${aspectj.version}</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>${aspectj.version}</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjtools</artifactId>
    <version>${aspectj.version}</version>
</dependency>

3）在pom中添加spring-aspects依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>3.1.2.RELEASE</version>
    <scope>compile</scope>
</dependency>

4) 添加 maven 插件，启用编译时 wieving：

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.4</version>
            <configuration>
                <showWeaveInfo>true</showWeaveInfo>
                <source>${compiler.version}</source>
                <target>${compiler.version}</target>
                <Xlint>ignore</Xlint>
                <complianceLevel>${compiler.version}</complianceLevel>
                <encoding>UTF-8</encoding>
                <verbose>false</verbose>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <!-- <goal>test-compile</goal> -->
                    </goals>
                </execution>
            </executions>
            <dependencies>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjrt</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjtools</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
            </dependencies>
        </plugin>

5）我的 pom 中还有 maven 编译器插件，这就是为什么我认为你最好也添加它：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <compilerVersion>${compiler.version}</compilerVersion>
        <fork>true</fork>
        <source>1.7</source>
        <target>1.7</target>
    </configuration>
</plugin>

*注意：我使用 jdk 1.7+ 版本。我的编译器和aspectj版本是sush：

<compiler.version>1.7</compiler.version>
<aspectj.version>1.6.12</aspectj.version>

我也有其他库的此类版本（但我认为这不是必需的）：

<org.springframework.version>3.1.0.RELEASE</org.springframework.version>
<org.hibernate.version>4.1.0.Final</org.hibernate.version>
<org.springdata.version>1.0.2.RELEASE</org.springdata.version>

您也可以尝试在 spring 中使用加载时间，但它更难配置（这是我的观点），不建议在生产中使用（正如我在几篇文章中读到的）。但是如果你决定使用它，你可以在 web 和 spring 参考文档中找到很多信息。

如果你想在没有 maven 的情况下使用编译时间，那么我不知道如何配置它。（我只用 Maven 测试过）。您可以尝试在 web 中查找此类信息，但我不建议这样做，因为使用 maven 处理依赖项要容易得多（并且在此示例的情况下 - 添加必要的插件）。

这是我用于测试的示例：

一些界面：

公共接口 TestClassInterface {
```
void testMethod();
```
}

一些实现此接口的测试类：

@Transactional(propagation = Propagation.REQUIRED, rollbackFor=Exception.class) @Component public class TestClass implements TestClassInterface {

@Autowired
private SpringDataFooDAO fooDao;

public void testMethod() {
    try {
        Foo foo = fooDao.findOne(2L);
        System.out.println(TransactionSynchronizationManager.getCurrentTransactionName());
        System.out.println(TransactionSynchronizationManager.isActualTransactionActive());
        foo.setName("should be rolled back");
        new ExceptionThrower().doSomething("default string");
    } catch(Exception e) {
        updateSomeProperty(1L, "Changed name");
        throw new RuntimeException(e);
    }
}

@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor=Exception.class)
private void updateSomeProperty(long id, String newFooName) {

    System.out.println("   ---   ");
    System.out.println(TransactionSynchronizationManager.getCurrentTransactionName());
    System.out.println(TransactionSynchronizationManager.isActualTransactionActive());

     // Update property of test object.
     Foo foo = fooDao.findOne(id);
     foo.setName(newFooName);    
}

}

另一个具有引发异常的方法的类：

公共类 ExceptionThrower {

public void doSomething(Object obj) throws Exception {
    throw new Exception();  
 }

}

请注意，我从 catch 块中重新抛出异常（我将其作为运行时异常执行，因为我不需要在上层类中处理它）。这是正确的外部事务回滚所必需的。

score 1 · Accepted Answer

查看spring 参考以了解如何使用 @Transactional。@Transactional 使用 spring 代理时有很多 ** 条件适用，您需要在将其应用到代码中之前了解它们。

在代理模式下（默认），只有通过代理传入的外部方法调用会被拦截。这意味着自调用，实际上是目标对象中的一个方法调用目标对象的另一个方法，在运行时不会导致实际事务，即使调用的方法被标记为@Transactional。

如果您希望自调用也与事务一起包装，请考虑使用 AspectJ 模式（请参见下表中的模式属性）。在这种情况下，首先不会有代理；相反，目标类将被编织（即，其字节码将被修改），以便将@Transactional 转换为任何类型的方法的运行时行为。

score 0 · Accepted Answer

您可以尝试指定 noRollbackFor = RuntimeException.class 或您想要的任何其他类，并希望它可以让您更新数据库。即@Transactional(noRollbackFor = RuntimeException.class)

score 0 · Accepted Answer

上述安排非常适合开始新事务并执行与原始事务不同的其他事情。

在我的情况下出错的一件事是，在另一个事务中，我自己抛出了一个异常，导致第二个事务再次回滚。

So The thing is beware off exception in the transaction because they ensure that the database state rolls back. It is for what they are meant for.

谢谢

score 0 · Accepted Answer

创建一个自定义异常并使用它来抛出，另外请在定义自定义异常时使用@ApplicationException(rollback=false) 作为类级别的注释。

例如

@ApplicationException(rollback=false)
public CustomException extends Exception{

java - 在新的事务范围内更新对象

5 回答 5

Related

Reference