Java 数据库事务管理

Question

I would like a Java based transaction manager that can handle nested database transactions in a web environment (database calls from different classes can share a transaction, and thread safe).

I believe this is possible because I recall that C# has something roughly equivalent to this:

namespace ConsoleApp
{
    class Program
    {
        public static readonly String CONNECTION_STRING = "x";

        static void Main(String[] args)
        {
            using (var transaction = new TransactionScope())
            {
                (new Person()).insertRecords();
                (new Hobbies()).insertRelatedRecords(); // Can see Person records
                transaction.Dispose();
            }
            (new Hobbies()).insertRelatedRecords(); // Can't see Person records
        }
    }

    public class Person
    {
        public void insertRecords() {
            using (SqlConnection conn = new SqlConnection(Program.CONNECTION_STRING)) {
                conn.Open();
                // insert records
            }
        }
    }

    public class Hobbies
    {
        public void insertRelatedRecords() {
            using (SqlConnection conn = new SqlConnection(Program.CONNECTION_STRING)) {
                conn.Open();
                // insert records
            }
        }
    }
}

In the example above, I am hoping to illustrate my intent to exercise the code, "Person and Hobbies must both complete the transaction successfully, otherwise roll back both of their changes. Hobbies should be able to see the data inserted by Person because it happened first in the transaction." It is important that these are happening in different classes or methods, but managed from the parent without having to pass around a connection or transaction object.

My application currently runs on Tomcat and creates database connections using an Oracle pooled connection (OracleDataSource class). It doesn't use Tomcat's database context. A single user/schema/login is used for all connections.

Realistically I only have Java librairies available to use, as requesting new libraries takes months and requests are often denied. I do have Oracle and Tomcat right now, but these may be changed in the future, so my solution must be in pure Java. There are no plans to add Spring or Hibernate.

Here is a minimalistic version of the Java class structure in the application:

public class Program {

    public static void main(String[] args) 
    {
        try {
            Program program = new Program();
            (program.new Person()).insertRecords();
            (program.new Hobbies()).insertRelatedRecords();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // Core classes //
    
    public static class DbDataSource 
    {
        private static DataSource dataSource;
        
        public static synchronized DataSource getDataSource() throws SQLException {
            if (dataSource == null) {
                OracleDataSource ods = new OracleDataSource();
                ods.setDriverType("x");
                ods.setURL("x");
                ods.setUser("x");
                ods.setPassword("x");
                dataSource = ods;
            }
            return dataSource;
        }
    }
    
    public class DbResource implements AutoCloseable
    {
        private Connection connection;
        
        public synchronized Connection getConnection() throws SQLException {
            if (connection == null) {
                connection = DbDataSource.getDataSource().getConnection();
            }
            return connection;
        }

        @Override
        public void close() throws Exception {
            if (connection != null) {
                connection.close();
                connection = null;
            }
        }
    }
    
    // Data base classes //
    
    public class DbClass 
    {
        private DbResource db;
        
        protected synchronized DbResource getDatabaseResource() {
            if (db == null) {
                db = new DbResource();
            }
            return db;
        }
    }
    
    // Data classes //
    
    public class Person extends DbClass
    {
        public void insertRecords() throws Exception {
            try (DbResource db = this.getDatabaseResource()) {
                // insert records
            }
        }
    }
    
    public class Hobbies extends DbClass
    {
        public void insertRelatedRecords() throws Exception {
            try (DbResource db = this.getDatabaseResource()) {
                // insert records related to Person
            }
        }
    }

}

My goal is to implement this without changing the Data class (rewriting the Data base class is fine). The idea would be to have code that resembles how transactions work in C# (but I'm also welcoming a better proposed solution). Something like the following:

public class Program {

    public static void main(String[] args) {
        try {
            try (DbTransaction transaction = new DbTransaction()) {
                Program program = new Program();
                (program.new Person()).insertRecords();
                (program.new Hobbies()).insertRelatedRecords(); // Can see person records
                transaction.rollback();
            }
            (program.new Hobbies()).insertRelatedRecords(); // Can't see person records
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // ... rest of the class ...
}

My current line of thinking include storing a static List or Map of transaction objects every time they are created, and pop them off when transaction.commit() is called (or the object is disposed and AutoCommit is on). However, this only works in a single threaded application (like many Desktop applications). I could restrict it to the current web session, by using a Map<Session, List>, but this is still not thread safe within the session. If a user opens multiple pages while they are still loading, this would fail to isolate them.

I'm not sure how to solve this for a web application that requires unique transaction lists for each scope/code stack. I don't believe there is any way to ask for instantiated objects within the current scope (that would include parent classes).

This is further complicated by pooled connections, where I cannot guarantee that any two calls share the same connection. However, if I could figure out a multi-threaded solution, I can worry about pooled connections separately.

Answer 1

The Oracle client already contains this functionality. On your Oracle connection, run the .setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED) method to allow dirty reads within a transaction. Then, disable auto-commit mode to allow you to manually commit or rollback operations on the connection using setAutoCommit(false) . Alternatively, you could also use Savepoints.

All of these are detailed in Oracle's JDBC tutorial .