1. What is a Java transaction?

The usual concept is that transactions are related to the database. A transaction is a sequence of operations to access the database. The database application system completes access to the database through transaction sets. The correct execution of transactions causes the database to transition from one state to another.

Transactions must comply with the ACID principles established by ISO/IEC.

ACID is the abbreviation for atomicity, consistency, isolation and durability. Transactions must comply with the ACID principles established by ISO/IEC. ACID is the abbreviation for atomicity, consistency, isolation and durability.

a. Atomicity

means indivisibility. Either all transactions are executed or none are executed. If all sub-transactions of the transaction are submitted successfully, all database operations are submitted and the database state is converted; if any sub-transaction fails, the database operations of other sub-transactions are rolled back, that is, the database returns to the state before the transaction was executed. No state transition occurs.

b. Consistency

The execution of a transaction converts the database from one correct state to another correct state.

c, Isolation

Before the transaction is correctly committed, any changes to the data by the transaction are not allowed to be provided to any other transaction, that is, before the transaction is correctly committed, its possible results are not Should be shown to any other transaction.

d. Durability

After a transaction is submitted correctly, its results will be permanently stored in the database. Even if there are other failures after the transaction is submitted, the processing results of the transaction will be saved.

Since the concept of transaction comes from the database, what is a Java transaction? What's the connection?

In fact, if a Java application system operates a database, it is implemented through JDBC. Then addition, modification, and deletion are all implemented indirectly through corresponding methods, and the control of transactions is also transferred to the Java program code accordingly. Therefore, database operation transactions are customarily called Java transactions.

2. Why transactions are needed

A simple sentence: maintain data consistency.

3. Java transaction types

There are three types of Java transactions: JDBC transactions, JTA (Java Transaction API) transactions, and container transactions. Here is the simplest introduction. Finally, we will introduce the use of jdbc transactions. You can search and learn the other two types by yourself.

a. JDBC transactions

JDBC transactions are controlled using Connection objects. The JDBC Connection interface (java.sql.Connection) provides two transaction modes: automatic submission and manual submission. java.sql.Connection provides the following methods to control transactions:

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

When using JDBC transaction demarcation, you can combine multiple SQL statements into a single transaction. One disadvantage of JDBC transactions is that the scope of the transaction is limited to one database connection. A JDBC transaction cannot span multiple databases.

b. JTA (Java Transaction API) transaction

JTA is a high-level, implementation-independent, and protocol-independent API. Applications and application servers can use JTA to access transactions. .

JTA allows applications to perform distributed transactions - access and update data on two or more network computer resources, which can be distributed across multiple databases. The JDBC driver's JTA support greatly enhances data access capabilities.

If you plan to use JTA to define transactions, you will need a JDBC driver that implements the javax.sql.XADataSource, javax.sql.XAConnection, and javax.sql.XAResource interfaces.

A driver that implements these interfaces will be able to participate in JTA transactions. A XADataSource object is a factory for XAConnection objects. XAConnections are JDBC connections that participate in JTA transactions, and you will need to set up the XADataSource using the application server's administration tools.

J2EE applications use JNDI to query data sources. Once the application finds the data source object, it calls javax.sql.DataSource.getConnection() to obtain a connection to the database.

XA connections are different from non-XA connections. It is important to remember that XA connections participate in JTA transactions. This means that XA connections do not support JDBC's autocommit feature. At the same time, applications must not call java.sql.Connection.commit() or java.sql.Connection.rollback() on XA connections.

Instead, applications should use UserTransaction.begin(), UserTransaction.commit(), and serTransaction.rollback().?

c. Container transactions

Container transactions are mainly provided by the J2EE application server. Most container transactions are completed based on JTA. This is a fairly complex API implementation based on JNDI. Compared with coding to implement JTA transaction management, we can complete the same function through the container transaction management mechanism (CMT) provided by the EJB container. This function is provided by the J2EE application server.

This allows us to simply specify which method to add to the transaction. Once specified, the container will be responsible for transaction management tasks. This is our civil engineering solution, because in this way we can exclude transaction code from logical coding, and at the same time leave all difficulties to the J2EE container to solve.

使用EJB CMT的另外一個好處就是程序員無需關心JTA API的編碼，不過，理論上我們必須使用EJB。

d、JDBC事務的使用

(1)步驟：

首先，設置事務的提交方式為非自動提交：conn.setAutoCommit(false);接下來，將需要添加事務的代碼放入try，catch塊中。

然后，在try塊內(nèi)添加事務的提交操作，表示操作無異常，提交事務：conn.commit();尤其不要忘記，在catch塊內(nèi)添加回滾事務，表示操作出現(xiàn)異常，撤銷事務：conn.rollback();最后，設置事務提交方式為自動提交：conn.setAutoCommit(true);這樣，通過簡單的幾步，我們就可以完成對事務處理的編寫了。

(2)偽代碼：

con = DriverManager.getConnection(url, user, password)；
String result = "";
String sql1 = "";
// LAST_INSERT_ID() 獲取剛剛插入的自動遞增的ID
String sql2 = "";
int flag;
try {
    con.setAutoCommit(false);// 更改JDBC事務的默認提交方式
    pstmt = con.prepareStatement(sql1);
    flag = pstmt.executeUpdate();
    if (flag > 0) {
        pstmt = con.prepareStatement(sql2);
        int i = pstmt.executeUpdate();
        if (i > 0) {
            con.commit();//提交JDBC事務
            result = "add data success!!";
        } else {
            result = "add data fail!!";
       }
    } else {
        result = "add data fail!!";
    }
} catch (SQLException e) {
    try {
        con.rollback();//回滾JDBC事務
    } catch (SQLException e1) {
    // TODO Auto-generated catch block
        result = "add data fail!! SQLException";
        e1.printStackTrace();
    }
    result = "add data fail!! SQLException";
    e.printStackTrace();
} finally {
    try {
        con.setAutoCommit(true); // 恢復JDBC事務的默認提交方式
    } catch (SQLException e) {
    // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
return result;

4、三種事務差異

1、JDBC事務控制的局限性在一個數(shù)據(jù)庫連接內(nèi)，但是其使用簡單。

2、JTA事務的功能強大，事務可以跨越多個數(shù)據(jù)庫或多個DAO，使用也比較復雜。

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

5、總結(jié)

事務控制是構(gòu)建J2EE應用不可缺少的一部分，合理選擇應用何種事務對整個應用系統(tǒng)來說至關重要。一般說來，在單個JDBC 連接連接的情況下可以選擇JDBC事務，在跨多個連接或者數(shù)據(jù)庫情況下，需要選擇使用JTA事務，如果用到了EJB，則可以考慮使用EJB容器事務。

更多相關知識請關注java基礎教程欄目

The above is the detailed content of Transaction processing in JAVA. For more information, please follow other related articles on the PHP Chinese website!