java开发JDBC连接数据库

1. JDBC连接数据库

1. •创建一个以JDBC连接数据库的程序，包含7个步骤：

1. 1、加载JDBC驱动程序：

1. 在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），

1. 这通过java.lang.Class类的静态方法forName(StringclassName)实现。

1. DriverManager 类是 JDBC 的管理层，作用于用户和驱动程序之间。它跟踪可用的驱动程序，并在数据库和相应驱动程序之间建立连接。另外， DriverManager 类也处理诸如驱动程序登录时间限制及登录和跟踪消息的显示等事务。

1. 通过调用方法 Class.forName。这将显式地加载驱动程序类。由于这与外部设置无关，因此推荐使用这种加载驱动程序的方法。以下代码加载类 nicol.db.Driver：

Class.forName("nicol.db.Driver");

Class.forName("nicol.db.Driver");

1. 例如：

<SPANstyle="FONT-SIZE:14px">try{
 //加载MySql的驱动类
 Class.forName("com.mysql.jdbc.Driver");
 }catch(ClassNotFoundExceptione){
 System.out.println("找不到驱动程序类，加载驱动失败！");
e.printStackTrace();
}</SPAN>

try{
//加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace() ;
}

1. 
   

1. 成功加载后，会将Driver类的实例注册到DriverManager类中。

1. 2、提供JDBC连接的URL

1. •连接URL定义了连接数据库时的协议、子协议、数据源标识。

1. •书写形式：协议：子协议：数据源标识

1. 协议：在JDBC中总是以jdbc开始

1. 子协议：是桥连接的驱动程序或是数据库管理系统名称。

1. 数据源标识：标记找到数据库来源的地址与连接端口。

1. 例如：（MySql的连接URL）

1. jdbc:mysql:
    //localhost:3306/test?useUnicode=true&characterEncoding=gbk;

    jdbc:mysql:   
           //localhost:3306/test?useUnicode=true&characterEncoding=gbk ;   

   
   

1. useUnicode=true：表示使用Unicode字符集。如果characterEncoding设置为

1. gb2312或GBK，本参数必须设置为true。characterEncoding=gbk：字符编码方式。

1. 3、创建数据库的连接

1. •要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，

1. 该对象就代表一个数据库的连接。

1. •使用DriverManager的getConnectin(Stringurl,Stringusername,

1. Stringpassword)方法传入指定的欲连接的数据库的路径、数据库的用户名和

1. 密码来获得。

1. 例如：

//连接MySql数据库，用户名和密码都是root
 Stringurl="jdbc:mysql://localhost:3306/test";
 Stringusername="root";
 Stringpassword="root";
 try{
Connectioncon=
DriverManager.getConnection(url,username,password);
 }catch(SQLExceptionse){
 System.out.println("数据库连接失败！");
se.printStackTrace();
}

//连接MySql数据库，用户名和密码都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("数据库连接失败！");
se.printStackTrace() ;
}

1. 
   

1. 4、创建一个Statement

1. •要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3

1. 种类型：

1. 1、执行静态SQL语句。通常通过Statement实例实现。

1. 2、执行动态SQL语句。通常通过PreparedStatement实例实现。

1. 3、执行数据库存储过程。通常通过CallableStatement实例实现。

1. 具体的实现方式：

1. 
   Statementstmt=con.createStatement();
   PreparedStatementpstmt=con.prepareStatement(sql);
   CallableStatementcstmt=
    con.prepareCall("{CALLdemoSp(?,?)}");

         
   Statement stmt = con.createStatement() ;
   PreparedStatement pstmt = con.prepareStatement(sql) ;
   CallableStatement cstmt =
   con.prepareCall("{CALL demoSp(? , ?)}") ;

   
   
   

1. 
   

1. 5、执行SQL语句

1. Statement接口提供了三种执行SQL语句的方法：executeQuery、executeUpdate

1. 和execute

1. 1、ResultSetexecuteQuery(StringsqlString)：执行查询数据库的SQL语句

1. ，返回一个结果集（ResultSet）对象。

