java调用输入参数、输出参数、输出参数为列表的存储过程(二)

于 2014-04-14 08:47:04 发布
阅读量898 收藏
点赞数
分类专栏： ORACLE
注意：oracle11g之前的版本，一定将Oracle/jdbc/lib/nl_charset12.jar 导入到项目中，否则当java调用存储过程，输入参数为数组的时候，数组中的字符串无法写入数据库中。

废话少说，直接上代码：
oracle建表：
create table STUDENT
(
  ID     INTEGER not null,
  SNAME  VARCHAR2(30),
  SCLASS VARCHAR2(20),
  SCORE  VARCHAR2(10),
  SUBJ   VARCHAR2(20);

create table STUDENT_COPY
(
  CP_ID INTEGER,
  SNAME VARCHAR2(30)
)


1. 实体类


import java.sql.Connection;
import java.sql.SQLException;

import oracle.jdbc.OracleTypes;
import oracle.jpub.runtime.MutableStruct;
import oracle.sql.Datum;
import oracle.sql.ORAData;
import oracle.sql.ORADataFactory;

public class StudentCppy implements ORAData {

private Integer v_id;
private String v_name;
//ORACLE 中创建的OBJECT对应的名称
public static final String ORACLE_OBJECT_NAME = "TEST_ARRAR_1";
//ORACLE 中创建的OBJECT——》TABLE对应的名称
public static final String oRACLE_TABLE_NAME_OF_OBJECT ="TEST_ARRAR_1_TABLE";
private MutableStruct struct;

//初始化结构体的类型：oracle中OBJECT的属性，依次对应的数据类型。
private int[] sqlTypes= {OracleTypes.INTEGER,OracleTypes.VARCHAR}; 
private ORADataFactory [] factory = new ORADataFactory[sqlTypes.length];
public StudentCppy(){
struct = new MutableStruct(new Object[sqlTypes.length],sqlTypes,factory);
}
public StudentCppy(Integer v_id,String v_name){
this();//只能在构造函数中的第一句调用,且在一个类中只能调用一次
this.v_id = v_id;
this.v_name= v_name;
}
/**
 * 实现方法，这是必须的
 */
public Datum toDatum(Connection conn) throws SQLException {
//给oracle的结构体（一个OBJECT——》TEABLE对象）设置值。
struct.setAttribute(0, this.v_id);
struct.setAttribute(1, this.v_name);
return struct.toDatum(conn, ORACLE_OBJECT_NAME);
}
public Integer getV_id() {
return v_id;
}
public void setV_id(Integer v_id) {
this.v_id = v_id;
}
public String getV_name() {
return v_name;
}
public void setV_name(String v_name) {
this.v_name = v_name;
}
}

2.操作类

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

import oracle.sql.ARRAY;
import oracle.sql.ArrayDescriptor;
import oracle.sql.STRUCT;
import oracle.sql.StructDescriptor;
 
public class TestProcedureOne {
  public TestProcedureOne() {
  }
  public static void main(String[] args ){
//   callProc1(); //调用只有输入参数的存储过程
//   callProc2(); //调用既有输入参数又有返回值（输出参数）的存储过程
//   callProc3(); //调用返回值（输出参数）为列表的存储过程
  callProc4(); //自动将实体StudentCppy封装为ORACLE对象
//   callProc5(); //手动将实体StudentCppy封装为ORACLE对象
  }
  
  /**
   调用只有输人参数的存储过程。 Oracle存储过程代码如下
   
     CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2, PARA2 IN VARCHAR2) AS
     BEGIN
           INSERT INTO student_copy VALUES (PARA1, PARA2);
     END TESTA;

   */
private static void callProc1() {
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:ZYJORCL1";
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;

try {
Class.forName(driver);
conn = DriverManager.getConnection(strUrl, "studyOracle", "orcl");
CallableStatement proc = null;
proc = conn.prepareCall("{ call TESTA(?,?) }");
proc.setString(1, "100");
proc.setString(2, "TestOne");
proc.execute();
} catch (SQLException ex2) {
ex2.printStackTrace();
} catch (Exception ex2) {
ex2.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
if (stmt != null) {
stmt.close();
}
if (conn != null) {
conn.close();
}
}
} catch (SQLException ex1) {
}
}
}
/**
 * 调用有返回值的存储过程。Oracle存储过程代码如下：
  ---输入参数PARA1 、 输出参数（返回值）PARA2
      CREATE OR REPLACE PROCEDURE TESTB(PARA1 IN INTEGER, PARA2 OUT VARCHAR2) AS
      BEGIN
        SELECT t.sname INTO PARA2 FROM student t WHERE ID = PARA1;
      END TESTB;
 
 */
