org.springframework.transaction.support.DefaultTransactionDefinition

@Test
public void propagationMandatoryFailsInCaseOfNoExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_MANDATORY);
    try {
        ptm.execute(definition, new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                return "result";
            }
        });
        fail("Should have thrown IllegalTransactionStateException");
    } catch (IllegalTransactionStateException ex) {
    // expected
    }
}

// end::repository_built_in[]
@Test
public void transactionalOperatorTest() {
    // tag::repository_transactional_operator[]
    DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
    transactionDefinition.setReadOnly(false);
    TransactionalOperator operator = TransactionalOperator.create(this.txManager, transactionDefinition);
    // end::repository_transactional_operator[]
    // tag::repository_operations_in_a_transaction[]
    User alice = new User("Alice", 29);
    User bob = new User("Bob", 60);
    this.userRepository.save(alice).then(this.userRepository.save(bob)).as(operator::transactional).block();
    this.userRepository.findAll().flatMap(a -> {
        a.setAge(a.getAge() - 1);
        return this.userRepository.save(a);
    }).as(operator::transactional).collectList().block();
    replacedertThat(this.userRepository.findAll().map(User::getAge).collectList().block()).containsExactlyInAnyOrder(28, 59);
// end::repository_operations_in_a_transaction[]
}

@Test
public void transactionTest() {
    User alice = new User("Alice", 29);
    User bob = new User("Bob", 60);
    User user = new User(null, 40);
    DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
    transactionDefinition.setReadOnly(false);
    TransactionalOperator operator = TransactionalOperator.create(this.txManager, transactionDefinition);
    reset(this.txManager);
    this.firestoreTemplate.save(alice).then(this.firestoreTemplate.save(bob)).then(this.firestoreTemplate.save(user)).as(operator::transactional).block();
    replacedertThat(this.firestoreTemplate.findAll(User.clreplaced).collectList().block()).containsExactlyInAnyOrder(bob, alice, user);
    verify(this.txManager, times(1)).commit(any());
    verify(this.txManager, times(0)).rollback(any());
    verify(this.txManager, times(1)).getReactiveTransaction(any());
    reset(this.txManager);
    // test rollback
    this.firestoreTemplate.saveAll(Mono.defer(() -> {
        throw new FirestoreDataException("BOOM!");
    })).then(this.firestoreTemplate.deleteAll(User.clreplaced)).as(operator::transactional).onErrorResume(throwable -> Mono.empty()).block();
    verify(this.txManager, times(0)).commit(any());
    verify(this.txManager, times(1)).rollback(any());
    verify(this.txManager, times(1)).getReactiveTransaction(any());
    replacedertThat(this.firestoreTemplate.count(User.clreplaced).block()).isEqualTo(3);
    this.firestoreTemplate.findAll(User.clreplaced).flatMap(a -> {
        a.setAge(a.getAge() - 1);
        return this.firestoreTemplate.save(a);
    }).as(operator::transactional).collectList().block();
    List<User> users = this.firestoreTemplate.findAll(User.clreplaced).collectList().block();
    replacedertThat(users).extracting("age").containsExactlyInAnyOrder(28, 59, 39);
    replacedertThat(users).extracting("name").doesNotContainNull();
    this.firestoreTemplate.deleteAll(User.clreplaced).as(operator::transactional).block();
    replacedertThat(this.firestoreTemplate.findAll(User.clreplaced).collectList().block()).isEmpty();
}

public void setDtf(DefaultTransactionDefinition dtf) {
    this.dtf = dtf;
}

private void doTestNewTransactionWithCommit(int propagationBehavior, final int synchMode) {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    ptm.setTransactionSynchronization(synchMode);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(propagationBehavior);
    definition.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            if (synchMode != WebSphereUowTransactionManager.SYNCHRONIZATION_NEVER) {
                replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            } else {
                replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            }
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void propagationNeverFailsInCaseOfExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
    try {
        ptm.execute(definition, new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                return "result";
            }
        });
        fail("Should have thrown IllegalTransactionStateException");
    } catch (IllegalTransactionStateException ex) {
    // expected
    }
}

private void doTestExistingTransactionWithParticipation(int propagationBehavior) {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(propagationBehavior);
    definition2.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            replacedertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status) {
                    replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                    replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                    return "result2";
                }
            }));
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertTrue(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void newTransactionWithRollback() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    try {
        ptm.execute(definition, new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                throw new OptimisticLockingFailureException("");
            }
        });
        fail("Should have thrown OptimisticLockingFailureException");
    } catch (OptimisticLockingFailureException ex) {
    // expected
    }
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertTrue(manager.getRollbackOnly());
}

@Test
public void newTransactionWithCommitException() {
    final RollbackException rex = new RollbackException();
    MockUOWManager manager = new MockUOWManager() {

        @Override
        public void runUnderUOW(int type, boolean join, UOWAction action) throws UOWException {
            throw new UOWException(rex);
        }
    };
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    try {
        ptm.execute(definition, new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                return "result";
            }
        });
        fail("Should have thrown TransactionSystemException");
    } catch (TransactionSystemException ex) {
        // expected
        replacedertTrue(ex.getCause() instanceof UOWException);
        replacedertSame(rex, ex.getRootCause());
        replacedertSame(rex, ex.getMostSpecificCause());
    }
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
}

@Test
public void newTransactionWithRollbackOnly() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            status.setRollbackOnly();
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertTrue(manager.getRollbackOnly());
}

