开发文章

Java应用程序使用JDBC连接数据库


  • 在学习JDBC之前,操作数据库的步骤:
    • 登陆到数据库服务器(不管是使用客户端服务器还是使用命令行),比如MySQL应该执行:mysql -u root -p
    • 编写SQL语句
    • 发送SQL语句到数据库服务器执行

那么JDBC究竟是什么呢?使用Java程序来操作数据库,后者更加直接的话就是使用Java程序来发送SQL语句的技术称之为:JDBC。

使用JDBC发送SQL的前提:
* 登陆数据库的服务器(连接数据库的服务器)。那么必须要知道哪些条件才能连接数据库的服务器呢(也就是说使用JDBC同样和使用客户端一样需要下面的参数)?
* 数据库服务器的IP地址
* 数据库服务器的端口地址
* 数据库服务器的用户名(通常是root)
* 数据库服务器的密码(自己设置好的)
* 编写SQL语句
* 发送SQL语句到数据库服务器执行

没有JDBC之前,使用驱动程序在Java程序与MySQL、Oracle、SQLServer等数据库之间建立连接,驱动程序就是在该课程中将要学到的内容。那么就存在一个问题:在同一个Java程序与数据库之间建立连接时,驱动程序是否是共用的呢?如果一样,很显然就能节省代码量,但是实际上是不一样的。一定要注意是不一样的。那么就存在一个问题:当底层数据库发生改变之后,数据库的驱动程序也会随之发生变化,那么该怎么解决该问题呢?于是JDBC出现了,目的是为了减轻开发人员的工作量,以提高代码的复用。

JDBC模式


在没有JDBC之前是程序开发人员主动去连接数据库,所以我们需要为各种不同的数据库写驱动程序,但是JDBC 出现之后,是数据库来了解我的Java代码,JDBC定好了一套规范(协议),如果数据库要连接我的Java程序,那么需要自己写一个驱动程序,但是你所 写的驱动必须遵守我定的规范(协议)。开发人员只需要维护自己的Java程序以及规范(协议,其中协议或者规范是固定的),数据库厂商需要维护自己的数据 库以及数据库的驱动程序(驱动程序用来实现Java和数据库的连接)。这样做的优点是:
* java开发人员值需要维护Java应用和一套规范
* 数据库厂商提供具体的Java驱动程序,数据库厂商的底层改变,那么必须相应的提供一套驱动,但是规范并不会发生变化。
现在的关注点是:规范(协议)究竟是什么呢?JDBC

JDBC定义


sun公司设计的一套通用的用Java语言操作不同数据库的接口,在接口中存在大量抽象的方法,这样做减轻了Java应用程序的开发周期以及简介性。JDBC的接口在哪里?在JDK中java.sql.*,和javax.sql.*(在JDK 2.0时出现)。

第一个JDBC程序

复制内容到剪贴板
  1. package com.juzhutech.jdbctest;  
  2. import java.sql.*;  
  3. import java.util.Properties;  
  4. public class JdbcTest {  
  5.   
  6.     public static void main(String[] args) throws SQLException  {      
  7.   
  8.         //连接数据库的URL  
  9.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";  
  10.         String user = "root";  //数据库用户名  
  11.         String password = "560128";  //密码  
  12.         //创建一个驱动程序的类对象  
  13.         Driver driver = new com.mysql.jdbc.Driver();  //新版本,推荐使用  
  14.         //Driver driver = new org.gjt.mm.mysql.Driver();  //旧版本,使用该类连接也是可行的  
  15.   
  16.   
  17.         //设置用户名和密码  
  18.         Properties properties = new Properties();  
  19.         properties.setProperty("user", user);  
  20.         properties.setProperty("password", password);  
  21.         //连接数据库  
  22.         Connection connection = driver.connect(url,properties);  
  23.         System.out.println(connection);   
  24.   
  25.     }  
  26.   
  27. }  

第二种连接数据库的方式:

