java存儲過程視頻
已儲存過程儲存在資料庫中。對已儲存過程的調用是 CallableStatement對象所含的內容。這種調用是用一種換碼語法來寫的，有兩種形式：一種形式帶結果參，另一種形式不帶結果參數。結果參數是一種輸出 (OUT) 參數，是已儲存過程的返回值。兩種形式都可帶有數量可變的輸入（IN 參數）、輸出（OUT 參數）或輸入和輸出（INOUT 參數）的參數。問號將用作參數的佔位符。 在JDBC 中調用已儲存過程的語法如下所示。注意，方括弧表示其間的內容是可選項；方括弧本身並不是語法的組成部份。{call 過程名[(?, ?, ...)]} 返回結果參數的過程的語法為：{? = call 過程名[(?, ?, ...)]} 不帶參數的已儲存過程的語法類似：{call 過程名} 通常，創建 CallableStatement 對象的人應當知道所用的 DBMS 是支持已儲存過程的，並且知道這些過程都是些什麼。然而，如果需要檢查，多種DatabaseMetaData 方法都可以提供這樣的信息。例如，如果 DBMS 支持已儲存過程的調用，則supportsStoredProceres 方法將返回 true，而getProceres 方法將返回對已儲存過程的描述。CallableStatement 繼承 Statement 的方法（它們用於處理一般的 sql 語句），還繼承了 PreparedStatement 的方法（它們用於處理 IN 參）。 CallableStatement 中定義的所有方法都用於處理 OUT 參數或 INOUT 參數的輸出部分：注冊 OUT 參數的 JDBC 類型（一般 SQL 類型）、從這些參數中檢索結果，或者檢查所返回的值是否為 JDBC NULL。 1、創建 CallableStatement 對象 CallableStatement 對象是用 Connection 方法 prepareCall 創建的。下例創建 CallableStatement 的實例，其中含有對已儲存過程 getTestData 調用。該過程有兩個變數，但不含結果參數：CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}"); 其中?佔位符為IN、OUT還是INOUT參數，取決於已儲存過程getTestData。 2、IN和OUT參數 將IN參數傳給 CallableStatement 對象是通過 setXXX 方法完成的。該方法繼承自 PreparedStatement。所傳入參數的類型決定了所用的setXXX方法（例如，用 setFloat 來傳入 float 值等）。 如果已儲存過程返回 OUT 參數，則在執行 CallableStatement 對象以前必須先注冊每個 OUT 參數的 JDBC 類型（這是必需的，因為某些 DBMS 要求 JDBC 類型）。注冊 JDBC 類型是用 registerOutParameter 方法來完成的。語句執行完後，CallableStatement 的 getXXX 方法將取回參數值。正確的 getXXX 方法是為各參數所注冊的 JDBC 類型所對應的 Java 類型。換言之， registerOutParameter 使用的是 JDBC 類型（因此它與資料庫返回的 JDBC 類型匹配），而 getXXX 將之轉換為 Java 類型。 作為示例，下述代碼先注冊 OUT 參數，執行由 cstmt 所調用的已儲存過程，然後檢索在 OUT 參數中返回的值。方法 getByte 從第一個 OUT 參數中取出一個 Java 位元組，而 getBigDecimal 從第二個 OUT 參數中取出一個 BigDecimal 對象（小數點後面帶三位數）：CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.registerOutParameter(2, java.sql.Types.DECIMAL, 3);
cstmt.executeQuery();
byte x = cstmt.getByte(1);
java.math.BigDecimal n = cstmt.getBigDecimal(2, 3); CallableStatement 與 ResultSet 不同，它不提供用增量方式檢索大 OUT 值的特殊機制。3、INOUT參數 既支持輸入又接受輸出的參數（INOUT 參數）除了調用 registerOutParameter 方法外，還要求調用適當的 setXXX 方法（該方法是從 PreparedStatement 繼承來的）。setXXX 方法將參數值設置為輸入參數，而 registerOutParameter 方法將它的 JDBC 類型注冊為輸出參數。setXXX 方法提供一個 Java 值，而驅動程序先把這個值轉換為 JDBC 值，然後將它送到資料庫中。這種 IN 值的 JDBC 類型和提供給 registerOutParameter 方法的 JDBC 類型應該相同。然後，要檢索輸出值，就要用對應的 getXXX 方法。例如，Java 類型為byte 的參數應該使用方法 setByte 來賦輸入值。應該給registerOutParameter 提供類型為 TINYINT 的 JDBC 類型，同時應使用 getByte 來檢索輸出值。 下例假設有一個已儲存過程 reviseTotal，其唯一參數是 INOUT 參數。方法setByte 把此參數設為 25，驅動程序將把它作為 JDBC TINYINT 類型送到資料庫中。接著，registerOutParameter 將該參數注冊為 JDBC TINYINT。執行完該已儲存過程後，將返回一個新的 JDBC TINYINT 值。方法 getByte 將把這個新值作為 Java byte 類型檢索。CallableStatement cstmt = con.prepareCall("{call reviseTotal(?)}");
cstmt.setByte(1, 25);
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.executeUpdate();
byte x = cstmt.getByte(1); 4、先檢索結果，再檢索 OUT 參數 由於某些 DBMS 的限制，為了實現最大的可移植性，建議先檢索由執行CallableStatement 對象所產生的結果，然後再用 CallableStatement.getXXX 方法來檢索 OUT 參數。如果 CallableStatement 對象返回多個 ResultSet 對象（通過調用 execute 方法），在檢索 OUT 參數前應先檢索所有的結果。這種情況下，為確保對所有的結果都進行了訪問，必須對 Statement 方法 getResultSet、getUpdateCount 和getMoreResults 進行調用，直到不再有結果為止。 檢索完所有的結果後，就可用 CallableStatement.getXXX 方法來檢索 OUT 參數中的值。 5、檢索作為OUT參數的NULL值 返回到 OUT 參數中的值可能會是JDBC NULL。當出現這種情形時，將對 JDBC NULL 值進行轉換以使 getXXX 方法所返回的值為 null、0 或 false，這取決於getXXX 方法類型。對於 ResultSet 對象，要知道0或false是否源於JDBCNULL的唯一方法，是用方法wasNull進行檢測。如果 getXXX 方法讀取的最後一個值是 JDBC NULL，則該方法返回 true，否則返回 flase。
復雜的返回值 關於存儲過程的知識，很多人好像就熟悉我們所討論的這些。如果這是存儲過程的全部功能，那麼存儲過程就不是其它遠程執行機制的替換方案了。存儲過程的功能比這強大得多。
某些DBMS允許從存儲過程中返回遊標的一個引用。JDBC並不支持這個功能，但是Oracle、PostgreSQL和DB2的JDBC驅動器都支持在ResultSet上打開到游標的指針（pointer）。
設想列出所有沒有活到退休年齡的詩人，下面是完成這個功能的存儲過程，返回一個打開的游標，同樣也使用PostgreSQL的pl/pgsql語言： create procere list_early_deaths () return refcursor as 'declare toesup refcursor;begin open toesup for SELECT poets.name, deaths.age FROM poets, deaths -- all entries in deaths are for poets. -- but the table might become generic. WHERE poets.id = deaths.mort_id AND deaths.age < 60; return toesup;end;' language 'plpgsql'; 下面是調用該存儲過程的Java方法，將結果輸出到PrintWriter：
PrintWriter: static void sendEarlyDeaths(PrintWriter out){ Connection con = null; CallableStatement toesUp = null; try { con = ConnectionPool.getConnection(); // PostgreSQL needs a transaction to do this... con. setAutoCommit(false); // Setup the call. CallableStatement toesUp = connection.prepareCall("{ ? = call list_early_deaths () }"); toesUp.registerOutParameter(1, Types.OTHER); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.getObject(1); while (rs.next()) { String name = rs.getString(1); int age = rs.getInt(2); out.println(name + " was " + age + " years old."); } rs.close(); } catch (SQLException e) { // We should protect these calls. toesUp.close(); con.close(); }} 因為JDBC並不直接支持從存儲過程中返回遊標，我們使用Types.OTHER來指示存儲過程的返回類型，然後調用getObject()方法並對返回值進行強制類型轉換。
這個調用存儲過程的Java方法是mapping的一個好例子。Mapping是對一個集上的操作進行抽象的方法。不是在這個過程上返回一個集，我們可以把操作傳送進去執行。本例中，操作就是把ResultSet列印到一個輸出流。這是一個值得舉例的很常用的例子，下面是調用同一個存儲過程的另外一個方法實現： public class ProcessPoetDeaths{ public abstract void sendDeath(String name, int age);} static void mapEarlyDeaths(ProcessPoetDeaths mapper){ Connection con = null; CallableStatement toesUp = null; try { con = ConnectionPool.getConnection(); con.setAutoCommit(false); CallableStatement toesUp = connection.prepareCall("{ ? = call list_early_deaths () }"); toesUp.registerOutParameter(1, Types.OTHER); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.getObject(1); while (rs.next()) { String name = rs.getString(1); int age = rs.getInt(2); mapper.sendDeath(name, age); } rs.close(); } catch (SQLException e) { // We should protect these calls. toesUp.close(); con.close(); }} 這允許在ResultSet數據上執行任意的處理，而不需要改變或者復制獲取ResultSet的方法： static void sendEarlyDeaths(final PrintWriter out){ ProcessPoetDeaths myMapper = new ProcessPoetDeaths() { public void sendDeath(String name, int age) { out.println(name + " was " + age + " years old."); } }; mapEarlyDeaths(myMapper);} 這個方法使用ProcessPoetDeaths的一個匿名實例調用mapEarlyDeaths。該實例擁有sendDeath方法的一個實現，和我們上面的例子一樣的方式把結果寫入到輸出流。當然，這個技巧並不是存儲過程特有的，但是和存儲過程中返回的ResultSet結合使用，是一個非常強大的工具。 結論存儲過程可以幫助你在代碼中分離邏輯，這基本上總是有益的。這個分離的好處有：
快速創建應用，使用和應用一起改變和改善的資料庫模式。
資料庫模式可以在以後改變而不影響Java對象，當我們完成應用後，可以重新設計更好的模式。
存儲過程通過更好的SQL嵌入使得復雜的SQL更容易理解。
編寫存儲過程比在Java中編寫嵌入的SQL擁有更好的工具－－大部分編輯器都提供語法高亮！
存儲過程可以在任何SQL命令行中測試，這使得調試更加容易。 並不是所有的資料庫都支持存儲過程，但是存在許多很棒的實現，包括免費/開源的和非免費的，所以移植並不是一個問題。Oracle、PostgreSQL和DB2都有類似的存儲過程語言，並且有在線的社區很好地支持。
存儲過程工具很多，有像TOAD或TORA這樣的編輯器、調試器和IDE，提供了編寫、維護PL/SQL或pl/pgsql的強大的環境。
存儲過程確實增加了你的代碼的開銷，但是它們和大多數的應用伺服器相比，開銷小得多。
B. 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;
C. java代碼怎麼調用存儲過程
方法如下：importjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.sql.Statement;/***LoadJDBCDriver*最基本的方法通過JDBC連接資料庫*@authorJacob**/publicclassLoadByPrimary{publicstaticvoidmain(String[]args)throwsClassNotFoundException{Stringdriver="oracle.jdbc.OracleDriver";Connectioncn=null;/***Class.forName手動載入一個類到方法區，Driver類中包含自動注冊驅動的靜態代碼塊*會自動在DriverManager中注冊驅動*/Class.forName(driver);Stringurl="jdbc:oracle:thin:@localhost:1521:ORACLE";//1521代表埠號，默認的Stringuser="用戶名";Stringpwd="密碼";try{/**Connection是介面，返回值是一個引用對象，是Oracle驅動提供實現類ojdbc7.jar*使用JDBCAPI介面，實際上是驅動實現類*/cn=DriverManager.getConnection(url,user,pwd);Statementstmt=cn.createStatement();Stringsql="SELECT*FROMstu_empWHEREdeptno=10";ResultSetrs=stmt.executeQuery(sql);while(rs.next()){System.out.println(rs.getInt("empno")+""+rs.getString("ename")+""+rs.getString("job"));}rs.close();stmt.close();}catch(SQLExceptione){e.printStackTrace();}finally{try{if(cn!=null){cn.close();}}catch(SQLExceptione2){e2.printStackTrace();}}}}這是通過preparedstatement實現更新數據，這里我把連接資料庫的方法進行了封裝，每次直接調用了。publicstaticvoidmain(String[]args){PreparedStatementDemopsd=newPreparedStatementDemo();psd.updateSalary("JACOB",3000);psd.selectSalary("JACOB");}publicvoipdateSalary(Stringename,doublesal){Stringsql="Updatestu_empsetsal=?Whereename=?";Connectioncn=null;PreparedStatementps=null;try{cn=DBPUtil.getConnection();ps=cn.prepareStatement(sql);ps.setDouble(1,sal);ps.setString(2,ename);intnum=ps.executeUpdate();System.out.println("提示：總共有"+num+"條數據已經更新！");}catch(SQLExceptione){e.printStackTrace();}finally{DBUtil.stmtClose(ps);DBUtil.connClose(cn);}}publicvoidselectSalary(Stringname){Stringsql="Select*Fromstu_empWhereename=?";Connectioncn=null;PreparedStatementps=null;ResultSetrs=null;try{cn=DBPUtil.getConnection();ps=cn.prepareStatement(sql);ps.setString(1,name);rs=ps.executeQuery();while(rs.next()){System.out.println(rs.getString("ename")+"的工資是："+rs.getInt("sal"));}}catch(SQLExceptione){e.printStackTrace();}finally{DBUtil.stmtClose(ps);DBUtil.rsClose(rs);DBUtil.connClose(cn);}}}
D. 有沒有Java教學視頻講如何jdbc鏈接mysql資料庫的的
一般的java web編程都會有jdbc編程教程，連接mysql oracle 等基本都是一樣的。
java資料庫編程要用JDBC
JDBC用法很簡單,創建一個以JDBC連接資料庫的程序，包含7個步驟：
1、載入JDBC驅動程序：
在連接資料庫之前，首先要載入想要連接的資料庫的驅動到JVM（Java虛擬機），
這通過java.lang.Class類的靜態方法forName(String className)實現。
例如：
try{
//載入MySql的驅動類
Class.forName("com.mysql.jdbc.Driver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驅動程序類 ，載入驅動失敗！");
e.printStackTrace() ;
}
成功載入後，會將Driver類的實例注冊到DriverManager類中。
2、提供JDBC連接的URL
•連接URL定義了連接資料庫時的協議、子協議、數據源標識。
•書寫形式：協議：子協議：數據源標識
協議：在JDBC中總是以jdbc開始
子協議：是橋連接的驅動程序或是資料庫管理系統名稱。
數據源標識：標記找到資料庫來源的地址與連接埠。
例如：（MySql的連接URL）
jdbc:mysql:
//localhost:3306/test?useUnicode=true&characterEncoding=gbk ;
useUnicode=true：表示使用Unicode字元集。如果characterEncoding設置為
gb2312或GBK，本參數必須設置為true 。characterEncoding=gbk：字元編碼方式。
3、創建資料庫的連接
•要連接資料庫，需要向java.sql.DriverManager請求並獲得Connection對象，
該對象就代表一個資料庫的連接。
•使用DriverManager的getConnectin(String url , String username ,
String password )方法傳入指定的欲連接的資料庫的路徑、資料庫的用戶名和
密碼來獲得。
例如：
//連接MySql資料庫，用戶名和密碼都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("資料庫連接失敗！");
se.printStackTrace() ;
}
4、創建一個Statement
•要執行SQL語句，必須獲得java.sql.Statement實例，Statement實例分為以下3
種類型：
1、執行靜態SQL語句。通常通過Statement實例實現。
2、執行動態SQL語句。通常通過PreparedStatement實例實現。
3、執行資料庫存儲過程。通常通過CallableStatement實例實現。
具體的實現方式：
Statement stmt = con.createStatement() ;
PreparedStatement pstmt = con.prepareStatement(sql) ;
CallableStatement cstmt =
con.prepareCall("{CALL demoSp(? , ?)}") ;
5、執行SQL語句
Statement介面提供了三種執行SQL語句的方法：executeQuery 、executeUpdate
和execute
1、ResultSet executeQuery(String sqlString)：執行查詢資料庫的SQL語句
，返回一個結果集（ResultSet）對象。
2、int executeUpdate(String sqlString)：用於執行INSERT、UPDATE或
DELETE語句以及SQL DDL語句，如：CREATE TABLE和DROP TABLE等
3、execute(sqlString):用於執行返回多個結果集、多個更新計數或二者組合的
語句。
具體實現的代碼：
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;
int rows = stmt.executeUpdate("INSERT INTO ...") ;
boolean flag = stmt.execute(String sql) ;
6、處理結果
兩種情況：
1、執行更新返回的是本次操作影響到的記錄數。
2、執行查詢返回的結果是一個ResultSet對象。
• ResultSet包含符合SQL語句中條件的所有行，並且它通過一套get方法提供了對這些
行中數據的訪問。
• 使用結果集（ResultSet）對象的訪問方法獲取數據：
while(rs.next()){
String name = rs.getString("name") ;
String pass = rs.getString(1) ; // 此方法比較高效
}
（列是從左到右編號的，並且從列1開始）
7、關閉JDBC對象
操作完成以後要把所有使用的JDBC對象全都關閉，以釋放JDBC資源，關閉順序和聲
明順序相反：
1、關閉記錄集
2、關閉聲明
3、關閉連接對象
if(rs != null){ // 關閉記錄集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 關閉聲明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(conn != null){ // 關閉連接對象
try{
conn.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
E. java中怎麼用存儲過程啊
對已儲存過程的調用是CallableStatement對象所含的內容。這種調用是用一種換碼語法來寫的，有兩種形式：一種形式帶結果參，另一種形式不帶結果參數。結果參數是一種輸出(OUT)參數，是已儲存過程的返回值。兩種形式都可帶有數量可變的輸入（IN參數）、輸出（OUT參數）或輸入和輸出（INOUT參數）的參數。問號將用作參數的佔位符。在JDBC中調用已儲存過程的語法如下所示。注意，方括弧表示其間的內容是可選項；方括弧本身並非語法的組成部份。 {call過程名[(?,?,...)]} 返回結果參數的過程的語法為： {?=call過程名[(?,?,...)]} 不帶參數的已儲存過程的語法類似： {call過程名} 通常，創建CallableStatement對象的人應當知道所用的DBMS是支持已儲存過程的，並且知道這些過程都是些什麼。然而，如果需要檢查，多種DatabaseMetaData方法都可以提供這樣的信息。例如，如果DBMS支持已儲存過程的調用，則supportsStoredProceres方法將返回true，而getProceres方法將返回對已儲存過程的描述。 CallableStatement繼承Statement的方法（它們用於處理一般的SQL語句），還繼承了PreparedStatement的方法（它們用於處理IN參）。 CallableStatement中定義的所有方法都用於處理OUT參數或INOUT參數的輸出部分：注冊OUT參數的JDBC類型（一般SQL類型）、從這些參數中檢索結果，或者檢查所返回的值是否為JDBCNULL。 JDBC存儲過程1、創建CallableStatement對象 CallableStatement對象是用Connection方法prepareCall創建的。下例創建CallableStatement的實例，其中含有對已儲存過程getTestData調用。該過程有兩個變數，但不含結果參數：CallableStatementc stmt=con.prepareCall("{callgetTestData(?,?)}");其中?佔位符為IN、OUT還是INOUT參數，取決於已儲存過程getTestData。 JDBC存儲過程2、IN和OUT參數 將IN參數傳給CallableStatement對象是通過setXXX方法完成的。該方法繼承自PreparedStatement。所傳入參數的類型決定了所用的setXXX方法（例如，用setFloat來傳入float值等）。如果已儲存過程返回OUT參數，則在執行CallableStatement對象以前必須先注冊每個OUT參數的JDBC類型（這是必需的，因為某些DBMS要求JDBC類型）。注冊JDBC類型是用registerOutParameter方法來完成的。語句執行完後，CallableStatement的getXXX方法將取回參數值。正確的getXXX方法是為各參數所注冊的JDBC類型所對應的Java類型。換言之，registerOutParameter使用的是JDBC類型（因此它與資料庫返回的JDBC類型匹配），而getXXX將之轉換為Java類型。 作為示例，下述代碼先注冊OUT參數，執行由cstmt所調用的已儲存過程，然後檢索在OUT參數中返回的值。方法getByte從第一個OUT參數中取出一個Java位元組，而getBigDecimal從第二個OUT參數中取出一個BigDecimal對象（小數點後面帶三位數）： CallableStatementc stmt=con.prepareCall("{callgetTestData(?,?)}"); cstmt.registerOutParameter(1,java.sql.Types.TINYINT); cstmt.registerOutParameter(2,java.sql.Types.DECIMAL,3); cstmt.executeQuery(); byte x=cstmt.getByte(1); java.math.BigDecimaln=cstmt.getBigDecimal(2,3); CallableStatement與ResultSet不同，它不提供用增量方式檢索大OUT值的特殊機制。JDBC存儲過程3、INOUT參數 既支持輸入又接受輸出的參數（INOUT參數）除了調用registerOutParameter方法外，還要求調用適當的setXXX方法（該方法是從PreparedStatement繼承來的）。setXXX方法將參數值設置為輸入參數，而registerOutParameter方法將它的JDBC類型注冊為輸出參數。setXXX方法提供一個Java值，而驅動程序先把這個值轉換為JDBC值，然後將它送到資料庫中。這種IN值的JDBC類型和提供給registerOutParameter方法的JDBC類型應該相同。然後，要檢索輸出值，就要用對應的getXXX方法。例如，Java類型為byte的參數應該使用方法setByte來賦輸入值。應該給registerOutParameter提供類型為TINYINT的JDBC類型，同時應使用getByte來檢索輸出值。 下例假設有一個已儲存過程reviseTotal，其唯一參數是INOUT參數。方法setByte把此參數設為25，驅動程序將把它作為JDBCTINYINT類型送到資料庫中。接著，registerOutParameter將該參數注冊為JDBCTINYINT。執行完該已儲存過程後，將返回一個新的JDBCTINYINT值。方法getByte將把這個新值作為Javabyte類型檢索。 CallableStatementc stmt=con.prepareCall("{callreviseTotal(?)}"); cstmt.setByte(1,25); cstmt.registerOutParameter(1,java.sql.Types.TINYINT); cstmt.executeUpdate(); byte x=cstmt.getByte(1); 1）返回一個結果集（ResultSet）。2）返回一個特定的值。下面來詳細的說明。1）返回一個結果集（ResultSet）,這種類似通常的處理結果集如果事先就有一個類似如下的procere CREATE PROCEDURE getShipQuantity @jsid int ASSELECT jf_js_id,SUM(jf_ship_quantity) AS shipqty FROM tjobsheet_finish f WHERE (jf_js_id=@jsid)GROUP BY jf_js_id 那麼我們將通過如下的代碼來調用 String sql = "{ call getShipQuantity(?) }";Connection con = conn.connection();ResultSet rs = null;BigDecimal shipQuantity = new BigDecimal(0);try{ CallableStatement cs = con.prepareCall(sql); cs.setInt(1,jsoId);//設置輸入參數 rs = cs.executeQuery();//返回結果集 if(rs.next()){ shipQuantity = new BigDecimal(rs.getDouble(2)); } logger.debug("shipQuantity --------------------- "+shipQuantity);}catch(Exception e){ logger.debug(e);}2）返回一個特定的值。也就是說，在procere的定義中已經用output輸出參數了。請看下面的proceercreate procere getSingleWgt @@singleWgt numeric(8,3) output,@jsnum varchar(11) = '0000-0480'asdeclare @stwgt numeric(8,3)select @stwgt = sum(b.stwgt)from js as ainner join jsactdtl as b on a.jsnum = b.jsnumwhere a.completion = 1 and b.stflag = 22and a.jsnum = @jsnumselect @@singleWgt = (@stwgt/orderedqty) from js where jsnum = @jsnum那麼我們將通過如下的代碼來調用String sql = "{ call getSingleWgt(?,?) }";Connection con = getSession().connection();//得到connectiontry{ CallableStatement cs = con.prepareCall(sql);//通過它來執行sql cs.registerOutParameter(1,java.sql.Types.FLOAT);//注冊輸出參數 cs.setString(2,shipment.getJsnum());//指出輸入參數 if(cs.execute()){//執行 float output = cs.getFloat(1);//返回值 }}catch(Exception e){logger.debug(e);｝
F. java訪問資料庫存儲過程
java中調用Oracle存儲過程
1、編寫存儲過程
<code class=" hljs oxygene">CREATE OR REPLACE PROCEDURE sp_pro3(sp_name VARCHAR2,sp_sal NUMBER )
IS
BEGIN
--根據用戶名修改工資
UPDATE emp SET sal=sp_sal WHERE ename=sp_name;
END;
</code>
2、引入jdbc6.jar，編寫測試類Test.java
<code class=" hljs java">package testOraclePro;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
public class Test {
public static void main(String[] args) {
try{
//1.載入驅動
Class.forName("oracle.jdbc.driver.OracleDriver");
//2.獲取連接
Connection ct=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:XE","sys as sysdba","123456");
//3.創建CallableStatement
CallableStatement cs=ct.prepareCall("{call sp_pro3(?,?)}");
//4.賦值
cs.setString(1, "zxs");
cs.setFloat(2,455f);
//5.執行
cs.execute();
//6.關閉資源
cs.close();
ct.close();
}catch(Exception e){
e.printStackTrace();
}
}
}</code>
執行上面的測試類,即可調用存儲過程，執行相應的程序了。
tips:可通過下面的SQL語句來獲取資料庫名稱：
<code class=" hljs ruleslanguage">SELECT * FROM V$INSTANCE </code>
G. 什麼是java中的存儲過程請教高手幫忙
java本身是沒儲存過程的，
存儲過程是由流控制和SQL語句書寫的過程，這個過程經編譯和優化後存儲在資料庫伺服器中，使用時只要調用即可。
比如說，在java調用oracle存儲過程。
H. 如何創建Java存儲過程
1、操作系統：windows 2000 Server
2、數 據 庫：Oracle 8i R2 (8.1.7) for NT 企業版
3、安裝路徑：C:\ORACLE
實現方法：
1、 創建一個文件為TEST.java
public class TEST
{
public static void main (String args[])
{
System.out.PRintln("HELLO THIS iS A JAVA PROCEDURE");
}
}
2、 javac TEST.java
3、 java TEST
4、 SQL> conn system/manager
SQL> grant create any Directory to scott;
SQL> conn scott/tiger
SQL> create or replace directory test_dir as 'd:\'
目錄已創建。
SQL> create or replace java class using bfile(test_dir,'TEST.CLASS')
2/
Java 已創建。
SQL> select object_name,object_type,STATUS from user_objects;
SQL> create or replace procere test_java
as language java
name 'TEST.main(java.lang.String[])';
/
過程已創建。
SQL> set serveroutput on size 5000
SQL> call dbms_java.set_output(5000);
調用完成。
SQL> execute test_java;
HELLO THIS iS A JAVA PROCEDURE
PL/SQL 過程已成功完成。
SQL> call test_java();
HELLO THIS iS A JAVA PROCEDURE
調用完成。
I. JAVA中如何調用存儲過程
Connection conn = null;
CallableStatement cStmt = null;
PreparedStatement pStmt = null;
ResultSet rs = null;
conn = ConnectionManagerDao.getConn();
//關鍵代碼
cStmt = conn.prepareCall("{call proc_PagingVie(?,?,?,?,?,?,?,?,?) }");
//call 存儲過程名（?,?,?）-問號的是參數
J. java中怎麼用存儲過程
存儲過程是資料庫的,可以通過觸發器來調用,存儲過程類似於方法