• Java代码调用存储过程和存储方法

    准备一个oracle 的JDBC jar 包：ojdbc14_11g.jar

    首先找到你的 oracle 安装位置，例如：

    1.创建一个JDBC数据库连接工具类：

    [java] view plain copy print?
    1. package com.test.db;  
    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 JDBCUtils {  
    10.   
    11.     private static String driver = "oracle.jdbc.OracleDriver";  
    12.     private static String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";  
    13.     private static String user = "数据库连接名";  
    14.     private static String password = "数据库连接密码";  
    15.       
    16.     //注册数据库驱动  
    17.     static{  
    18.         try {  
    19.             Class.forName(driver);  
    20.         } catch (Exception e) {  
    21.             throw new ExceptionInInitializerError(e);  
    22.         }  
    23.     }  
    24.       
    25.     /** 
    26.      * 获取数据库连接 
    27.      * @return 
    28.      */  
    29.     public static Connection getConnection(){  
    30.         try {  
    31.             return DriverManager.getConnection(url,user,password);  
    32.         } catch (SQLException e) {  
    33.             e.printStackTrace();  
    34.         }  
    35.         return null;  
    36.     }  
    37.       
    38.     /** 
    39.      * 释放数据库连接资源 
    40.      * @param conn 
    41.      * @param st 
    42.      * @param rs 
    43.      */  
    44.     public static void release(Connection conn,Statement st,ResultSet rs){  
    45.         if (rs!=null) {  
    46.             try {  
    47.                 rs.close();  
    48.             } catch (SQLException e) {  
    49.                 e.printStackTrace();  
    50.             }finally{  
    51.                 rs = null;  
    52.             }  
    53.         }  
    54.           
    55.         if (st!=null) {  
    56.             try {  
    57.                 st.close();  
    58.             } catch (SQLException e) {  
    59.                 e.printStackTrace();  
    60.             }finally{  
    61.                 st = null;  
    62.             }  
    63.         }  
    64.           
    65.         if (conn!=null) {  
    66.             try {  
    67.                 conn.close();  
    68.             } catch (SQLException e) {  
    69.                 e.printStackTrace();  
    70.             }finally{  
    71.                 conn = null;  
    72.             }  
    73.         }  
    74.     }  
    75. }  
    package com.test.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCUtils {

	private static String driver = "oracle.jdbc.OracleDriver";
	private static String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
	private static String user = "数据库连接名";
	private static String password = "数据库连接密码";
	
	//注册数据库驱动
	static{
		try {
			Class.forName(driver);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}
	
	/**
	 * 获取数据库连接
	 * @return
	 */
	public static Connection getConnection(){
		try {
			return DriverManager.getConnection(url,user,password);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 释放数据库连接资源
	 * @param conn
	 * @param st
	 * @param rs
	 */
	public static void release(Connection conn,Statement st,ResultSet rs){
		if (rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally{
				rs = null;
			}
		}
		
		if (st!=null) {
			try {
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally{
				st = null;
			}
		}
		
		if (conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally{
				conn = null;
			}
		}
	}
}

    2.调用 存储过程：

    [java] view plain copy print?
    1. package com.test.demo;  
    2.   
    3. import java.sql.CallableStatement;  
    4. import java.sql.Connection;  
    5.   
    6. import org.junit.Test;  
    7.   
    8. import oracle.jdbc.internal.OracleTypes;  
    9. import oracle.jdbc.oracore.OracleType;  
    10.   
    11. import com.hwb.db.JDBCUtils;  
    12.   
    13. /** 
    14.  * 调用存储过程  一个输入参数，多个 输出参数 
    15.  * @author Administrator 
    16.  * 
    17.  */  
    18. public class ProcedureTest {  
    19.   
    20.     /** 
    21.      * create or replace procedure selectUserById(uid in number, 
    22.                                            uName out VARCHAR2, 
    23.                                            uAge out number, 
    24.                                            uSex out char) 
    25.      */  
    26.       
    27.     @Test  
    28.     public void testProcedure(){  
    29.           
    30.         String sql = "{call selectUserById(?,?,?,?)}";  
    31.           
    32.         Connection conn = null;  
    33.         CallableStatement call = null;  
    34.         try {  
    35.             //得到一个数据库连接  
    36.             conn = JDBCUtils.getConnection();  
    37.             //通过连接创建出statement  
    38.             call = conn.prepareCall(sql);  
    39.             //对于in参数，赋值  
    40.             call.setInt(1, 2);  // (第几个问号,要赋的值)  
    41.             //对out参数，声明  
    42.             call.registerOutParameter(2, OracleTypes.VARCHAR);  //(第几个问号，声明的类型)  
    43.             call.registerOutParameter(3, OracleTypes.NUMBER);  
    44.             call.registerOutParameter(4, OracleTypes.CHAR);  
    45.               
    46.             //执行调用  
    47.             call.execute();  
    48.               
    49.             //取出结果  
    50.             String userName = call.getString(2);  
    51.             int userAge = call.getInt(3);  
    52.             String userSex = call.getString(4);  
    53.               
    54.             System.out.println("用户姓名："+userName+" 年龄:"+userAge+" 性别："+userSex);  
    55.               
    56.         } catch (Exception e) {  
    57.             e.printStackTrace();  
    58.         }finally{  
    59.                     //关闭连接，释放资源  
    60.                    JDBCUtils.release(conn, call, null);  
    61.         }  
    62.           
    63.     }  
    64. }  
    package com.test.demo;

import java.sql.CallableStatement;
import java.sql.Connection;

import org.junit.Test;

import oracle.jdbc.internal.OracleTypes;
import oracle.jdbc.oracore.OracleType;

import com.hwb.db.JDBCUtils;

/**
 * 调用存储过程  一个输入参数，多个 输出参数
 * @author Administrator
 *
 */
public class ProcedureTest {

	/**
	 * create or replace procedure selectUserById(uid in number,
                                           uName out VARCHAR2,
                                           uAge out number,
                                           uSex out char)
	 */
	
	@Test
	public void testProcedure(){
		
		String sql = "{call selectUserById(?,?,?,?)}";
		
		Connection conn = null;
		CallableStatement call = null;
		try {
			//得到一个数据库连接
			conn = JDBCUtils.getConnection();
			//通过连接创建出statement
			call = conn.prepareCall(sql);
			//对于in参数，赋值
			call.setInt(1, 2);  // (第几个问号,要赋的值)
			//对out参数，声明
			call.registerOutParameter(2, OracleTypes.VARCHAR);  //(第几个问号，声明的类型)
			call.registerOutParameter(3, OracleTypes.NUMBER);
			call.registerOutParameter(4, OracleTypes.CHAR);
			
			//执行调用
			call.execute();
			
			//取出结果
			String userName = call.getString(2);
			int userAge = call.getInt(3);
			String userSex = call.getString(4);
			
			System.out.println("用户姓名："+userName+"
	年龄:"+userAge+"
	性别："+userSex);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
                    //关闭连接，释放资源
                   JDBCUtils.release(conn, call, null);
		}
		
	}
}

    3.调用存储方法：

    [java] view plain copy print?
    1. package com.test.demo;  
    2.   
    3. import java.sql.CallableStatement;  
    4. import java.sql.Connection;  
    5.   
    6. import oracle.jdbc.internal.OracleTypes;  
    7.   
    8. import org.junit.Test;  
    9.   
    10. import com.hwb.db.JDBCUtils;  
    11.   
    12. /** 
    13.  * 调用存储函数，一个输入参数，一个输出参数 
    14.  * @author Administrator 
    15.  * 
    16.  */  
    17. public class FunctionTest {  
    18.   
    19.     /** 
    20.      * create or replace function selectAge(eno in number) 
    21.         return number  
    22.      */  
    23.     @Test  
    24.     public void testFunction(){  
    25.         //{？= call <procedure-name>[<arg1>,<arg2>...]}  
    26.         String sql = "{call selectAge(?)}";  
    27.         Connection conn = null;  
    28.         CallableStatement call = null;  
    29.         try {  
    30.             //得到数据库连接  
    31.             conn = JDBCUtils.getConnection();  
    32.               
    33.             //通过数据库连接创建statement  
    34.             call = conn.prepareCall(sql);  
    35.               
    36.             //对于输出参数，声明  
    37.             call.registerOutParameter(1, OracleTypes.NUMBER);  
    38.               
    39.             //对于输入参数，赋值  
    40.             call.setInt(2, 3);  
    41.               
    42.             //执行调用  
    43.             call.execute();  
    44.               
    45.                         //获取返回的结果  
    46.             int age = call.getInt(1);  
    47.               
    48.             System.out.println("该用户年龄："+age);  
    49.         } catch (Exception e) {  
    50.             e.printStackTrace();  
    51.         }finally{  
    52.             JDBCUtils.release(conn, call, null);  
    53.         }  
    54.     }  
    55. }  
    package com.test.demo;

import java.sql.CallableStatement;
import java.sql.Connection;

import oracle.jdbc.internal.OracleTypes;

import org.junit.Test;

import com.hwb.db.JDBCUtils;

/**
 * 调用存储函数，一个输入参数，一个输出参数
 * @author Administrator
 *
 */
public class FunctionTest {

	/**
	 * create or replace function selectAge(eno in number)
		return number 
	 */
	@Test
	public void testFunction(){
		//{？= call <procedure-name>[<arg1>,<arg2>...]}
		String sql = "{call selectAge(?)}";
		Connection conn = null;
		CallableStatement call = null;
		try {
			//得到数据库连接
			conn = JDBCUtils.getConnection();
			
			//通过数据库连接创建statement
			call = conn.prepareCall(sql);
			
			//对于输出参数，声明
			call.registerOutParameter(1, OracleTypes.NUMBER);
			
			//对于输入参数，赋值
			call.setInt(2, 3);
			
			//执行调用
			call.execute();
			
                        //获取返回的结果
			int age = call.getInt(1);
			
			System.out.println("该用户年龄："+age);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.release(conn, call, null);
		}
	}
}

    4.调用存储过程，一个输入参数，返回一个查询结果集合

    [java] view plain copy print?
    1. package com.hwb.demo;  
    2.   
    3. import java.sql.CallableStatement;  
    4. import java.sql.Connection;  
    5. import java.sql.ResultSet;  
    6.   
    7.   
    8.   
    9.   
    10. import org.junit.Test;  
    11.   
    12. import oracle.jdbc.internal.OracleCallableStatement;  
    13. import oracle.jdbc.internal.OracleTypes;  
    14.   
    15. import com.hwb.db.JDBCUtils;  
    16. /** 
    17.  * 存储过程  一个输入参数，返回一个查询结果集合 
    18.  * @author Administrator 
    19.  * 
    20.  */  
    21. public class CursorTest {  
    22.   
    23.     /** 
    24.      * create or replace package Mypackage as 
    25.         procedure queryUserList(uid in number,userList out usercursor); 
    26.         end mypackage; 
    27.      */  
    28.     @Test  
    29.     public void testCursor(){  
    30.         String sql = "{call Mypackage.queryUserList(?,?) }";  
    31.           
    32.         Connection conn = null;  
    33.         CallableStatement call = null;  
    34.         ResultSet rs = null;  
    35.         try {  
    36.             //得到数据库连接  
    37.             conn = JDBCUtils.getConnection();  
    38.             //通过数据库连接创建statement  
    39.             call = conn.prepareCall(sql);  
    40.               
    41.             //对于输入参数，赋值  
    42.             call.setInt(1, 1);  
    43.             //对于输出参数，声明  
    44.             call.registerOutParameter(2, OracleTypes.CURSOR);  
    45.             //执行调用  
    46.             call.execute();  
    47.             //将CallableStatement 强转成  OracleCallableStatement 用来获取光标类型Cursor，并得到结果ResultSet  
    48.             rs = ((OracleCallableStatement)call).getCursor(2);  
    49.             //遍历 ResultSet  
    50.             while (rs.next()) {  
    51.                 //根据类型和列名取值  
    52.                 int id = rs.getInt("user_id");    //括号内为 列名  
    53.                 String user_name = rs.getString("user_name");  
    54.                 int age = rs.getInt("user_age");  
    55.                 String sex = rs.getString("user_sex");  
    56.                 System.out.println("查询到的用户信息： id:"+id+" 姓名："+user_name  
    57.                         +" 年龄："+age+" 性别："+sex);  
    58.             }  
    59.               
    60.               
    61.               
    62.         } catch (Exception e) {  
    63.             e.printStackTrace();  
    64.         }finally{  
    65.             JDBCUtils.release(conn, call, rs);  
    66.         }  
    67.     }  
    68. }  
    package com.hwb.demo;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;




import org.junit.Test;

import oracle.jdbc.internal.OracleCallableStatement;
import oracle.jdbc.internal.OracleTypes;

import com.hwb.db.JDBCUtils;
/**
 * 存储过程  一个输入参数，返回一个查询结果集合
 * @author Administrator
 *
 */
public class CursorTest {

	/**
	 * create or replace package Mypackage as
		procedure queryUserList(uid in number,userList out usercursor);
		end mypackage;
	 */
	@Test
	public void testCursor(){
		String sql = "{call Mypackage.queryUserList(?,?) }";
		
		Connection conn = null;
		CallableStatement call = null;
		ResultSet rs = null;
		try {
			//得到数据库连接
			conn = JDBCUtils.getConnection();
			//通过数据库连接创建statement
			call = conn.prepareCall(sql);
			
			//对于输入参数，赋值
			call.setInt(1, 1);
			//对于输出参数，声明
			call.registerOutParameter(2, OracleTypes.CURSOR);
			//执行调用
			call.execute();
			//将CallableStatement 强转成  OracleCallableStatement 用来获取光标类型Cursor，并得到结果ResultSet
			rs = ((OracleCallableStatement)call).getCursor(2);
			//遍历 ResultSet
			while (rs.next()) {
				//根据类型和列名取值
				int id = rs.getInt("user_id");    //括号内为 列名
				String user_name = rs.getString("user_name");
				int age = rs.getInt("user_age");
				String sex = rs.getString("user_sex");
				System.out.println("查询到的用户信息：
	id:"+id+"
	姓名："+user_name
						+"
	年龄："+age+"
	性别："+sex);
			}
			
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.release(conn, call, rs);
		}
	}
}
  • 相关阅读:
    链路的有效性检测 及 基于TCP的通信为什么需要RETRY
    python join
    协程
    python socket 选项
    Spring @Resource、@Autowired、@Qualifier的区别
    maven插件
    代码中的特殊注释
    AOP 底层技术比较
    关于Android开发中的证书和密钥等问题
    tomcat部署web项目的3中方法
  • 原文地址：https://www.cnblogs.com/firstdream/p/8631072.html
Copyright © 2020-2023  润新知