复制内容到剪贴板
  1. package com.juzhutech.jdbctest;  
  2. import java.sql.*;  
  3. import java.util.Properties;  
  4. public class JdbcTest {  
  5.   
  6.     public static void main(String[] args) throws SQLException  {      
  7.   
  8.         //第一种连接数据库的办法  
  9.         //连接数据库的URL  
  10.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";  
  11.         String user = "root";  //数据库用户名  
  12.         String password = "560128";  //密码  
  13.         //创建一个驱动程序的类对象  
  14.         Driver driver = new com.mysql.jdbc.Driver();  //新版本,推荐使用  
  15.         //Driver driver = new org.gjt.mm.mysql.Driver();  //旧版本,使用该类连接也是可行的  
  16.   
  17.   
  18.         //设置用户名和密码  
  19.         Properties properties = new Properties();  
  20.         properties.setProperty("user", user);  
  21.         properties.setProperty("password", password);  
  22.         //连接数据库  
  23.         Connection connection = driver.connect(url,properties);  
  24.         System.out.println(connection);   
  25.         test();  
  26.   
  27.     }  
  28.   
  29.   
  30.     //第二种连接数据库的方法,使用的是DriverManager  
  31.     public static void test() throws SQLException{  
  32.         Driver driver = new com.mysql.jdbc.Driver();  
  33.         //注册驱动程序,可以注册多个启动程序  
  34.         DriverManager.registerDriver(driver);  
  35.   
  36.   
  37.         //连接数据库的URL  
  38.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";  
  39.         String user = "root";  //数据库用户名  
  40.         String password = "560128";  //密码  
  41.         //连接到具体的数据库  
  42.         Connection connection = DriverManager.getConnection(url, user, password);  
  43.         System.out.println(connection);  
  44.     }  
  45.   
  46. }  

在我们实际编程的过程中,以上的两种方法都显得十分的繁琐,实际上看com.mysql.jdbc.Driver就会知道,在该类中有一个静态代码块,只要想办法加载该类就会执行静态代码块中的内容,看下面的实现,这种实现也是平时我们最频繁使用的JDBC连接数据库的方法

复制内容到剪贴板
  1. package com.juzhutech.jdbctest;  
  2. import java.sql.*;  
  3. import java.util.Properties;  
  4. public class JdbcTest {  
  5.   
  6.     public static void main(String[] args) throws SQLException, ClassNotFoundException  {      
  7.   
  8.         //第一种连接数据库的办法  
  9.         //连接数据库的URL  
  10.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";  
  11.         String user = "root";  //数据库用户名  
  12.         String password = "560128";  //密码  
  13.         //创建一个驱动程序的类对象  
  14.         Driver driver = new com.mysql.jdbc.Driver();  //新版本,推荐使用  
  15.         //Driver driver = new org.gjt.mm.mysql.Driver();  //旧版本,使用该类连接也是可行的  
  16.   
  17.   
  18.         //设置用户名和密码  
  19.         Properties properties = new Properties();  
  20.         properties.setProperty("user", user);  
  21.         properties.setProperty("password", password);  
  22.         //连接数据库  
  23.         Connection connection = driver.connect(url,properties);  
  24.         //System.out.println(connection);   
  25.         test();  
  26.   
  27.     }  
  28.   
  29.   
  30.     //第二种连接数据库的方法,使用的是drivermanager  
  31.     public static void test() throws SQLException, ClassNotFoundException{  
  32.         //Driver driver = new com.mysql.jdbc.Driver();  
  33.         //注册驱动程序,可以注册多个启动程序  
  34.         //DriverManager.registerDriver(driver);  
  35.   
  36.         //通过得到字节码对象的方式加载静态大妈快,从而注册驱动程序  
  37.         Class.forName("com.mysql.jdbc.Driver");  //使用驱动管理器的方式去连接数据库  
  38.   
  39.         //连接数据库的URL  
  40.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";   //连接不同的数据库体现在url上  
  41.         String user = "root";  //数据库用户名  
  42.         String password = "560128";  //密码  
  43.         //连接到具体的数据库  
  44.         Connection connection = DriverManager.getConnection(url, user, password);  
  45.         System.out.println(connection);  
  46.     }  
  47.   
  48. }  

JDBC核心API


