一、什么是事务处理
事务处理就是当执行多个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 plaincopy
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 = 0i <sqls.lengthi++) {
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”这条记录依旧存在于数据表中。
项目中使用了spring jpa与spring jdbc但在实际使用中发现spring jdbc中的事务没有被提交到，处理方式主要有以下几点
1. 确保工程中启用了事务
2.确保在方法上添加了事务注释
这两点在系统中都已经添加，但还是不生效，查看spring jpa的文档发现确实是支持jpa的事务和jdbc的事务 https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/orm/jpa/JpaTransactionManager.html ，通过debug发现Jpa的事务处理主要在JpaTransactionManager.doBegin中，在执行时会判断是否使用jdbc的事务；
系统中指定了JpaTransactionManager但没有指定JpaDialect，如果不指定默认给的是DefaultJpaDialect，而DefaultJpaDialect中并不会对JdbcConnection做处理，所以就导致了jdbc事务无法提交，解决办法也比较简单手动指定jpaDialect为HibernateJpaDialect；
如何用java开启mysql事务，要求详细看你是什么事务，jdbc事务，还是分布式事务，还是容器事务
1，编程式事务管理（jdbc的事务是绑定在connection上的）
Connection conn = null
try
{
Class.forName("com.mysql.jdbc.Driver")
conn = DriverManager.getConnection("jdbc:oracle:thin:@host:1521:SID","username","password")
conn.setAutoCommit(false) //取消自动提交
PreparedStatement ps = conn.prepareCall("update something")
ResultSet rs = ps.executeQuery()
conn.commit() //手动提交
}
catch (Exception e)
{
conn.rollback()
e.printStackTrace()
}
finally
{
conn.close()
}
2，声明式事务
先在工程的application.xml配置文件中添加如下代码，开启事务
<!-- 声明式事务控制配置 -->
<tx:annotation-driven transaction-manager="txManager"/>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="datasource" ref="bassDataSource"></property>
</bean>
然后在你需要开启事务的接口前面添加注解
@Transactional(rollbackFor = IOException.class)
public void add(String name) throws IOException
{
System.out.println("可以再类里和方法里面添加事务注解0~0")
throw new IOException()
}
直接调用接口方法就好
分布式事务处理（mysql貌似在5.X之后才支持） 的话，
1.可以直接使用spring+atomikos框架进行管理
参考：http://blog.chinaunix.net/uid-21162795-id-3424973.html
就不贴测试代码了，自己看着配置吧
2，使用JTA（Java Transaction API）进行分布式事务管理（测试代码如下）
import java.sql.Connection
import java.sql.PreparedStatement
import java.sql.SQLException
import javax.naming.InitialContext
import javax.sql.DataSource
import javax.transaction.SystemException
import javax.transaction.UserTransaction
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource
//分布式事务处理
public class transferAccount
{
@SuppressWarnings("null")
public void testTransferAccount()
{
UserTransaction userts = null
Connection connA = null
PreparedStatement psA = null
InitialContext context = null
Connection connB = null
PreparedStatement psB = null
try
{
//获得事务管理对象
userts = (UserTransaction) context.lookup("java:comp/UserTransaction")
//获取两个数据库
connA = getDataSourceA().getConnection()
connB = getDataSourceB().getConnection()
//开启事务
userts.begin()
//sql语句
psA = connA.prepareStatement("我加1")
psB = connB.prepareStatement("我减1")
//执行sql
psA.executeUpdate()
psB.executeUpdate()
//事务提交
userts.commit()
} catch (Exception e)
{
try
{
userts.rollback()
} catch (IllegalStateException | SecurityException
| SystemException e1)
{
e1.printStackTrace()
}
e.printStackTrace()
}
finally
{
try
{
psA.close()
psB.close()
connA.close()
connB.close()
} catch (SQLException e)
{
e.printStackTrace()
}
}
}
public DataSource getDataSourceA()
{
MysqlDataSource dataSource = new MysqlDataSource()
dataSource.setDatabaseName("mysql")
dataSource.setServerName("server")
dataSource.setPortNumber(1433)
dataSource.setUser("test")
dataSource.setPassword("test")
return dataSource
}
public DataSource getDataSourceB()
{
MysqlDataSource dataSource = new MysqlDataSource()
dataSource.setDatabaseName("mysql")
dataSource.setServerName("server")
dataSource.setPortNumber(1435)
dataSource.setUser("test1")
dataSource.setPassword("test1")
return dataSource
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）