A. java中的JDBC事务和JTA的区别是什么
在说他们之间的区别之前，先考虑如下几个问题：
1、getCurrentSession()与openSession()的区别？
* 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()
创建的session则不会
* 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession()
创建的session必须手动关闭
2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：
* 如果使用的是本地事务（jdbc事务）
<property name="hibernate.current_session_context_class">thread</property>
* 如果使用的是全局事务（jta事务）
<property name="hibernate.current_session_context_class">jta</property>
以上是hibernate中一些使用，下面来说说jdbc与jta的区别：
JDBC 事务
JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。
#在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。
# 在jdbc中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调 用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用 rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下：
try {
conn =
DriverManager.getConnection
("jdbc:oracle:thin:@host:1521:SID","username","userpwd";
conn.setAutoCommit(false);//禁止自动提交，设置回滚点
stmt = conn.createStatement();
stmt.executeUpdate(“alter table …”); //数据库更新操作1
stmt.executeUpdate(“insert into table …”); //数据库更新操作2
conn.commit(); //事务提交
}catch(Exception ex) {
ex.printStackTrace();
try {
conn.rollback(); //操作不成功则回滚
}catch(Exception e) {
e.printStackTrace();
}
}
JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。
JTA事务
JTA(Java Transaction API) 为 J2EE 平台提供了分布式事务服务。
要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。例如：
utx.begin();
// ...
DataSource ds = obtainXADataSource();
Connection conn = ds.getConnection();
pstmt = conn.prepareStatement("UPDATE MOVIES ...");
pstmt.setString(1, "Spinal Tap");
pstmt.executeUpdate();
// ...
utx.commit();
让我们来关注下面的话：
“用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。”
要使用JTA事务，必须使用XADataSource来产生数据库连接，产生的连接为一个XA连接。
XA连接（javax.sql.XAConnection）和非XA（java.sql.Connection）连接的区别在于：XA可以参与JTA的事务，而且不支持自动提交。
注意:
Oracle, Sybase, DB2, SQL Server等大型数据库才支持XA, 支持分布事务。
My SQL 连本地都支持不好，更别说分布事务了。
JTA方式的实现过程：
用XADataSource产生的XAConnection它扩展了一个getXAResource()方法,事务通过这个方法把它加入到事务容器中进行 管理.对于调用者来说,根本看不到事务是如果管理的,你只要声明开始事务,告诉容器我下面的操作要求事务参与了,最后告诉事务说到这儿可以提交或回滚了, 别的都是黑箱操作。
在使用JTA之前，你必须首先实现一个Xid类用来标识事务（在普通情况下这将由事务管理程序来处理）。Xid包含三个元素：formatID、gtrid（全局事务标识符）和bqual（分支修饰词标识符）。
下面的例子说明Xid的实现：
import javax.transaction.xa.*;
public class MyXid implements Xid
{
protected int formatId;
protected byte gtrid[];
protected byte bqual[];
public MyXid()
{
}
public MyXid(int formatId, byte gtrid[], byte bqual[])
{
this.formatId = formatId;
this.gtrid = gtrid;
this.bqual = bqual;
}
public int getFormatId()
{
return formatId;
}
public byte[] getBranchQualifier()
{
return bqual;
}
public byte[] getGlobalTransactionId()
{
return gtrid;
}
}
其次，你需要创建一个你要使用的数据库的数据源：
public DataSource getDataSource()
throws SQLException
{
SQLServerDataSource xaDS = new
com.merant.datadirect.jdbcx.sqlserver.SQLServerDataSource();
xaDS.setDataSourceName("SQLServer");
xaDS.setServerName("server");
xaDS.setPortNumber(1433);
xaDS.setSelectMethod("cursor");
return xaDS;
}
例1 这个例子是用“两步提交协议”来提交一个事务分支：
XADataSource xaDS;
XAConnection xaCon;
XAResource xaRes;
Xid xid;
Connection con;
Statement stmt;
int ret;
xaDS = getDataSource();
xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password");
xaRes = xaCon.getXAResource();
con = xaCon.getConnection();
stmt = con.createStatement();
xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02});
try {
xaRes.start(xid, XAResource.TMNOFLAGS);
stmt.executeUpdate("insert into test_table values (100)");
xaRes.end(xid, XAResource.TMSUCCESS);
ret = xaRes.prepare(xid);
if (ret == XAResource.XA_OK) {
xaRes.commit(xid, false);
}
}
catch (XAException e) {
e.printStackTrace();
}
finally {
stmt.close();
con.close();
xaCon.close();
}
当然，实际过程中，我们不需要写这些代码，这些代码是JTA最终的实现代码。
关于“两步提交协议”，可以参看下面的文章：
http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0505weber/index.html
两阶段提交（Two-Phase-Commit）协议
首先，两阶段提交（Two-Phase-Commit）事务的启动与常规的单阶段提交（One-Phase-Commit）事务类似。接着，应用程序/客 户机对该两阶段提交（Two-Phase-Commit）操作中所涉及的所有数据库执行其修改工作。现在，在最终提交该事务之前，客户机通知参与的数据库准备提交（第 1 阶段）。如果客户机从数据库收到一条“okay”，就发出命令向数据库提交该事务（第 2 阶段）。最后分布式事务（Distributed Transaction）结束。
上面的例子演示了如何在 Java 中使用 JTA 实现两阶段提交（Two-Phase-Commit）协议。在该应用程序中，如果一个事务分支报告了错误，您就要负责进行错误处理。但是“两阶段提交协议 简介”小节中提到仍然存在一个问题，那就是如果第 2 阶段中一个事务分支发生故障，该怎么办呢？
如果再次查看程序代码，您可以看到在“第 1 阶段”和“第 2 阶段”之间有一个很小的时间间隔。在这一时间间隔中，出于某种理由，其中某一参与数据库可能崩溃。如果发生了，我们将陷入分布式事务已经部分提交的情形中。
假 定下列情形：在“第 1 阶段”之后，您从 DB2 和 IDS 数据库中都收到了“okay”。在下一步中，应用程序成功提交了 DB2 的事务分支。接着，应用程序通知 DB2 事务分支提交事务。现在，在应用程序可以通知 IDS 事务分支提交它这一部分之前，IDS 引擎由于断电发生崩溃。这就是一种部分提交全局事务的情形。您现在该怎么办呢？
在重启之后，DB2 和 IDS 都将尝试恢复打开的事务分支。该引擎等待来自应用程序的提示如何做。如果应用程序没有准备重新发送“第 2 阶段”的提交，该事务分支将被引擎所启动的试探性回滚中止。这是非常糟糕的，因为这将使该全局事务处于不一致状态。
一种解决方案是用一个小型应用程序连接引擎中打开的事务分支，并通知引擎提交或回滚这一打开的事务。如果您使用 IDS 作为后端，那么还有一个隐藏的 onmode 标志，允许您结束打开的事务分支。（onmode -Z xid）。
在 DB2 UDB 中，您可以发出 LIST INDOUBT TRANSACTIONS 来获得打开的 XA 事务的有关信息。您必须查看 DB2 Information Center 中的描述来解决该问题。
上面描述的情形是一个很好的例子，也是使用应用程序服务器（Application Server）或事务监控器（Transaction Monitor）的理由。在使用一个中间层服务器时，就由该服务器负责保持事情正常。
B. jdbc有哪些事务，各个事务特点
事务的：原子性、一致性、分离性、持久性
原子性、一致性、分离性、持久性
(1) 原子性
事务的原子性指的是，事务中包含的程序作为数据库的逻辑工作单位，它所做的对数据修改操作要么全部执行，要么完全不执行。这种特性称为原子性。
事务的原子性要求，如果把一个事务可看作是一个程序，它要么完整的被执行，要么完全不执行。就是说事务的操纵序列或者完全应用到数据库或者完全不影响数据库。这种特性称为原子性。
假如用户在一个事务内完成了对数据库的更新，这时所有的更新对外部世界必须是可见的，或者完全没有更新。前者称事务已提交，后者称事务撤消（或流产）。DBMS必须确保由成功提交的事务完成的所有操纵在数据库内有完全的反映，而失败的事务对数据库完全没有影响。
(2) 一致性
事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。这种特性称为事务的一致性。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。
一致性处理数据库中对所有语义约束的保护。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。例如，当数据库处于一致性状态S1时，对数据库执行一个事务，在事务执行期间假定数据库的状态是不一致的，当事务执行结束时，数据库处在一致性状态S2。
(3) 分离性
分离性指并发的事务是相互隔离的。即一个事务内部的操作及正在操作的数据必须封锁起来，不被其它企图进行修改的事务看到。
分离性是DBMS针对并发事务间的冲突提供的安全保证。DBMS可以通过加锁在并发执行的事务间提供不同级别的分离。假如并发交叉执行的事务没有任何控制，操纵相同的共享对象的多个并发事务的执行可能引起异常情况。
DBMS可以在并发执行的事务间提供不同级别的分离。分离的级别和并发事务的吞吐量之间存在反比关系。较多事务的可分离性可能会带来较高的冲突和较多的事务流产。流产的事务要消耗资源，这些资源必须要重新被访问。因此，确保高分离级别的DBMS需要更多的开销。
(4)持久性
持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即一旦一个事务提交，DBMS保证它对数据库中数据的改变应该是永久性的，耐得住任何系统故障。持久性通过数据库备份和恢复来保证。
持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即对已提交事务的更新能恢复。一旦一个事务被提交，DBMS必须保证提供适当的冗余，使其耐得住系统的故障。所以，持久性主要在于DBMS的恢复性能。
C. Jdbc中是否支持事务,如果支持包含了哪些
事务处理是在针对数据库操作时一个重要环节，它可以保证执行多条记录的一致性，实现数据库中表与表之间的关联，同时提高了对数据操作的准确性、安全性。本文主要一起来学习在Java程序中如何使用JDBC来实现数据间的事务处理。
一、什么是事务处理
事务处理就是当执行多个SQL指令时，如果因为某个原因使其中一条指令执行有错误，则取消先前执行过的所有指令。它的作用是保证各项操作的一致性和完整性。
二、JDBC中的事务控制
JDBC API中的JDBC事务是通过Connection对象进行控制的。Connection对象提供了两种事务模式：自动提交模式和手工提交模式。系统默认为自动提交模式，即，对数据库进行操作的每一条记录，都被看作是一项事务。操作成功后，系统会自动提交，否则自动取消事务。 如果想对多个SQL进行统一的事务处理，就必须先取消自动提交模式，通过使用Connection 的setAutoCommit(false) 方法来取消自动提交事务。Connection类中还提供了如下其他控制事务的方法：
1）public boolean getAutoCommit()：判断当前事务模式是否为自动提交，如果是则返回ture，否则返回false；
2）public void commit()：提交事务；
3）public void rollback()：回滚事务；
注意：
Java中使用JDBC事务处理，一个JDBC不能跨越多个数据库而且需要判断当前使用的数据库是否支持事务。这时可以使用 DatabaseMedaData 的supportTranslations() 方法进行检查数据库是否支持事务处理，若返回 true 则说明支持事务处理，否则返回 false 。如使用MySQL 的事务功能，就要求MySQL里的表的类型为Innodb才支持事务控制处理，否则，在Java程序中做了 commit 或 rollback ，但数据库中是不生效的。
三、JDBC 事务处理基本流程
实现事务处理的基本流程如下：
1）判断当前使用的JDBC驱动程序和数据库是否支持事务处理；
2）在支持事务处理的前提下，取消系统自动提交模式；
3）添加需要进行的事务信息；
4）将事务处理提交到数据库；
5）在处理事务时，若某条信息发生错误，则执行事务回滚操作，并回滚到事务提交前的状态。
四、事务处理的实例
利用JDBC实现事务处理的实例，将4条SQL语句加在同一个事务里，当其中一条语句发生错误时，则执行事务回滚，取消所有的操作。所以在最后的运行结果中，并没有发现有数据更新。
1、具体的代码如下：
[java] view plain
package chp07;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Java_Transa {
// 数据库连接
public static Connection getConnection() {
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver"); // 加载Mysql数据驱动
con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/myuser", "root", "root"); // 创建数据连接
} catch (Exception e) {
System.out.println("数据库连接失败");
}
return con;
}
// 判断数据库是否支持事务
public static boolean JudgeTransaction(Connection con) {
try {
// 获取数据库的元数据
DatabaseMetaData md = con.getMetaData();
// 获取事务处理支持情况
return md.supportsTransactions();
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
// 将一组SQL语句放在一个事务里执行，要么全部执行通过，要么全部不执行
public static void StartTransaction(Connection con, String[] sqls) throws Exception {
if (sqls == null) {
return;
}
Statement sm = null;
try {
// 事务开始
System.out.println("事务处理开始！");
con.setAutoCommit(false); // 设置连接不自动提交，即用该连接进行的操作都不更新到数据库
sm = con.createStatement(); // 创建Statement对象
//依次执行传入的SQL语句
for (int i = 0; i < sqls.length; i++) {
sm.execute(sqls[i]);// 执行添加事物的语句
}
System.out.println("提交事务处理！");
con.commit(); // 提交给数据库处理
System.out.println("事务处理结束！");
// 事务结束
//捕获执行SQL语句组中的异常
} catch (SQLException e) {
try {
System.out.println("事务执行失败，进行回滚！\n");
con.rollback(); // 若前面某条语句出现异常时，进行回滚，取消前面执行的所有操作
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
sm.close();
}
}
// 查询表 staff
public static void query_student() throws Exception {
Connection conect = getConnection(); // 获取连接
System.out.println("执行事物处理后，表 staff 的全部记录为：\n");
try {
String sql = "select * from staff"; // 查询数据的sql语句
Statement st = (Statement) conect.createStatement(); // 创建Statement对象
ResultSet rs = st.executeQuery(sql); // 执行SQL语句并返回查询数据的结果集
//打印输出查询结果
while (rs.next()) { // 判断是否还有下一个数据
// 根据字段名获取相应的值
String name = charset(rs.getString("name"));
int age = rs.getInt("age");
String sex = charset(rs.getString("sex"));
String depart = charset(rs.getString("depart"));
String address = charset(rs.getString("address"));
int worklen = rs.getInt("worklen");
int wage = rs.getInt("wage");
System.out.println(name + " " + age + " " + sex + " "
+ address + " " + depart + " " + worklen + " " + wage);
}
System.out.println();
} catch (SQLException e) {
System.out.println("查询数据失败");
}
}
// 字符集的设定，解决中文乱码
public static String charset(String str) throws Exception {
String newStr = new String(str.getBytes("ISO8859-1"), "UTF-8");
return newStr;
}
public static void main(String[] args) throws Exception {
String[] arry = new String[4]; // 定义一组事物处理语句
arry[0] = "delete from staff where name='Serein'"; //删除staff表格中 name 字段值为 "Serein" 的员工记录
arry[1] = "UPDATE staff SET address='Shenzhen' where name=lili";// 执行这条语句会引起错误，因为表 staff 中name='lili'不存在
arry[2] = "INSERT INTO student (name,age,sex,address,depart,worklen,wage)" //SQL插入记录语句
+ "values ('Allen',19,'M','Beijing','Engine',4,4800)";
arry[3] = "select * from staff"; //SQL查询表 staff 语句
Connection con = null;
try {
con = getConnection(); // 获得数据库连接
boolean judge = JudgeTransaction(con); // 判断是否支持批处理
System.out.print("支持事务处理吗？ ");
System.out.println(judge ? "支持" : "不支持");
if (judge) {
StartTransaction(con, arry); // 如果支持则开始执行事务
}
} catch (Exception e) {
e.printStackTrace();
} finally {
con.close(); // 关闭数据库连接
}
query_student();
}
}
说明：该Java程序中数据库操作涉及的数据库为 “myuser ” ，并使用其中的 “staff” 表格，也就是我之前的文章《JDBC连接MySQL数据库及示例》里所创建的数据库和表。如果需要跟着去实现并运行这个例子的话，可以前去参考创建，或者根据你自己的数据库情况去修改其中有关连接MySQL的代码以及SQL语句。
附上程序运行前的“staff”表格中的数据：
注意观察里面的第三条记录，即 name 字段值为“Seren”的记录。即将运行的 Java 程序的第113代码中的 SQL 语句表示要删除该条记录，但是由于后面的事务出错，所以全部的事务不执行，并回滚，所以最后的结果是name为“Serein”这条记录依旧存在于数据表中。
D. jdbc的事务和jdbc传统的crud有什么区别
在jdbc的数据库操作中，一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。我们通过提交commit()或是回滚rollback（）来结束事务的操作。关于事务操作的方法都位于接口java.sql.Connection中。
2． 特点：
★ 在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。
★ 在jdbc中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下：
try {
conn = DriverManager.getConnection ；
conn.setAutoCommit(false);//禁止自动提交，设置回滚点
stmt = conn.createStatement()；
stmt.executeUpdate(“alter table …”); //数据库更新操作1
stmt.executeUpdate(“insert into table …”); //数据库更新操作2
conn.commit(); //事务提交
}catch(Exception ex) {
ex.printStackTrace();
try {
conn.rollback(); //操作不成功则回滚
}catch(Exception e) {
e.printStackTrace();
}
}
最后一句话，传统CRUD就是走一步算一步，事务就是要做一起做，要不就都撤销。
E. 请问jdbc处理事务的时候，为什么非要保证同一个数据库链接
第一 JDBC是Java中操作数据库数据的规范，注意是规范和标准，除此之外别无它号，即使Hibernite，Batis 也是要建立在JDBC基础上的。JDBC定义了如何链接数据库（Connection），如何操作数据（ResultSet，Stement）和事务管理（Transcation ，SavePoint...)，JDBC具体的实现是由数据库厂商或第三方提供。
第二理论上说，不用JDBC也可以直接操作数据库，但是很多情况下这些东西是无法实现的，比如在链接一个数据库时厂商会对通讯协议中的部分内容保密仅提供数据库驱动，很难查找到相关的资料,即使有也会涉及到版权这些问题。除此之外上层的数据操作接口也要重新定义和编写。
第三 其实JDBC 发展到现在 4.X 版本已经很优秀了，毕竟我们没有必要重新发明轮子
F. java程序如何借助jdbc定义一个事务
1. 事务是具备以下特征(ACID)的工作单元：
原子性（Atomicity）—— 如果因故障而中断，则所有结果均被撤消；
一致性（Consistency）—— 事务的结果保留不变；
孤立性（Isolation）—— 中间状态对其它事务是不可见的；
持久性（Durability）—— 已完成的事务结果上持久的。
原子操作，也就是不可分割的操作，必须一起成功一起失败。
2. 事务处理四步曲：（事务是一个边界）
① connection.setAutoCommit(false); //把自动提交关闭
② 正常的DB操作 //若有一条SQL语句失败了，自动回滚
③ connection.commit() //主动提交
或 connection.rollback() //主动回滚
4. Con.close();关闭数据库链接
3. JDBC事务并发产生的问题和事务隔离级别
完整的代码片段：
try{
con.setAutoCommit(false); //step① 把自动提交关闭
Statement stm = con.createStatement();
stm.executeUpdate("insert into person(id, name, age) values(520, 'X-Man', 18)");
stm.executeUpdate("insert into Person(id, name, age) values(521, 'Super', 19)");
//step② 正常的DB操作
con.commit(); //step③ 成功主动提交
} catch(SQLException e){
Try {
con.rollback();
} Catch (Exception e) {
e.printStackTrace();
} //step③ 失败则主动回滚
} finally{
//4关闭连接
If(con!=null){
Con.close();
}
}
G. JAVA-JDBC连接数据库一个问题：我采用通过事务提交添加属性值，为什么没有虽然没有添加，但是ID自动增加
首先自增ID本来就被设计成为不参与数据库事务的，原因是什么呢？为了防止ID生成阻塞和防止ID错乱，因为对了一张表来说，不是只有你一个线程在申请ID，其他的新增线程了也在申请ID，假设你在事务中第一次申请到了ID=1，但这时你的事务并没提交，也就是这个等于1的ID现在并没有真正入库，想想这时别人的进程也去申请同一个表的ID时，ID生成器该给他1还是2？当然是2啦！如果你这时你回滚你的事务，假设事务把ID=1回滚了，给回ID生成器，ID生成器还能把它给出去别人用么？肯定不行啦，为啥，如果这时那个上次拿到2的线程这次又去拿，不是要拿到1了？说好的自增呢？！也许你会说可以等你下次申请ID时给你呀，把3给刚刚那个拿了2的呀，不好意思，数据库会话(SqlSession)一关，谁记得你呀！
H. 网页显示无法打开JDBC连接事务;嵌套异常java.sql.SQLException:无法连接、 如何处理这种问题
这种情况一般是数据库连接串有问题，没设置对，或者连接池用户数已经满都可能出现无法链接的问题。
如果链接正常，而仅仅在做事务处理的时候有异常。
可能的情况：你的当前数据库链接在已经启动一个事务，未提交的情况下，又开启了一个新的事务。造成要操作的数据表锁定。
如果数据链接正常的话，楼主要给出更详细的信息才能判断。。
I. 关于jdbc中数据库事务的提交和回滚
首先，连接数据库异常，可能是数据库JDBC连接问题，也可能是驱动问题。
第二，没找到数据库
第三，数据库字段拼写错误。
第四，SQL语句错误
第五，还没发现。呵呵。这个是我最近2天遇到的问题。。。都在这里啦。。
J. 如何通过jdbc连接mysql数据库
在网上搜索jdbc代码。很多的。
1.引入mysql连接驱动jar包。
2.建立连接；
3.注册驱动；
4.提交连接（url,username,password）;
5.执行增删改等；
6.注意事务处理；
7.使用完关闭连接。