我只知道一点，跟你粗略的讲一下，存储过程是对数据库的操作语句，他保存在数据库的（可编程性）里面，把一些数据库命令语句，写到这里在方法中调用可以调高程序的安全性，防止SQL注入等。
⑵ java中怎么用存储过程
存储过程是数据库的,可以通过触发器来调用,存储过程类似于方法
⑶ java中怎么用存储过程啊
创建存储过程 create or replace procere p_find_emp( i_emp_id in tb_employee.emp_id%type ) is v_str_emp_name tb_employee.emp_name%type; begin select emp_name into v_str_emp_name from tb_employee where emp_id=i_emp_id; dbms_output.put_line('该雇员名字叫：'||v_str_emp_name); end p_find_emp; oracle 分页 --创建游标 create or replace package pkg_query is type cur_result_type is ref cursor;--游标的类型 end pkg_query; create or replace procere p_query_page( str_page_action in varchar2, ---分页动作，可以使上一页：previous_page,下一页:next_page, ----首页：first_page,尾页：last_page，指定页：page_number str_query_table in varchar2, -----需要查询的表，可以以单表或通过连接出来的虚拟表 str_query_condition in varchar2,-----分页的查询条件 str_result_col in varchar2,-----需要输出的字段名 str_order_condition in varchar2,-----查询的排序条件 str_order_style in varchar2,-----排序的风格，升序或降序 i_page_size in out number,-------每页显示的数据条数 i_current_page in out number, ----当前页索引 i_total_record out number,-----当前符合条件的总记录条数 i_total_page out number,-----当前符合条件的总页数 cur_query_result out pkg_query.cur_result_type------查询的结果 ) is v_str_query_sql varchar2(10000):='';-----查询的sql语句 v_i_start_record number(10):=0;----起始记录位置 v_i_end_record number(10):=0;----终止记录的位置 begin -------检验指定需要查询的表的参数是否为空 if(str_query_table is null or str_query_table = '') then raise_application_error(-20001,'需要查询的表不能为空'); end if; v_str_query_sql:='select count(*) from '||str_query_table; ------当查询的条件不为空时，将相应的查询条件拼接到sql中 if(str_query_condition is not null and str_query_condition <> '')then v_str_query_sql:=v_str_query_sql||'where '||str_query_condition; end if; -----PL/Sq 动态调用sql execute immediate v_str_query_sql into i_total_record; --------检测每页数据量，如果小于等于零，把每页数据量设为默认值10； if ( i_page_size <= 0 )then i_page_size := 10; end if; ------求当前符合条件的信息的总页数 if mod(i_total_record,i_page_size)=0 then i_total_page := (i_total_record/i_page_size); else i_total_page := trunc(i_total_record/i_page_size)+1; end if; ------根据当前的分页动作转换当前页索引 case str_page_action when 'first_page' then i_current_page := 1; when 'last_page' then i_current_page := i_total_page; when 'previous_page' then i_current_page := i_current_page-1; when 'next_page' then i_current_page := i_current_page+1; when 'page_number' then i_current_page := i_current_page; else i_current_page := 1; end case; ------求起始记录的索引位置和终止记录的索引位置 v_i_start_record := (i_current_page-1)*i_page_size+1; v_i_end_record := i_current_page*i_page_size; -----根据以上结果拼接sql语句。 v_str_query_sql:='select '; if (str_result_col is null or str_result_col='') then raise_application_error(-20002,'需要输出的字段不能为空'); end if; v_str_query_sql:=v_str_query_sql||str_result_col||' from '||str_query_table||' where 1=1 '; ------当查询条件不为空时，把相应的查询条件拼接到sql语句中 if (str_query_condition is not null and str_query_condition <> '') then v_str_query_sql:=v_str_query_sql||str_query_condition; end if; ----当查询的条件不等于空，将查询条件拼接到sql中 if (str_order_condition is not null and str_order_condition <> '') then v_str_query_sql:=v_str_query_sql||' order by '||str_order_condition; if str_order_style is not null and str_order_style <> '' then v_str_query_sql:=v_str_query_sql||' '||str_order_style; end if; end if; v_str_query_sql:='select * from ( select A.*,rownum rn from ( '||v_str_query_sql ||' ) A where rownum <='||v_i_end_record||' ) B where rn >= '||v_i_start_record; dbms_output.put_line(v_str_query_sql); open cur_query_result for v_str_query_sql; end p_query_page; ok 现在看下怎么样调用上面的存储过程 package com.softeem.dbc; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Map; import oracle.jdbc.driver.OracleTypes; public class DBConnection { private final static String DRIVER_CLASS = "oracle.jdbc.driver.OracleDriver"; private final static String URL = "jdbc:oracle:thin:@127.0.0.1:1521:orcl"; private final static String USER_NAME = "tangzheng"; private final static String PASSWORD = "123456"; public static Connection getconnection() { Connection conn = null; try { Class.forName(DRIVER_CLASS); } catch (ClassNotFoundException e) { System.out.println("驱动加载失败"); e.printStackTrace(); } try { conn = DriverManager.getConnection(URL, USER_NAME, PASSWORD); } catch (SQLException e) { System.out.println("获取连接失败"); e.printStackTrace(); } return conn; } public PageDTO findOnePage(String pageAction, int pagesize, int currentPage) throws SQLException { String table = "tb_employee emp"; String queryCondition = "emp.emp_id<15"; String resultcol = "*"; String orderCondition = "emp.emp_id"; String orderstyle = "asc"; Connection conn = getconnection(); PageDTO pageinfo = null; try { CallableStatement cs = conn .prepareCall("{call p_query_page(?,?,?,?,?,?,?,?,?,?,?)}"); cs.setString(1, pageAction); cs.setString(2, table); cs.setString(3, queryCondition); cs.setString(4, resultcol); cs.setString(5, orderCondition); cs.setString(6, orderstyle); cs.setInt(7, pagesize); cs.setInt(8, currentPage); cs.registerOutParameter(7, OracleTypes.INTEGER); cs.registerOutParameter(8, OracleTypes.INTEGER); cs.registerOutParameter(9, OracleTypes.INTEGER); cs.registerOutParameter(10, OracleTypes.INTEGER); cs.registerOutParameter(11, OracleTypes.CURSOR); cs.execute(); pageinfo = new PageDTO(); pageinfo.setCurrentPage(cs.getInt(7)); pageinfo.setCurrentPage(cs.getInt(8)); pageinfo.setTotalRecord(cs.getInt(9)); pageinfo.setTotalPage(cs.getInt(10)); ResultSet rs = (ResultSet) cs.getObject(11); List employees = new ArrayList(); EmployeeDTO employee = null; while (rs.next()) { employee = new EmployeeDTO(); employee.setEmpId(rs.getInt("emp_id")); employee.setEmpName(rs.getString("emp_name")); employee.setSex(rs.getString("sex")); employee.setSal(rs.getDouble("sal")); employees.add(employee); } pageinfo.setResult(employees); } finally { if (conn != null && !conn.isClosed()) { conn.close(); } } return pageinfo; } public static void main(String[] args) { String pageAction = "nextPage"; int pagesize = 5; int currentpage = 2; DBConnection db = new DBConnection(); try { PageDTO pageinfo = db .findOnePage(pageAction, pagesize, currentpage); List<EmployeeDTO> list = pageinfo.getResult(); System.out.println("总页数：" + pageinfo.getCurrentPage()); System.out.println("总记录数：" + pageinfo.getTotalRecord()); for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i).toString()); } } catch (SQLException e) { e.printStackTrace(); } } }
⑷ java里面怎么调用存储过程
最近做一个自动发邮件的schele，由于取数据的sql太长，直接分割很麻烦，就想到调用PL/SQL，网上查了资料做了练习，在此做下小结。
1、只有输入参数而没有返回结果的存储过程。
sql：
1 create or replace procere prc_1(deptno in number,dname in varchar2,loc in varchar2)
2 is
3 begin
4 insert into dept values(deptno,dname,loc);
5 end prc_1;
java：
1 static void test1(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 try {
5 conn=JDBCUtils.getConnection();
6 conn.setAutoCommit(false);
7 csmt=conn.prepareCall("call prc_1(?,?,?)");
8 csmt.setInt(1,80);
9 csmt.setString(2,"ioc");
10 csmt.setString(3,"fhp");
11 csmt.execute();
12 conn.commit();
13 System.out.println("success insert data");
14 } catch (SQLException e) {
15 e.printStackTrace();
16 }
17 }
2、有输入参数且有一个返回值的存储过程。
sql：
1 create or replace procere prc_2(p_deptno in number,p_loc out varchar2) is
2 begin
3 select loc into p_loc from dept where deptno=p_deptno;
4 end prc_2;
java：
1 static void test2(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 try {
5 conn=JDBCUtils.getConnection();
6 conn.setAutoCommit(false);
7 csmt=conn.prepareCall("call prc_2(?,?)");
8 csmt.setInt(1,70);
9 csmt.registerOutParameter(2,Types.VARCHAR);
10 csmt.execute();
11 conn.commit();
12 System.out.println("MIS位置："+csmt.getString(2));
13 } catch (SQLException e) {
14 e.printStackTrace();
15 }
16 }
3、返回多行记录（游标）的存储过程。
sql：
首先要建立一个返回游标，以便接收返回结果。
1 create or replace package testpackage is
2 type test_cursor is ref cursor;
3 end testpackage;
4
5 create or replace procere prc_3(p_cursor out testpackage.test_cursor)is
6 begin
7 open p_cursor for
8 select * from dept order by deptno;
9 end prc_3;
java：
1 static void test3(){
2 Connection conn=null;
3 CallableStatement csmt=null;
4 ResultSet rs=null;
5 try {
6 conn=JDBCUtils.getConnection();
7 conn.setAutoCommit(false);
8 csmt=conn.prepareCall("call prc_3(?)");
9 csmt.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR);
10 csmt.execute();
11 rs=(ResultSet) csmt.getObject(1);
12 while(rs.next()){
13 System.out.println(rs.getString("deptno")+'\t'+rs.getString("dname")+'\t'+rs.getString("loc"));
14 }
15 } catch (SQLException e) {
16 // TODO Auto-generated catch block
17 e.printStackTrace();
18 }finally{
19 JDBCUtils.free(rs, csmt, conn);
20 }
21 }
⑸ 执行存储过程有多少种方法java
Java执行存储过程的方法：
简单的老的JDBC通过CallableStatement类支持存储过程的调用。该类实际上是PreparedStatement的一个子类。假设有一个poets数据库。数据库中有一个设置诗人逝世年龄的存储过程。下面是对老酒鬼Dylan Thomas（old soak Dylan Thomas，不指定是否有关典故、文化，请批评指正。译注）进行调用的详细代码：
try{
intage=39;
StringpoetName="dylanthomas";
CallableStatementproc=connection.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,poetName);
proc.setInt(2,age);
cs.execute();
}catch(SQLExceptione){//....}传给prepareCall方法的字串是存储过程调用的书写规范。它指定了存储过程的名称，？代表了需要指定的参数。
和JDBC集成是存储过程的一个很大的便利：为了从应用中调用存储过程，不需要存根（stub）类或者配置文件，除了你的DBMS的JDBC驱动程序外什么也不需要。
当这段代码执行时，数据库的存储过程就被调用。我们没有去获取结果，因为该存储过程并不返回结果。执行成功或失败将通过例外得知。失败可能意味着调用存储过程时的失败（比如提供的一个参数的类型不正确），或者一个应用程序的失败（比如抛出一个例外指示在poets数据库中并不存在“Dylan Thomas”）
结合SQL操作与存储过程
映射Java对象到SQL表中的行相当简单，但是通常需要执行几个SQL语句；可能是一个SELECT查找ID，然后一个INSERT插入指定ID的数据。在高度规格化（符合更高的范式，译注）的数据库模式中，可能需要多个表的更新，因此需要更多的语句。Java代码会很快地膨胀，每一个语句的网络开销也迅速增加。
将这些SQL语句转移到一个存储过程中将大大简化代码，仅涉及一次网络调用。所有关联的SQL操作都可以在数据库内部发生。并且，存储过程语言，例如PL/SQL，允许使用SQL语法，这比Java代码更加自然。早期的存储过程，使用Oracle的PL/SQL语言编写：
createprocereset_death_age(poetVARCHAR2,poet_ageNUMBER)
poet_idNUMBER;
beginSELECTidINTOpoet_idFROMpoetsWHEREname=poet;
INSERTINTOdeaths(mort_id,age)VALUES(poet_id,poet_age);
endset_death_age;
set_death_age几乎可以肯定是一个很烂的实现。应该在poets表中添加一列来存储逝世年龄。Java代码中并不关心数据库模式是怎么实现的，因为它仅调用存储过程。以后可以改变数据库模式以提高性能，但是不必修改代码。
下面是调用上面存储过程的Java代码：
publicstaticvoidsetDeathAge(PoetdyingBard,intage)throwsSQLException{
Connectioncon=null;
CallableStatementproc=null;
try{
con=connectionPool.getConnection();
proc=con.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,dyingBard.getName());
proc.setInt(2,age);
proc.execute();
}
finally{
try{proc.close();}
catch(SQLExceptione){}
con.close();
}
}为了确保可维护性，建议使用像这儿这样的static方法。这也使得调用存储过程的代码集中在一个简单的模版代码中。如果用到许多存储过程，就会发现仅需要拷贝、粘贴就可以创建新的方法。因为代码的模版化，甚至也可以通过脚本自动生产调用存储过程的代码。
Functions
存储过程可以有返回值，所以CallableStatement类有类似getResultSet这样的方法来获取返回值。当存储过程返回一个值时，必须使用registerOutParameter方法告诉JDBC驱动器该值的SQL类型是什么。也必须调整存储过程调用来指示该过程返回一个值。
下面接着上面的例子。这次查询Dylan Thomas逝世时的年龄。这次的存储过程使用PostgreSQL的pl/pgsql：
createfunctionsnuffed_it_when(VARCHAR)returnsinteger'declare
poet_idNUMBER;
poet_ageNUMBER;
begin
--.
SELECTidINTOpoet_idFROMpoetsWHEREname=$1;
--getandreturntheage.
SELECTageINTOpoet_ageFROMdeathsWHEREmort_id=poet_id;
returnage;
end;'language'pl/pgsql';
另外，注意pl/pgsql参数名通过Unix和DOS脚本的$n语法引用。同时，也注意嵌入的注释，这是和Java代码相比的另一个优越性。在Java中写这样的注释当然是可以的，但是看起来很凌乱，并且和SQL语句脱节，必须嵌入到Java String中。
下面是调用这个存储过程的Java代码：
connection.setAutoCommit(false);
CallableStatementproc=connection.prepareCall("{?=callsnuffed_it_when(?)}");
proc.registerOutParameter(1,Types.INTEGER);
proc.setString(2,poetName);
cs.execute();
intage=proc.getInt(2);
如果指定了错误的返回值类型会怎样？那么，当调用存储过程时将抛出一个RuntimeException，正如你在ResultSet操作中使用了一个错误的类型所碰到的一样。
复杂的返回值
如果这是存储过程的全部功能，那么存储过程就不是其它远程执行机制的替换方案了。存储过程的功能比这强大得多。
当执行一个SQL查询时，DBMS创建一个叫做cursor（游标）的数据库对象，用于在返回结果中迭代每一行。ResultSet是当前时间点的游标的一个表示。这就是为什么没有缓存或者特定数据库的支持，只能在ResultSet中向前移动。
某些DBMS允许从存储过程中返回游标的一个引用。JDBC并不支持这个功能，但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针（pointer）。
设想列出所有没有活到退休年龄的诗人，下面是完成这个功能的存储过程，返回一个打开的游标，同样也使用PostgreSQL的pl/pgsql语言：
createprocerelist_early_deaths()returnrefcursoras'declare
toesuprefcursor;
begin
opentoesupforSELECTpoets.name,deaths.ageFROMpoets,deaths--allentriesindeathsareforpoets.--butthetablemightbecomegeneric.
WHEREpoets.id=deaths.mort_idANDdeaths.age<60;
returntoesup;
end;'language'plpgsql';
下面是调用该存储过程的Java方法，将结果输出到PrintWriter：
PrintWriter:
staticvoidsendEarlyDeaths(PrintWriterout){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
//...con.
setAutoCommit(false);//Setupthecall.
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
out.println(name+"was"+age+"yearsold.");
}
rs.close();
}
catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();con.close();
}
}因为JDBC并不直接支持从存储过程中返回游标，使用Types.OTHER来指示存储过程的返回类型，然后调用getObject()方法并对返回值进行强制类型转换。
这个调用存储过程的Java方法是mapping的一个好例子。Mapping是对一个集上的操作进行抽象的方法。不是在这个过程上返回一个集，可以把操作传送进去执行。本例中，操作就是把ResultSet打印到一个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过程的另外一个方法实现：
publicclassProcessPoetDeaths{
publicabstractvoidsendDeath(Stringname,intage);
}
staticvoidmapEarlyDeaths(ProcessPoetDeathsmapper){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
con.setAutoCommit(false);
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
mapper.sendDeath(name,age);
}
rs.close();
}catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();
con.close();
}
}这允许在ResultSet数据上执行任意的处理，而不需要改变或者复制获取ResultSet的方法：
staticvoidsendEarlyDeaths(finalPrintWriterout){
ProcessPoetDeathsmyMapper=newProcessPoetDeaths(){
publicvoidsendDeath(Stringname,intage){
out.println(name+"was"+age+"yearsold.");
}
};
mapEarlyDeaths(myMapper);
}这个方法使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath方法的一个实现，和我们上面的例子一样的方式把结果写入到输出流。当然，这个技巧并不是存储过程特有的，但是和存储过程中返回的ResultSet结合使用，是一个非常强大的工具。
⑹ Java中是如何调用存储过程的
//存储过程create or replace Procere countBySal(
p_sal emp.sal%type,
p_count OUT number
)as
begin
select count(*) into p_count from emp where sal >= p_sql;
end countBySal; //调用步奏import java.sql.CallableStatement; //带哦用存储过程所必须的语句借口
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Types;public class EmpUtil {
public static int countBySal(double sal) throws Exception{
Class.forName("oracle.jdbc.driver.OracleDriver");
String url="jdbc:oracle:thin:@localhost:1521:test";
Connection cn=DriverManager.getConnection(url, "scott", "tiger");
String sql="{call countBySal(?,?)}";//调用存储过程的语句，call后面的就是存储过程名和需要传入的参数
CallableStatement cst=cn.prepareCall(sql);
cst.setDouble(1, sal);//设置in参数的值
cst.registerOutParameter(2, Types.INTEGER);//注册out参数的类型
cst.execute();
int result = cst.getInt(2);
cst.close();
cn.close();
return result;
}
public static void main(String[] args) {
int count;
try {
count = EmpUtil.countBySal(3000);
System.out.println("工资在3000元以上的人数为："+count);
} catch (Exception e) {
e.printStackTrace();
}
}
}
⑺ 如何在java中创建存储过程
视图定义一次就可以了，
为什么还要在存储过程中来创建呢？
如果真要这样做，
使用动态sql。
在存储过程中加入如下：
execute
immediate
'create
view
v_viewname
as
select
*
from
tabname'
;
⑻ java编程中怎样调用存储过程
JDBC调用存储过程: CallableStatement
在Java里面调用存储过程，写法那是相当的固定：
Class.forName(....
Connection conn = DriverManager.getConnection(....
/**
*p是要调用的存储过程的名字，存储过程的4个参数，用4个？号占位符代替
*其余地方写法固定
*/
CallableStatement cstmt = conn.prepareCall("{call p(?,?,?,?)}");
/**
*告诉JDBC，这些个参数，哪些是输出参数，输出参数的类型用java.sql.Types来指定
*下面的意思是，第3个？和第4个？是输出参数，类型是INTEGER的
*Types后面具体写什么类型，得看你的存储过程参数怎么定义的
*/
cstmt.registerOutParameter(3, Types.INTEGER);
cstmt.registerOutParameter(4, Types.INTEGER);
/**
*在我这里第1个？和第2个？是输入参数，第3个是输出参数，第4个既输入又输出
*下面是设置他们的值,第一个设为3，第二个设为4，第4个设置为5
*没设第3个，因为它是输出参数
*/
cstmt.setInt(1, 3);
cstmt.setInt(2, 4);
cstmt.setInt(4, 5);
//执行
cstmt.execute();
//把第3个参数的值当成int类型拿出来
int three = cstmt.getInt(3);
System.out.println(three);
//把第4个参数的值当成int类型拿出来
int four = cstmt.getInt(4);
System.out.println(four);
//用完别忘给人家关了，后开的先关
cstmt.close();
conn.close();
JDBC调用存储过程，掌握这一个程序足够了.
以下是上面程序使用的存储过程的代码，我用的是Oracle数据库，不过不论是什么数据库，对于你的程序，JDBC这一端写法都是一样的.
create or replace procere p
(v_a in number,v_b number,v_ret out number,v_temp in out number)
is
begin
if(v_a > v_b) then
v_ret := v_a;
else
v_ret := v_b;
end if;
v_temp := v_temp + 1;
end;
⑼ Java存储过程
java.sql.SQLException: ORA-00942: 表或视图不存在
这句就说明了一切，你的存储过程中操作的表或者是视图，在数据库中根本就没有！！！！！！没有！！！！！！
⑽ java中如何调用数据库的存储过程
Java调用存储过程的方法是通过调用Connection的实例方法prepareCall，prepareCall方法返回CallableStatement对象用于填充存储过程的参数。prepareCall方法形参是调用存储过程的sql语句，此参数的语法格式如下：
{callstoredProcereName(parameter-list)}其中，storedProcereName是存储过程名称，parameter-list是存储过程参数列表。
例如，存储过程名为usp_test，有两个输入参数a,b。则调用代码看起来如下所示：
=connection.prepareCall("{callusp_test(?,?)}");
callableStatement.setObject("a","value-1");
callableStatement.setObject("b","value-2");
callableStatement.execute();