mysql

/*SESSION LEVEL*/select @@tx_isolation;/*GLOBAL LEVEL*/select @@global.tx_isolation;select 'SESSION' as scope,@@tx_isolation UNIONselect 'GLOBAL' as scope,@@global.tx_isolation;-- SESSION    REPEATABLE-READ-- GLOBAL    REPEATABLE-READ

 

java.sql;

Connection

/**     * A constant indicating that transactions are not supported.     */    int TRANSACTION_NONE             = 0;    /**     * A constant indicating that     * dirty reads, non-repeatable reads and phantom reads can occur.     * This level allows a row changed by one transaction to be read     * by another transaction before any changes in that row have been     * committed (a "dirty read").  If any of the changes are rolled back,     * the second transaction will have retrieved an invalid row.     */    int TRANSACTION_READ_UNCOMMITTED = 1;    /**     * A constant indicating that     * dirty reads are prevented; non-repeatable reads and phantom     * reads can occur.  This level only prohibits a transaction     * from reading a row with uncommitted changes in it.     */    int TRANSACTION_READ_COMMITTED   = 2;    /**     * A constant indicating that     * dirty reads and non-repeatable reads are prevented; phantom     * reads can occur.  This level prohibits a transaction from     * reading a row with uncommitted changes in it, and it also     * prohibits the situation where one transaction reads a row,     * a second transaction alters the row, and the first transaction     * rereads the row, getting different values the second time     * (a "non-repeatable read").     */    int TRANSACTION_REPEATABLE_READ  = 4;    /**     * A constant indicating that     * dirty reads, non-repeatable reads and phantom reads are prevented.     * This level includes the prohibitions in     * TRANSACTION_REPEATABLE_READ and further prohibits the     * situation where one transaction reads all rows that satisfy     * a WHERE condition, a second transaction inserts a row that     * satisfies that WHERE condition, and the first transaction     * rereads for the same condition, retrieving the additional     * "phantom" row in the second read.     */    int TRANSACTION_SERIALIZABLE     = 8;    /**     * Attempts to change the transaction isolation level for this     * Connection object to the one given.     * The constants defined in the interface Connection     * are the possible transaction isolation levels.     * 
     * Note: If this method is called during a transaction, the result     * is implementation-defined.     *     * @param level one of the following Connection constants:     *        Connection.TRANSACTION_READ_UNCOMMITTED,     *        Connection.TRANSACTION_READ_COMMITTED,     *        Connection.TRANSACTION_REPEATABLE_READ, or     *        Connection.TRANSACTION_SERIALIZABLE.     *        (Note that Connection.TRANSACTION_NONE cannot be used     *        because it specifies that transactions are not supported.)     * @exception SQLException if a database access error occurs, this     * method is called on a closed connection     *            or the given parameter is not one of the Connection     *            constants     * @see DatabaseMetaData#supportsTransactionIsolationLevel     * @see #getTransactionIsolation     */    void setTransactionIsolation(int level) throws SQLException;    /**     * Retrieves this Connection object's current     * transaction isolation level.     *     * @return the current transaction isolation level, which will be one     *         of the following constants:     *        Connection.TRANSACTION_READ_UNCOMMITTED,     *        Connection.TRANSACTION_READ_COMMITTED,     *        Connection.TRANSACTION_REPEATABLE_READ,     *        Connection.TRANSACTION_SERIALIZABLE, or     *        Connection.TRANSACTION_NONE.     * @exception SQLException if a database access error occurs     * or this method is called on a closed connection     * @see #setTransactionIsolation     */    int getTransactionIsolation() throws SQLException;

 

org.springframework.transaction;

