05.JDBC编程之处理存储过程&Transaction

转载请标明出处：http://blog.csdn.net/u012637501

一、存储过程处理

1.存储过程

    概念 类似与函数 ，就是 把一段代码封装起来。当要执行这一段代码的时候，可以通过调用该存储过程来实现 。 在封装的语句体里面，可以用if/else、case、while等控制结构(参数、控制结构、循环)，可以进行sql编程。

(1)sql语法 

a.查看现有的存储过程

    show procedure status \G

b.创建存储过程

    delimiter $    //修改语句结束符

    create procedure 存储过程名字(参数列表)

        begin

                封装sql的语句

        end$

c.删除存储过程

    drop procedure 存储过程名字;

d.调用存储过程

    call 存储过程名字()$

    call 存储过程名字(参数)$

(2)存储过程实例

    在MySQL终端预先创建一个存储过程 -计算1+2+3+...+100的和

create procedure pro(nam char(10),n smallint)

begin

    declare i int;    

    declare s int;

    set i=1;

    set s=0;

    while i<=n do

        set s=s+i;

        set i=i+1;

    end while;

    insert into test(name,age,score) values(nam,0,s) ;        

end$

注：

◇declare 声明一个变量

◇set 设置变量的值

◇select 输出/查看某个变量或列

◇存储过程名只有用 单个字符

2.JDBC处理存储过程

    CallableStatement 对象为所有的DBMS 提供了一种以标准形式调用已储存过程的方法。已储存过程储存在数据库中。对已储存过程的调用是 CallableStatement对象所含的内容。这种调用是 用一种换码语法来写的，有两种形式:一种形式带结果参，另一种形式不带结果参数。结果参数是 一种输出 (OUT) 参数，是已储存过程的返回值。两种形式都可带有数量可变的输入(IN 参数)、 输出(OUT 参数)或输入和输出(INOUT 参数)的参数。问号将用作参数的占位符。

    CallableStatement 对象是用 Connection 方法 prepareCall 创建的，应用代码如下：

CallableStatement  callStmt=conn.prepareCall("call pro(?,?)");  //调用Connection对象的prepareCall方法获取CallableStatement对象

callStmt.setString(1, "pro");   //向第一个占位符参数，赋值nam='pro'  

callStmt.setInt( 2 ,  100 );         //向第二个占位符，赋值为n=100   

callStmt.execute();              //执行sql语句   

3.源码实战

(1)创建存储过程

    该存储过程完成计算1+2+3+...+100的和，并将求和结果作为score值插入到表中。

(2)编写JDBC数据库应用程序调用该存储过程

1. import java.sql.CallableStatement;  
2. import java.sql.Connection;  
3. import java.sql.DriverManager;  
4. import java.sql.SQLException;  
5.   
6. /*MySQL数据库编程  
7.  * 实例(6)：JDBC批量处理存储过程*/    
8.   
9. public class JDBC_Procedure {  
10.     public static void main(String[] args) {  
11.           
12.         //0.连接数据库相关参数  
13.         String url="jdbc:mysql://localhost:3306/jdbc_test_db";  //数据库URL(资源定位唯一标识符)  
14.         String DBusername="root";   //数据库用户名  
15.         String DBpasswd="111111";   //数据库密码  
16.           
17.         //1.加载数据库驱动,将Driver注册到DriverManager中  
18.         try{  
19.             Class.forName("com.mysql.jdbc.Driver");  
20.         }catch(ClassNotFoundException e){  
21.             e.printStackTrace();  
22.         }         
23.         //2.通过数据库URL连接到数据库  
24.         Connection conn=null;  
25.         CallableStatement callStmt=null;  
26.         try{  
27.             //3.获得表示连接到数据库的Connection对象  
28.             conn=DriverManager.getConnection(url, DBusername, DBpasswd);  
29.             //4.获取执行存储过程SQL语句的CallableStatement对象  
30.             callStmt=conn.prepareCall("call pro(?,?)");  
31.             callStmt.setString(1, "pro");   //向第一个占位符参数，赋值nam='pro'  
32.             callStmt.setInt(2, 100);        //向第二个占位符，赋值为n=100  
33.             callStmt.execute();             //执行sql语句  
34.         }catch(SQLException e){  
35.             e.printStackTrace();  
36.         }  
37.         //5.释放JDBC资源  
38.         if(callStmt!=null)      //关闭声明  
39.         {  
40.             try{  
41.                 callStmt.close();  
42.             }catch(SQLException e){  
43.                 e.printStackTrace();  
44.             }             
45.         }  
46.           
47.         if(conn!=null)          //关闭连接  
48.         {  
49.             try{  
50.                 conn.close();  
51.             }catch(SQLException e){  
52.                 e.printStackTrace();  
53.             }             
54.         }  
55.     }  
56. }  