private static void callProc2(){
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:ZYJORCL1";
 Statement stmt = null;
 ResultSet rs = null;
 Connection conn = null;
 try {
    Class.forName(driver);
    conn = DriverManager.getConnection(strUrl, "studyOracle", "orcl");
    CallableStatement proc = null;
    proc = conn.prepareCall("{ call TESTB(?,?) }");
    proc.setString(1, "1");//设置输入参数
    proc.registerOutParameter(2, Types.VARCHAR);//注册输出参数
    proc.execute();
    /*
     这里的proc.getString(2)中的数值2并非任意的，而是和存储过程中的out列对应的，
     如果out是在第一个位置，那就是proc.getString(1)，如果是第三个位置，就是proc.getString(3)，
     当然也可以同时有多个返回值，那就是再多加几个out参数了。
     * */
    String testPrint = proc.getString(2);
    System.out.println("=testPrintis===》"+testPrint);
    }
    catch (SQLException ex2) {
      ex2.printStackTrace();
    }
    catch (Exception ex2) {
      ex2.printStackTrace();
    }
    finally{
      try {
        if(rs != null){
          rs.close();
          if(stmt!=null){
            stmt.close();
          }
          if(conn!=null){
            conn.close();
          }
        }
      }
      catch (SQLException ex1) {
      }
    }
  }
/**
 调用返回值为列表的存储过程。
 由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，
 所以不能用一般的参数，必须要用pagkage了.所以要分两部分。
 1，  建一个程序包。如下：
           CREATE OR REPLACE PACKAGE TESTPACKAGE    AS
           TYPE Test_CURSOR  IS REF Cursor;
           END  TESTPACKAGE;
           
 2，建立存储过程，存储过程为：
           CREATE OR REPLACE PROCEDURE TESTC(p_CURSOR out TESTPACKAGE.Test_CURSOR) IS
           BEGIN
              OPEN p_CURSOR FOR
                SELECT * FROM student;
           END TESTC;
   可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。
 
 * */
private static void callProc3(){
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:ZYJORCL1";
    Statement stmt = null;
    ResultSet rs = null;
    Connection conn = null;
//  StructDescriptor
    
    try {
      Class.forName(driver);
      conn = DriverManager.getConnection(strUrl, "studyOracle", "orcl");
      CallableStatement proc = null;
      proc = conn.prepareCall("{ call testc(?) }");
      proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);//注册返回值（输出参数）
      proc.execute();
      rs = (ResultSet)proc.getObject(1);//获取返回的列表
 
      while(rs.next())
      {
         System.out.println("ID:" + rs.getInt(1) + "\t\tSname:"
+ rs.getString(2) + "\t\tSCLASS:" + rs.getString(3)
+ "\t\tSCORE:" + rs.getString(4)+"\t\tSUBJ:"+rs.getString(5));
         
      }
    }
    catch (SQLException ex2) {
      ex2.printStackTrace();
    }
    catch (Exception ex2) {
      ex2.printStackTrace();
    }
    finally{
      try {
        if(rs != null){
          rs.close();
          if(stmt!=null){
            stmt.close();
          }
          if(conn!=null){
            conn.close();
          }
        }
      }
      catch (SQLException ex1) {
      }
    }
}
/**
 * 自动将实体封装为ORACLE的数组对象。
 * ORACLE部分代码：
     ---创建对象
         create or replace type TEST_ARRAR_1 as OBJECT(
          v_id  integer,
          v_name varchar2(30)
         );
         ---创建TEST_ARRAR_1对应的数组对象
         create or replace type TEST_ARRAR_1_TABLE as table of TEST_ARRAR_1;
         ---创建输入参数为结构型的存储过程
         create or replace procedure test_array_table1_proc( array_table1  in test_arrar_1_table)
         as
         v_array test_arrar_1;
         begin
           for i in array_table1.first()..array_table1.last()  loop  
               v_array := array_table1(i);
                 insert into student_copy values(v_array.v_id , v_array.v_name);
                 insert into student(id,sname) values(v_array.v_id , v_array.v_name);
           end loop; 
  
         end;
         /       
 
 */