TransactionDefinitio/**

* Interface that defines Spring-compliant transaction properties. * Based on the propagation behavior definitions analogous to EJB CMT attributes. * * 
Note that isolation level and timeout settings will not get applied unless * an actual new transaction gets started. As only {
     @link #PROPAGATION_REQUIRED}, * {
     @link #PROPAGATION_REQUIRES_NEW} and {
     @link #PROPAGATION_NESTED} can cause * that, it usually doesn't make sense to specify those settings in other cases. * Furthermore, be aware that not all transaction managers will support those * advanced features and thus might throw corresponding exceptions when given * non-default values. * * 
The {
     @link #isReadOnly() read-only flag} applies to any transaction context, * whether backed by an actual resource transaction or operating non-transactionally * at the resource level. In the latter case, the flag will only apply to managed * resources within the application, such as a Hibernate {
     @code Session}. * * @author Juergen Hoeller * @since 08.05.2003 * @see PlatformTransactionManager#getTransaction(TransactionDefinition) * @see org.springframework.transaction.support.DefaultTransactionDefinition * @see org.springframework.transaction.interceptor.TransactionAttribute */public interface TransactionDefinition {    /**     * Support a current transaction; create a new one if none exists.     * Analogous to the EJB transaction attribute of the same name.     * 
This is typically the default setting of a transaction definition,     * and typically defines a transaction synchronization scope.     */    int PROPAGATION_REQUIRED = 0;    /**     * Support a current transaction; execute non-transactionally if none exists.     * Analogous to the EJB transaction attribute of the same name.     * 
NOTE: For transaction managers with transaction synchronization,     * {
     @code PROPAGATION_SUPPORTS} is slightly different from no transaction     * at all, as it defines a transaction scope that synchronization might apply to.     * As a consequence, the same resources (a JDBC {
     @code Connection}, a     * Hibernate {
     @code Session}, etc) will be shared for the entire specified     * scope. Note that the exact behavior depends on the actual synchronization     * configuration of the transaction manager!     * 
In general, use {
     @code PROPAGATION_SUPPORTS} with care! In particular, do     * not rely on {
     @code PROPAGATION_REQUIRED} or {
     @code PROPAGATION_REQUIRES_NEW}     * within a {
     @code PROPAGATION_SUPPORTS} scope (which may lead to     * synchronization conflicts at runtime). If such nesting is unavoidable, make sure     * to configure your transaction manager appropriately (typically switching to     * "synchronization on actual transaction").     * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization     * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#SYNCHRONIZATION_ON_ACTUAL_TRANSACTION     */    int PROPAGATION_SUPPORTS = 1;    /**     * Support a current transaction; throw an exception if no current transaction     * exists. Analogous to the EJB transaction attribute of the same name.     * 
Note that transaction synchronization within a {
     @code PROPAGATION_MANDATORY}     * scope will always be driven by the surrounding transaction.     */    int PROPAGATION_MANDATORY = 2;    /**     * Create a new transaction, suspending the current transaction if one exists.     * Analogous to the EJB transaction attribute of the same name.     * 
NOTE: Actual transaction suspension will not work out-of-the-box     * on all transaction managers. This in particular applies to     * {
     @link org.springframework.transaction.jta.JtaTransactionManager},     * which requires the {
     @code javax.transaction.TransactionManager} to be     * made available it to it (which is server-specific in standard Java EE).     * 
A {
     @code PROPAGATION_REQUIRES_NEW} scope always defines its own     * transaction synchronizations. Existing synchronizations will be suspended     * and resumed appropriately.     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager     */    int PROPAGATION_REQUIRES_NEW = 3;    /**     * Do not support a current transaction; rather always execute non-transactionally.     * Analogous to the EJB transaction attribute of the same name.     * 
NOTE: Actual transaction suspension will not work out-of-the-box     * on all transaction managers. This in particular applies to     * {
     @link org.springframework.transaction.jta.JtaTransactionManager},     * which requires the {
     @code javax.transaction.TransactionManager} to be     * made available it to it (which is server-specific in standard Java EE).     * 
Note that transaction synchronization is not available within a     * {
     @code PROPAGATION_NOT_SUPPORTED} scope. Existing synchronizations     * will be suspended and resumed appropriately.     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager     */    int PROPAGATION_NOT_SUPPORTED = 4;    /**     * Do not support a current transaction; throw an exception if a current transaction     * exists. Analogous to the EJB transaction attribute of the same name.     * 
Note that transaction synchronization is not available within a     * {
     @code PROPAGATION_NEVER} scope.     */    int PROPAGATION_NEVER = 5;    /**     * Execute within a nested transaction if a current transaction exists,     * behave like {
     @link #PROPAGATION_REQUIRED} else. There is no analogous     * feature in EJB.     * 
NOTE: Actual creation of a nested transaction will only work on     * specific transaction managers. Out of the box, this only applies to the JDBC     * {
     @link org.springframework.jdbc.datasource.DataSourceTransactionManager}     * when working on a JDBC 3.0 driver. Some JTA providers might support     * nested transactions as well.     * @see org.springframework.jdbc.datasource.DataSourceTransactionManager     */    int PROPAGATION_NESTED = 6;/**     * Use the default timeout of the underlying transaction system,     * or none if timeouts are not supported.     */    int TIMEOUT_DEFAULT = -1;    /**     * Return the propagation behavior.     * 
Must return one of the {
     @code PROPAGATION_XXX} constants     * defined on {
     @link TransactionDefinition this interface}.     * @return the propagation behavior     * @see #PROPAGATION_REQUIRED     * @see org.springframework.transaction.support.TransactionSynchronizationManager#isActualTransactionActive()     */    int getPropagationBehavior();    /**     * Return the isolation level.     * 
Must return one of the {
     @code ISOLATION_XXX} constants     * defined on {
     @link TransactionDefinition this interface}.     * 
Only makes sense in combination with {
     @link #PROPAGATION_REQUIRED}     * or {
     @link #PROPAGATION_REQUIRES_NEW}.     * 
Note that a transaction manager that does not support custom isolation levels     * will throw an exception when given any other level than {
     @link #ISOLATION_DEFAULT}.     * @return the isolation level     */    int getIsolationLevel();    /**     * Return the transaction timeout.     * 
Must return a number of seconds, or {
     @link #TIMEOUT_DEFAULT}.     * 
Only makes sense in combination with {
     @link #PROPAGATION_REQUIRED}     * or {
     @link #PROPAGATION_REQUIRES_NEW}.     * 
Note that a transaction manager that does not support timeouts will throw     * an exception when given any other timeout than {
     @link #TIMEOUT_DEFAULT}.     * @return the transaction timeout     */    int getTimeout();    /**     * Return whether to optimize as a read-only transaction.     * 
The read-only flag applies to any transaction context, whether     * backed by an actual resource transaction     * ({
     @link #PROPAGATION_REQUIRED}/{
     @link #PROPAGATION_REQUIRES_NEW}) or     * operating non-transactionally at the resource level     * ({
     @link #PROPAGATION_SUPPORTS}). In the latter case, the flag will     * only apply to managed resources within the application, such as a     * Hibernate {
     @code Session}.     <<     * 
This just serves as a hint for the actual transaction subsystem;     * it will not necessarily cause failure of write access attempts.     * A transaction manager which cannot interpret the read-only hint will     * not throw an exception when asked for a read-only transaction.     * @return {
     @code true} if the transaction is to be optimized as read-only     * @see org.springframework.transaction.support.TransactionSynchronization#beforeCommit(boolean)     * @see org.springframework.transaction.support.TransactionSynchronizationManager#isCurrentTransactionReadOnly()     */    boolean isReadOnly();    /**     * Return the name of this transaction. Can be {
     @code null}.     * 
This will be used as the transaction name to be shown in a     * transaction monitor, if applicable (for example, WebLogic's).     * 
In case of Spring's declarative transactions, the exposed name will be     * the {
     @code fully-qualified class name + "." + method name} (by default).     * @return the name of this transaction     * @see org.springframework.transaction.interceptor.TransactionAspectSupport     * @see org.springframework.transaction.support.TransactionSynchronizationManager#getCurrentTransactionName()     */    String getName();}

 

 

 