private void doTestNewTransactionSynchronization(int propagationBehavior, final int synchMode) {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    ptm.setTransactionSynchronization(synchMode);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(propagationBehavior);
    definition.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            if (synchMode == WebSphereUowTransactionManager.SYNCHRONIZATION_ALWAYS) {
                replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            } else {
                replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
                replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            }
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void newTransactionWithCommitAndTimeout() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setTimeout(10);
    definition.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(10, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

/**
 * Base clreplaced for listener container implementations which are based on polling.
 * Provides support for listener handling based on {@link javax.jms.MessageConsumer},
 * optionally participating in externally managed transactions.
 *
 * <p>This listener container variant is built for repeated polling attempts,
 * each invoking the {@link #receiveAndExecute} method. The MessageConsumer used
 * may be reobtained fo reach attempt or cached in between attempts; this is up
 * to the concrete implementation. The receive timeout for each attempt can be
 * configured through the {@link #setReceiveTimeout "receiveTimeout"} property.
 *
 * <p>The underlying mechanism is based on standard JMS MessageConsumer handling,
 * which is perfectly compatible with both native JMS and JMS in a Java EE environment.
 * Neither the JMS {@code MessageConsumer.setMessageListener} facility  nor the JMS
 * ServerSessionPool facility is required. A further advantage of this approach is
 * full control over the listening process, allowing for custom scaling and throttling
 * and of concurrent message processing (which is up to concrete subclreplacedes).
 *
 * <p>Message reception and listener execution can automatically be wrapped
 * in transactions through preplaceding a Spring
 * {@link org.springframework.transaction.PlatformTransactionManager} into the
 * {@link #setTransactionManager "transactionManager"} property. This will usually
 * be a {@link org.springframework.transaction.jta.JtaTransactionManager} in a
 * Java EE environment, in combination with a JTA-aware JMS ConnectionFactory
 * obtained from JNDI (check your application server's doreplacedentation).
 *
 * <p>This base clreplaced does not replacedume any specific mechanism for asynchronous
 * execution of polling invokers. Check out {@link DefaultMessageListenerContainer}
 * for a concrete implementation which is based on Spring's
 * {@link org.springframework.core.task.TaskExecutor} abstraction,
 * including dynamic scaling of concurrent consumers and automatic self recovery.
 *
 * @author Juergen Hoeller
 * @since 2.0.3
 * @see #createListenerConsumer
 * @see #receiveAndExecute
 * @see #setTransactionManager
 */
public abstract clreplaced AbstractPollingMessageListenerContainer extends AbstractMessageListenerContainer {

    /**
     * The default receive timeout: 1000 ms = 1 second.
     */
    public static final long DEFAULT_RECEIVE_TIMEOUT = 1000;

    private final MessageListenerContainerResourceFactory transactionalResourceFactory = new MessageListenerContainerResourceFactory();

    private boolean sessionTransactedCalled = false;

    @Nullable
    private PlatformTransactionManager transactionManager;

    private DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();

    private long receiveTimeout = DEFAULT_RECEIVE_TIMEOUT;

    @Override
    public void setSessionTransacted(boolean sessionTransacted) {
        super.setSessionTransacted(sessionTransacted);
        this.sessionTransactedCalled = true;
    }

    /**
     * Specify the Spring {@link org.springframework.transaction.PlatformTransactionManager}
     * to use for transactional wrapping of message reception plus listener execution.
     * <p>Default is none, not performing any transactional wrapping.
     * If specified, this will usually be a Spring
     * {@link org.springframework.transaction.jta.JtaTransactionManager} or one
     * of its subclreplacedes, in combination with a JTA-aware ConnectionFactory that
     * this message listener container obtains its Connections from.
     * <p><b>Note: Consider the use of local JMS transactions instead.</b>
     * Simply switch the {@link #setSessionTransacted "sessionTransacted"} flag
     * to "true" in order to use a locally transacted JMS Session for the entire
     * receive processing, including any Session operations performed by a
     * {@link SessionAwareMessageListener} (e.g. sending a response message). This
     * allows for fully synchronized Spring transactions based on local JMS
     * transactions, similar to what
     * {@link org.springframework.jms.connection.JmsTransactionManager} provides. Check
     * {@link AbstractMessageListenerContainer}'s javadoc for
     * a discussion of transaction choices and message redelivery scenarios.
     * @see #setSessionTransacted(boolean)
     * @see org.springframework.transaction.jta.JtaTransactionManager
     * @see org.springframework.jms.connection.JmsTransactionManager
     */
    public void setTransactionManager(@Nullable PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * Return the Spring PlatformTransactionManager to use for transactional
     * wrapping of message reception plus listener execution.
     */
    @Nullable
    protected final PlatformTransactionManager getTransactionManager() {
        return this.transactionManager;
    }

    /**
     * Specify the transaction name to use for transactional wrapping.
     * Default is the bean name of this listener container, if any.
     * @see org.springframework.transaction.TransactionDefinition#getName()
     */
    public void setTransactionName(String transactionName) {
        this.transactionDefinition.setName(transactionName);
    }

    /**
     * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>.
     * Default is none, using the transaction manager's default timeout.
     * @see org.springframework.transaction.TransactionDefinition#getTimeout()
     * @see #setReceiveTimeout
     */
    public void setTransactionTimeout(int transactionTimeout) {
        this.transactionDefinition.setTimeout(transactionTimeout);
    }

    /**
     * Set the timeout to use for receive calls, in <b>milliseconds</b>.
     * The default is 1000 ms, that is, 1 second.
     * <p><b>NOTE:</b> This value needs to be smaller than the transaction
     * timeout used by the transaction manager (in the appropriate unit,
     * of course). 0 indicates no timeout at all; however, this is only
     * feasible if not running within a transaction manager and generally
     * discouraged since such a listener container cannot cleanly shut down.
     * A negative value such as -1 indicates a no-wait receive operation.
     * @see #receiveFromConsumer(MessageConsumer, long)
     * @see javax.jms.MessageConsumer#receive(long)
     * @see javax.jms.MessageConsumer#receiveNoWait()
     * @see javax.jms.MessageConsumer#receive()
     * @see #setTransactionTimeout
     */
    public void setReceiveTimeout(long receiveTimeout) {
        this.receiveTimeout = receiveTimeout;
    }

    /**
     * Return the receive timeout (ms) configured for this listener container.
     * @since 4.2
     */
    protected long getReceiveTimeout() {
        return this.receiveTimeout;
    }

    @Override
    public void initialize() {
        // Set sessionTransacted=true in case of a non-JTA transaction manager.
        if (!this.sessionTransactedCalled && this.transactionManager instanceof ResourceTransactionManager && !TransactionSynchronizationUtils.sameResourceFactory((ResourceTransactionManager) this.transactionManager, obtainConnectionFactory())) {
            super.setSessionTransacted(true);
        }
        // Use bean name as default transaction name.
        if (this.transactionDefinition.getName() == null) {
            String beanName = getBeanName();
            if (beanName != null) {
                this.transactionDefinition.setName(beanName);
            }
        }
        // Proceed with superclreplaced initialization.
        super.initialize();
    }

    /**
     * Create a MessageConsumer for the given JMS Session,
     * registering a MessageListener for the specified listener.
     * @param session the JMS Session to work on
     * @return the MessageConsumer
     * @throws javax.jms.JMSException if thrown by JMS methods
     * @see #receiveAndExecute
     */
    protected MessageConsumer createListenerConsumer(Session session) throws JMSException {
        Destination destination = getDestination();
        if (destination == null) {
            String destinationName = getDestinationName();
            replacedert.state(destinationName != null, "No destination set");
            destination = resolveDestinationName(session, destinationName);
        }
        return createConsumer(session, destination);
    }

    /**
     * Execute the listener for a message received from the given consumer,
     * wrapping the entire operation in an external transaction if demanded.
     * @param session the JMS Session to work on
     * @param consumer the MessageConsumer to work on
     * @return whether a message has been received
     * @throws JMSException if thrown by JMS methods
     * @see #doReceiveAndExecute
     */
    protected boolean receiveAndExecute(Object invoker, @Nullable Session session, @Nullable MessageConsumer consumer) throws JMSException {
        if (this.transactionManager != null) {
            // Execute receive within transaction.
            TransactionStatus status = this.transactionManager.getTransaction(this.transactionDefinition);
            boolean messageReceived;
            try {
                messageReceived = doReceiveAndExecute(invoker, session, consumer, status);
            } catch (JMSException | RuntimeException | Error ex) {
                rollbackOnException(this.transactionManager, status, ex);
                throw ex;
            }
            this.transactionManager.commit(status);
            return messageReceived;
        } else {
            // Execute receive outside of transaction.
            return doReceiveAndExecute(invoker, session, consumer, null);
        }
    }

    /**
     * Actually execute the listener for a message received from the given consumer,
     * fetching all requires resources and invoking the listener.
     * @param session the JMS Session to work on
     * @param consumer the MessageConsumer to work on
     * @param status the TransactionStatus (may be {@code null})
     * @return whether a message has been received
     * @throws JMSException if thrown by JMS methods
     * @see #doExecuteListener(javax.jms.Session, javax.jms.Message)
     */
    protected boolean doReceiveAndExecute(Object invoker, @Nullable Session session, @Nullable MessageConsumer consumer, @Nullable TransactionStatus status) throws JMSException {
        Connection conToClose = null;
        Session sessionToClose = null;
        MessageConsumer consumerToClose = null;
        try {
            Session sessionToUse = session;
            boolean transactional = false;
            if (sessionToUse == null) {
                sessionToUse = ConnectionFactoryUtils.doGetTransactionalSession(obtainConnectionFactory(), this.transactionalResourceFactory, true);
                transactional = (sessionToUse != null);
            }
            if (sessionToUse == null) {
                Connection conToUse;
                if (sharedConnectionEnabled()) {
                    conToUse = getSharedConnection();
                } else {
                    conToUse = createConnection();
                    conToClose = conToUse;
                    conToUse.start();
                }
                sessionToUse = createSession(conToUse);
                sessionToClose = sessionToUse;
            }
            MessageConsumer consumerToUse = consumer;
            if (consumerToUse == null) {
                consumerToUse = createListenerConsumer(sessionToUse);
                consumerToClose = consumerToUse;
            }
            Message message = receiveMessage(consumerToUse);
            if (message != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Received message of type [" + message.getClreplaced() + "] from consumer [" + consumerToUse + "] of " + (transactional ? "transactional " : "") + "session [" + sessionToUse + "]");
                }
                messageReceived(invoker, sessionToUse);
                boolean exposeResource = (!transactional && isExposeListenerSession() && !TransactionSynchronizationManager.hasResource(obtainConnectionFactory()));
                if (exposeResource) {
                    TransactionSynchronizationManager.bindResource(obtainConnectionFactory(), new LocallyExposedJmsResourceHolder(sessionToUse));
                }
                try {
                    doExecuteListener(sessionToUse, message);
                } catch (Throwable ex) {
                    if (status != null) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Rolling back transaction because of listener exception thrown: " + ex);
                        }
                        status.setRollbackOnly();
                    }
                    handleListenerException(ex);
                    // Rethrow JMSException to indicate an infrastructure problem
                    // that may have to trigger recovery...
                    if (ex instanceof JMSException) {
                        throw (JMSException) ex;
                    }
                } finally {
                    if (exposeResource) {
                        TransactionSynchronizationManager.unbindResource(obtainConnectionFactory());
                    }
                }
                // Indicate that a message has been received.
                return true;
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Consumer [" + consumerToUse + "] of " + (transactional ? "transactional " : "") + "session [" + sessionToUse + "] did not receive a message");
                }
                noMessageReceived(invoker, sessionToUse);
                // Nevertheless call commit, in order to reset the transaction timeout (if any).
                if (shouldCommitAfterNoMessageReceived(sessionToUse)) {
                    commitIfNecessary(sessionToUse, null);
                }
                // Indicate that no message has been received.
                return false;
            }
        } finally {
            JmsUtils.closeMessageConsumer(consumerToClose);
            JmsUtils.closeSession(sessionToClose);
            ConnectionFactoryUtils.releaseConnection(conToClose, getConnectionFactory(), true);
        }
    }

    /**
     * This implementation checks whether the Session is externally synchronized.
     * In this case, the Session is not locally transacted, despite the listener
     * container's "sessionTransacted" flag being set to "true".
     * @see org.springframework.jms.connection.JmsResourceHolder
     */
    @Override
    protected boolean isSessionLocallyTransacted(Session session) {
        if (!super.isSessionLocallyTransacted(session)) {
            return false;
        }
        JmsResourceHolder resourceHolder = (JmsResourceHolder) TransactionSynchronizationManager.getResource(obtainConnectionFactory());
        return (resourceHolder == null || resourceHolder instanceof LocallyExposedJmsResourceHolder || !resourceHolder.containsSession(session));
    }

    /**
     * Determine whether to trigger a commit after no message has been received.
     * This is a good idea on any modern-day JMS provider.
     * @param session the current JMS Session which received no message
     * @return whether to call {@link #commitIfNecessary} on the given Session
     */
    protected boolean shouldCommitAfterNoMessageReceived(Session session) {
        return true;
    }

    /**
     * Perform a rollback, handling rollback exceptions properly.
     * @param status object representing the transaction
     * @param ex the thrown listener exception or error
     */
    private void rollbackOnException(PlatformTransactionManager manager, TransactionStatus status, Throwable ex) {
        logger.debug("Initiating transaction rollback on listener exception", ex);
        try {
            manager.rollback(status);
        } catch (RuntimeException ex2) {
            logger.error("Listener exception overridden by rollback exception", ex);
            throw ex2;
        } catch (Error err) {
            logger.error("Listener exception overridden by rollback error", ex);
            throw err;
        }
    }

    /**
     * Receive a message from the given consumer.
     * @param consumer the MessageConsumer to use
     * @return the Message, or {@code null} if none
     * @throws JMSException if thrown by JMS methods
     */
    @Nullable
    protected Message receiveMessage(MessageConsumer consumer) throws JMSException {
        return receiveFromConsumer(consumer, getReceiveTimeout());
    }

    /**
     * Template method that gets called right when a new message has been received,
     * before attempting to process it. Allows subclreplacedes to react to the event
     * of an actual incoming message, for example adapting their consumer count.
     * @param invoker the invoker object (preplaceded through)
     * @param session the receiving JMS Session
     */
    protected void messageReceived(Object invoker, Session session) {
    }

    /**
     * Template method that gets called when <i>no</i> message has been received,
     * before returning to the receive loop again. Allows subclreplacedes to react to
     * the event of no incoming message, for example marking the invoker as idle.
     * @param invoker the invoker object (preplaceded through)
     * @param session the receiving JMS Session
     */
    protected void noMessageReceived(Object invoker, Session session) {
    }

    /**
     * Fetch an appropriate Connection from the given JmsResourceHolder.
     * <p>This implementation accepts any JMS 1.1 Connection.
     * @param holder the JmsResourceHolder
     * @return an appropriate Connection fetched from the holder,
     * or {@code null} if none found
     */
    @Nullable
    protected Connection getConnection(JmsResourceHolder holder) {
        return holder.getConnection();
    }

    /**
     * Fetch an appropriate Session from the given JmsResourceHolder.
     * <p>This implementation accepts any JMS 1.1 Session.
     * @param holder the JmsResourceHolder
     * @return an appropriate Session fetched from the holder,
     * or {@code null} if none found
     */
    @Nullable
    protected Session getSession(JmsResourceHolder holder) {
        return holder.getSession();
    }

    /**
     * ResourceFactory implementation that delegates to this listener container's protected callback methods.
     */
    private clreplaced MessageListenerContainerResourceFactory implements ConnectionFactoryUtils.ResourceFactory {

        @Override
        @Nullable
        public Connection getConnection(JmsResourceHolder holder) {
            return AbstractPollingMessageListenerContainer.this.getConnection(holder);
        }

        @Override
        @Nullable
        public Session getSession(JmsResourceHolder holder) {
            return AbstractPollingMessageListenerContainer.this.getSession(holder);
        }

        @Override
        public Connection createConnection() throws JMSException {
            if (AbstractPollingMessageListenerContainer.this.sharedConnectionEnabled()) {
                Connection sharedCon = AbstractPollingMessageListenerContainer.this.getSharedConnection();
                return new SingleConnectionFactory(sharedCon).createConnection();
            } else {
                return AbstractPollingMessageListenerContainer.this.createConnection();
            }
        }

        @Override
        public Session createSession(Connection con) throws JMSException {
            return AbstractPollingMessageListenerContainer.this.createSession(con);
        }

        @Override
        public boolean isSynchedLocalTransactionAllowed() {
            return AbstractPollingMessageListenerContainer.this.isSessionTransacted();
        }
    }
}

