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

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

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

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

[java] view plain copy print?

  1. package com.test.db;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  7. public class JDBCUtils {
  8. private static String driver = "oracle.jdbc.OracleDriver";
  9. private static String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
  10. private static String user = "数据库连接名";
  11. private static String password = "数据库连接密码";
  12. //注册数据库驱动
  13. static{
  14. try {
  15. Class.forName(driver);
  16. } catch (Exception e) {
  17. throw new ExceptionInInitializerError(e);
  18. }
  19. }
  20. /**
  21. * 获取数据库连接
  22. * @return
  23. */
  24. public static Connection getConnection(){
  25. try {
  26. return DriverManager.getConnection(url,user,password);
  27. } catch (SQLException e) {
  28. e.printStackTrace();
  29. }
  30. return null;
  31. }
  32. /**
  33. * 释放数据库连接资源
  34. * @param conn
  35. * @param st
  36. * @param rs
  37. */
  38. public static void release(Connection conn,Statement st,ResultSet rs){
  39. if (rs!=null) {
  40. try {
  41. rs.close();
  42. } catch (SQLException e) {
  43. e.printStackTrace();
  44. }finally{
  45. rs = null;
  46. }
  47. }
  48. if (st!=null) {
  49. try {
  50. st.close();
  51. } catch (SQLException e) {
  52. e.printStackTrace();
  53. }finally{
  54. st = null;
  55. }
  56. }
  57. if (conn!=null) {
  58. try {
  59. conn.close();
  60. } catch (SQLException e) {
  61. e.printStackTrace();
  62. }finally{
  63. conn = null;
  64. }
  65. }
  66. }
  67. }
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. import java.sql.CallableStatement;
  3. import java.sql.Connection;
  4. import org.junit.Test;
  5. import oracle.jdbc.internal.OracleTypes;
  6. import oracle.jdbc.oracore.OracleType;
  7. import com.hwb.db.JDBCUtils;
  8. /**
  9. * 调用存储过程  一个输入参数，多个 输出参数
  10. * @author Administrator
  11. *
  12. */
  13. public class ProcedureTest {
  14. /**
  15. * create or replace procedure selectUserById(uid in number,
  16. uName out VARCHAR2,
  17. uAge out number,
  18. uSex out char)
  19. */
  20. @Test
  21. public void testProcedure(){
  22. String sql = "{call selectUserById(?,?,?,?)}";
  23. Connection conn = null;
  24. CallableStatement call = null;
  25. try {
  26. //得到一个数据库连接
  27. conn = JDBCUtils.getConnection();
  28. //通过连接创建出statement
  29. call = conn.prepareCall(sql);
  30. //对于in参数，赋值
  31. call.setInt(1, 2);  // (第几个问号,要赋的值)
  32. //对out参数，声明
  33. call.registerOutParameter(2, OracleTypes.VARCHAR);  //(第几个问号，声明的类型)
  34. call.registerOutParameter(3, OracleTypes.NUMBER);
  35. call.registerOutParameter(4, OracleTypes.CHAR);
  36. //执行调用
  37. call.execute();
  38. //取出结果
  39. String userName = call.getString(2);
  40. int userAge = call.getInt(3);
  41. String userSex = call.getString(4);
  42. System.out.println("用户姓名："+userName+"\n\t年龄:"+userAge+"\n\t性别："+userSex);
  43. } catch (Exception e) {
  44. e.printStackTrace();
  45. }finally{
  46. //关闭连接，释放资源
  47. JDBCUtils.release(conn, call, null);
  48. }
  49. }
  50. }
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+"\n\t年龄:"+userAge+"\n\t性别："+userSex);

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
                    //关闭连接，释放资源
                   JDBCUtils.release(conn, call, null);
		}

	}
}

3.调用存储方法：

[java] view plain copy print?

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

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.release(conn, call, rs);
		}
	}
}

原文地址：https://www.cnblogs.com/firstdream/p/8621422.html

时间： 2024-09-29 09:50:56

Java代码调用存储过程和存储方法的相关文章

在Java语言中调用存储过程、存储函数、包头、包体

需要拷贝连接Oracle的jar包,路径如下图所示: 连接Oracle数据库的代码: package demo.utils; 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 Stri

java代码调用数据库存储过程

由于前边有写java代码调用数据库,感觉应该把java调用存储过程也写一下,所以笔者补充该篇! package testSpring; import java.sql.CallableStatement;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet; import oracle.jdbc.OracleCalla

Java代码调用Shell脚本并传入参数实现DB2数据库表导出到文件

本文通过Java代码调用Shell脚本并传入参数实现DB2数据库表导出到文件,代码如下: import java.io.File; import java.io.IOException; import java.io.InputStreamReader; import java.io.LineNumberReader; import java.util.HashMap; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import

java程序调用存储过程

java程序调用存储过程     PL/SQL子程序,很多情况下是给应用程序来调用的,所有我们要掌握使用其他编程语言来调用我们写好的存储过程.下面我们介绍下使用java调用Oracle的存储过程.   准备代码: package com.mscncn.plsql.util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class DBUtil { s

ubuntu下用java代码调用命令将java格式文件转换为html格式文件

首先我们应该在电脑上装上GNU Source-highlight 3.1.7,给个链接参考: http://www.gnu.org/software/src-highlite/#mozTocId120994 下面代码实现了 将java类型的代码转换为html文件类型的代码,如果java代码的文件名为 helloword.java,则转换为html格式的文件名为helloword.java.html,将java代码在浏览器上显示出来.其次我还将html文件中的内容提取出来,便于在html文件里编写

Java 反射调用私有域和方法（setAccessible）

Java 反射调用私有域和方法(setAccessible) @author ixenos AccessibleObject类 Method.Field和Constructor类共同继承了AccessibleObject类,该基类有两个setAccessible方法能在运行时压制Java语言访问控制检查(Java language access control checks),从而能任意调用被私有化保护的方法.域和构造方法 public class AccessibleObjectextends

我也谈谈 代码调用存储过程超时，SQL Server Management Studio里运行很快的问题

最近遇到了一个问题就是 一个执行速度很快的存储过程,在代码中调用的时候却超时了. 后来看到了两篇文章: 其中一篇是这样介绍的 今天同事用代码调用存储过程时超时,在SQL Server Management Studio里运行却很快就有结果,这和我上次遇到的情况一下,现在将解决方案记录如下,谨为大家作一提醒. 解决方案就是: 把存储过程中多余的空格删掉. 瞠目吧结舌吧,不过这就是现实,现实是残酷的,现实是无情的,哈哈 不一定是哪个空格就引起了超时,试着看吧  上面的解决方案是将存储过程里的空格去掉

使用java代码调用exe程序 （包括参数传递）

使用Java代码调用exe 1使用场景 我现在使用eclipse+tomcat的架构建立了web server, 在这个web project中我需要建立一个定时任务,在定时任务中执行本地的一个C#工程生成的exe. 2Java代码 public class MyTask extends TimerTask { public void run() { System.out.println("call at " + (new Date())); // TODO æ­¤å¤?æ·»å? å

存储过程之七—java代码调用

一.简介 jdbc调用存储过程与调用一般的sql语句有些差别.jdbc调用一般的sql语句的时候,返回的是结果集,或是sql语句后是否执行成功的标记量.而存储过程返回的可以是结果集,输出参数.返回状态和受影响行数.而mysql存储过程不支持return,所以只有剩下的三种返回方式. 调用的过程一般如下: 1.创建连接 Connection conn = DriverManager.getConnection(url, user, password); 2.创建CallableStatement