Java Transactions and JTA

First, what is the common understanding of Java transactions, the transaction is a set of atomic operations unit, from the database point of view, is a set of SQL instructions, or all successful execution, if for some reason one of the instructions executed error, then undo all previously executed instructions.　　The simpler answer is: either all succeeds or the revocation is not executed. Transactions must be subject to the ACID principles established by ISO/IEC.　　Atomicity (atomicity) Consistency (consistency) isolation (isolation) persistence (durability) atomicity indicates that any failure in the execution of a transaction will invalidate any modifications made by the firm.　　Consistency means that when a transaction fails, all data affected by the transaction should revert to the state it was before the transaction was executed.　　Isolation represents the modification of data during the execution of a transaction and is not visible to other transactions before the transaction commits.　　Persistence indicates that the submitted data should be in the correct state when the transaction execution fails. Since the concept of transactions comes from the database, what is a Java transaction?　　What is the connection between them? In fact, a Java application, if you want to manipulate the database, is implemented through JDBC. Additions, modifications, and deletions are implemented indirectly through the corresponding methods, and the control of transactions is transferred to the Java program code accordingly. Therefore, the transactions of database operations are customarily referred to as Java transactions.　　Second, why the need for Java transaction transaction is to solve the data security operations proposed, transaction control is actually the control of data security access. To give a simple example: for example, bank transfer business, account A to the account of 1000 yuan to the B account, a balance of the first account to subtract 1000 yuan, then the B account to increase 1000 yuan. If there is a problem in the intermediary network, a account minus 1000 yuan has ended, b because the network outage and operation failed, then the entire business failure, must be control, require a account transfer business revocation. This will ensure the correctness of the business, the completion of this operation requires a transaction, the A-account capital reduction and the B-account capital increase into a transaction, or all of the successful execution, or the operation of all the revocation, so that the security of the data. Java transaction types have three types of Java transactions: JDBC transaction, JTA (Java Transaction API) transaction, container transaction. 1. JDBC Transaction JDBC transaction is controlled by Connection object. The JDBC Connection Interface (java.sql.Connection) provides two transaction modes: Autocommit and Manual commit. Java.sql.Connection provides the following methods for controlling transactions: [Java] View plain copy public VoID Setautocommit (Boolean) public boolean getautocommit () public void commit () public void rollback () When using JDBC transaction demarcation, you can add multiple SQL statements into a single transaction. One drawback of JDBC transactions is that the scope of a transaction is limited to a single database connection. A JDBC transaction cannot span multiple databases.　　2. JTA (Java Transaction API) transaction JTA is a high-level, non-implementation-agnostic, protocol-independent API that enables applications and application servers to access transactions using JTA. 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 JTA support of the JDBC driver greatly enhances the data access capability. If you plan to define transactions with JTA, you 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 the JTA transaction. A Xadatasource object is a factory of a Xaconnection object.　　Xaconnections is a JDBC connection that participates in JTA transactions. You will need to set up Xadatasource with the Application Server's administration tool. (the relevant guidance can be learned from the application server and the JDBC driver documentation) The Java EE application queries the data source with JNDI.　　Once the application finds the data source object, it calls Javax.sql.DataSource.getConnection () to get a connection to the database. XA connections are not the same as non-XA connections. Be sure to remember that the XA connection participates in the JTA transaction. This means that the XA connection does not support the auto-commit feature of JDBC. Also, the application must not call Java.sql.Connection.commit () or Java.sql.Connection.rollback () on the XA connection. Instead, applications should use Usertransaction.begin (), Usertransaction.commit (), and Usertransaction.rollback (). 3, container transaction container business is mainly the Java EE Application ServiceThe container transaction is mostly based on JTA, which is a jndi-based, fairly complex API implementation. Relative coding implements JTA transaction management, and we can accomplish the same function through the container transaction management mechanism (CMT) provided by the EJB container, which is provided by the Java EE Application Server. This allows us to simply specify which method to join the transaction, and once specified, the container will be responsible for the transaction management task. This is our way of doing civil work, because in this way we can exclude the transaction code from the logic code, and all the difficulties to the Java EE container to solve. Another benefit of using EJB CMT is that programmers do not have to care about the coding of the JTA API, but in theory we have to use EJBS. Four or three Java transaction differences 1, the limitations of JDBC transaction control are within a database connection, but they are simple to use. 2. JTA transactions are powerful, and transactions can span multiple databases or multiple DAO, and are more complex to use. 3, container transaction, mainly refers to the Java EE Application Server provides transaction management, limited to the use of EJB applications. V. Summarizing the Java transaction control is an indispensable part of building the EE application, and it is very important for the whole application system to choose what kind of transaction to use rationally. In general, the JDBC transaction can be selected in the case of a single JDBC connection connection, with the option to use JTA transactions across multiple connections or databases, and if EJB is used, consider using EJB container transactions. Six, JTA principle Transaction (transaction) divided into two local Transaction and Global Transaction relates to a connection commit, called local Transaction A commit that involves multiple connection, called Global transactionlocal transaction is not a problem with JDBC transaction implementations, but the implementation of global transaction is not guaranteed, So I have to understand the magic of JTA, but in fact such a transaction is problematic, the following will point out that XA requires two phase commit--prepare and commit. Assuming there are two connection, Con1, Con2, the general process is as follows [Java] View plain copy con1 = xaresouce1.getconnection ... con2 = Xaresouce2.getconnec tion. Con1 do some thing. Con2 do some thing. After they finish. Or:1 = Xaresouce1.prepare (); Pre2 = Xaresouce2.prepare (); if (both Pre1 and Pre2 are OK) {XAResouce1 and 2 commit}else {XAResouce1 and 2 rollback} at XAResouce1 and 2 commit XAResouce1 commit () succeeded, XAResouce2 commit () failed. At this point, a "heuristic exception" is thrown. The program can handle this exception. For example, Xaresouce.recover () or something like that. But in general, there is no other way, it is necessary for the data administrator to undo all operations according to the data operation log, or to restore the data backup. Some databases generate an "Anti-action" log when they perform data operations. For example, insert to delete, and so on. The Global Transaction requires support for the XA interface (including in JTA). Import javax.sql.XAConnection; Import Javax.transaction.xa.Xid; Import Javax.transaction.xa.XAResource; Import javax.transaction.xa.XAException; Import javax.transaction.Transaction; Import Javax.transaction.TransactionManager; the javax.sql.XAConnection; Javax.transaction.xa.Xid; Javax.transaction.xa.XAResource; The implementation of these XA interfaces requires JDBC from the database. The database itself is to support XA. The JDBC of the database also provides an implementation of XA. The implementation of TransactionManager can handle multiple xaresouce (a xaresouce list). Like Tyrex. or JBoss EJB server transaction Implementation code excerpt from: "1" http://blog.csdn.net/terryzero/article/details/4464118 "2" http// Blog.csdn.net/terryzero/article/details/4467739 "3" http://blog.csdn.net/codepest/article/details/8437661

Java transactions and JTA