/**
 * 开启新的只读事务
 */
public static TransactionStatus beginNewReadTransaction() {
    DefaultTransactionDefinition td = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    td.setReadOnly(true);
    TransactionStatus status = getTransactionManager().getTransaction(td);
    return status;
}

/**
 * 若没有事务则开启事务，有则使用当前事务。
 */
public static TransactionStatus beginTransaction() {
    DefaultTransactionDefinition td = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED);
    TransactionStatus status = getTransactionManager().getTransaction(td);
    return status;
}

/**
 * 开启新事务
 */
public static TransactionStatus beginNewTransaction() {
    DefaultTransactionDefinition td = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    TransactionStatus status = getTransactionManager().getTransaction(td);
    return status;
}

private void doTestNewTransactionWithCommit(int propagationBehavior, final int synchMode) {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    ptm.setTransactionSynchronization(synchMode);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(propagationBehavior);
    definition.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            if (synchMode != WebSphereUowTransactionManager.SYNCHRONIZATION_NEVER) {
                replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
                replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
                replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
            } else {
                replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
                replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
                replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            }
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

private void doTestNewTransactionSynchronization(int propagationBehavior, final int synchMode) {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    ptm.setTransactionSynchronization(synchMode);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(propagationBehavior);
    definition.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            if (synchMode == WebSphereUowTransactionManager.SYNCHRONIZATION_ALWAYS) {
                replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
                replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
                replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
            } else {
                replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
                replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
                replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            }
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

private void doTestExistingTransactionWithParticipation(int propagationBehavior) {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(propagationBehavior);
    definition2.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            replacedertThat(ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status1) {
                    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
                    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
                    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
                    return "result2";
                }
            })).isEqualTo("result2");
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isTrue();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void propagationMandatoryFailsInCaseOfNoExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_MANDATORY);
    replacedertThatExceptionOfType(IllegalTransactionStateException.clreplaced).isThrownBy(() -> ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            return "result";
        }
    }));
}

