java中调用存储过程或函数

1.调用函数

     CallableStatement cs=con.prepareCall("{?=call get_pname(?,?,?)}");

     第一个？表示返回的值，后面的？可以是输入参数，也可以是输出参数。

     第一个？是返回参数，所以必须有语句：

     connection.registerOutParameter(1, Types.VARCHAR);（Types.varchar是类型）

     后面的？如果是输出参数，应该也加上registerOutParameter语句： 

     connection.registerOutParameter(2, Types.VARCHAR);（2是第2个占位符，Types.varchar是类型）
     最后打印输出的结果：

     System.out.println(cs.getString(1)); （1是对应输出参数，第一个输出参数）

 

  2.调用存储过程

     CallableStatement cs=con.prepareCall("{call stu_pro(?,?,?)}");（与函数的区别是：没有？=）
     java程序中要打印调用过程获得的值，需调用有输出参数的存储过程，用法和调用函数一样。

 

  3.简单例子

Java代码  

1. package com.dgy.app;  
2.   
3. import java.sql.CallableStatement;  
4. import java.sql.Connection;  
5. import java.sql.DriverManager;  
6. import java.sql.SQLException;  
7. import java.sql.Types;  
8.   
9.   
10. public class OraclePro {  
11.     /** 
12.      * 连接数据库 
13.      */  
14.     public static Connection getConnection(){  
15.          Connection con = null;  
16.          try {  
17.             Class.forName("oracle.jdbc.driver.OracleDriver");  
18.             String url = "jdbc:oracle:thin:@PC-200911181406:1521:dgy";  
19.             String user = "dwj";  
20.             String pwd = "dwj";           
21.             con = DriverManager.getConnection(url,user,pwd);  
22.         } catch (ClassNotFoundException e) {  
23.             e.printStackTrace();  
24.         } catch (SQLException e) {  
25.             e.printStackTrace();  
26.         }  
27.         return con;  
28.     }  
29.     public static void main(String[] args) throws SQLException {  
30.          //System.out.println(OraclePro.getConnection());         
31.         Connection con=OraclePro.getConnection();  
32.         CallableStatement cs=con.prepareCall("{?=call get_pname}");//没有参数的函数  
33.         cs.registerOutParameter(1, Types.VARCHAR);//第一个占位为输出，类型是varchar  
34.         cs.execute();                  //不能忘记execute()  
35.         System.out.println(cs.getString(1)); //打印输出结果，对应registerOutParameter  
36.     }  
37. }  
38.    

package com.dgy.app;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Types;


public class OraclePro {
	/**
	 * 连接数据库
	 */
	public static Connection getConnection(){
		 Connection con = null;
		 try {
			Class.forName("oracle.jdbc.driver.OracleDriver");
			String url = "jdbc:oracle:thin:@PC-200911181406:1521:dgy";
			String user = "dwj";
			String pwd = "dwj";			
			con = DriverManager.getConnection(url,user,pwd);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return con;
	}
	public static void main(String[] args) throws SQLException {
		 //System.out.println(OraclePro.getConnection());		
		Connection con=OraclePro.getConnection();
		CallableStatement cs=con.prepareCall("{?=call get_pname}");//没有参数的函数
		cs.registerOutParameter(1, Types.VARCHAR);//第一个占位为输出，类型是varchar
		cs.execute();                  //不能忘记execute()
		System.out.println(cs.getString(1)); //打印输出结果，对应registerOutParameter
	}
}
 

Java代码  

1. //有1个输入参数的函数          
2. CallableStatement cs=con.prepareCall("{?=call get_pname1(?)}");  
3. cs.registerOutParameter(1, Types.VARCHAR);  
4. cs.setLong(2,25);     //输入参数是25  
5. cs.execute();  
6.   
7. //有1个输出参数的函数      
8. CallableStatement cs=con.prepareCall("{?=call get_pname2(?)}");  
9. cs.registerOutParameter(1, Types.VARCHAR);  
10. cs.registerOutParameter(2, Types.VARCHAR);  
11. cs.execute();  
12. System.out.println(cs.getString(1));  
13. System.out.println(cs.getString(2));  
14. //上面两个结果一样，因为两个意思是一样的  
15.   
16. //1个输入参数，1个输出参数       
17. CallableStatement cs=con.prepareCall("{?=call get_pname3(?,?)}");  
18. //第1个是返回值，第2个是输入参数，第3个是输出参数       
19. cs.registerOutParameter(1, Types.VARCHAR);  
20. cs.setLong(2, 25);    
21. cs.registerOutParameter(3, Types.VARCHAR);        
22. cs.execute();  
23. System.out.println(cs.getString(1));  
24. System.out.println(cs.getString(3));  

//有1个输入参数的函数		
CallableStatement cs=con.prepareCall("{?=call get_pname1(?)}");
cs.registerOutParameter(1, Types.VARCHAR);
cs.setLong(2,25);	  //输入参数是25
cs.execute();

//有1个输出参数的函数	
CallableStatement cs=con.prepareCall("{?=call get_pname2(?)}");
cs.registerOutParameter(1, Types.VARCHAR);
cs.registerOutParameter(2, Types.VARCHAR);
cs.execute();
System.out.println(cs.getString(1));
System.out.println(cs.getString(2));
//上面两个结果一样，因为两个意思是一样的

//1个输入参数，1个输出参数		
CallableStatement cs=con.prepareCall("{?=call get_pname3(?,?)}");
//第1个是返回值，第2个是输入参数，第3个是输出参数		
cs.registerOutParameter(1, Types.VARCHAR);
cs.setLong(2, 25);	
cs.registerOutParameter(3, Types.VARCHAR);		
cs.execute();
System.out.println(cs.getString(1));
System.out.println(cs.getString(3));

 

   调用存储过程与调用函数的方法一样，就只是con.prepareCall("{call  procedure(?,?)}")没有?=。