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(2100);        //向第二个占位符,赋值为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(2100);        //向第二个占位符,赋值为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操作;
第三步:提交事物或者撤销操作,事物结束(下次使用事物需重新开启)
    commit;或者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()结果
技术分享
技术分享

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。