全部的API都在java.sql.*和javax.sql.*,下面展示其中核心的API,也是在JDBC编程郭晨中。

  • Driver接口:表示Java驱动程序接口,所有具体的数据库厂商都要来实现此接口。
    • connect(url,properties):连接数据库的方法
      • url:连接数据库的url(用来定位具体的数据库资源)
        • url语法:jdbc:mysql(oracle、sqlserver等)://数据库所在主机的IP地址/端口号/具体要使用的数据库名称
        • user:数据库的用户名
        • password:数据库的用户密码。
  • DriverManager类:驱动管理器类,用于管理所有注册的驱动程序。

    • registerDriver(driver):注册驱动类对象
    • Connection getConnection(url,uer,password):获取连接的对象,其返回值为Connection对象
  • Connection接口:表示Java程序和数据库的连接对象,拿到此接口,就表示和数据库已经建立连接

    • createStatement:创建statement对象
    • preparedStatement():创建PreparedStatement对象
    • CallableStatement prepareCall():创建一个CallableStatement对象
  • Statement接口:用于执行静态SQL语句并返回其结果

    • executeUpdate(String sql):执行静态的更新SQL语句(DDL、DML)
    • executeQuery(String sql):执行静态的查询SQL语句
  • PreparedStatement接口:

    • int executeUpdate():执行预编译的更新SQL语句(DDL、DML)
    • ResultSet executeQuery():执行预编译的查询SQL语句(DQL)
  • CallableStatement接口:用于执行存储过程的SQL语句(call xx语句的执行)

    • ResultSet executeQuery():执行预编译的查询SQL语句(DQL)
  • ResultSet接口:用于封装查询出来的数据,表示结果集

    • next():将光标移动到下一行
    • getxx():获取列的值
Connection接口使用

  • 使用Statement执行静态SQL语句
    Statement对象在整个JDBC的使用过程中都充当的是一艘货船的作用,也就是说java应用程序的SQL语句需要使用Statement对象的方 法将其运送至数据库服务器端用来执行,与此同时Statement对象也会装载其运行结果,将结果从数据库服务器运行至java应用程序,下面看一个简单 的示例:
  •  
复制内容到剪贴板
  1. //创建数据库中表的代码  
  2. package com.juzhutech.jdbctest;  
  3. import java.sql.*;  
  4. import java.util.Properties;  
  5. public class JdbcTest {  
  6.   
  7.     public static void main(String[] args) throws SQLException, ClassNotFoundException  {      
  8.   
  9.         //第一种连接数据库的办法  
  10.         //连接数据库的URL  
  11.         String url = "jdbc:mysql://192.168.101.44:3306/tpch";  
  12.         String user = "root";  //数据库用户名  
  13.         String password = "560128";  //密码  
  14.         //创建一个驱动程序的类对象  
  15.         Driver driver = new com.mysql.jdbc.Driver();  //新版本,推荐使用  
  16.         //Driver driver = new org.gjt.mm.mysql.Driver();  //旧版本,使用该类连接也是可行的  
  17.   
  18.   
  19.         //设置用户名和密码  
  20.         Properties properties = new Properties();  
  21.         properties.setProperty("user", user);  
  22.         properties.setProperty("password", password);  
  23.         //连接数据库  
  24.         Connection connection = driver.connect(url,properties);  
  25.         //System.out.println(connection);   
  26.         test();  
  27.   
  28.     }  
  29.   
  30.   
  31.     //第二种连接数据库的方法,使用的是drivermanager  
  32.     public static void test() throws SQLException, ClassNotFoundException{  
  33.         //Driver driver = new com.mysql.jdbc.Driver();  
  34.         //注册驱动程序,可以注册多个启动程序  
  35.         //DriverManager.registerDriver(driver);  
  36.   
  37.         //通过得到字节码对象的方式加载静态大妈快,从而注册驱动程序  
  38.         //连接到具体的数据库  
  39.         Connection connection = null;  
  40.         //创建一个select * from customer;该怎么做呢?可以把Statement对象看成一艘装在SQL语句的船,可以实现将SQL语句从Java程序  
  41.                 //运送到MySQL数据库服务器上,并且将生成的结果再带回到Java的Statement对象中  
  42.         Statement statement = null;  
  43.         try {  
  44.                 Class.forName("com.mysql.jdbc.Driver");  //使用驱动管理器的方式去连接数据库  
  45.   
  46.                 //连接数据库的URL  
  47.                 String url = "jdbc:mysql://192.168.101.44:3306/amon";   //连接不同的数据库体现在url上  
  48.                 String user = "root";  //数据库用户名  
  49.                 String password = "560128";  //密码  
  50.                 connection = DriverManager.getConnection(url, user, password);  
  51.   
  52.                 statement = connection.createStatement();  
  53.   
  54.                 //准备SQL语句  
  55.                 String sql = "create table student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20))";  
  56.   
  57.                 //发送SQL语句到数据库服务器中,用于执行  
  58.                 int count = statement.executeUpdate(sql);  
  59.   
  60.                 //输出  
  61.                 System.out.println("影响了"+count+"行");  
  62.         } catch (Exception e) {  
  63.             throw new RuntimeException(e);  
  64.         }  
  65.   
  66.         //关闭java程序与数据库的连接,关闭的顺序是后打开的先关闭  
  67.         statement.close();  
  68.         connection.close();  
  69.     }  
  70.   
  71. }  
