Spring @Transaction方法通过同一个类内的方法调用，不起作用？

Question

我是 Spring 事务的新手。我觉得很奇怪，也许我确实正确理解了这一点。

我想在方法级别进行事务处理，并且我在同一个类中有一个调用者方法，但它似乎不喜欢那样，必须从单独的类中调用它。我不明白这怎么可能。

如果有人知道如何解决这个问题，我将不胜感激。我想使用同一个类来调用带注释的事务方法。

这是代码：

public class UserService {

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
            // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                    .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            addUser(user.getUserName, user.getPassword);
        }
    } 
}

Answer 1

这是 Spring AOP 的限制（动态对象和 cglib）。

如果您将 Spring 配置为使用 AspectJ 来处理事务，您的代码将正常工作。

简单且可能是最好的替代方法是重构代码。例如，一个处理用户的类和一个处理每个用户的类。然后 Spring AOP 的默认事务处理将起作用。

---

使用 AspectJ 处理事务的配置提示

要使 Spring 能够使用 AspectJ 进行事务，您必须将模式设置为 AspectJ：

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

如果您使用的 Spring 版本低于 3.0，则还必须将其添加到 Spring 配置中：

<bean class="org.springframework.transaction.aspectj
        .AnnotationTransactionAspect" factory-method="aspectOf">
    <property name="transactionManager" ref="transactionManager" />
</bean>

Answer 2

在 Java 8+ 中存在一种可能性，我更喜欢这种可能性，原因如下：

@Service
public class UserService {

    @Autowired
    private TransactionHandler transactionHandler;

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            transactionHandler.runInTransaction(() -> addUser(user.getUsername, user.getPassword));
        }
    }

    private boolean addUser(String username, String password) {
        // TODO call userRepository
    }
}

@Service
public class TransactionHandler {

    @Transactional(propagation = Propagation.REQUIRED)
    public <T> T runInTransaction(Supplier<T> supplier) {
        return supplier.get();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public <T> T runInNewTransaction(Supplier<T> supplier) {
        return supplier.get();
    }
}

这种方法具有以下优点：

1. 它可以应用于私有方法。因此，您不必仅仅为了满足 Spring 限制而通过将方法公开来破坏封装。

2. 可以在不同的事务传播中调用相同的方法，由调用者选择合适的方法。比较这两行：

    transactionHandler.runInTransaction(() -> userService.addUser(user.getUserName, user.getPassword));
   
    transactionHandler.runInNewTransaction(() -> userService.addUser(user.getUserName, user.getPassword));
   

3. 它是明确的，因此更具可读性。

Answer 3

这里的问题是，Spring 的 AOP 代理不会扩展，而是包装您的服务实例来拦截调用。这样做的效果是，从服务实例内对“this”的任何调用都会直接在该实例上调用，并且不能被包装代理拦截（代理甚至不知道任何此类调用）。已经提到了一种解决方案。另一个巧妙的方法是简单地让 Spring 将服务的实例注入到服务本身中，并在注入的实例上调用您的方法，该实例将成为处理事务的代理。但请注意，如果您的服务 bean 不是单例，这也可能会产生不好的副作用：

<bean id="userService" class="your.package.UserService">
  <property name="self" ref="userService" />
    ...
</bean>

public class UserService {
    private UserService self;

    public void setSelf(UserService self) {
        this.self = self;
    }

    @Transactional
    public boolean addUser(String userName, String password) {
        try {
        // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                .setRollbackOnly();

        }
    }

    public boolean addUsers(List<User> users) {
        for (User user : users) {
            self.addUser(user.getUserName, user.getPassword);
        }
    } 
}

Answer 4

使用 Spring 4 可以自行自动装配

@Service
@Transactional
public class UserServiceImpl implements UserService{
    @Autowired
    private  UserRepository repository;

    @Autowired
    private UserService userService;

    @Override
    public void update(int id){
       repository.findOne(id).setName("ddd");
    }

    @Override
    public void save(Users user) {
        repository.save(user);
        userService.update(1);
    }
}

Answer 5

这是我的自调用解决方案：

public class SBMWSBL {
    private SBMWSBL self;

    @Autowired
    private ApplicationContext applicationContext;

    @PostConstruct
    public void postContruct(){
        self = applicationContext.getBean(SBMWSBL.class);
    }

    // ...
}

Answer 6

您可以在同一个类中自动装配 BeanFactory 并执行

getBean(YourClazz.class)

它会自动代理您的类并考虑您的 @Transactional 或其他 aop 注释。

Answer 7

以下是我对同一类中仅少量使用方法调用的小型项目所做的操作。强烈建议使用代码内文档，因为这对同事来说可能看起来很奇怪。但是它可以与单例一起使用，易于测试、简单、快速实现，并且使我无需使用完整的 AspectJ 工具。然而，对于更频繁的使用，我建议使用 AspectJ 解决方案，如 Espens 答案中所述。

@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
class PersonDao {

    private final PersonDao _personDao;

    @Autowired
    public PersonDao(PersonDao personDao) {
        _personDao = personDao;
    }

    @Transactional
    public void addUser(String username, String password) {
        // call database layer
    }

    public void addUsers(List<User> users) {
        for (User user : users) {
            _personDao.addUser(user.getUserName, user.getPassword);
        }
    }
}

Answer 8

使用 Spring 2.5.15 进行测试，您使用 @Resource 进行自调用。请参阅下面的测试类示例

@Service
@RequiredArgsConstructor
public class Example {
   private final EntityManager entityManager;
   
   @Resource
   private Example self;


   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void testSelf(){
      self.transaction();
   }


   @Transactional(propagation = Propagation.SUPPORTS)
   public void transaction(){
       entityManager.persist(new MyEntity(28L));
   }

：

@SpringBootTest
class ExampleTest {
    @Autowired
    private Example example;
    @Autowired
    private EntityManager entityManager;

    @Test
    void testSelf(){
        transactionHandler.testSelf();
        assertNotNull(entityManager.find(Estado.class, 28L));
    }
}

Answer 9

该问题与 spring 如何加载类和代理有关。除非您在另一个类中编写内部方法/事务，或者转到其他类，然后再次来到您的类，然后编写内部嵌套事务方法，否则它将不起作用。

总而言之，Spring 代理不允许您面临的场景。你必须在其他类中编写第二个事务方法

Answer 10

只需在服务顶部添加以下注释

@Scope(proxyMode = TARGET_CLASS)

Answer 11

使用 AspectJ 或其他方式是没有意义的。只需使用 AOP 就足够了。因此，我们可以在 addUsers(Listusers) 中添加 @Transactional 来解决当前问题。

public class UserService {
    
    private boolean addUser(String userName, String password) {
        try {
            // call DAO layer and adds to database.
        } catch (Throwable e) {
            TransactionAspectSupport.currentTransactionStatus()
                    .setRollbackOnly();

        }
    }

    @Transactional
    public boolean addUsers(List<User> users) {
        for (User user : users) {
            addUser(user.getUserName, user.getPassword);
        }
    } 
}