/**
 * Base clreplaced for listener container implementations which are based on polling.
 * Provides support for listener handling based on {@link javax.jms.MessageConsumer},
 * optionally participating in externally managed transactions.
 *
 * <p>This listener container variant is built for repeated polling attempts,
 * each invoking the {@link #receiveAndExecute} method. The MessageConsumer used
 * may be reobtained fo reach attempt or cached in between attempts; this is up
 * to the concrete implementation. The receive timeout for each attempt can be
 * configured through the {@link #setReceiveTimeout "receiveTimeout"} property.
 *
 * <p>The underlying mechanism is based on standard JMS MessageConsumer handling,
 * which is perfectly compatible with both native JMS and JMS in a Java EE environment.
 * Neither the JMS {@code MessageConsumer.setMessageListener} facility  nor the JMS
 * ServerSessionPool facility is required. A further advantage of this approach is
 * full control over the listening process, allowing for custom scaling and throttling
 * and of concurrent message processing (which is up to concrete subclreplacedes).
 *
 * <p>Message reception and listener execution can automatically be wrapped
 * in transactions through preplaceding a Spring
 * {@link org.springframework.transaction.PlatformTransactionManager} into the
 * {@link #setTransactionManager "transactionManager"} property. This will usually
 * be a {@link org.springframework.transaction.jta.JtaTransactionManager} in a
 * Java EE enviroment, in combination with a JTA-aware JMS ConnectionFactory
 * obtained from JNDI (check your application server's doreplacedentation).
 *
 * <p>This base clreplaced does not replacedume any specific mechanism for asynchronous
 * execution of polling invokers. Check out {@link DefaultMessageListenerContainer}
 * for a concrete implementation which is based on Spring's
 * {@link org.springframework.core.task.TaskExecutor} abstraction,
 * including dynamic scaling of concurrent consumers and automatic self recovery.
 *
 * @author Juergen Hoeller
 * @since 2.0.3
 * @see #createListenerConsumer
 * @see #receiveAndExecute
 * @see #setTransactionManager
 */