复制内容到剪贴板
  1. //实现数据库的增、删、改、查功能  
  2. package com.jpzhutech.jdbcdml;  
  3.   
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.SQLException;  
  7. import java.sql.Statement;  
  8.   
  9.   
  10. /** 
  11.  *  功能:使用Statement执行DML语句,操作的数据库对象为MySQL 
  12.  *  @author 朱君鹏 
  13.  *  @version 1.0 
  14.  *  @category JDBC使用 
  15.  * */  
  16.   
  17. public class TestJdbcDML {  
  18.   
  19.     public static void main(String[] args) throws ClassNotFoundException, SQLException {  
  20.   
  21.             Class.forName("com.mysql.jdbc.Driver");  
  22.             String url = "jdbc:mysql://192.168.101.44/amon";  
  23.             String user = "root";  
  24.             String password = "560128";  
  25.             Connection connection = DriverManager.getConnection(url, user, password);  //导包是一定要注意,导入接口的包,不要导入实现类的包  
  26.   
  27.   
  28.             //准备一个SQL语句  
  29.   
  30.             String sql = "INSERT INTO student(NAME) VALUES('张三')"//注意在VALUES时要使用单引号,使用双引号会发生错误  
  31.   
  32.             //创建一个Statement对象  
  33.             Statement statement = connection.createStatement();  
  34.             int count = statement.executeUpdate(sql);  
  35.             statement.close();  
  36.             connection.close();  
  37.     }  
  38. }  

注意:数据库的增、删、改功能都和上面的代码(插入代码)基本是一致的,唯一不一致的就是sql语句上的区别,值需要将固定的SQL语句写好,放在相应的位置即可实现全部的功能。

改进

从上面的代码中可以看出:在使用JDBC协议连接数据库时必须要做的操作是:Java应用程序与数据库建立连接、关闭连接,这两个步骤是所有的JDBC程序都要做的,所以下面我将这个公共的部分做成一个工具库,看下面的代码:

复制内容到剪贴板
  1. package com.jpzhutech.jdbcutil;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.SQLException;  
  6. import java.sql.Statement;  
  7.   
  8. public class JdbcUtil {  
  9.     //数据库信息  
  10.     private static String url = "jdbc:mysql://192.168.101.44/amon";  
  11.     private static String user = "root";  
  12.     private static String password = "560128";  
  13.   
  14.     static{  
  15.         try {  
  16.             Class.forName("com.mysql.jdbc>driver");  
  17.         } catch (ClassNotFoundException e) {  
  18.             System.out.println("注册驱动程序失败!");  
  19.             throw new RuntimeException(e);  
  20.         }   
  21.     }  
  22.   
  23.     //获取数据库连接的方法,该方法在JDBC操作中是普遍存在的,因此将其包装为一个工具类  
  24.     public static Connection getConnection(){  
  25.         try {  
  26.             Connection connection = DriverManager.getConnection(url, user, password);  
  27.             return connection;  
  28.         } catch (SQLException e) {  
  29.             throw new RuntimeException(e);  
  30.         }  
  31.     }  
  32.   
  33.     public static void close(Connection connection,Statement statement) throws SQLException{  
  34.         if(statement != null){  
  35.             statement.close();  
  36.         }  
  37.         if(connection != null){  
  38.             connection.close();  
  39.         }  
  40.     }  
  41. }  
执行数据查询操作

查询操作的代码如下:

复制内容到剪贴板
  1. package com.jpzhutech.select;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.sql.Statement;  
  8.   
  9. public class SelectTest {  
  10.   
  11.     public static void main(String[] args) {  
  12.         Connection connection = null;  
  13.         Statement statement = null;  
  14.         try {  
  15.             String url = "jdbc:mysql://192.168.101.44/amon";  
  16.             String user = "root";  
  17.             String password = "560128";  
  18.             Class.forName("com.mysql.jdbc.Driver");  
  19.             connection= DriverManager.getConnection(url, user, password);  
  20.             String sql = "select * from student";  
  21.             statement = connection.createStatement();  
  22.             /** 
  23.              * 关于ResultSet的理解:Java程序中数据库查询结果的展现形式,或者说得到了一个结果集的表 
  24.              * 在文档的开始部分有详细的讲解该接口中应该注意的问题,请阅读JDK 
  25.              * */  
  26.             ResultSet resultSet = statement.executeQuery(sql);  
  27.             while(resultSet.next()){  
  28.                  //取出列值  
  29.                 int id = resultSet.getInt(1);  
  30.                 String name = resultSet.getString(2);  
  31.                 System.out.println(id+","+name+",");  
  32.   
  33.             }  
  34.         } catch (Exception e) {  
  35.             throw new RuntimeException(e);  
  36.         }finally{  
  37.             try {  
  38.                 statement.close();  
  39.             } catch (SQLException e) {  
  40.                 e.printStackTrace();  
  41.                 throw new RuntimeException(e);  
  42.             }finally{  
  43.                 try {  
  44.                     connection.close();  
  45.                 } catch (SQLException e) {  
  46.                     e.printStackTrace();  
  47.                     throw new RuntimeException(e);  
  48.                 }  
  49.             }  
  50.   
  51.         }  
  52.     }  
  53.   
  54. }  

当获取到结果集之后,重点的问题是程序中怎么获取相应字段的值是一个很重要的问题,在JDK中提供了许多方法去获取,简单的总结就是必须要告知程序你想要 获取的结果的所在的行(由next指针控制光标所在的位置),具体要读取值是由下面的方法去获取,因为在数据库中实际上定义了不同的数据类型,也就是不同 的字段数据类型不一样,怎么获取呢?下表显示了在MySQL数据库中获取相应字段的方法,对于其他数据库中的数据类型请参见JDK中 java.sql.ResultSet中的方法,并且每种方法都有两个重载的方法,分别是根据数据库中的索引(索引从1开始)和列名获取。

数据库中的索引.png

preparedStatement接口使用

preparedStatement执行预编译的SQL语句。究竟什么是预编译的SQL语句呢?下面以插入语句为例来说明什么是预编译的SQL语句。

  • 静态SQL语句
复制内容到剪贴板
  1. String sql = "INSERT INTO student(NAME) VALUES('张三')";   

预编译SQL语句,其中一个?代表一个预编译的SQL语句。

复制内容到剪贴板
  1. String sql = "INSERT INTO student(NAME) VALUES(?)";   
  2.   
  3. String sql = "INSERT INTO student(NAME,gender) VALUES(?,?)";   

执行增、删、改的操作

复制内容到剪贴板
  1. package com.jpzhutech.compile;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.SQLException;  
  7.   
  8. public class TestPreCompile {  
  9.   
  10.     public static void main(String[] args) throws SQLException {  
  11.         Connection connection = null;  
  12.         PreparedStatement preparedStatement = null;  
  13.         try {  
  14.             Class.forName("com.mysql.jdbc.Driver");  
  15.             String url = "jdbc:mysql://192.168.101.44/amon";  
  16.             String user = "root";  
  17.             String password = "560128";  
  18.             try {  
  19.                 connection = DriverManager.getConnection(url, user, password);  
  20.             } catch (SQLException e) {  
  21.                 throw new RuntimeException(e);  
  22.             }  
  23.             String sql = "INSERT INTO student(NAME) VALUES(?)";  
  24.             preparedStatement = connection.prepareStatement(sql);  
  25.   
  26.             //设置参数的值,替换预编译语句中的?  
  27.             //在该种情况下第一个参数代表一个索引,该索引值不是该字段在数据库中的索引,而是指在预编译SQL语句中的位置  
  28.             preparedStatement.setString(1"zhujunpeng");  
  29.   
  30.             //向数据库服务器发送预编译SQL语句,形成可执行的语句,和Statement中的方法不一样  
  31.             int count = preparedStatement.executeUpdate();  
  32.             System.out.println("影响了"+count+"行");  
  33.         } catch (ClassNotFoundException e) {  
  34.             throw new RuntimeException(e);  
  35.         } finally {  
  36.             try {  
  37.                 connection.close();  
  38.             } catch (SQLException e) {  
  39.                 throw new RuntimeException(e);  
  40.             }  
  41.         }  
  42.         TestDelete();  
  43.     }  
  44.   
  45.     public static void TestDelete() throws SQLException{  
  46.         Connection connection = null;  
  47.         PreparedStatement preparedStatement = null;  
  48.         try {  
  49.             Class.forName("com.mysql.jdbc.Driver");  
  50.             String url = "jdbc:mysql://192.168.101.44/amon";  
  51.             String user = "root";  
  52.             String password = "560128";  
  53.             try {  
  54.                 connection = DriverManager.getConnection(url, user, password);  
  55.             } catch (SQLException e) {  
  56.                 throw new RuntimeException(e);  
  57.             }  
  58.             String sql = "DELETE from student where id=?";  
  59.             preparedStatement = connection.prepareStatement(sql);  
  60.   
  61.             //设置参数的值,替换预编译语句中的?  
  62.             //在该种情况下第一个参数代表一个索引,该索引值不是该字段在数据库中的索引,而是指在预编译SQL语句中的位置  
  63.             preparedStatement.setInt(18);  
  64.   
  65.             //向数据库服务器发送预编译SQL语句,形成可执行的语句,和Statement中的方法不一样  
  66.             int count = preparedStatement.executeUpdate();  
  67.             System.out.println("影响了"+count+"行");  
  68.         } catch (ClassNotFoundException e) {  
  69.             throw new RuntimeException(e);  
  70.         } finally {  
  71.             try {  
  72.                 connection.close();  
  73.             } catch (SQLException e) {  
  74.                 throw new RuntimeException(e);  
  75.             }  
  76.         }  
  77.     }  
  78.   
  79. }  