运行结果

二、事物(Transaction)处理

1.事物(Transaction)

   事物是指一组操作，要么都成功执行，要么都不执行。事物有 原子性 、 隔离性 、一致性、 持久性 四大ACID特性。

(1)原子性(Atomicity)：原子意为最小粒子，或者说不能再分的事物。数据库事物的不可再分的原

                                    则即为原子性;

(2)一致性(Consistency)：事物发生前和发生后，数据的总额依然匹配;

(3)隔离性(Isolation)：在所有的操作没有执行完毕之前，其他会话不能够看到中间改变的过程;

(4)持久性(Durability)：事物产生的影响不能够撤销，如果除了错误，事物也不允许撤销，只能通过"补偿性事物"

2.事物的用法

第一步： 开启事物语句

    start transaction;

第二步： 执行sql操作，即普通sql操作;

第三步： 提交事物 或者撤销操作，事物结束(下次使用事物需重新开启)

    commi t;或者rollback;

注意：有一些语句会造成事物的隐式提交，如重复执行start transaction。另外，建表的时候选择innodb引擎。

3.JDBC处理存储过程

(1)由于JDBC对事物的处理，默认是自动提交事物；  所以，在执行SQL语句之前，我们先调用Connection对象的 setAutoCommit()并传入false参数。

    Connection  conn=DriverManager.getConnection(url, DBusername, DBpasswd); 

     conn.setAutoCommit( false );   
(2)添加需要处理的SQL语句，最后调用Connection对象的commit方法提交事物，使SQL语句生效。
Statement stmt=conn.createStatement();

stmt=conn.createStatement();  
 stmt.addBatch( "insert into test(name,age,score) values('haha',10,33)" );  
stmt.executeBatch();     //批量执行SQL语句   
conn.commit();   //提交事物   
conn.setAutoCommit( true );   

4.源码实战

1. import java.sql.Connection;  
2. import java.sql.DriverManager;  
3. import java.sql.SQLException;  
4. import java.sql.Statement;  
5. public class JDBC_Transaction {  
6.   
7.     /*MySQL数据库编程  
8.      * 实例(7)：JDBC批量处理事物Transaction*/   
9.     public static void main(String[] args) {  
10.   
11.         //0.连接数据库相关参数  
12.         String url="jdbc:mysql://localhost:3306/jdbc_test_db";  //数据库URL(资源定位唯一标识符)  
13.         String DBusername="root";   //数据库用户名  
14.         String DBpasswd="896013";   //数据库密码  
15.           
16.         //1.加载数据库驱动,将Driver注册到DriverManager中  
17.         try{  
18.             Class.forName("com.mysql.jdbc.Driver");  
19.         }catch(ClassNotFoundException e){  
20.             e.printStackTrace();  
21.         }         
22.         //2.通过数据库URL连接到数据库  
23.         Connection conn=null;  
24.         Statement stmt=null;  
25.         try{  
26.             //3.获得表示连接到数据库的Connection对象  
27.             conn=DriverManager.getConnection(url, DBusername, DBpasswd);  
28.             //4.设置SQL语句不自动执行  
29.             conn.setAutoCommit(false);  
30.             //5.获取Statement对象  
31.             stmt=conn.createStatement();  
32.             stmt.addBatch("insert into test(name,age,score) values('haha',10,33)");  
33.             stmt.addBatch("insert into test(name,age,score) values('heihei',11,44)");  
34.             stmt.addBatch("insert into test(name,age,score) values('xixi',14,55)");  
35.             stmt.executeBatch();    //批量执行SQL语句  
36.             conn.commit();  //提交事物  
37.             conn.setAutoCommit(true);  
38.         }catch(SQLException e){  
39.             e.printStackTrace();  
40.         }  
41.         //5.释放JDBC资源  
42.         if(stmt!=null)      //关闭声明  
43.         {  
44.             try{  
45.                 stmt.close();  
46.             }catch(SQLException e){  
47.                 e.printStackTrace();  
48.             }             
49.         }  
50.           
51.         if(conn!=null)          //关闭连接  
52.         {  
53.             try{  
54.                 conn.close();  
55.             }catch(SQLException e){  
56.                 e.printStackTrace();  
57.             }             
58.         }  
59.     }  
60. }  

运行结果：

(1)注释事物提交语句

    //conn.commit();

    // conn.setAutoCommit(true);

(2)执行conn.commit()结果