使用@Transactional(propagation = Propagation.SUPPORTS)和不加@Transactional 有什么区别？

/**
 * Set when this transaction manager should activate the thread-bound
 * transaction synchronization support. Default is "always".
 * <p>Note that transaction synchronization isn't supported for
 * multiple concurrent transactions by different transaction managers.
 * Only one transaction manager is allowed to activate it at any time.
 * @see #SYNCHRONIZATION_ALWAYS
 * @see #SYNCHRONIZATION_ON_ACTUAL_TRANSACTION
 * @see #SYNCHRONIZATION_NEVER
 * @see TransactionSynchronizationManager
 * @see TransactionSynchronization
 */
public final void setTransactionSynchronization(int transactionSynchronization) {
   this.transactionSynchronization = transactionSynchronization;
}

package org.springframework.transaction.support;

import java.io.Flushable;

/**
 * Interface for transaction synchronization callbacks.
 * Supported by AbstractPlatformTransactionManager.
 *
 * <p>TransactionSynchronization implementations can implement the Ordered interface
 * to influence their execution order. A synchronization that does not implement the
 * Ordered interface is appended to the end of the synchronization chain.
 *
 * <p>System synchronizations performed by Spring itself use specific order values,
 * allowing for fine-grained interaction with their execution order (if necessary).
 *
 * @author Juergen Hoeller
 * @since 02.06.2003
 * @see TransactionSynchronizationManager
 * @see AbstractPlatformTransactionManager
 * @see org.springframework.jdbc.datasource.DataSourceUtils#CONNECTION_SYNCHRONIZATION_ORDER
 */
public interface TransactionSynchronization extends Flushable {

   /** Completion status in case of proper commit */
   int STATUS_COMMITTED = 0;

   /** Completion status in case of proper rollback */
   int STATUS_ROLLED_BACK = 1;

   /** Completion status in case of heuristic mixed completion or system errors */
   int STATUS_UNKNOWN = 2;


   /**
    * Suspend this synchronization.
    * Supposed to unbind resources from TransactionSynchronizationManager if managing any.
    * @see TransactionSynchronizationManager#unbindResource
    */
   void suspend();

   /**
    * Resume this synchronization.
    * Supposed to rebind resources to TransactionSynchronizationManager if managing any.
    * @see TransactionSynchronizationManager#bindResource
    */
   void resume();

   /**
    * Flush the underlying session to the datastore, if applicable:
    * for example, a Hibernate/JPA session.
    * @see org.springframework.transaction.TransactionStatus#flush()
    */
   @Override
   void flush();

   /**
    * Invoked before transaction commit (before "beforeCompletion").
    * Can e.g. flush transactional O/R Mapping sessions to the database.
    * <p>This callback does <i>not</i> mean that the transaction will actually be committed.
    * A rollback decision can still occur after this method has been called. This callback
    * is rather meant to perform work that's only relevant if a commit still has a chance
    * to happen, such as flushing SQL statements to the database.
    * <p>Note that exceptions will get propagated to the commit caller and cause a
    * rollback of the transaction.
    * @param readOnly whether the transaction is defined as read-only transaction
    * @throws RuntimeException in case of errors; will be <b>propagated to the caller</b>
    * (note: do not throw TransactionException subclasses here!)
    * @see #beforeCompletion
    */
   void beforeCommit(boolean readOnly);

   /**
    * Invoked before transaction commit/rollback.
    * Can perform resource cleanup <i>before</i> transaction completion.
    * <p>This method will be invoked after {@code beforeCommit}, even when
    * {@code beforeCommit} threw an exception. This callback allows for
    * closing resources before transaction completion, for any outcome.
    * @throws RuntimeException in case of errors; will be <b>logged but not propagated</b>
    * (note: do not throw TransactionException subclasses here!)
    * @see #beforeCommit
    * @see #afterCompletion
    */
   void beforeCompletion();

   /**
    * Invoked after transaction commit. Can perform further operations right
    * <i>after</i> the main transaction has <i>successfully</i> committed.
    * <p>Can e.g. commit further operations that are supposed to follow on a successful
    * commit of the main transaction, like confirmation messages or emails.
    * <p><b>NOTE:</b> The transaction will have been committed already, but the
    * transactional resources might still be active and accessible. As a consequence,
    * any data access code triggered at this point will still "participate" in the
    * original transaction, allowing to perform some cleanup (with no commit following
    * anymore!), unless it explicitly declares that it needs to run in a separate
    * transaction. Hence: <b>Use {@code PROPAGATION_REQUIRES_NEW} for any
    * transactional operation that is called from here.</b>
    * @throws RuntimeException in case of errors; will be <b>propagated to the caller</b>
    * (note: do not throw TransactionException subclasses here!)
    */
   void afterCommit();

   /**
    * Invoked after transaction commit/rollback.
    * Can perform resource cleanup <i>after</i> transaction completion.
    * <p><b>NOTE:</b> The transaction will have been committed or rolled back already,
    * but the transactional resources might still be active and accessible. As a
    * consequence, any data access code triggered at this point will still "participate"
    * in the original transaction, allowing to perform some cleanup (with no commit
    * following anymore!), unless it explicitly declares that it needs to run in a
    * separate transaction. Hence: <b>Use {@code PROPAGATION_REQUIRES_NEW}
    * for any transactional operation that is called from here.</b>
    * @param status completion status according to the {@code STATUS_*} constants
    * @throws RuntimeException in case of errors; will be <b>logged but not propagated</b>
    * (note: do not throw TransactionException subclasses here!)
    * @see #STATUS_COMMITTED
    * @see #STATUS_ROLLED_BACK
    * @see #STATUS_UNKNOWN
    * @see #beforeCompletion
    */
   void afterCompletion(int status);

}