上面的代码中实现了增加的功能,删除和修改(update)功能只是SQL语句和set值时不一样,其他的都一样。

  • 对比使用预编译SQL和非预编译的SQL,两者的执行效率是存在差异的,比较两者的执行过程:
    • 将SQL语句发送给数据库服务器,并检查语法是否正确
    • 进行权限的检查,看是否具有执行该语句的权限
    • 执行SQL。在数据库内部有一个SQL的缓冲池,将SQL语句加入到缓冲池中,每一个SQL都对应一个执行任务,
    • 数据库从缓冲池中取出SQL语句进行执行

在执行多条类似SQL,由于使用PreparedStatement导致缓冲池的大小明显的降低,执行效率也高了,所以在程序设计时要注意这个问题

  • 探讨一个有意思的SQL语句,下面的SQL语句导致用户的输入被破解,下面两个SQL语句的执行是一样的,下面的代码成为SQL注入。
复制内容到剪贴板
  1. select * from users where name='eric' or 1=1 --'AND password='123456'  
  2.   
  3. select * from users where name='ericasasaasasa' or 1=1 --'AND password='123456'  

Statement会导致SQL注入,安全性极其差,但是PreparedStatement不会有SQL注入的风险,尽量使用PreparedStatement

CallableStatement接口使用

首先写一个简单的存储过程

复制内容到剪贴板
  1. DELIMITER $  
  2. CREATE PROCEDURE pro_findById(IN sid INT)  
  3. BEGIN  
  4.     SELECT * FROM  student WHERE id=sid;  
  5. END $  
复制内容到剪贴板
  1. CALL pro_findById(4);  --调用存储过程  

上面演示了写好存储过程之后,在命令行下或者在客户端下进行调用的过程,那么使用Java应用程序怎么实现存储过程的调用呢?使用CallableStatement接口可以实现存储过程的调用。

