Spring 需要弹簧撑杆。。加入

我使用Spring，有两个方法使用声明性事务

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

在某些情况下，methodA调用methodB。。我需要知道的是，在声明式传输中，提交是否发生两次

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

范例

public void methodA() throws Exception {

            this.transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED)
                final Order order = this.transactionTemplate.execute(new TransactionCallback<Order>() {
                    @Override
                    public Order doInTransaction(TransactionStatus status) {
                            Order order = new Order();
                            String name = "Customer 2 " + (new Date()).toLocaleString();
                            order.setCustomer(name);                                                            
                            entityManager.persist(order);
                         ..........................
                           .......................
                         // call methodB
                        methodB();

 }

public void methodB() throws Exception {


this.transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
                    final Address add = this.transactionTemplate.execute(new TransactionCallback<Address >() {
                        @Override
                        public Order doInTransaction(TransactionStatus status) {
                                Address add= new Address ();
                                add.setAddress("address");                                                          
                                entityManager.persist(add);

                        ......................
                        .....................
    }

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

我将sychronizer添加到methodA中的事务中：

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

TransactionSynchronizationManager.registerSynchronization（新建TransactionSynchronization（））{

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

我得到的输出是在methodA完成后得到的：：

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

====> AFTER SUCCESSFUL COMMIT 2 TO DB...
====> AFTER SUCCESSFUL COMMIT 1 TO DB...

---

我猜这意味着两个Syncroniser被分配给trans..manager，当提交发生一次时，两个同步器都被调用。正确吗？

因为您使用的是

传播\u REQUIRED

不会有两个不同的事务，两个方法都将在同一事务中运行。如果您查看def需要启动

传播\u

它说

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

支持当前事务；如果不存在事务，则创建新事务

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }

---

因此，如果

methodB

成功完成，则不会提交事务，但如果失败，则会将事务标记为

仅回滚

。实际提交或回滚的责任将由创建事务的人员承担。在您的情况下，无论`methodB（）在

methodA（）的
doInTransaction（）{}
中调用；`

我相信当methodA中的事务完成..并准备好提交时，它将首先在methodB事务上调用commit，然后在methodA事务上调用commit…任何失败都将同时回滚…任何提交钩子也将按相反顺序调用..methodB钩子，然后是methodA钩子..我说得对吗？因为您正在使用

传播ION_REQUIRED

不会有两个不同的事务，两种方法都将在同一事务中运行。如果您查看

传播_REQUIRED

的定义，它会说

支持当前事务；如果不存在，则创建一个新事务。

是的，我同意，开始添加同步挂钩以检查行为…a您是对的。谢谢您的确认。这似乎不再是事实，请参阅：

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){

                    public void afterCommit() {
                        System.out.println("====> AFTER SUCCESSFUL COMMIT 2 TO DB..."); 


                    }