1. 2、intexecuteUpdate(StringsqlString)：用于执行INSERT、UPDATE或

1. DELETE语句以及SQLDDL语句，如：CREATETABLE和DROPTABLE等

1. 3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的

1. 语句。

1. 具体实现的代码：

1. ResultSetrs=stmt.executeQuery("SELECT*FROM...");
    introws=stmt.executeUpdate("INSERTINTO...");
    booleanflag=stmt.execute(Stringsql);

   ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;
   int rows = stmt.executeUpdate("INSERT INTO ...") ;
   boolean flag = stmt.execute(String sql) ;
   

   
   
   

1. 6、处理结果

1. 两种情况：

1. 1、执行更新返回的是本次操作影响到的记录数。

1. 2、执行查询返回的结果是一个ResultSet对象。

1. •ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些

1. 行中数据的访问。

1. •使用结果集（ResultSet）对象的访问方法获取数据：

while(rs.next()){
 Stringname=rs.getString("name");
 Stringpass=rs.getString(1);//此方法比较高效
}

while(rs.next()){
String name = rs.getString("name") ;
String pass = rs.getString(1) ; // 此方法比较高效
}

1. 
   

1. （列是从左到右编号的，并且从列1开始）

1. 7、关闭JDBC对象

1. 操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声

1. 明顺序相反：

1. 1、关闭记录集

1. 2、关闭声明

1. 3、关闭连接对象

if(rs!=null){//关闭记录集
 try{
rs.close();
 }catch(SQLExceptione){
e.printStackTrace();
}
}
 if(stmt!=null){//关闭声明
 try{
stmt.close();
 }catch(SQLExceptione){
e.printStackTrace();
}
}
 if(conn!=null){//关闭连接对象
 try{
conn.close();
 }catch(SQLExceptione){
e.printStackTrace();
}
}