org.springframework.transaction.annotation；

enum Isolation

/** * Enumeration that represents transaction isolation levels for use * with the {
    @link Transactional} annotation, corresponding to the * {
    @link TransactionDefinition} interface. * * @author Colin Sampaleanu * @author Juergen Hoeller * @since 1.2 */public enum Isolation {    /**     * Use the default isolation level of the underlying datastore.     * All other levels correspond to the JDBC isolation levels.     * @see java.sql.Connection     */    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),    /**     * A constant indicating that dirty reads, non-repeatable reads and phantom reads     * can occur. This level allows a row changed by one transaction to be read by     * another transaction before any changes in that row have been committed     * (a "dirty read"). If any of the changes are rolled back, the second     * transaction will have retrieved an invalid row.     * @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED     */    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),    /**     * A constant indicating that dirty reads are prevented; non-repeatable reads     * and phantom reads can occur. This level only prohibits a transaction     * from reading a row with uncommitted changes in it.     * @see java.sql.Connection#TRANSACTION_READ_COMMITTED     */    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),    /**     * A constant indicating that dirty reads and non-repeatable reads are     * prevented; phantom reads can occur. This level prohibits a transaction     * from reading a row with uncommitted changes in it, and it also prohibits     * the situation where one transaction reads a row, a second transaction     * alters the row, and the first transaction rereads the row, getting     * different values the second time (a "non-repeatable read").     * @see java.sql.Connection#TRANSACTION_REPEATABLE_READ     */    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),    /**     * A constant indicating that dirty reads, non-repeatable reads and phantom     * reads are prevented. This level includes the prohibitions in     * {
    @code ISOLATION_REPEATABLE_READ} and further prohibits the situation     * where one transaction reads all rows that satisfy a {
    @code WHERE}     * condition, a second transaction inserts a row that satisfies that     * {
    @code WHERE} condition, and the first transaction rereads for the     * same condition, retrieving the additional "phantom" row in the second read.     * @see java.sql.Connection#TRANSACTION_SERIALIZABLE     */    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);    private final int value;    Isolation(int value) { this.value = value; }    public int value() { return this.value; }}

 

