码迷，mamicode.com
首页 > 数据库 > 详细

JDBC Transaction Management Example---reference

时间：2015-01-10 23:40:30      阅读：363      评论：0      收藏：0      [点我收藏+]

标签：

In this post, we want to talk about JDBC Transactions and how we can manage the operations in a database.

The most popular DBMS like MySQL and Oracle have by default the option autocommit enabled, it means immediately after any DML Operation saves the changes and makes them visible to all users. To use transactions must set the databse parameter autocommit to false.

The management of the database using transaction allows us to maintain consistency in the data, according to his ‘ACID’ property.

Transaction Properties

What we want with Transactions? To Maintain this four properties:

  • Atomicity, it’s simple either all operations in database occur, or nothing occurs.
  • Consistency, ensures that the database is in a valid state before and after the transaction.
  • Isolation, any transaction is independent of another, and your result doesn’t depends of any other.
  • Durability, the result of commit a transaction must persist in a non-volatile memory even if occurs a crash or power loss.

Tools

For this example we use:

  1. JDK 1.7.0_67 (rt.jar includes java.sql package)
  2. Mysql-connector-java 5.1.34
  3. Eclipse Luna
  4. MySQL Community Server 5.6.22

1. Example:

DBConnection.java:

01 package com.javacodegeeks.jdbc.transactions;
02  
03 import java.sql.Connection;
04 import java.sql.DriverManager;
05 import java.sql.SQLException;
06  
07 /**
08  * @author Andres.Cespedes
09  *
10  */
11 public class DBConnection {
12  
13     private static String DB_URL = "jdbc:mysql://localhost:3307/test";
14     private static String DB_USER = "admin";
15     private static String DB_PASSWORD = "admin";
16  
17     public static Connection getConnection() throws SQLException {
18         Connection connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
19         return connection;
20     }
21 }

We use DBConnection only to get the connection, any other operation is handled in the main class.

DBTransaction.java:

01 package com.javacodegeeks.jdbc.transactions;
02  
03 import java.sql.Connection;
04 import java.sql.PreparedStatement;
05 import java.sql.SQLException;
06  
07 /**
08  * @author Andres.Cespedes
09  *
10  */
11 public class DBTransaction {
12  
13     private static String INSERT = "INSERT INTO test.department (idDepartment, name) VALUES (?, ?)";
14  
15     /**
16      * @param args
17      */
18     public static void main(String[] args) {
19         Connection connection = null;
20         PreparedStatement pstmt = null;
21         PreparedStatement pstmt2 = null;
22         try {
23             connection = DBConnection.getConnection();
24         } catch (SQLException e) {
25             System.err.println("There was an error getting the connection");
26         }
27         try {
28             connection.setAutoCommit(false);
29             System.err.println("The autocommit was disabled!");
30         } catch (SQLException e) {
31             System.err.println("There was an error disabling autocommit");
32         }
33         // Starts JDBC Transaction
34         try {
35             pstmt = connection.prepareStatement(INSERT);
36             pstmt2 = connection.prepareStatement(INSERT);
37              
38             pstmt.setInt(1, 1);
39             pstmt.setString(2, "Madrid");
40             pstmt.execute();
41              
42             pstmt2.setInt(1, 2);
43             pstmt2.setString(2, "Galicia");
44             pstmt2.execute();
45              
46             connection.commit();
47             System.err.println("The transaction was successfully executed");
48         } catch (SQLException e) {
49             try {
50                 //We rollback the transaction, atomicity!
51                 connection.rollback();
52                 System.err.println(e.getMessage());
53                 System.err.println("The transaction was rollback");
54             } catch (SQLException e1) {
55                 System.err.println("There was an error making a rollback");
56             }
57         }
58     }
59 }

The connection.commit() applies all the changes before him. The key is to disable the autocommit and to group the sentences to to manage them in a transaction with a final commit.

We try to execute the transaction and this was the result.

1 The connection is successfully obtained
2 The autocommit was disabled!
3 The transaction was successfully executed

Here we should note that if one of the operations does not run correctly, all entries aren’t made and the database remains unchanged.

DBSavePoint.java:

01 package com.javacodegeeks.jdbc.transactions;
02  
03 import java.sql.Connection;
04 import java.sql.PreparedStatement;
05 import java.sql.SQLException;
06 import java.sql.Savepoint;
07  
08 /**
09  * @author Andres.Cespedes
10  *
11  */
12 public class DBSavePoint {
13  
14     private static String INSERT = "INSERT INTO test.department (idDepartment, name) VALUES (?, ?)";
15  
16     public static void insertRow(Connection conn, int idRow, String contentRow)
17             throws SQLException {
18         PreparedStatement pstmt = null;
19         pstmt = conn.prepareStatement(INSERT);
20         pstmt.setInt(1, idRow);
21         pstmt.setString(2, contentRow);
22         pstmt.execute();
23         pstmt.close();
24     }
25  
26     /**
27      * @param args
28      */
29     public static void main(String[] args) {
30         Connection connection = null;
31         Savepoint savepoint = null;
32         try {
33             connection = DBConnection.getConnection();
34         } catch (SQLException e) {
35             System.err.println("There was an error getting the connection");
36         }
37         try {
38             connection.setAutoCommit(false);
39             System.err.println("The autocommit was disabled!");
40         } catch (SQLException e) {
41             System.err.println("There was an error disabling autocommit");
42         }
43         // Starts JDBC Transaction
44         try {
45             insertRow(connection, 1, "Madrid");
46             insertRow(connection, 2, "Eibar");
47             savepoint = connection.setSavepoint("SavePoint1");
48             insertRow(connection, 3, "Galicia");
49  
50             connection.commit();
51             System.err.println("The transaction was successfully executed");
52         } catch (SQLException e) {
53             try {
54                 // We rollback the transaction, to the last SavePoint!
55                 connection.rollback(savepoint);
56                 System.err.println(e.getMessage());
57                 System.err
58                         .println("The transaction was rollback to the last savepoint");
59             } catch (SQLException e1) {
60                 System.err.println("There was an error making a rollback");
61             }
62         }
63     }
64  
65 }

The method setSavepoint of class Connection allows to create a checkpoint internally in the transaction, and if a error occurs we can back to the savepoint with all of changes made before.

2. Summary

Here we tried to understand how to manage the JDBC Operations through transactions and how to make check points by means ofSavePoint class.

 

http://examples.javacodegeeks.com/core-java/sql/jdbc-transaction-management-example/

JDBC Transaction Management Example---reference

标签：

原文地址：http://www.cnblogs.com/davidwang456/p/4215864.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！