public abstract clreplaced AbstractPollingMessageListenerContainer extends AbstractMessageListenerContainer {

    /**
     * The default receive timeout: 1000 ms = 1 second.
     */
    public static final long DEFAULT_RECEIVE_TIMEOUT = 1000;

    private final MessageListenerContainerResourceFactory transactionalResourceFactory = new MessageListenerContainerResourceFactory();

    private boolean sessionTransactedCalled = false;

    private PlatformTransactionManager transactionManager;

    private DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();

    private long receiveTimeout = DEFAULT_RECEIVE_TIMEOUT;

    private volatile Boolean commitAfterNoMessageReceived;

    @Override
    public void setSessionTransacted(boolean sessionTransacted) {
        super.setSessionTransacted(sessionTransacted);
        this.sessionTransactedCalled = true;
    }

    /**
     * Specify the Spring {@link org.springframework.transaction.PlatformTransactionManager}
     * to use for transactional wrapping of message reception plus listener execution.
     * <p>Default is none, not performing any transactional wrapping.
     * If specified, this will usually be a Spring
     * {@link org.springframework.transaction.jta.JtaTransactionManager} or one
     * of its subclreplacedes, in combination with a JTA-aware ConnectionFactory that
     * this message listener container obtains its Connections from.
     * <p><b>Note: Consider the use of local JMS transactions instead.</b>
     * Simply switch the {@link #setSessionTransacted "sessionTransacted"} flag
     * to "true" in order to use a locally transacted JMS Session for the entire
     * receive processing, including any Session operations performed by a
     * {@link SessionAwareMessageListener} (e.g. sending a response message). This
     * allows for fully synchronized Spring transactions based on local JMS
     * transactions, similar to what
     * {@link org.springframework.jms.connection.JmsTransactionManager} provides. Check
     * {@link AbstractMessageListenerContainer}'s javadoc for
     * a discussion of transaction choices and message redelivery scenarios.
     * @see #setSessionTransacted(boolean)
     * @see org.springframework.transaction.jta.JtaTransactionManager
     * @see org.springframework.jms.connection.JmsTransactionManager
     */
    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * Return the Spring PlatformTransactionManager to use for transactional
     * wrapping of message reception plus listener execution.
     */
    protected final PlatformTransactionManager getTransactionManager() {
        return this.transactionManager;
    }

    /**
     * Specify the transaction name to use for transactional wrapping.
     * Default is the bean name of this listener container, if any.
     * @see org.springframework.transaction.TransactionDefinition#getName()
     */
    public void setTransactionName(String transactionName) {
        this.transactionDefinition.setName(transactionName);
    }

    /**
     * Specify the transaction timeout to use for transactional wrapping, in <b>seconds</b>.
     * Default is none, using the transaction manager's default timeout.
     * @see org.springframework.transaction.TransactionDefinition#getTimeout()
     * @see #setReceiveTimeout
     */
    public void setTransactionTimeout(int transactionTimeout) {
        this.transactionDefinition.setTimeout(transactionTimeout);
    }

    /**
     * Set the timeout to use for receive calls, in <b>milliseconds</b>.
     * The default is 1000 ms, that is, 1 second.
     * <p><b>NOTE:</b> This value needs to be smaller than the transaction
     * timeout used by the transaction manager (in the appropriate unit,
     * of course). -1 indicates no timeout at all; however, this is only
     * feasible if not running within a transaction manager.
     * @see javax.jms.MessageConsumer#receive(long)
     * @see javax.jms.MessageConsumer#receive()
     * @see #setTransactionTimeout
     */
    public void setReceiveTimeout(long receiveTimeout) {
        this.receiveTimeout = receiveTimeout;
    }

    /**
     * Return the receive timeout (ms) configured for this listener container.
     * @since 4.2
     */
    protected long getReceiveTimeout() {
        return this.receiveTimeout;
    }

    @Override
    public void initialize() {
        // Set sessionTransacted=true in case of a non-JTA transaction manager.
        if (!this.sessionTransactedCalled && this.transactionManager instanceof ResourceTransactionManager && !TransactionSynchronizationUtils.sameResourceFactory((ResourceTransactionManager) this.transactionManager, getConnectionFactory())) {
            super.setSessionTransacted(true);
        }
        // Use bean name as default transaction name.
        if (this.transactionDefinition.getName() == null) {
            this.transactionDefinition.setName(getBeanName());
        }
        // Proceed with superclreplaced initialization.
        super.initialize();
    }

    /**
     * Create a MessageConsumer for the given JMS Session,
     * registering a MessageListener for the specified listener.
     * @param session the JMS Session to work on
     * @return the MessageConsumer
     * @throws javax.jms.JMSException if thrown by JMS methods
     * @see #receiveAndExecute
     */
    protected MessageConsumer createListenerConsumer(Session session) throws JMSException {
        Destination destination = getDestination();
        if (destination == null) {
            destination = resolveDestinationName(session, getDestinationName());
        }
        return createConsumer(session, destination);
    }

    /**
     * Execute the listener for a message received from the given consumer,
     * wrapping the entire operation in an external transaction if demanded.
     * @param session the JMS Session to work on
     * @param consumer the MessageConsumer to work on
     * @return whether a message has been received
     * @throws JMSException if thrown by JMS methods
     * @see #doReceiveAndExecute
     */
    protected boolean receiveAndExecute(Object invoker, Session session, MessageConsumer consumer) throws JMSException {
        if (this.transactionManager != null) {
            // Execute receive within transaction.
            TransactionStatus status = this.transactionManager.getTransaction(this.transactionDefinition);
            boolean messageReceived;
            try {
                messageReceived = doReceiveAndExecute(invoker, session, consumer, status);
            } catch (JMSException ex) {
                rollbackOnException(status, ex);
                throw ex;
            } catch (RuntimeException ex) {
                rollbackOnException(status, ex);
                throw ex;
            } catch (Error err) {
                rollbackOnException(status, err);
                throw err;
            }
            this.transactionManager.commit(status);
            return messageReceived;
        } else {
            // Execute receive outside of transaction.
            return doReceiveAndExecute(invoker, session, consumer, null);
        }
    }

    /**
     * Actually execute the listener for a message received from the given consumer,
     * fetching all requires resources and invoking the listener.
     * @param session the JMS Session to work on
     * @param consumer the MessageConsumer to work on
     * @param status the TransactionStatus (may be {@code null})
     * @return whether a message has been received
     * @throws JMSException if thrown by JMS methods
     * @see #doExecuteListener(javax.jms.Session, javax.jms.Message)
     */
    protected boolean doReceiveAndExecute(Object invoker, Session session, MessageConsumer consumer, TransactionStatus status) throws JMSException {
        Connection conToClose = null;
        Session sessionToClose = null;
        MessageConsumer consumerToClose = null;
        try {
            Session sessionToUse = session;
            boolean transactional = false;
            if (sessionToUse == null) {
                sessionToUse = ConnectionFactoryUtils.doGetTransactionalSession(getConnectionFactory(), this.transactionalResourceFactory, true);
                transactional = (sessionToUse != null);
            }
            if (sessionToUse == null) {
                Connection conToUse;
                if (sharedConnectionEnabled()) {
                    conToUse = getSharedConnection();
                } else {
                    conToUse = createConnection();
                    conToClose = conToUse;
                    conToUse.start();
                }
                sessionToUse = createSession(conToUse);
                sessionToClose = sessionToUse;
            }
            MessageConsumer consumerToUse = consumer;
            if (consumerToUse == null) {
                consumerToUse = createListenerConsumer(sessionToUse);
                consumerToClose = consumerToUse;
            }
            Message message = receiveMessage(consumerToUse);
            if (message != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Received message of type [" + message.getClreplaced() + "] from consumer [" + consumerToUse + "] of " + (transactional ? "transactional " : "") + "session [" + sessionToUse + "]");
                }
                messageReceived(invoker, sessionToUse);
                boolean exposeResource = (!transactional && isExposeListenerSession() && !TransactionSynchronizationManager.hasResource(getConnectionFactory()));
                if (exposeResource) {
                    TransactionSynchronizationManager.bindResource(getConnectionFactory(), new LocallyExposedJmsResourceHolder(sessionToUse));
                }
                try {
                    doExecuteListener(sessionToUse, message);
                } catch (Throwable ex) {
                    if (status != null) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Rolling back transaction because of listener exception thrown: " + ex);
                        }
                        status.setRollbackOnly();
                    }
                    handleListenerException(ex);
                    // Rethrow JMSException to indicate an infrastructure problem
                    // that may have to trigger recovery...
                    if (ex instanceof JMSException) {
                        throw (JMSException) ex;
                    }
                } finally {
                    if (exposeResource) {
                        TransactionSynchronizationManager.unbindResource(getConnectionFactory());
                    }
                }
                // Indicate that a message has been received.
                return true;
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Consumer [" + consumerToUse + "] of " + (transactional ? "transactional " : "") + "session [" + sessionToUse + "] did not receive a message");
                }
                noMessageReceived(invoker, sessionToUse);
                // Nevertheless call commit, in order to reset the transaction timeout (if any).
                // However, don't do this on Tibco since this may lead to a deadlock there.
                if (shouldCommitAfterNoMessageReceived(sessionToUse)) {
                    commitIfNecessary(sessionToUse, message);
                }
                // Indicate that no message has been received.
                return false;
            }
        } finally {
            JmsUtils.closeMessageConsumer(consumerToClose);
            JmsUtils.closeSession(sessionToClose);
            ConnectionFactoryUtils.releaseConnection(conToClose, getConnectionFactory(), true);
        }
    }

    /**
     * This implementation checks whether the Session is externally synchronized.
     * In this case, the Session is not locally transacted, despite the listener
     * container's "sessionTransacted" flag being set to "true".
     * @see org.springframework.jms.connection.JmsResourceHolder
     */
    @Override
    protected boolean isSessionLocallyTransacted(Session session) {
        if (!super.isSessionLocallyTransacted(session)) {
            return false;
        }
        JmsResourceHolder resourceHolder = (JmsResourceHolder) TransactionSynchronizationManager.getResource(getConnectionFactory());
        return (resourceHolder == null || resourceHolder instanceof LocallyExposedJmsResourceHolder || !resourceHolder.containsSession(session));
    }

    /**
     * Determine whether to trigger a commit after no message has been received.
     * This is a good idea on any JMS provider other than Tibco, which is what
     * this default implementation checks for.
     * @param session the current JMS Session which received no message
     * @return whether to call {@link #commitIfNecessary} on the given Session
     */
    protected boolean shouldCommitAfterNoMessageReceived(Session session) {
        if (this.commitAfterNoMessageReceived == null) {
            Session target = ConnectionFactoryUtils.getTargetSession(session);
            this.commitAfterNoMessageReceived = !target.getClreplaced().getName().startsWith("com.tibco.tibjms.");
        }
        return this.commitAfterNoMessageReceived;
    }

    /**
     * Perform a rollback, handling rollback exceptions properly.
     * @param status object representing the transaction
     * @param ex the thrown listener exception or error
     */
    private void rollbackOnException(TransactionStatus status, Throwable ex) {
        logger.debug("Initiating transaction rollback on listener exception", ex);
        try {
            this.transactionManager.rollback(status);
        } catch (RuntimeException ex2) {
            logger.error("Listener exception overridden by rollback exception", ex);
            throw ex2;
        } catch (Error err) {
            logger.error("Listener exception overridden by rollback error", ex);
            throw err;
        }
    }

    /**
     * Receive a message from the given consumer.
     * @param consumer the MessageConsumer to use
     * @return the Message, or {@code null} if none
     * @throws JMSException if thrown by JMS methods
     */
    protected Message receiveMessage(MessageConsumer consumer) throws JMSException {
        return (this.receiveTimeout < 0 ? consumer.receive() : consumer.receive(this.receiveTimeout));
    }

    /**
     * Template method that gets called right when a new message has been received,
     * before attempting to process it. Allows subclreplacedes to react to the event
     * of an actual incoming message, for example adapting their consumer count.
     * @param invoker the invoker object (preplaceded through)
     * @param session the receiving JMS Session
     */
    protected void messageReceived(Object invoker, Session session) {
    }

    /**
     * Template method that gets called when <i>no</i> message has been received,
     * before returning to the receive loop again. Allows subclreplacedes to react to
     * the event of no incoming message, for example marking the invoker as idle.
     * @param invoker the invoker object (preplaceded through)
     * @param session the receiving JMS Session
     */
    protected void noMessageReceived(Object invoker, Session session) {
    }

    /**
     * Fetch an appropriate Connection from the given JmsResourceHolder.
     * <p>This implementation accepts any JMS 1.1 Connection.
     * @param holder the JmsResourceHolder
     * @return an appropriate Connection fetched from the holder,
     * or {@code null} if none found
     */
    protected Connection getConnection(JmsResourceHolder holder) {
        return holder.getConnection();
    }

    /**
     * Fetch an appropriate Session from the given JmsResourceHolder.
     * <p>This implementation accepts any JMS 1.1 Session.
     * @param holder the JmsResourceHolder
     * @return an appropriate Session fetched from the holder,
     * or {@code null} if none found
     */
    protected Session getSession(JmsResourceHolder holder) {
        return holder.getSession();
    }

    /**
     * ResourceFactory implementation that delegates to this listener container's protected callback methods.
     */
    private clreplaced MessageListenerContainerResourceFactory implements ConnectionFactoryUtils.ResourceFactory {

        @Override
        public Connection getConnection(JmsResourceHolder holder) {
            return AbstractPollingMessageListenerContainer.this.getConnection(holder);
        }

        @Override
        public Session getSession(JmsResourceHolder holder) {
            return AbstractPollingMessageListenerContainer.this.getSession(holder);
        }

        @Override
        public Connection createConnection() throws JMSException {
            if (AbstractPollingMessageListenerContainer.this.sharedConnectionEnabled()) {
                Connection sharedCon = AbstractPollingMessageListenerContainer.this.getSharedConnection();
                return new SingleConnectionFactory(sharedCon).createConnection();
            } else {
                return AbstractPollingMessageListenerContainer.this.createConnection();
            }
        }

        @Override
        public Session createSession(Connection con) throws JMSException {
            return AbstractPollingMessageListenerContainer.this.createSession(con);
        }

        @Override
        public boolean isSynchedLocalTransactionAllowed() {
            return AbstractPollingMessageListenerContainer.this.isSessionTransacted();
        }
    }
}

