我只知道一點，跟你粗略的講一下，存儲過程是對資料庫的操作語句，他保存在資料庫的（可編程性）裡面，把一些資料庫命令語句，寫到這里在方法中調用可以調高程序的安全性，防止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();