复制内容到剪贴板
  1. package com.jpzhutech.callablestatement;  
  2.   
  3. import java.sql.CallableStatement;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8.   
  9. import org.junit.Test;  
  10.   
  11. public class TestCallableStatement {  
  12.     @Test  
  13.     /*带有存储参数的输入过程,test1函数使用的是下面的存储过程 
  14.     DELIMITER $ 
  15.     CREATE PROCEDURE pro_findById(IN sid INT) 
  16.     BEGIN 
  17.         SELECT * FROM  student WHERE id=sid; 
  18.     END $ 
  19.     */  
  20.     public void test1() {  
  21.         Connection connection = null;  
  22.         CallableStatement callableStatement = null ;  
  23.         try {  
  24.             Class.forName("com.mysql.jdbc.Driver");  
  25.             String url = "jdbc:mysql://192.168.101.44:/amon";  
  26.             String user = "root";  
  27.             String password = "560128";  
  28.   
  29.             try {  
  30.                 connection = DriverManager.getConnection(url, user, password);  
  31.                 String sql = "CALL pro_findById(?);";  
  32.   
  33.                 //预编译SQL  
  34.                 callableStatement = connection.prepareCall(sql);  
  35.   
  36.                 //设置输入参数  
  37.                 callableStatement.setInt(14);  
  38.   
  39.                 //发送SQL语句给数据库服务器  
  40.                 ResultSet resultSet = callableStatement.executeQuery();  //所有调用存储过程的方法都使用excuteQuery调用,没有例外  
  41.                 while(resultSet.next()){  
  42.                     int id = resultSet.getInt("id");  
  43.                     String name = resultSet.getString("NAME");  
  44.                     System.out.println(id+","+name);  
  45.                 }  
  46.             } catch (SQLException e) {  
  47.                 throw new RuntimeException(e);  
  48.             }  
  49.         } catch (ClassNotFoundException e) {  
  50.             throw new RuntimeException(e);  
  51.         }finally{  
  52.             try {  
  53.                 callableStatement.close();  
  54.                 connection.close();  
  55.             } catch (SQLException e) {  
  56.                 throw new RuntimeException(e);  
  57.             }  
  58.         }  
  59.     }  
  60.   
  61.     @Test  
  62.     /** 
  63.      * 带有输出参数的存储过程 
  64.      DELIMITER $ 
  65.      CREATE PROCEDURE pro_findById2(IN sid INT,out sname VARCHAR(20)) 
  66.      BEGIN 
  67.           SELECT NAME INTO sname FROM student WHERE id=sid 
  68.      END $ 
  69.  
  70.      CALL pro_fineById2(5,@NAME) 
  71.      SELECT @NAME 
  72.      **/  
  73.   
  74.     public void test2(){  
  75.         Connection connection = null;  
  76.         CallableStatement callableStatement = null ;  
  77.         try {  
  78.             Class.forName("com.mysql.jdbc.Driver");  
  79.             String url = "jdbc:mysql://192.168.101.44:/amon";  
  80.             String user = "root";  
  81.             String password = "560128";  
  82.   
  83.             try {  
  84.                 connection = DriverManager.getConnection(url, user, password);  
  85.                 String sql = "CALL pro_findById2(?,?);";  //第一个?是一个输入参数,第二个参数是一个输出参数  
  86.   
  87.                 //预编译SQL  
  88.                 callableStatement = connection.prepareCall(sql);  
  89.   
  90.                 //设置输入参数  
  91.                 callableStatement.setInt(14);  
  92.   
  93.                 //设置输出参数,注册输出参数  
  94.                 callableStatement.registerOutParameter(2, java.sql.Types.VARCHAR);  
  95.   
  96.                 //发送SQL语句给数据库服务器,因为结果并不在ResultSet结果集中,所以根本不需要使用ResultSet去接结果,那么结果放在哪里了呢?结果返回到输出参数中   
  97.                 callableStatement.executeQuery();  //所有调用存储过程的方法都使用excuteQuery调用,没有例外  
  98.   
  99.                 //得到输出参数的值,在CallableStatement中定义了很多的getxx方法,专门用于获取存储过程中的输出参数  
  100.                 //输出参数的索引和注册输出参数时的位置索引是一样的,否则会抛出异常  
  101.                 //在CallableStatement中定义了大量的getxx方法,但是其和在ResultSet中的getxx方法是不一样的  
  102.                 //后者是在结果集中取出相应的输出,而前者是将输出参数中的结果取出  
  103.                 String result = callableStatement.getString(2);  
  104.                 System.out.println(result);  
  105.             } catch (SQLException e) {  
  106.                 throw new RuntimeException(e);  
  107.             }  
  108.         } catch (ClassNotFoundException e) {  
  109.             throw new RuntimeException(e);  
  110.         }finally{  
  111.             try {  
  112.                 callableStatement.close();  
  113.                 connection.close();  
  114.             } catch (SQLException e) {  
  115.                 throw new RuntimeException(e);  
  116.             }  
  117.         }  
  118.     }  
  119.   
  120. }  

总结


通过上面的过程,基本已经学习了JDBC中常用操作所在的接口,这些在我们操作数据库时经常会用到,总之在面向接口的编程中要多注意熟悉其中的接口以及方法含义。

参考资料


  1. http://www.jpzhutech.com

感谢 朱君鹏 支持 磐实编程网 原文地址:
blog.csdn.net/jpzhu16/article/details/51556859

文章信息

发布时间:2016-06-01

作者:朱君鹏

发布者:aquwcw

浏览次数: