Java中JDBC事务与JTA分布式事务总结与区别

Java中JDBC事务与JTA分布式事务总结与区别

1. JDBC事务

1.1 JDBC事务的定义

JDBC事务是指从JDBC连接开始，到结束提交或回滚的整个过程。JDBC事务采用的是本地事务的原理，即在一个本地数据库中进行的一组操作。

1.2 JDBC事务的使用步骤

JDBC事务的使用步骤如下：

1. 获取连接：使用DriverManager.getConnection(url,username,password)方法获取数据库连接对象Connection。
2. 关闭自动提交：使用conn.setAutoCommit(false)关闭自动提交，保证多个SQL语句在同一个事务中执行。
3. 执行SQL语句：使用conn.prepareStatement(sql)执行SQL语句，并调用相应的执行方法（如executeQuery()、executeUpdate()等）执行。
4. 提交或回滚事务：如果所有SQL语句都执行成功，使用conn.commit()提交事务；如果SQL语句执行失败，使用conn.rollback()回滚事务。
5. 关闭连接：使用conn.close()关闭数据库连接。

1.3 JDBC事务示例

以下是一个简单的JDBC事务示例，它包含两条SQL语句，用于向一个用户表中插入数据：

Connection conn = null;
PreparedStatement ps = null;
try {
    conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/user", "root", "123456");
    conn.setAutoCommit(false);

    //第一条SQL语句
    String sql1 = "insert into user_info(username,password) values('admin','admin123')";
    ps = conn.prepareStatement(sql1);
    ps.executeUpdate();

    //第二条SQL语句
    String sql2 = "insert into user_role(user_id,role_id) values(1,1)";
    ps = conn.prepareStatement(sql2);
    ps.executeUpdate();

    conn.commit();
} catch (SQLException e) {
    if (conn != null) {
        try {
            conn.rollback();
        } catch (SQLException ex) {
            e.printStackTrace();
        }
    }
    e.printStackTrace();
} finally {
    if (ps != null) {
        try {
            ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

2. JTA分布式事务

2.1 JTA分布式事务的定义

JTA（Java Transaction API）分布式事务是指在多个不同的数据源中进行的事务，即跨多个本地事务、多个数据库的事务。JTA采用了两阶段提交协议（2PC），保证事务的原子性、一致性、持久性和隔离性。

2.2 JTA分布式事务的使用步骤

JTA分布式事务的使用步骤如下：

1. 获取UserTransaction对象：使用InitialContext()方法获取UserTransaction接口对象。
2. 开启事务：使用UserTransaction.begin()方法开启事务。
3. 获取数据库连接：使用JNDI的方式获取数据源或直接使用JDBC连接数据库。
4. 执行SQL语句：使用获取到的连接执行SQL语句。
5. 提交或回滚事务：如果所有SQL语句都执行成功，使用UserTransaction.commit()提交事务；如果SQL语句执行失败，使用UserTransaction.rollback()回滚事务。
6. 关闭连接：关闭数据库连接。

2.3 JTA分布式事务示例

以下是一个简单的JTA分布式事务示例，它跨越了两个不同的数据源，分别是MySQL和Oracle，用于向两个用户表中插入数据：

UserTransaction tx = null;
Connection con1 = null;
Connection con2 = null;
PreparedStatement ps1 = null;
PreparedStatement ps2 = null;
try {
    //获取UserTransaction对象
    tx = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");

    tx.begin();//开启事务

    //获取数据库连接
    con1 = DriverManager.getConnection("jdbc:mysql://localhost:3306/user", "root", "123456");
    con2 = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "system", "123456");

    //执行SQL语句
    String sql1 = "insert into user_info(username,password) values('admin','admin123')";
    ps1 = con1.prepareStatement(sql1);
    ps1.executeUpdate();

    String sql2 = "insert into user_role(user_id,role_id) values(1,1)";
    ps2 = con2.prepareStatement(sql2);
    ps2.executeUpdate();

    tx.commit();//提交事务
} catch (Exception e) {
    if (tx != null) {
        try {
            tx.rollback();//回滚事务
        } catch (Exception ex) {
            e.printStackTrace();
        }
    }
    e.printStackTrace();
} finally {
    if (ps1 != null) {
        try {
            ps1.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (ps2 != null) {
        try {
            ps2.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (con1 != null) {
        try {
            con1.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (con2 != null) {
        try {
            con2.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3. JDBC事务和JTA分布式事务的区别

JDBC事务和JTA分布式事务的区别主要有以下几点：

1. 作用范围不同：JDBC事务作用于同一个数据库中的多个SQL语句；JTA分布式事务作用于多个不同数据库中的多个SQL语句。
2. 实现方式不同：JDBC事务采用本地事务的实现方式；JTA分布式事务采用两阶段提交协议（2PC）实现。
3. 错误处理方式不同：JDBC事务的错误处理方式主要是回滚本地事务；而JTA分布式事务由于需要涉及多个数据库，因此错误处理方式更加复杂。

4. 总结

JDBC事务和JTA分布式事务是Java中实现事务的两种方式，前者用于本地多个SQL语句操作的事务处理，后者用于涉及多个不同数据库的跨数据库事务处理。在实际开发中，需要根据实际的业务需求选择合适的事务处理方式。