private void saveToSelfDB() {
    // ???????? ????????? ? ????
    final DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setName("SomeTxName");
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    TransactionStatus status = Spring.getInstance().getTxManager().getTransaction(def);
    try {
        if (input_data == null) {
            // ??? ??? ???? ?????? ????????? ?????????? ?? ?? ??? ????????? ?????? ?? ???, ? ??? ???? ???? ????? ?????
            // /Here is the same zhed by the pull of the pull to set the contention that the entered data is not zero, and they rarely need this input
            input_data = "";
        }
        List<Integer> finishStates = Arrays.asList(0, 10, 13);
        if (finishStates.contains(getStateIn())) {
            // QLog.l().logQUser().info("Client is in finish state, clear comments...");
            setTempComments("");
        }
        Spring.getInstance().getHt().saveOrUpdate(this);
        // QLog.l().logQUser().info("Saved customer");
        // ???????. ???? ???????? ??????? ?????? ?????? ??? ????? ? ??, ?.?. ?? ????? ?????? ??? ? ???.
        // Crutch. If the customizer left a comment before getting into the database, ie. While working with him.
        if (resps.size() > 0) {
            Spring.getInstance().getHt().saveAll(resps);
            resps.clear();
        }
    } catch (Exception ex) {
        Spring.getInstance().getTxManager().rollback(status);
        throw new ServerException("?????? ??? ?????????? :: Error while saving \n" + ex.toString() + "\n" + Arrays.toString(ex.getStackTrace()));
    }
    Spring.getInstance().getTxManager().commit(status);
// QLog.l().logger().debug("?????????.");
}

@Test
public void existingNonSpringTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertTrue(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void existingTransactionUsingPropagationNotSupported() {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
    definition2.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            replacedertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status) {
                    replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                    replacedertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                    return "result2";
                }
            }));
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    replacedertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

private void doTestExistingTransactionWithSuspension(final int propagationBehavior) {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(propagationBehavior);
    definition2.setReadOnly(true);
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
            replacedertTrue(TransactionSynchronizationManager.isActualTransactionActive());
            replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            replacedertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status) {
                    replacedertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                    replacedertEquals(propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW, TransactionSynchronizationManager.isActualTransactionActive());
                    replacedertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                    return "result2";
                }
            }));
            return "result";
        }
    }));
    replacedertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    replacedertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    replacedertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    replacedertEquals(0, manager.getUOWTimeout());
    if (propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    } else {
        replacedertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
    }
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void propagationNestedFailsInCaseOfExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
    try {
        ptm.execute(definition, new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                return "result";
            }
        });
        fail("Should have thrown NestedTransactionNotSupportedException");
    } catch (NestedTransactionNotSupportedException ex) {
    // expected
    }
}

@Test
public void uowManagerFoundInJndi() {
    MockUOWManager manager = new MockUOWManager();
    ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate(WebSphereUowTransactionManager.DEFAULT_UOW_MANAGER_NAME, manager);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager();
    ptm.setJndiTemplate(jndiTemplate);
    ptm.afterPropertiesSet();
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            return "result";
        }
    }));
    replacedertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    replacedertFalse(manager.getJoined());
    replacedertFalse(manager.getRollbackOnly());
}

@Test
public void testDefaultTransactionDefinition() throws Exception {
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    try {
        dialect.beginTransaction(null, definition);
        fail("expected exception");
    } catch (TransactionException e) {
    // ok
    }
}

/**
 * Provides a light JTA TransactionManager based upon the
 * {@link PlatformTransactionManager} This is the transaction manager that Teiid
 * code sees.
 *
 * If no third party transaction manager found, but there are multiple data
 * sources are defined, then this clreplaced will provide light weight JTA *like*
 * functionality. Here in case of failure it is totally on the user to manually
 * rollback any changes if any datasources failed to commit during the commit
 * run. This transaction manager is best used when we are dealing with only 1
 * transactional resource.
 */
