java 事务的底层 java事务有哪些

转载

编程梦想实现家 2023-07-15 18:05:25

文章标签 java 事务的底层数据库数据库连接 sql 文章分类 Java 后端开发

Java事务的类型有三种。

JDBC事务、JTA（Java Transaction API）事务、容器事务。

1、JDBC事务

　　JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口（ java.sql.Connection ）提供了两种事务模式：自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法：

public void setAutoCommit(boolean)  
public boolean getAutoCommit()  
public void commit()  
public void rollback()
public void setAutoCommit(boolean)  
public boolean getAutoCommit()  
public void commit()  
public void rollback()

　　使用 JDBC 事务界定时，您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

2、JTA

JTA是一种高层的，与实现无关的，与协议无关的API，应用程序和应用服务器可以使用JTA来访问事务。

　　JTA允许应用程序执行分布式事务处理——在两个或多个网络计算机资源上访问并且更新数据，这些数据可以分布在多个数据库上。JDBC驱动程序的JTA支持极大地增强了数据访问能力。

　　如果计划用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnections 是参与 JTA 事务的 JDBC 连接。

　　您将需要用应用服务器的管理工具设置 XADataSource。（从应用服务器和 JDBC 驱动程序的文档中可以了解到相关的指导）

　　J2EE应用程序用 JNDI 查询数据源。一旦应用程序找到了数据源对象，它就调用 javax.sql.DataSource.getConnection（）以获得到数据库的连接。

　　XA 连接与非 XA 连接不同。一定要记住 XA 连接参与了 JTA 事务。这意味着 XA 连接不支持 JDBC 的自动提交功能。同时，应用程序一定不要对 XA 连接调用 java.sql.Connection.commit（）或者 java.sql.Connection.rollback（） .相反，应用程序应该使用 UserTransaction.begin（）、 UserTransaction.commit（）和 UserTransaction.rollback（）

2.1 JTA 分布式事务处理（注意：connA 和 connB 是来自不同数据库的连接）

