01: /*
02: * Copyright 2002-2005 the original author or authors.
03: *
04: * Licensed under the Apache License, Version 2.0 (the "License");
05: * you may not use this file except in compliance with the License.
06: * You may obtain a copy of the License at
07: *
08: * http://www.apache.org/licenses/LICENSE-2.0
09: *
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: private final int value;
83:
84: Isolation(int value) {
85: this .value = value;
86: }
87:
88: public int value() {
89: return value;
90: }
91:
92: }
|