public final clreplaced PlatformTransactionManagerAdapter implements TransactionManager {

    public static clreplaced TransactionHolder {

        public final TransactionStatus status;

        public final Transaction transaction;

        TransactionHolder(TransactionStatus status, PlatformTransactionAdapter adapter) {
            this.status = status;
            this.transaction = adapter;
        }
    }

    private List<PlatformTransactionManager> txnManagersForEachDataSource = new ArrayList<>();

    private static DefaultTransactionDefinition NEW_TRANSACTION_DEFINITION = new DefaultTransactionDefinition();

    static {
        NEW_TRANSACTION_DEFINITION.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    }

    private static DefaultTransactionDefinition EXISTING_TRANSACTION_DEFINITION = new DefaultTransactionDefinition();

    static {
        EXISTING_TRANSACTION_DEFINITION.setPropagationBehavior(TransactionDefinition.PROPAGATION_MANDATORY);
    }

    private static final ThreadLocal<TransactionHolder> TRANSACTION_HOLDERS = new ThreadLocal<>();

    private static final clreplaced PlatformTransactionAdapter implements Transaction {

        private WeakReference<TransactionStatus> transactionStatus;

        PlatformTransactionAdapter(TransactionStatus status) {
            this.transactionStatus = new WeakReference<TransactionStatus>(status);
        }

        @Override
        public void registerSynchronization(final Synchronization synch) throws IllegalStateException, RollbackException, SystemException {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

                @Override
                public void beforeCompletion() {
                    synch.beforeCompletion();
                }

                @Override
                public void afterCompletion(int status) {
                    switch(status) {
                        case TransactionSynchronization.STATUS_COMMITTED:
                            status = Status.STATUS_COMMITTED;
                            break;
                        case TransactionSynchronization.STATUS_ROLLED_BACK:
                            status = Status.STATUS_ROLLEDBACK;
                            break;
                        case TransactionSynchronization.STATUS_UNKNOWN:
                            status = Status.STATUS_UNKNOWN;
                            break;
                    }
                    synch.afterCompletion(status);
                }
            });
        }

        @Override
        public void setRollbackOnly() throws IllegalStateException, SystemException {
            TransactionStatus status = transactionStatus.get();
            if (status == null) {
                throw new IllegalStateException();
            }
            status.setRollbackOnly();
        }

        @Override
        public void rollback() throws IllegalStateException, SystemException {
            throw new SystemException("This is a spring managed transaction, it should not direclty manipulated");
        }

        @Override
        public void commit() throws HeuristicMixedException, HeuristicRollbackException, RollbackException, SecurityException, SystemException {
            throw new SystemException("This is a spring managed transaction, it should not direclty manipulated");
        }

        @Override
        public boolean delistResource(XAResource xaRes, int flag) throws IllegalStateException, SystemException {
            throw new SystemException("This is a spring managed transaction, it should not direclty manipulated");
        }

        @Override
        public boolean enlistResource(XAResource xaRes) throws IllegalStateException, RollbackException, SystemException {
            throw new SystemException("This is a spring managed transaction, it should not direclty manipulated");
        }

        @Override
        public int getStatus() throws SystemException {
            throw new SystemException("This is a spring managed transation.  This method isn not implemented.");
        }
    }

    private PlatformTransactionManager platformTransactionManager;

    private WeakHashMap<TransactionStatus, PlatformTransactionAdapter> transactions = new WeakHashMap<>();

    public PlatformTransactionManagerAdapter() {
    }

    public void setPlatformTransactionManager(PlatformTransactionManager platformTransactionManager) {
        this.platformTransactionManager = platformTransactionManager;
        if (this.platformTransactionManager instanceof DelegatingPlatformTransactionManager) {
            ((DelegatingPlatformTransactionManager) this.platformTransactionManager).setTransactionManagers(this.txnManagersForEachDataSource);
        }
    }

    @Override
    public Transaction getTransaction() throws SystemException {
        try {
            if (platformTransactionManager == null) {
                return null;
            }
            TransactionHolder holder = getOrCreateTransaction(false);
            if (holder == null) {
                return null;
            }
            return holder.transaction;
        } catch (IllegalTransactionStateException e) {
            return null;
        }
    }

    public TransactionHolder getOrCreateTransaction(boolean start) {
        TransactionStatus status = null;
        try {
            // Spring managed transaction
            status = TransactionAspectSupport.currentTransactionStatus();
        } catch (NoTransactionException e) {
            // Teiid programatically managed transaction
            if (start) {
                status = platformTransactionManager.getTransaction(NEW_TRANSACTION_DEFINITION);
                TransactionHolder holder = new TransactionHolder(status, new PlatformTransactionAdapter(status));
                TRANSACTION_HOLDERS.set(holder);
                return holder;
            } else {
                try {
                    status = platformTransactionManager.getTransaction(EXISTING_TRANSACTION_DEFINITION);
                    // success means that there is one defined/replacedociated, so we are safe to use
                    // the thread local
                    return TRANSACTION_HOLDERS.get();
                } catch (TransactionException e1) {
                    TRANSACTION_HOLDERS.remove();
                }
            }
        }
        if (status == null) {
            return null;
        }
        synchronized (transactions) {
            PlatformTransactionAdapter adapter = transactions.get(status);
            if (adapter == null) {
                adapter = new PlatformTransactionAdapter(status);
                transactions.put(status, adapter);
            }
            return new TransactionHolder(status, adapter);
        }
    }

    @Override
    public void rollback() throws IllegalStateException, SecurityException, SystemException {
        throw useTransactionManager();
    }

    @Override
    public void commit() throws HeuristicMixedException, HeuristicRollbackException, IllegalStateException, RollbackException, SecurityException, SystemException {
        throw useTransactionManager();
    }

    @Override
    public void begin() throws NotSupportedException, SystemException {
        throw useTransactionManager();
    }

    @Override
    public Transaction suspend() throws SystemException {
        throw useTransactionManager();
    }

    @Override
    public void setTransactionTimeout(int seconds) throws SystemException {
        throw useTransactionManager();
    }

    @Override
    public void resume(Transaction tobj) throws IllegalStateException, InvalidTransactionException, SystemException {
        throw useTransactionManager();
    }

    @Override
    public void setRollbackOnly() throws IllegalStateException, SystemException {
        throw useTransactionManager();
    }

    @Override
    public int getStatus() throws SystemException {
        throw useTransactionManager();
    }

    private SystemException useTransactionManager() {
        return new SystemException("The system is only setup for spring managed transactions.  " + "If you need Teiid to manage transactions, then a third-party transaction manager like narayana-spring-boot-starter needs to be configured.");
    }

    public void addDataSource(DataSource ds) {
        this.txnManagersForEachDataSource.add(new DataSourceTransactionManager(ds));
    }

    @SuppressWarnings("rawtypes")
    public void addDataSource(BaseConnectionFactory bean) {
    // TODO: not used currently, need to come up some strategy here.
    }

    public void commit(TransactionStatus status) {
        this.platformTransactionManager.commit(status);
        TRANSACTION_HOLDERS.remove();
    }

    public void rollback(TransactionStatus status) {
        this.platformTransactionManager.rollback(status);
        TRANSACTION_HOLDERS.remove();
    }
}

@Test
public void testDoBeginReadOnly() {
    when(transactionManager.begin()).thenReturn(transactionContext);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setReadOnly(true);
    TransactionSynchronizationManager.unbindResource(this.databaseClient);
    manager.doBegin(tx, definition);
    replacedert.replacedertNull(tx.getTransactionManager());
    replacedert.replacedertNotNull(tx.getTransactionContext());
    replacedert.replacedertNotEquals(tx.getTransactionContext(), transactionContext);
    replacedert.replacedertTrue(tx.isReadOnly());
    verify(transactionManager, times(0)).begin();
    verify(transactionManager, times(0)).getState();
}

private void doTestExistingTransactionWithSuspension(final int propagationBehavior) {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(propagationBehavior);
    definition2.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            replacedertThat(ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status1) {
                    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
                    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo((propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW));
                    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
                    return "result2";
                }
            })).isEqualTo("result2");
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    if (propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
        replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    } else {
        replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
    }
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void newTransactionWithRollbackOnly() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            status.setRollbackOnly();
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isTrue();
}

@Test
public void uowManagerFoundInJndi() {
    MockUOWManager manager = new MockUOWManager();
    ExpectedLookupTemplate jndiTemplate = new ExpectedLookupTemplate(WebSphereUowTransactionManager.DEFAULT_UOW_MANAGER_NAME, manager);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager();
    ptm.setJndiTemplate(jndiTemplate);
    ptm.afterPropertiesSet();
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void propagationNeverFailsInCaseOfExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
    replacedertThatExceptionOfType(IllegalTransactionStateException.clreplaced).isThrownBy(() -> ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            return "result";
        }
    }));
}