org.springframework.transaction;

TransactionDefinitio/**

 

 

/**     * Use the default isolation level of the underlying datastore.     * All other levels correspond to the JDBC isolation levels.     * @see java.sql.Connection     */    int ISOLATION_DEFAULT = -1;    /**     * Indicates that dirty reads, non-repeatable reads and phantom reads     * can occur.     * 
This level allows a row changed by one transaction to be read by another     * transaction before any changes in that row have been committed (a "dirty read").     * If any of the changes are rolled back, the second transaction will have     * retrieved an invalid row.     * @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED     */    int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;    /**     * Indicates that dirty reads are prevented; non-repeatable reads and     * phantom reads can occur.     * 
This level only prohibits a transaction from reading a row     * with uncommitted changes in it.     * @see java.sql.Connection#TRANSACTION_READ_COMMITTED     */    int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;    /**     * Indicates that dirty reads and non-repeatable reads are prevented;     * phantom reads can occur.     * 
This level prohibits a transaction from reading a row with uncommitted changes     * in it, and it also prohibits the situation where one transaction reads a row,     * a second transaction alters the row, and the first transaction re-reads the row,     * getting different values the second time (a "non-repeatable read").     * @see java.sql.Connection#TRANSACTION_REPEATABLE_READ     */    int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;    /**     * Indicates that dirty reads, non-repeatable reads and phantom reads     * are prevented.     * 
This level includes the prohibitions in {
    @link #ISOLATION_REPEATABLE_READ}     * and further prohibits the situation where one transaction reads all rows that     * satisfy a {
    @code WHERE} condition, a second transaction inserts a row     * that satisfies that {
    @code WHERE} condition, and the first transaction     * re-reads for the same condition, retrieving the additional "phantom" row     * in the second read.     * @see java.sql.Connection#TRANSACTION_SERIALIZABLE     */    int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;