KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > springframework > transaction > annotation > Isolation


1 /*
2  * Copyright 2002-2005 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.springframework.transaction.annotation;
18
19 import org.springframework.transaction.TransactionDefinition;
20
21 /**
22  * Enumeration that represents transaction isolation levels
23  * for use with the JDK 1.5+ transaction annotation, corresponding
24  * to the TransactionDefinition interface.
25  *
26  * @author Colin Sampaleanu
27  * @author Juergen Hoeller
28  * @since 1.2
29  * @see org.springframework.transaction.annotation.Transactional
30  * @see org.springframework.transaction.TransactionDefinition
31  */
32 public enum Isolation {
33     
34     /**
35      * Use the default isolation level of the underlying datastore.
36      * All other levels correspond to the JDBC isolation levels.
37      * @see java.sql.Connection
38      */
39     DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
40
41     /**
42      * A constant indicating that dirty reads, non-repeatable reads and phantom reads
43      * can occur. This level allows a row changed by one transaction to be read by
44      * another transaction before any changes in that row have been committed
45      * (a "dirty read"). If any of the changes are rolled back, the second
46      * transaction will have retrieved an invalid row.
47      * @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED
48      */
49     READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
50
51     /**
52      * A constant indicating that dirty reads are prevented; non-repeatable reads
53      * and phantom reads can occur. This level only prohibits a transaction
54      * from reading a row with uncommitted changes in it.
55      * @see java.sql.Connection#TRANSACTION_READ_COMMITTED
56      */
57     READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
58
59     /**
60      * A constant indicating that dirty reads and non-repeatable reads are
61      * prevented; phantom reads can occur. This level prohibits a transaction
62      * from reading a row with uncommitted changes in it, and it also prohibits
63      * the situation where one transaction reads a row, a second transaction
64      * alters the row, and the first transaction rereads the row, getting
65      * different values the second time (a "non-repeatable read").
66      * @see java.sql.Connection#TRANSACTION_REPEATABLE_READ
67      */
68     REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
69
70     /**
71      * A constant indicating that dirty reads, non-repeatable reads and phantom
72      * reads are prevented. This level includes the prohibitions in
73      * <code>ISOLATION_REPEATABLE_READ</code> and further prohibits the situation
74      * where one transaction reads all rows that satisfy a <code>WHERE</code>
75      * condition, a second transaction inserts a row that satisfies that
76      * <code>WHERE</code> condition, and the first transaction rereads for the
77      * same condition, retrieving the additional "phantom" row in the second read.
78      * @see java.sql.Connection#TRANSACTION_SERIALIZABLE
79      */
80     SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);
81
82
83     private final int value;
84
85
86     Isolation(int value) { this.value = value; }
87     
88     public int value() { return value; }
89     
90 }
91
Popular Tags