if(rs != null){ // 关闭记录集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 关闭声明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(conn != null){ // 关闭连接对象
try{
conn.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
} 

Statement篇：

1. Statement 对象用于将 SQL 语句发送到数据库中。实际上有三种 Statement 对象，它们都作为在给定连接上执行 SQL 语句的包容器：Statement、PreparedStatement（它从 Statement 继承而来）和 CallableStatement（它从 PreparedStatement 继承而来）。它们都专用于发送特定类型的 SQL 语句： Statement 对象用于执行不带参数的简单 SQL 语句；PreparedStatement 对象用于执行带或不带 IN 参数的预编译 SQL 语句；CallableStatement 对象用于执行对数据库已存储过程的调用。

1. 
   

1. 
   

1. 　　Statement 接口提供了执行语句和获取结果的基本方法。PreparedStatement 接口添加了处理 IN 参数的方法；而 CallableStatement 添加了处理 OUT 参数的方法。

1. 
   

1. 
   

1. 
   

1. 
   

1. 
   

1. 
   

1. 　　1、创建 Statement 对象

1. 
   

1. 
   

1. 　　建立了到特定数据库的连接之后，就可用该连接发送 SQL 语句。Statement 对象用 Connection 的方法 createStatement 创建，如下列代码段中所示：

1. 
   

1. 
   

1. Connectioncon=DriverManager.getConnection(url,"sunny","");
   Statementstmt=con.createStatement();

   Connection con = DriverManager.getConnection(url, "sunny", ""); 
   Statement stmt = con.createStatement(); 

   
   
   

1. 
   

1. 
   

1. 　　为了执行 Statement 对象，被发送到数据库的 SQL 语句将被作为参数提供给 Statement 的方法：

1. 
   

1. 
   

1. ResultSetrs=stmt.executeQuery("SELECTa,b,cFROMTable");

   ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM Table"); 

   
   

1. 
   

1. 
   

1. 　　2、使用 Statement 对象执行语句

1. 
   

1. 
   

1. 　　Statement 接口提供了三种执行 SQL 语句的方法：executeQuery、executeUpdate 和 execute。使用哪一个方法由 SQL 语句所产生的内容决定。

1. 
   

1. 
   

1. 　　方法 executeQuery 用于产生单个结果集的语句，例如 SELECT 语句。

1. 
   

1. 
   

1. 　　方法 executeUpdate 用于执行 INSERT、UPDATE 或 DELETE 语句以及 SQL DDL（数据定义语言）语句，例如 CREATE TABLE 和 DROP TABLE。INSERT、UPDATE 或 DELETE 语句的效果是修改表中零行或多行中的一列或多列。executeUpdate 的返回值是一个整数，指示受影响的行数（即更新计数）。对于 CREATE TABLE 或 DROP TABLE 等不操作行的语句，executeUpdate 的返回值总为零。

1. <SPANstyle="LINE-HEIGHT:19px;BACKGROUND-COLOR:rgb(240,242,251);FONT-SIZE:14px"></SPAN>

   
   
   　　方法 execute 用于执行返回多个结果集、多个更新计数或二者组合的语句。因为多数程序员不会需要该高级功能，所以本概述后面将在单独一节中对其进行介绍。
   
   
   　　执行语句的所有方法都将关闭所调用的 Statement 对象的当前打开结果集（如果存在）。这意味着在重新执行 Statement 对象之前，需要完成对当前 ResultSet 对象的处理。
   
   
   　　应注意，继承了 Statement 接口中所有方法的 PreparedStatement 接口都有自己的 executeQuery、executeUpdate 和 execute 方法。Statement 对象本身不包含 SQL 语句，因而必须给 Statement.execute 方法提供 SQL 语句作为参数。PreparedStatement 对象并不将 SQL 语句作为参数提供给这些方法，因为它们已经包含预编译 SQL 语句。CallableStatement 对象继承这些方法的 PreparedStatement 形式。对于这些方法的 PreparedStatement 或 CallableStatement 版本，使用查询参数将抛出 SQLException。
   
   
   　　3、语句完成
   
   
   　　当连接处于自动提交模式时，其中所执行的语句在完成时将自动提交或还原。语句在已执行且所有结果返回时，即认为已完成。对于返回一个结果集的 executeQuery 方法，在检索完 ResultSet 对象的所有行时该语句完成。对于方法 executeUpdate，当它执行时语句即完成。但在少数调用方法 execute 的情况中，在检索所有结果集或它生成的更新计数之后语句才完成。
   
   
   　　有些 DBMS 将已存储过程中的每条语句视为独立的语句；而另外一些则将整个过程视为一个复合语句。在启用自动提交时，这种差别就变得非常重要，因为它影响什么时候调用 commit 方法。在前一种情况中，每条语句单独提交；在后一种情况中，所有语句同时提交。
   
   
   　　4、关闭 Statement 对象
   
   
   　　Statement 对象将由 Java 垃圾收集程序自动关闭。而作为一种好的编程风格，应在不需要 Statement 对象时显式地关闭它们。这将立即释放 DBMS 资源，有助于避免潜在的内存问题。
   
2. 5、Statement 对象中的 SQL 转义语法
   
   
   　　Statement 可包含使用 SQL 转义语法的 SQL 语句。转义语法告诉驱动程序其中的代码应该以不同方式处理。驱动程序将扫描任何转义语法，并将它转换成特定数据库可理解的代码。这使得转义语法与 DBMS 无关，并允许程序员使用在没有转义语法时不可用的功能。
   
   
   　　转义子句由花括号和关键字界定：
   
   
   {keyword . . . parameters . . . }
   
   
   　　该关键字指示转义子句的类型，如下所示。
   
   
   　　escape 表示 LIKE 转义字符
   
   
   　　字符“%”和“_”类似于 SQL LIKE 子句中的通配符（“%”匹配零个或多个字符，而“_”则匹配一个字符）。为了正确解释它们，应在其前面加上反斜杠（“\”），它是字符串中的特殊转义字符。在查询末尾包括如下语法即可指定用作转义字符的字符：
   
   
   {escape 'escape-character'}
   
   
   　　例如，下列查询使用反斜杠字符作为转义字符，查找以下划线开头的标识符名：
   
   
   stmt.executeQuery("SELECT name FROM Identifiers
   WHERE Id LIKE `\_%' {escape `\'};
   
   
   　　fn 表示标量函数
   
   
   　　几乎所有 DBMS 都具有标量值的数值、字符串、时间、日期、系统和转换函数。要使用这些函数，可使用如下转义语法：关键字 fn 后跟所需的函数名及其参数。例如，下列代码调用函数 concat 将两个参数连接在一起：
   
   
   {fn concat("Hot", "Java")};
   
   
   　　可用下列语法获得当前数据库用户名：
   
   
   {fn user()};
   
   
   　　标量函数可能由语法稍有不同的 DBMS 支持，而它们可能不被所有驱动程序支持。各种 DatabaseMetaData 方法将列出所支持的函数。例如，方法 getNumericFunctions 返回用逗号分隔的数值函数列表，而方法 getStringFunctions 将返回字符串函数，等等。
   
   
   　　驱动程序将转义函数调用映射为相应的语法，或直接实现该函数。
   
   
   　　d、t 和 ts 表示日期和时间文字
   
   
   　　DBMS 用于日期、时间和时间标记文字的语法各不相同。JDBC 使用转义子句支持这些文字的语法的 ISO 标准格式。驱动程序必须将转义子句转换成 DBMS 表示。
   
   
   　　例如，可用下列语法在 JDBC SQL 语句中指定日期：
   
   
   {d `yyyy-mm-dd'}
   
   
   　　在该语法中，yyyy 为年代，mm 为月份，而 dd 则为日期。驱动程序将用等价的特定于 DBMS 的表示替换这个转义子句。例如，如果 '28- FEB-99' 符合基本数据库的格式，则驱动程序将用它替换 {d 1999-02-28}。
   
   
   　　对于 TIME 和 TIMESTAMP 也有类似的转义子句：
   
   
   {t `hh:mm:ss'}
   {ts `yyyy-mm-dd hh:mm:ss.f . . .'}
   
   
   　　TIMESTAMP 中的小数点后的秒（.f . . .）部分可忽略。
   
   
   　　call 或 ? = call 表示已存储过程
   
   
   　　如果数据库支持已存储过程，则可从 JDBC 中调用它们，语法为：
   
   
   {call procedure_name[(?, ?, . . .)]}
   
   
   　　或（其中过程返回结果参数）：
   
   
   {? = call procedure_name[(?, ?, . . .)]}
   
   
   　　方括号指示其中的内容是可选的。它们不是语法的必要部分。
   
   
   　　输入参数可以为文字或参数。有关详细信息，参见 JDBC 指南中第 7 节，“CallableStatement”。
   
   
   　　可通过调用方法 DatabaseMetaData.supportsStoredProcedures 检查数据库是否支持已存储过程。
   
   
   　　oj 表示外部连接
   
   
   　　外部连接的语法为
   
   
   {oj outer-join}
   
   
   　　其中 outer-join 形式为
   
   
   table LEFT OUTER JOIN {table / outer-join} ON search-condition
   
   
   　　外部连接属于高级功能。有关它们的解释可参见 SQL 语法。JDBC 提供了三种 DatabaseMetaData 方法用于确定驱动程序支持哪些外部连接类型：supportsOuterJoins、supportsFullOuterJoins 和 supportsLimitedOuterJoins。
   
   
   　　方法 Statement.setEscapeProcessing 可打开或关闭转义处理；缺省状态为打开。当性能极为重要时，程序员可能想关闭它以减少处理时间。但通常它将出于打开状态。应注意： setEscapeProcessing 不适用于 PreparedStatement 对象，因为在调用该语句前它就可能已被发送到数据库。有关预编译的信息，参见 PreparedStatement。
   
   
   　　6、使用方法 execute
   
   
   　　execute 方法应该仅在语句能返回多个 ResultSet 对象、多个更新计数或 ResultSet 对象与更新计数的组合时使用。当执行某个已存储过程或动态执行未知 SQL 字符串（即应用程序程序员在编译时未知）时，有可能出现多个结果的情况，尽管这种情况很少见。例如，用户可能执行一个已存储过程（使用 CallableStatement 对象 - 参见第 135 页的 CallableStatement），并且该已存储过程可执行更新，然后执行选择，再进行更新，再进行选择，等等。通常使用已存储过程的人应知道它所返回的内容。
   
   
   　　因为方法 execute 处理非常规情况，所以获取其结果需要一些特殊处理并不足为怪。例如，假定已知某个过程返回两个结果集，则在使用方法 execute 执行该过程后，必须调用方法 getResultSet 获得第一个结果集，然后调用适当的 getXXX 方法获取其中的值。要获得第二个结果集，需要先调用 getMoreResults 方法，然后再调用 getResultSet 方法。如果已知某个过程返回两个更新计数，则首先调用方法 getUpdateCount，然后调用 getMoreResults，并再次调用 getUpdateCount。
   
   
   　　对于不知道返回内容，则情况更为复杂。如果结果是 ResultSet 对象，则方法 execute 返回 true；如果结果是 Java int，则返回 false。如果返回 int，则意味着结果是更新计数或执行的语句是 DDL 命令。在调用方法 execute 之后要做的第一件事情是调用 getResultSet 或 getUpdateCount。调用方法 getResultSet 可以获得两个或多个 ResultSet 对象中第一个对象；或调用方法 getUpdateCount 可以获得两个或多个更新计数中第一个更新计数的内容。
   
   
   　　当 SQL 语句的结果不是结果集时，则方法 getResultSet 将返回 null。这可能意味着结果是一个更新计数或没有其它结果。在这种情况下，判断 null 真正含义的唯一方法是调用方法 getUpdateCount，它将返回一个整数。这个整数为调用语句所影响的行数；如果为 -1 则表示结果是结果集或没有结果。如果方法 getResultSet 已返回 null（表示结果不是 ResultSet 对象），则返回值 -1 表示没有其它结果。也就是说，当下列条件为真时表示没有结果（或没有其它结果）：
   
   
   ((stmt.getResultSet() == null) && (stmt.getUpdateCount() == -1))
   
   
   　　如果已经调用方法 getResultSet 并处理了它返回的 ResultSet 对象，则有必要调用方法 getMoreResults 以确定是否有其它结果集或更新计数。如果 getMoreResults 返回 true，则需要再次调用 getResultSet 来检索下一个结果集。如上所述，如果 getResultSet 返回 null，则需要调用 getUpdateCount 来检查 null 是表示结果为更新计数还是表示没有其它结果。
   
   
   　　当 getMoreResults 返回 false 时，它表示该 SQL 语句返回一个更新计数或没有其它结果。因此需要调用方法 getUpdateCount 来检查它是哪一种情况。在这种情况下，当下列条件为真时表示没有其它结果：
   
   
   ((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))
   
   
   　　下面的代码演示了一种方法用来确认已访问调用方法 execute 所产生的全部结果集和更新计数：
   
   
   

   stmt.execute(queryStringWithUnknownResults);
    while(true){
    introwCount=stmt.getUpdateCount();
    if(rowCount>0){//它是更新计数
    System.out.println("Rowschanged="+count);
   stmt.getMoreResults();
    continue;
   }
    if(rowCount==0){//DDL命令或0个更新
   System.out.println("NorowschangedorstatementwasDDL
   command");
   stmt.getMoreResults();
    continue;
   }
   
   
    //执行到这里，证明有一个结果集
    //或没有其它结果
   
   
   ResultSetrs=stmt.getResultSet;
    if(rs!=null){
    　...//使用元数据获得关于结果集列的信息
    　while(rs
    break;//没有其它结果

   stmt.execute(queryStringWithUnknownResults); 
   while (true) { 
   int rowCount = stmt.getUpdateCount(); 
   if (rowCount > 0) { // 它是更新计数 
   System.out.println("Rows changed = " + count); 
   stmt.getMoreResults(); 
   continue; 
   } 
   if (rowCount == 0) { // DDL 命令或 0 个更新 
   System.out.println(" No rows changed or statement was DDL 
   command"); 
   stmt.getMoreResults(); 
   continue; 
   } 
   
   
   // 执行到这里，证明有一个结果集 
   // 或没有其它结果 
   
   
   ResultSet rs = stmt.getResultSet; 
   if (rs != null) { 
   　. . . // 使用元数据获得关于结果集列的信息 
   　while ( rs 
   break; // 没有其它结果

   
   CallableStatement 篇
   
3. CallableStatement 对象为所有的 DBMS 提供了一种以标准形式调用已储存过程的方法。已储存过程储存在数据库中。对已储存过程的调用是 CallableStatement对象所含的内容。这种调用是用一种换码语法来写的，有两种形式：一种形式带结果参，另一种形式不带结果参数。结果参数是一种输出 (OUT) 参数，是已储存过程的返回值。两种形式都可带有数量可变的输入（IN 参数）、输出（OUT 参数）或输入和输出（INOUT 参数）的参数。问号将用作参数的占位符。
   
   　　在 JDBC 中调用已储存过程的语法如下所示。注意，方括号表示其间的内容是可选项；方括号本身并不是语法的组成部份。
   
   
   {call 过程名[(?, ?, ...)]}
   
   
   　　返回结果参数的过程的语法为：
   
   
   {? = call 过程名[(?, ?, ...)]}
   
   
   　　不带参数的已储存过程的语法类似：
   
   
   {call 过程名}
   
   
   　　通常，创建 CallableStatement 对象的人应当知道所用的 DBMS 是支持已储存过程的，并且知道这些过程都是些什么。然而，如果需要检查，多种DatabaseMetaData 方法都可以提供这样的信息。例如，如果 DBMS 支持已储存过程的调用，则supportsStoredProcedures 方法将返回 true，而getProcedures 方法将返回对已储存过程的描述。CallableStatement 继承 Statement 的方法（它们用于处理一般的 SQL 语句），还继承了 PreparedStatement 的方法（它们用于处理 IN 参）。
   
   
   　　CallableStatement 中定义的所有方法都用于处理 OUT 参数或 INOUT 参数的输出部分：注册 OUT 参数的 JDBC 类型（一般 SQL 类型）、从这些参数中检索结果，或者检查所返回的值是否为 JDBC NULL。
   
   
   　　1、创建 CallableStatement 对象
   
   
   　　CallableStatement 对象是用 Connection 方法 prepareCall 创建的。下例创建 CallableStatement 的实例，其中含有对已储存过程 getTestData 调用。该过程有两个变量，但不含结果参数：
   
   
   

   CallableStatementcstmt=con.prepareCall("{callgetTestData(?,?)}");

   CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");

   
   
   
   
   　　其中?占位符为IN、OUT还是INOUT参数，取决于已储存过程getTestData。
   
   
   　　2、IN和OUT参数
   
   
   　　将IN参数传给 CallableStatement 对象是通过 setXXX 方法完成的。该方法继承自 PreparedStatement。所传入参数的类型决定了所用的setXXX方法（例如，用 setFloat 来传入 float 值等）。
   
   
   　　如果已储存过程返回 OUT 参数，则在执行 CallableStatement 对象以前必须先注册每个 OUT 参数的 JDBC 类型（这是必需的，因为某些 DBMS 要求 JDBC 类型）。注册 JDBC 类型是用 registerOutParameter 方法来完成的。语句执行完后，CallableStatement 的 getXXX 方法将取回参数值。正确的 getXXX 方法是为各参数所注册的 JDBC 类型所对应的 Java 类型。换言之， registerOutParameter 使用的是 JDBC 类型（因此它与数据库返回的 JDBC 类型匹配），而 getXXX 将之转换为 Java 类型。
   
   
   　　作为示例，下述代码先注册 OUT 参数，执行由 cstmt 所调用的已储存过程，然后检索在 OUT 参数中返回的值。方法 getByte 从第一个 OUT 参数中取出一个 Java 字节，而 getBigDecimal 从第二个 OUT 参数中取出一个 BigDecimal 对象（小数点后面带三位数）：
   
   
   

   CallableStatementcstmt=con.prepareCall("{callgetTestData(?,?)}");
    cstmt.registerOutParameter(1,java.sql.Types.TINYINT);
    cstmt.registerOutParameter(2,java.sql.Types.DECIMAL,3);
   cstmt.executeQuery();
    bytex=cstmt.getByte(1);
    java.math.BigDecimaln=cstmt.getBigDecimal(2,3);

   CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");
   cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
   cstmt.registerOutParameter(2, java.sql.Types.DECIMAL, 3);
   cstmt.executeQuery();
   byte x = cstmt.getByte(1);
   java.math.BigDecimal n = cstmt.getBigDecimal(2, 3);

   
   
   
   
   　　CallableStatement 与 ResultSet 不同，它不提供用增量方式检索大 OUT 值的特殊机制。
   
4. 　3、INOUT参数
   
   　　既支持输入又接受输出的参数（INOUT 参数）除了调用 registerOutParameter 方法外，还要求调用适当的 setXXX 方法（该方法是从 PreparedStatement 继承来的）。setXXX 方法将参数值设置为输入参数，而 registerOutParameter 方法将它的 JDBC 类型注册为输出参数。setXXX 方法提供一个 Java 值，而驱动程序先把这个值转换为 JDBC 值，然后将它送到数据库中。这种 IN 值的 JDBC 类型和提供给 registerOutParameter 方法的 JDBC 类型应该相同。然后，要检索输出值，就要用对应的 getXXX 方法。例如，Java 类型为byte 的参数应该使用方法 setByte 来赋输入值。应该给registerOutParameter 提供类型为 TINYINT 的 JDBC 类型，同时应使用 getByte 来检索输出值。
   
   　　下例假设有一个已储存过程 reviseTotal，其唯一参数是 INOUT 参数。方法setByte 把此参数设为 25，驱动程序将把它作为 JDBC TINYINT 类型送到数据库中。接着，registerOutParameter 将该参数注册为 JDBC TINYINT。执行完该已储存过程后，将返回一个新的 JDBC TINYINT 值。方法 getByte 将把这个新值作为 Java byte 类型检索。
   

   CallableStatementcstmt=con.prepareCall("{callreviseTotal(?)}");
    cstmt.setByte(1,25);
    cstmt.registerOutParameter(1,java.sql.Types.TINYINT);
   cstmt.executeUpdate();
    bytex=cstmt.getByte(1);

   CallableStatement cstmt = con.prepareCall("{call reviseTotal(?)}");
   cstmt.setByte(1, 25);
   cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
   cstmt.executeUpdate();
   byte x = cstmt.getByte(1);

   
   
   　　4、先检索结果，再检索 OUT 参数
   
   　　由于某些 DBMS 的限制，为了实现最大的可移植性，建议先检索由执行CallableStatement 对象所产生的结果，然后再用 CallableStatement.getXXX 方法来检索 OUT 参数。如果 CallableStatement 对象返回多个 ResultSet 对象（通过调用 execute 方法），在检索 OUT 参数前应先检索所有的结果。这种情况下，为确保对所有的结果都进行了访问，必须对 Statement 方法 getResultSet、getUpdateCount 和getMoreResults 进行调用，直到不再有结果为止。
   
   　　检索完所有的结果后，就可用 CallableStatement.getXXX 方法来检索 OUT 参数中的值。
   
   　　5、检索作为OUT参数的NULL值
   
   　　返回到 OUT 参数中的值可能会是JDBC NULL。当出现这种情形时，将对 JDBC NULL 值进行转换以使 getXXX 方法所返回的值为 null、0 或 false，这取决于getXXX 方法类型。对于 ResultSet 对象，要知道0或false是否源于JDBCNULL的唯一方法，是用方法wasNull进行检测。如果 getXXX 方法读取的最后一个值是 JDBC NULL，则该方法返回 true，否则返回 flase。