public void transferAccount() { 
 UserTransaction userTx = null; 
 Connection connA = null; 
 Statement stmtA = null; 
 Connection connB = null; 
 Statement stmtB = null; 
    
 try{ 
       // 获得 Transaction 管理对象
 userTx = (UserTransaction)getContext().lookup("\
       java:comp/UserTransaction"); 
 // 从数据库 A 中取得数据库连接
 connA = getDataSourceA().getConnection(); 
 // 从数据库 B 中取得数据库连接
 connB = getDataSourceB().getConnection(); 
      
                        // 启动事务
 userTx.begin();
 // 将 A 账户中的金额减少 500 
 stmtA = connA.createStatement(); 
 stmtA.execute("
            update t_account set amount = amount - 500 where account_id = 'A'");
 // 将 B 账户中的金额增加 500 
 stmtB = connB.createStatement(); 
 stmtB.execute("\
             update t_account set amount = amount + 500 where account_id = 'B'");
 // 提交事务
 userTx.commit();
 // 事务提交：转账的两步操作同时成功（数据库 A 和数据库 B 中的数据被同时更新）
 } catch(SQLException sqle){ 
 try{ 
         // 发生异常，回滚在本事务中的操纵
                  userTx.rollback();
 // 事务回滚：转账的两步操作完全撤销 
 //( 数据库 A 和数据库 B 中的数据更新被同时撤销）
 stmt.close(); 
                 conn.close(); 
 ... 
 }catch(Exception ignore){ 
 } 
 sqle.printStackTrace(); 
 } catch(Exception ne){ 
 e.printStackTrace(); 
 } 
 }
public void transferAccount() { 
 UserTransaction userTx = null; 
 Connection connA = null; 
 Statement stmtA = null; 
 Connection connB = null; 
 Statement stmtB = null; 
    
 try{ 
       // 获得 Transaction 管理对象
 userTx = (UserTransaction)getContext().lookup("\
       java:comp/UserTransaction"); 
 // 从数据库 A 中取得数据库连接
 connA = getDataSourceA().getConnection(); 
 // 从数据库 B 中取得数据库连接
 connB = getDataSourceB().getConnection(); 
      
                        // 启动事务
 userTx.begin();
 // 将 A 账户中的金额减少 500 
 stmtA = connA.createStatement(); 
 stmtA.execute("
            update t_account set amount = amount - 500 where account_id = 'A'");
 // 将 B 账户中的金额增加 500 
 stmtB = connB.createStatement(); 
 stmtB.execute("\
             update t_account set amount = amount + 500 where account_id = 'B'");
 // 提交事务
 userTx.commit();
 // 事务提交：转账的两步操作同时成功（数据库 A 和数据库 B 中的数据被同时更新）
 } catch(SQLException sqle){ 
 try{ 
         // 发生异常，回滚在本事务中的操纵
                  userTx.rollback();
 // 事务回滚：转账的两步操作完全撤销 
 //( 数据库 A 和数据库 B 中的数据更新被同时撤销）
 stmt.close(); 
                 conn.close(); 
 ... 
 }catch(Exception ignore){ 
 } 
 sqle.printStackTrace(); 
 } catch(Exception ne){ 
 e.printStackTrace(); 
 } 
 }

3、容器事务

　　容器事务主要是J2EE应用服务器提供的，容器事务大多是基于JTA完成，这是一个基于JNDI的，相当复杂的API实现。相对编码实现JTA事务管理，我们可以通过EJB容器提供的容器事务管理机制（CMT）完成同一个功能，这项功能由J2EE应用服务器提供。这使得我们可以简单的指定将哪个方法加入事务，一旦指定，容器将负责事务管理任务。这是我们土建的解决方式，因为通过这种方式我们可以将事务代码排除在逻辑编码之外，同时将所有困难交给J2EE容器去解决。使用EJB CMT的另外一个好处就是程序员无需关心JTA API的编码，不过，理论上我们必须使用EJB.

4、上述三种事务的差异

1、JDBC事务控制的局限性在一个数据库连接内，但是其使用简单。

2、JTA事务的功能强大，事务可以跨越多个数据库或多个DAO，使用也比较复杂。

3、容器事务，主要指的是J2EE应用服务器提供的事务管理，局限于EJB应用使用。

5、JTA 实现原理

很多开发人员都会对 JTA 的内部工作机制感兴趣：我编写的代码没有任何与事务资源（如数据库连接）互动的代码，但是我的操作（数据库更新）却实实在在的被包含在了事务中，那 JTA 究竟是通过何种方式来实现这种透明性的呢？要理解 JTA 的实现原理首先需要了解其架构：它包括事务管理器（Transaction Manager）和一个或多个支持 XA 协议的资源管理器 ( Resource Manager ) 两部分，我们可以将资源管理器看做任意类型的持久化数据存储；事务管理器则承担着所有事务参与单元的协调与控制。根据所面向对象的不同，我们可以将 JTA 的事务管理器和资源管理器理解为两个方面：面向开发人员的使用接口（事务管理器）和面向服务提供商的实现接口（资源管理器）。其中开发接口的主要部分即为上述示例中引用的 UserTransaction 对象，开发人员通过此接口在信息系统中实现分布式事务；而实现接口则用来规范提供商（如数据库连接提供商）所提供的事务服务，它约定了事务的资源管理功能，使得 JTA 可以在异构事务资源之间执行协同沟通。以数据库为例，IBM 公司提供了实现分布式事务的数据库驱动程序，Oracle 也提供了实现分布式事务的数据库驱动程序，在同时使用 DB2 和 Oracle 两种数据库连接时， JTA 即可以根据约定的接口协调者两种事务资源从而实现分布式事务。正是基于统一规范的不同实现使得 JTA 可以协调与控制不同数据库或者 JMS 厂商的事务资源，其架构如下图所示：

java 事务的底层 java事务有哪些_数据库连接

下面将通过具体的代码向读者介绍 JTA 实现原理。下图列出了示例实现中涉及到的 Java 类，其中 UserTransactionImpl 实现了 UserTransaction 接口，TransactionManagerImpl 实现了 TransactionManager 接口，TransactionImpl 实现了 Transaction 接口。

java 事务的底层 java事务有哪些_数据库_02

清单 3. 开始事务 - 
UserTransactionImpl implenments UserTransaction
public void begin() throws NotSupportedException, SystemException { 
   // 将开始事务的操作委托给 TransactionManagerImpl 
   TransactionManagerImpl.singleton().begin(); 
     }
清单 3. 开始事务 - 
UserTransactionImpl implenments UserTransaction
public void begin() throws NotSupportedException, SystemException { 
   // 将开始事务的操作委托给 TransactionManagerImpl 
   TransactionManagerImpl.singleton().begin(); 
     }

清单 4. 开始事务 - 
TransactionManagerImpl implements TransactionManager
// 此处 transactionHolder 用于将 Transaction 所代表的事务对象关联到线程上
private static ThreadLocal<TransactionImpl> transactionHolder 
        = new ThreadLocal<TransactionImpl>(); 
 //TransacationMananger 必须维护一个全局对象，因此使用单实例模式实现
 private static TransactionManagerImpl singleton = new TransactionManagerImpl(); 
 private TransactionManagerImpl(){ 
 } 
 public static TransactionManagerImpl singleton(){ 
 return singleton; 
 } 
 public void begin() throws NotSupportedException, SystemException { 
 //XidImpl 实现了 Xid 接口，其作用是唯一标识一个事务
 XidImpl xid = new XidImpl(); 
 // 创建事务对象，并将对象关联到线程
 TransactionImpl tx = new TransactionImpl(xid); 
 transactionHolder.set(tx); 
 }
清单 4. 开始事务 - 
TransactionManagerImpl implements TransactionManager
// 此处 transactionHolder 用于将 Transaction 所代表的事务对象关联到线程上
private static ThreadLocal<TransactionImpl> transactionHolder 
        = new ThreadLocal<TransactionImpl>(); 
 //TransacationMananger 必须维护一个全局对象，因此使用单实例模式实现
 private static TransactionManagerImpl singleton = new TransactionManagerImpl(); 
 private TransactionManagerImpl(){ 
 } 
 public static TransactionManagerImpl singleton(){ 
 return singleton; 
 } 
 public void begin() throws NotSupportedException, SystemException { 
 //XidImpl 实现了 Xid 接口，其作用是唯一标识一个事务
 XidImpl xid = new XidImpl(); 
 // 创建事务对象，并将对象关联到线程
 TransactionImpl tx = new TransactionImpl(xid); 
 transactionHolder.set(tx); 
 }

现在我们就可以理解 Transaction 接口上没有定义 begin 方法的原因了：Transaction 对象本身就代表了一个事务，在它被创建的时候就表明事务已经开始，因此也就不需要额外定义 begin() 方法了。

清单 5. 提交事务 -
UserTransactionImpl implenments UserTransaction
      public void commit() throws RollbackException, HeuristicMixedException, 
 HeuristicRollbackException, SecurityException, 
 IllegalStateException, SystemException { 
 // 检查是否是 Roll back only 事务，如果是回滚事务
        if(rollBackOnly){ 
     rollback(); 
     return; 
       } else { 
    // 将提交事务的操作委托给 TransactionManagerImpl 
    TransactionManagerImpl.singleton().commit(); 
       } 
 }
清单 5. 提交事务 -
UserTransactionImpl implenments UserTransaction
      public void commit() throws RollbackException, HeuristicMixedException, 
 HeuristicRollbackException, SecurityException, 
 IllegalStateException, SystemException { 
 // 检查是否是 Roll back only 事务，如果是回滚事务
        if(rollBackOnly){ 
     rollback(); 
     return; 
       } else { 
    // 将提交事务的操作委托给 TransactionManagerImpl 
    TransactionManagerImpl.singleton().commit(); 
       } 
 }

清单 6. 提交事务 - 
TransactionManagerImpl implenments TransactionManager
public void commit() throws RollbackException, HeuristicMixedException, 
    HeuristicRollbackException, SecurityException, 
    IllegalStateException, SystemException { 
     // 取得当前事务所关联的事务并通过其 commit 方法提交
     TransactionImpl tx = transactionHolder.get(); 
     tx.commit(); 
         }
清单 6. 提交事务 - 
TransactionManagerImpl implenments TransactionManager
public void commit() throws RollbackException, HeuristicMixedException, 
    HeuristicRollbackException, SecurityException, 
    IllegalStateException, SystemException { 
     // 取得当前事务所关联的事务并通过其 commit 方法提交
     TransactionImpl tx = transactionHolder.get(); 
     tx.commit(); 
         }

同理， rollback、getStatus、setRollbackOnly 等方法也采用了与 commit() 相同的方式实现。 UserTransaction 对象不会对事务进行任何控制，所有的事务方法都是通过 TransactionManager 传递到实际的事务资源即 Transaction 对象上。

上述示例演示了 JTA 事务的处理过程，下面将为您展示事务资源（数据库连接，JMS）是如何以透明的方式加入到 JTA 事务中的。首先需要明确的一点是，在 JTA 事务代码中获得的数据库源 ( DataSource ) 必须是支持分布式事务的。在如下的代码示例中，尽管所有的数据库操作都被包含在了 JTA 事务中，但是因为 MySql 的数据库连接是通过本地方式获得的，对 MySql 的任何更新将不会被自动包含在全局事务中。

清单 7. JTA 事务处理
 public void transferAccount() { 
 UserTransaction userTx = null; 
 Connection mySqlConnection = null; 
 Statement mySqlStat = null; 
 Connection connB = null; 
 Statement stmtB = null; 
    
 try{ 
        // 获得 Transaction 管理对象
 userTx = (UserTransaction)getContext().lookup("java:comp/UserTransaction");
 // 以本地方式获得 mySql 数据库连接
 mySqlConnection = DriverManager.getConnection("localhost:1111"); 
 // 从数据库 B 中取得数据库连接， getDataSourceB 返回应用服务器的数据源
 connB = getDataSourceB().getConnection(); 
      
 // 启动事务
 userTx.begin();
 // 将 A 账户中的金额减少 500 
 //mySqlConnection 是从本地获得的数据库连接，不会被包含在全局事务中
 mySqlStat = mySqlConnection.createStatement(); 
 mySqlStat.execute("update t_account set amount = amount - 500 where account_id = 'A'");
 //connB 是从应用服务器得的数据库连接，会被包含在全局事务中
 stmtB = connB.createStatement(); 
 stmtB.execute("update t_account set amount = amount + 500 where account_id = 'B'");
 // 事务提交：connB 的操作被提交，mySqlConnection 的操作不会被提交
 userTx.commit();
 } catch(SQLException sqle){ 
 // 处理异常代码
 } catch(Exception ne){ 
 e.printStackTrace(); 
 } 
 }
清单 7. JTA 事务处理
 public void transferAccount() { 
 UserTransaction userTx = null; 
 Connection mySqlConnection = null; 
 Statement mySqlStat = null; 
 Connection connB = null; 
 Statement stmtB = null; 
    
 try{ 
        // 获得 Transaction 管理对象
 userTx = (UserTransaction)getContext().lookup("java:comp/UserTransaction");
 // 以本地方式获得 mySql 数据库连接
 mySqlConnection = DriverManager.getConnection("localhost:1111"); 
 // 从数据库 B 中取得数据库连接， getDataSourceB 返回应用服务器的数据源
 connB = getDataSourceB().getConnection(); 
      
 // 启动事务
 userTx.begin();
 // 将 A 账户中的金额减少 500 
 //mySqlConnection 是从本地获得的数据库连接，不会被包含在全局事务中
 mySqlStat = mySqlConnection.createStatement(); 
 mySqlStat.execute("update t_account set amount = amount - 500 where account_id = 'A'");
 //connB 是从应用服务器得的数据库连接，会被包含在全局事务中
 stmtB = connB.createStatement(); 
 stmtB.execute("update t_account set amount = amount + 500 where account_id = 'B'");
 // 事务提交：connB 的操作被提交，mySqlConnection 的操作不会被提交
 userTx.commit();
 } catch(SQLException sqle){ 
 // 处理异常代码
 } catch(Exception ne){ 
 e.printStackTrace(); 
 } 
 }

为什么必须从支持事务的数据源中获得的数据库连接才支持分布式事务呢？其实支持事务的数据源与普通的数据源是不同的，它实现了额外的 XADataSource 接口。我们可以简单的将 XADataSource 理解为普通的数据源（继承了 java.sql.PooledConnection），只是它为支持分布式事务而增加了 getXAResource 方法。另外，由 XADataSource 返回的数据库连接与普通连接也是不同的，此连接除了实现 java.sql.Connection 定义的所有功能之外还实现了 XAConnection 接口。我们可以把 XAConnection 理解为普通的数据库连接，它支持所有 JDBC 规范的数据库操作，不同之处在于 XAConnection 增加了对分布式事务的支持。通过下面的类图读者可以对这几个接口的关系有所了解：

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。