private static void callProc4(){
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:ZYJORCL1";
    Statement stmt = null;
    ResultSet rs = null;
    Connection conn = null;
    
    try {
      Class.forName(driver);
      conn = DriverManager.getConnection(strUrl, "studyOracle", "orcl");
      List<StudentCppy>  listStu = getList1();
      //转换对象为oracle的数组对象
      ArrayDescriptor arraydesc = new ArrayDescriptor(StudentCppy.oRACLE_TABLE_NAME_OF_OBJECT,conn);
      //转换为Oracle的数组
      ARRAY array = new ARRAY(arraydesc,conn,listStu.toArray());
      CallableStatement proc = null;
      proc = conn.prepareCall("{ call test_array_table1_proc(?) }");
      proc.setArray(1, array);//设置参数
      proc.execute();
    }
    catch (SQLException ex2) {
      ex2.printStackTrace();
    }
    catch (Exception ex2) {
      ex2.printStackTrace();
    }
    finally{
      try {
        if(rs != null){
          rs.close();
          if(stmt!=null){
            stmt.close();
          }
          if(conn!=null){
            conn.close();
          }
        }
      }
      catch (SQLException ex1) {
      }
      System.out.println("-----wancheng");
    }
}
private static List<StudentCppy> getList1(){
 List<StudentCppy> list = new ArrayList<StudentCppy>();
 StudentCppy s1 = new StudentCppy(5,"11Name");
 StudentCppy s2 = new StudentCppy(6,"22Name");
 StudentCppy s3 = new StudentCppy(7,"33Name");
 list.add(s1);
 list.add(s2);
 list.add(s3);
 return list;
}

/**
 *  手动将实体封装为ORACLE的数组对象
  ORACLE部分代码：
     ---创建对象
         create or replace type TEST_ARRAR_1 as OBJECT(
          v_id  integer,
          v_name varchar2(30)
         );
         ---创建TEST_ARRAR_1对应的数组对象
         create or replace type TEST_ARRAR_1_TABLE as table of TEST_ARRAR_1;
         ---创建输入参数为结构型的存储过程
         create or replace procedure test_array_table1_proc( array_table1  in test_arrar_1_table)
         as
         v_array test_arrar_1;
         begin
           for i in array_table1.first()..array_table1.last()  loop  
               v_array := array_table1(i);
                 insert into student_copy values(v_array.v_id , v_array.v_name);
                 insert into student(id,sname) values(v_array.v_id , v_array.v_name);
           end loop; 
  
         end;
         /   
 */
private static void callProc5(){
String driver = "oracle.jdbc.driver.OracleDriver";
String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:ZYJORCL1";
    Connection conn = null;
    CallableStatement proc = null;
    try {
      Class.forName(driver);
      conn = DriverManager.getConnection(strUrl, "studyOracle", "orcl");
      List<StudentCppy>  listStu = getList1();
      //创建一个ORACLE的OBJECT描述符
      StructDescriptor structDsec = StructDescriptor.createDescriptor(StudentCppy.ORACLE_OBJECT_NAME, conn);
      //ORACLE的结构体（模拟多行数据）
      List<STRUCT> listStruct = new ArrayList<STRUCT>();
      //生成多行数据
      for(StudentCppy stu:listStu){
       String [] record  = new String[2];
       record[0] = stu.getV_id()+"";
       record[1] = stu.getV_name();
       STRUCT struct = new STRUCT(structDsec,conn,record);
       listStruct.add(struct);
      }
             
      //转换对象为oracle的数组对象
      ArrayDescriptor arraydesc = new ArrayDescriptor(StudentCppy.oRACLE_TABLE_NAME_OF_OBJECT,conn);
      //转换为Oracle的数组
      ARRAY array = new ARRAY(arraydesc,conn,listStruct.toArray());
      proc = conn.prepareCall("{ call TEST_ARRAY_TABLE1_PROC(?) }");
      proc.setArray(1, array);//设置参数
      proc.execute();
    }
    catch (SQLException ex2) {
      ex2.printStackTrace();
    }
    catch (Exception ex2) {
      ex2.printStackTrace();
    }
    finally{
      try {
       if(conn!=null){
            conn.close();
          }
      }
      catch (SQLException ex1) {
      }
      System.out.println("完成");
    }
}
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值