@Test
public void newTransactionWithCommitException() {
    final RollbackException rex = new RollbackException();
    MockUOWManager manager = new MockUOWManager() {

        @Override
        public void runUnderUOW(int type, boolean join, UOWAction action) throws UOWException {
            throw new UOWException(rex);
        }
    };
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThatExceptionOfType(TransactionSystemException.clreplaced).isThrownBy(() -> ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            return "result";
        }
    })).withCauseInstanceOf(UOWException.clreplaced).satisfies(ex -> {
        replacedertThat(ex.getRootCause()).isSameAs(rex);
        replacedertThat(ex.getMostSpecificCause()).isSameAs(rex);
    });
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
}

@Test
public void newTransactionWithRollback() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThatExceptionOfType(OptimisticLockingFailureException.clreplaced).isThrownBy(() -> ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            throw new OptimisticLockingFailureException("");
        }
    }));
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isTrue();
}

@Test
public void newTransactionWithCommitAndTimeout() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setTimeout(10);
    definition.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(10);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void testDefaultTransactionDefinition() throws Exception {
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    replacedertThatExceptionOfType(TransactionException.clreplaced).isThrownBy(() -> dialect.beginTransaction(null, definition));
}

public TransactionStatus startTransaction(final boolean readonly) {
    final DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    def.setReadOnly(readonly);
    return txManager.getTransaction(def);
}

private static TransactionStatus beginTransaction(PlatformTransactionManager txManager) {
    if (txManager == null) {
        return null;
    }
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    return txManager.getTransaction(definition);
}

/**
 * 开启事物
 * @param transactionManager
 */
public void start(DataSourceTransactionManager transactionManager) {
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    /*PROPAGATION_REQUIRES_NEW:  事物隔离级别，开启新事务*/
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    status = transactionManager.getTransaction(def);
}

public boolean atomicSave(AlarmContract alarmContract) {
    boolean isValidCron = CronExpression.isValidExpression(alarmContract.getCron());
    if (!isValidCron) {
        throw new ProtocolException(510, "cron表达式非法");
    }
    padAlarm(alarmContract);
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    TransactionStatus status = frostmourneTransactionManager.getTransaction(def);
    try {
        save(alarmContract);
    } catch (Exception ex) {
        frostmourneTransactionManager.rollback(status);
        LOGGER.error("error when save alarm", ex);
        throw ex;
    }
    frostmourneTransactionManager.commit(status);
    return true;
}

/**
 * 事务实体类
 * @author  Dennie [email protected]
 * @date	 2018年11月16日 上午11:37:39
 * @version v1.0
 */
public clreplaced TransactionBean {

    private DataSourceTransactionManager dtm;

    private DefaultTransactionDefinition dtf;

    private TransactionStatus ts;

    /**
     * 提交事务
     */
    public void commit() {
        this.dtm.commit(this.ts);
    }

    /**
     * 回滚事务
     */
    public void rollback() {
        this.dtm.rollback(this.ts);
    }

    /**
     * 事务管理器
     * @return DataSourceTransactionManager
     */
    public DataSourceTransactionManager getDtm() {
        return dtm;
    }

    public void setDtm(DataSourceTransactionManager dtm) {
        this.dtm = dtm;
    }

    /**
     * 默认事务定义
     * @return DefaultTransactionDefinition
     */
    public DefaultTransactionDefinition getDtf() {
        return dtf;
    }

    public void setDtf(DefaultTransactionDefinition dtf) {
        this.dtf = dtf;
    }

    /**
     * 传输状态
     * @return TransactionStatus
     */
    public TransactionStatus getTs() {
        return ts;
    }

    public void setTs(TransactionStatus ts) {
        this.ts = ts;
    }
}

private TransactionStatus getTransactionStatus() {
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    definition.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    return transactionManager.getTransaction(definition);
}

@Test
public void existingTransactionUsingPropagationNotSupported() {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
    definition2.setReadOnly(true);
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            replacedertThat(ptm.execute(definition2, new TransactionCallback<String>() {

                @Override
                public String doInTransaction(TransactionStatus status1) {
                    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
                    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
                    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
                    return "result2";
                }
            })).isEqualTo("result2");
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isFalse();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void existingNonSpringTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
            replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
            return "result";
        }
    })).isEqualTo("result");
    replacedertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
    replacedertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
    replacedertThat(manager.getUOWTimeout()).isEqualTo(0);
    replacedertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
    replacedertThat(manager.getJoined()).isTrue();
    replacedertThat(manager.getRollbackOnly()).isFalse();
}

@Test
public void propagationNestedFailsInCaseOfExistingTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
    replacedertThatExceptionOfType(NestedTransactionNotSupportedException.clreplaced).isThrownBy(() -> ptm.execute(definition, new TransactionCallback<String>() {

        @Override
        public String doInTransaction(TransactionStatus status) {
            return "result";
        }
    }));
}

/**
 * Сохранить календарь.
 */
public void save() {
    QLog.l().logger().info("Save the calendar ID = " + calcId);
    final DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setName("SomeTxName");
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    TransactionStatus status = Spring.getInstance().getTxManager().getTransaction(def);
    try {
        final LinkedList<FreeDay> dels = new LinkedList<>();
        for (FreeDay bad : days_del) {
            boolean f = true;
            for (FreeDay good : days) {
                if (good.equals(bad)) {
                    f = false;
                }
            }
            if (f) {
                dels.add(bad);
            }
        }
        Spring.getInstance().getHt().deleteAll(dels);
        Spring.getInstance().getHt().saveOrUpdateAll(days);
    } catch (Exception ex) {
        Spring.getInstance().getTxManager().rollback(status);
        throw new ClientException("Error performing the operation of modifying data in the database (JDBC).\nPerhaps you added a new calendar, changed it, tried to save the contents of the calendar, but did not save the overall configuration.\nSave the entire configuration (Ctrl + S) and try again to save the contents of the calendar.\n\n[" + ex.getLocalizedMessage() + "]\n(" + ex.toString() + ")");
    }
    Spring.getInstance().getTxManager().commit(status);
    QLog.l().logger().debug("Saved a new calendar");
    // Type so that there are actual internal data
    days_del = new ArrayList<>(days);
}

public void beginTransaction(boolean readOnly) {
    TransactionStatus txnStatus = currTxnStatus.get();
    if (txnStatus != null) {
        if (txnStatus.isCompleted()) {
            // 当前事务已结束
            currTxnStatus.remove();
            txnStatus = null;
        } else if (txnStatus.isRollbackOnly() != readOnly) {
            // 当前事务与要开始的事务不一致
            throw new RuntimeException("Unable to start new transaction with out commit/rollback current");
        } else {
            // 完全一致, do nothing
            if (logger.isDebugEnabled()) {
                logger.debug("beginTransaction(" + readOnly + ") is the same with current txn, do nothing");
            }
            return;
        }
    } else {
        DefaultTransactionDefinition txnDef = new DefaultTransactionDefinition();
        txnDef.setReadOnly(readOnly);
        txnStatus = tm.getTransaction(txnDef);
        currTxnStatus.set(txnStatus);
        if (logger.isDebugEnabled()) {
            logger.debug("beginTransaction(" + readOnly + ")");
        }
    }
}

@Override
public <T> T applyAndReturn(final StartSagaBuilder builder, final Function<StartSagaBuilder, T> function) {
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED);
    def.setIsolationLevel(ISOLATION_DEFAULT);
    return applyAndReturn(builder, function, def);
}

See More Examples