Spring jdbcTemplate调用Oracle存储过程返回List集合

springjdbctemplate调用存储过程，返回list对象

springjdbctemplate调⽤存储过程，返回list对象注：本⽂来源于《》spring jdbctemplate调⽤存储过程，返回list对象⽅法：/*** 调⽤存储过程* @param spName*/@SuppressWarnings("unchecked")public List<HashMap<String, Object>> executeSP(String procedure) {//procedure = "{call WCITY2_STATISTIC.sp_uservisit_stat(?)}";return (List<HashMap<String, Object>>) jdbcTemplate.execute(procedure,new CallableStatementCallback() {public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();cs.registerOutParameter(1, OracleTypes.CURSOR);cs.execute();ResultSet rs = (ResultSet) cs.getObject(1);while (rs.next()) {HashMap<String, Object> dataMap = new HashMap<String, Object>();ResultSetMetaData rsMataData = rs.getMetaData();for (int i = 1; i <= rsMataData.getColumnCount(); i++) {dataMap.put(rsMataData.getColumnName(i), rs.getString(rsMataData.getColumnName(i)));}list.add(dataMap);}return list;}});}存储过程：replace package WCITY2_STATISTIC-- Author : ADMINISTRATOR-- Created : 2012/10/24 9:48:34-- Purpose :type Ref_Cursor ref ;--sp_pager_stats;--访问信息sp_uservisit_stat(c_uservisit out Ref_Cursor);WCITY2_STATISTIC;replace package body WCITY2_STATISTIC--页⾯信息sp_pager_stats-- cur_page as select * from OMS_WIRELESS. TEMPLATE_FILE_WORKING;;sp_pager_stats;--访问信息sp_uservisit_stat(c_uservisit out Ref_Cursor)--定义游标/*cursor c_uservisit isselect t.city,ername,ername as telphone,'' as ipfrom INTERFACE_ER_LOGIN_LOG t ;*/c_uservisitt.city, ername, ername telphone, '' ipINTERFACE_ER_LOGIN_LOG t;;WCITY2_STATISTIC;调⽤⽅法：@SuppressWarnings("rawtypes")String getUserVisitStat(){//List lst=jdbcService.executeSP("");String = "{call WCITY2_STATISTIC.sp_uservisit_stat(?)}";List lst=spService.executeSP();(lst!=){System.out.println(lst.());}SUCCESS;}⾃⼰编写的代码import java..CallableStatement;import java..ResultSet;import java..ResultSetMetaData;import java..SQLException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.dao.DataAccessException;import org.springframework.jdbc.core.CallableStatementCallback;import org.springframework.jdbc.core.JdbcTemplate;import com.tt.pwp.framework.data.dao.DaoFactory;import oracle.jdbc.OracleTypes;class FuncReportTaskService {protected final Logger logger = LoggerFactory.getLogger(this.getClass()); @Autowiredprivate DaoFactory daoFactory;/*** 调⽤存储过程* @param spName*/@SuppressWarnings("unchecked")List<HashMap<String, Object>> executeSP(String ) {JdbcTemplate jdbcTemplate = daoFactory.getDao().getJdbcTemplate(); // = "{call WCITY2_STATISTIC.sp_uservisit_stat(?)}";(List<HashMap<String, Object>>) jdbcTemplate.(,new CallableStatementCallback() {Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>(); cs.registerOutParameter(1, OracleTypes.);cs.();ResultSet rs = (ResultSet) cs.getObject(1);(rs.()) {HashMap<String, Object> dataMap = new HashMap<String, Object>();ResultSetMetaData rsMataData = rs.getMetaData();( i = 1; i <= rsMataData.getColumnCount(); i++) {dataMap.put(rsMataData.getColumnName(i), rs.getString(rsMataData.getColumnName(i)));}list.(dataMap);}list;}});}}。

Java调用Oracle存储过程返回结果集

Java调⽤Oracle存储过程返回结果集CREATE OR REPLACE PACKAGE typesASTYPE ref_cursor IS REF CURSOR;END;/CREATE TABLE STOCK_PRICES(RIC VARCHAR(6) PRIMARY KEY,PRICE NUMBER(7,2),UPDATED DATE );/CREATE OR REPLACE FUNCTION sp_get_stocks(v_price IN NUMBER)RETURN types.ref_cursorASstock_cursor types.ref_cursor;BEGINOPEN stock_cursor FORSELECT ric,price,updated FROM stock_prices WHERE price < v_price;RETURN stock_cursor;END;2. ⽤ sqlplus 测试过程SQL> var results refcursorSQL> exec :results := sp_get_stocks(20.0)SQL> print results3. 从 Java 调⽤import java.sql.*;import java.io.*;import oracle.jdbc.driver.*;public class JDBCDemo {/*** Compile-time flag for deciding which query to use*/private boolean useOracleQuery = true;/*** Class name of Oracle JDBC driver*/private String driver = "oracle.jdbc.driver.OracleDriver";/*** Initial url fragment*/private String url = "jdbc:oracle:thin:@";/*** Standard Oracle listener port*/private String port = "1521";/*** Oracle style of calling a stored procedure*/private String oracleQuery = "begin ? := sp_get_stocks(?); end;";/*** JDBC style of calling a stored procedure*/private String genericQuery = "{ call ? := sp_get_stocks(?) }";/*** Connection to database*/private Connection conn = null;/*** Constructor. Loads the JDBC driver and establishes a connection** @param host the host the db is on* @param db the database name* @param user user's name* @param password user's password*/public JDBCDemo(String host, String db, String user, String password) throws ClassNotFoundException, SQLException {// construct the urlurl = url + host + ":" + port + ":" + db;// load the Oracle driver and establish a connectiontry {Class.forName(driver);conn = DriverManager.getConnection(url, user, password);}catch (ClassNotFoundException ex) {System.out.println("Failed to find driver class: " + driver);throw ex;}catch (SQLException ex) {System.out.println("Failed to establish a connection to: " + url);throw ex;}}/*** Execute the stored procedure** @param price price parameter for stored procedure*/private void execute(float price)throws SQLException {String query = useOracleQuery ? oracleQuery : genericQuery;System.out.println("Query: " + query + "n");CallableStatement stmt = conn.prepareCall(query);// register the type of the out param - an Oracle specific typestmt.registerOutParameter(1, OracleTypes.CURSOR);// set the in paramstmt.setFloat(2, price);// execute and retrieve the result setstmt.execute();ResultSet rs = (ResultSet)stmt.getObject(1);// print the resultswhile (rs.next()) {System.out.println(rs.getString(1) + "t" +rs.getFloat(2) + "t" +rs.getDate(3).toString());}rs.close();stmt.close();}/*** Cleanup the connection*/private void cleanup() throws SQLException {if (conn != null)conn.close();}/*** Prints usage statement on stdout*/static private void usage() {System.out.println("java com.enterprisedt.demo.oracle.JDBCDemo " + " host db user password price");}/*** Runs the class*/public static void main(String[] args) throws Exception {if (args.length != 5) {age();System.exit(1);}else {try {// assign the args to sensible variables for clarityString host = args[0];String db = args[1];String user = args[2];String password = args[3];float price = Float.valueOf(args[4]).floatValue();// and execute the stored procJDBCDemo jdbc = new JDBCDemo(host, db, user, password); jdbc.execute(price);jdbc.cleanup();}catch (ClassNotFoundException ex) {System.out.println("Demo failed");}catch (SQLException ex) {System.out.println("Demo failed: " + ex.getMessage());}}}}。

用java调用oracle存储过程总结3-返回列表-偶爱老婆-搜狐博客

用java调用oracle存储过程总结3-返回列表-偶爱老婆-搜狐博客三：返回列表由于oracle存储过程没有返回值，它的所有返回值都是通过out 参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage了.所以要分两部分，1，建一个程序包。

如下：CREATE OR REPLACE PACKAGE TESTPACKAGE ASTYPE Test_CURSOR IS REF CURSOR;end TESTPACKAGE;2，建立存储过程，存储过程为：CREATE OR REPLACE PROCEDURE TESTC(p_CURSOR out TESTPACKAGE.T est_CURSOR) ISBEGINOPEN p_CURSOR FOR SELECT * FROM HYQ.TESTTB;END TESTC;可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。

在java里调用时就用下面的代码：package com.hyq.src;import java.sql.*;import java.io.OutputStream;import java.io.Writer;import java.sql.PreparedStatement;import java.sql.ResultSet;import oracle.jdbc.driver.*;public class TestProcedureTHREE {public TestProcedureTHREE() {}public static void main(String[] args ){String driver = "oracle.jdbc.driver.OracleDriver";String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521:hyq";Statement stmt = null;ResultSet rs = null;Connection conn = null;try {Class.forName(driver);conn = DriverManager.getConnection(strUrl, "hyq", "hyq");CallableStatement proc = null;proc = conn.prepareCall("{ call hyq.testc(?) }");proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURS OR);proc.execute();rs = (ResultSet)proc.getObject(1);while(rs.next()){System.out.println("<tr><td>" + rs.getString(1) + "</td><td>"+rs.getString(2)+"</td></tr>");}}catch (SQLException ex2) {ex2.printStackTrace();}catch (Exception ex2) {ex2.printStackTrace();}finally{try {if(rs != null){rs.close();if(stmt!=null){stmt.close();}if(conn!=null){conn.close();}}}catch (SQLException ex1) { }}}}。

jdbctemplate返回对象集合

jdbctemplate返回对象集合JdbcTemplate是Spring Framework提供的一种 JDBC 抽象框架，它可以大量简化JDBC应用程序的开发过程。

其中包括了大量的面向对象手段，极大的提高了安全性和可维护性。

JdbcTemplate具有JDBC操作中的所有功能，包括基本的CRUD操作，批处理，对象映射等。

在JdbcTemplate 中，我们通常使用三个主要接口：JdbcOperations，PreparedStatementSetter和ResultSetExtractor。

它们用来处理不同的DML操作，例如查询、插入、更新和删除。

在JdbcTemplate的操作之中，有时我们需要返回一批对象集合，例如一张表的所有数据，或者是根据某些搜索条件返回的一些对象列表。

JdbcTemplate提供了一种便捷的方式来实现这个功能，这就是返回对象集合。

本文将介绍JdbcTemplate如何返回对象集合，以及如何使用这个功能来提高我们应用程序的效率。

1.查询操作一般情况下，我们在使用JdbcTemplate进行查询操作时，都是返回一个ResultSet结果集，然后通过循环遍历结果集得到每行数据。

这种操作方式虽然能够满足我们的需求，但是在数据量比较大的情况下，效率较低。

因此，使用JdbcTemplate返回对象集合是一种非常好的选择。

首先，我们需要先定义一个对象，它代表了表中的一行数据：``` public class User { private int id; private String name; private String gender; private String email; // getter and setter }```然后，我们需要定义一个接口，用来映射数据库中的表和我们定义的对象：``` public interface UserDao { List<User> findByGender(String gender); } ```在实现Dao接口时，我们可以使用JdbcTemplate进行操作数据库，从而返回一个包含所有符合条件的User对象集合。

jdbctemplate调用存储过程返回多行

jdbctemplate调用存储过程返回多行在Spring 的JdbcTemplate 中，如果要调用存储过程并返回多行结果，可以使用`query` 方法，并通过`RowMapper` 将每行结果映射到相应的对象。

下面是一个简单的示例：假设有一个存储过程，接收输入参数，并返回多行结果：```sqlCREATE PROCEDURE getEmployees(IN departmentId INT)BEGINSELECT * FROM employees WHERE department_id = departmentId;END;```然后，你可以使用JdbcTemplate 来调用这个存储过程：```javaimport org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;import org.springframework.stereotype.Repository;import java.sql.ResultSet;import java.sql.SQLException;import java.util.List;@Repositorypublic class EmployeeRepository {private final JdbcTemplate jdbcTemplate;public EmployeeRepository(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}public List<Employee> getEmployeesByDepartment(int departmentId) {String sql = "CALL getEmployees(?)";// 使用query 方法调用存储过程，通过RowMapper 映射结果到Employee 对象return jdbcTemplate.query(sql, new Object[]{departmentId}, new EmployeeRowMapper());}private static class EmployeeRowMapper implements RowMapper<Employee> {@Overridepublic Employee mapRow(ResultSet resultSet, int i) throws SQLException {// 将查询结果映射到Employee 对象Employee employee = new Employee();employee.setId(resultSet.getInt("id"));employee.setName(resultSet.getString("name"));// 其他属性的映射...return employee;}}}```在上述示例中，`EmployeeRepository` 类通过`jdbcTemplate.query` 方法调用存储过程，并使用`EmployeeRowMapper` 将查询结果映射到`Employee` 对象。

Spring jdbcTemplate调用Oracle存储过程返回List集合

jdbcTemplate调用Oracle存储过程返回List集合作者:xyzc(cr10210206@)1.编写存储过程-- 模糊查询返回多条数据CREATE OR REPLACE PROCEDURE P_EMP_SELECT(RESULTLIST OUT SYS_REFCURSOR,V_ID IN NUMBER,V_NAME IN VARCHAR2)ISSQL_STR VARCHAR2(500);BEGINSQL_STR:='SELECT * FROM EMP WHERE 1=1 ';DBMS_OUTPUT.put_line('V_ID='||V_ID ||' V_NAME='||V_NAME);IF(V_ID<>0)THENBEGINSQL_STR:=SQL_STR ||' AND EMPNO>= '|| V_ID;END;END IF;IF(V_NAME IS NOT NULL)THEN-- 判断字符串是否为空BEGINSQL_STR:=SQL_STR ||' AND ENAME LIKE '''||V_NAME ||'%'' ';-- 字符串是四个单引号 ''A%'' END;END IF;DBMS_OUTPUT.put_line(' SQL_STR:'||SQL_STR);-- 输出SQL语句OPEN RESULTLIST FOR SQL_STR;END;-- 测试DECLAREMYCRS SYS_REFCURSOR;-- 注意这里用分号；V_EMP EMP%ROWTYPE;BEGIN-- 调用过程，返回的是已经打开的CURSORP_EMP_SELECT(MYCRS,7900,'');LOOPFETCH MYCRS INTO V_EMP;EXIT WHEN MYCRS%NOTFOUND;DBMS_OUTPUT.put_line(V_EMP.EMPNO||' '||V_EMP.ENAME);END LOOP;CLOSE MYCRS;END;2.编写Java代码package com.zc.test;import java.sql.CallableStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import oracle.jdbc.driver.OracleTypes;import org.springframework.dao.DataAccessException;import org.springframework.jdbc.core.CallableStatementCallback; import org.springframework.jdbc.core.JdbcTemplate;/*** 测试Oracle存储过程* */public class TestOraclePro {private static JdbcTemplate jdbcTemplate= TestDao.getJdbcTemplateOracle();/*** 测试* */public static void main(String[] args) {TestOraclePro test = new TestOraclePro();List<HashMap<String, Object>> result = test.testPro();System.out.println("\nresult:\n" + result);/*** 返回的结果：** [{DEPTNO=20, COMM=null, HIREDATE=1980-12-17 00:00:00.0, MGR=7902, SAL=800, JOB=CLERK, ENAME=SMITH, EMPNO=7369},* {DEPTNO=30, COMM=300, HIREDATE=1981-02-20 00:00:00.0, MGR=7698, SAL=1600, JOB=SALESMAN, ENAME=ALLEN, EMPNO=7499}, * {DEPTNO=30, COMM=500, HIREDATE=1981-02-22 00:00:00.0, MGR=7698, SAL=1250, JOB=SALESMAN, ENAME=WARD, EMPNO=7521},* {DEPTNO=20, COMM=null, HIREDATE=1981-04-02 00:00:00.0,MGR=7839, SAL=2975, JOB=MANAGER, ENAME=JONES, EMPNO=7566},* {DEPTNO=30, COMM=1400, HIREDATE=1981-09-28 00:00:00.0, MGR=7698, SAL=1250, JOB=SALESMAN, ENAME=MARTIN, EMPNO=7654}, * {DEPTNO=30, COMM=null, HIREDATE=1981-05-01 00:00:00.0, MGR=7839, SAL=2850, JOB=MANAGER, ENAME=BLAKE, EMPNO=7698},* {DEPTNO=10, COMM=null, HIREDATE=1981-06-09 00:00:00.0, MGR=7839, SAL=2450, JOB=MANAGER, ENAME=CLARK, EMPNO=7782},* {DEPTNO=20, COMM=null, HIREDATE=1987-04-19 00:00:00.0, MGR=7566, SAL=3000, JOB=ANALYST, ENAME=SCOTT, EMPNO=7788},* {DEPTNO=10, COMM=null, HIREDATE=1981-11-17 00:00:00.0, MGR=null, SAL=5000, JOB=PRESIDENT, ENAME=KING, EMPNO=7839}, * {DEPTNO=30, COMM=0, HIREDATE=1981-09-08 00:00:00.0, MGR=7698, SAL=1500, JOB=SALESMAN, ENAME=TURNER, EMPNO=7844}, * {DEPTNO=20, COMM=null, HIREDATE=1987-05-23 00:00:00.0, MGR=7788, SAL=1100, JOB=CLERK, ENAME=ADAMS, EMPNO=7876},* {DEPTNO=30, COMM=null, HIREDATE=1981-12-03 00:00:00.0, MGR=7698, SAL=950, JOB=CLERK, ENAME=JAMES, EMPNO=7900},* {DEPTNO=20, COMM=null, HIREDATE=1981-12-03 00:00:00.0, MGR=7566, SAL=3000, JOB=ANALYST, ENAME=FORD, EMPNO=7902},* {DEPTNO=10, COMM=null, HIREDATE=1982-01-23 00:00:00.0, MGR=7782, SAL=1300, JOB=CLERK, ENAME=MILLER, EMPNO=7934}]* */}/*** 调用存储过程返回 List<HashMap<String, Object>>* */@SuppressWarnings({ "unchecked", "rawtypes" })public List<HashMap<String, Object>> testPro(){final String sql = "{call P_EMP_SELECT(?,?,?)}";List<HashMap<String, Object>> result = (List<HashMap<String, Object>>) jdbcTemplate.execute(sql,new CallableStatementCallback(){ public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();cs.registerOutParameter(1, OracleTypes.CURSOR); //输出参数：游标cs.setInt(2, 2000);//输入参数cs.setString(3, "");//输入参数cs.execute();//执行ResultSet rs = null;try {rs = (ResultSet) cs.getObject(1);//获取结果集while (rs.next()) {HashMap<String, Object> dataMap = new HashMap<String, Object>();ResultSetMetaData rsMataData = rs.getMetaData();for(int i = 1; i <= rsMataData.getColumnCount(); i++) {dataMap.put(rsMataData.getColumnName(i),rs.getString(rsMataData.getColumnName(i)));}list.add(dataMap);}} catch (Exception e) {e.printStackTrace();}finally{if(rs != null){rs.close();}}return list;}});return result;}}。

Spring之jdbcTemplate：查询的三种方式（单个值、单个对象、对象集合）

Spring之jdbcTemplate：查询的三种⽅式（单个值、单个对象、对象集合）JdbcTemplateDemo2.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.JdbcTemplate;45import java.sql.*;6import java.util.List;78/**9 * 功能：通过JdbcTemplate实现查询操作10 * 查询结果需要⾃⼰封装(实现RowMapper接⼝)11*/1213public class JdbcTemplateDemo2 {14// JdbcTemplate使⽤步骤：15// 1、导⼊jar包；2、设置数据库信息；3、设置数据源；4、调⽤jdbcTemplate对象中的⽅法实现操作1617public static void main(String[] args) {18// 设置数据库信息和据源19 JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();20 JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();2122// 插⼊数据23// insertData();2425// 查询返回某⼀个值：查询表中数据总数26 queryForOne(jdbcTemplate);2728// 查询返回对象29 queryForObject(jdbcTemplate);3031// 查询返回list集合32 queryForList(jdbcTemplate);3334// 使⽤JDBC底层实现查询35 queryWithJDBC();36 }3738// 插⼊数据39public static void insertData() {40 JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();41 JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();42// 调⽤jdbcTemplate对象中的⽅法实现操作43 String sql = "insert into user value(?,?,?)";44//表结构：id（int、⾃增）,name(varchar 100),age(int 10)45int rows = jdbcTemplate.update(sql, null, "Tom", 35);46 System.out.println("插⼊⾏数：" + rows);47 }4849/**50 * 查询返回某⼀个值：查询表中数据总数51*/52public static void queryForOne(JdbcTemplate jdbcTemplate) {53 String sql = "select count(*) from user";54// 调⽤⽅法获得记录数55int count = jdbcTemplate.queryForObject(sql, Integer.class);56 System.out.println("数据总数：" + count);57 }5859/**60 * 功能：查询返回单个对象61 * 步骤：新建MyRowMapper类实现RowMapper接⼝，重写mapRow⽅法，指定返回User对象62*/63public static void queryForObject(JdbcTemplate jdbcTemplate) {64 String sql = "select * from user where name = ?";65// 新建MyRowMapper类实现RowMapper接⼝，重写mapRow⽅法，指定返回User对象66 User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "Tom");67 System.out.println(user);68 }6970/**71 * 功能：查询返回对象集合72 * 步骤：新建MyRowMapper类实现RowMapper接⼝，重写mapRow⽅法，指定返回User对象73*/74public static void queryForList(JdbcTemplate jdbcTemplate) {75 String sql = "select * from user";76// 第三个参数可以省略77 List<User> users = jdbcTemplate.query(sql, new MyRowMapper());78 System.out.println(users);79 }8081/**82 * 使⽤JDBC底层实现查询83*/84public static void queryWithJDBC() {85 Connection conn = null;86 PreparedStatement psmt = null;87 ResultSet rs = null;88 String jdbcUrl = "jdbc:mysql://192.168.184.130:3306/gxrdb";8990try {91// 加载驱动92 Class.forName("com.mysql.jdbc.Driver");93// 创建连接94 conn = DriverManager.getConnection(jdbcUrl, "root", "root");95 String sql = "select * from user where name = ?";96// 预编译sql97 psmt = conn.prepareStatement(sql);98// 从1开始，没有就不需要99 psmt.setString(1, "Tom");100// 执⾏sql101 rs = psmt.executeQuery();102// int num = psmt.executeUpdate(); //增删改，返回操作记录数103104// 遍历结果集105while (rs.next()) {106//根据列名查询对应的值，也可以是位置序号107 String name = rs.getString("name");108 String age = rs.getString("age");109 System.out.println(name);110 System.out.println(age);111 }112 } catch (Exception e) {113 e.printStackTrace();114 } finally {115try {116 rs.close();117 psmt.close();118 conn.close();119 } catch (SQLException e) {120 e.printStackTrace();121 }122 }123 }124125 }MyRowMapper.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.RowMapper;45import java.sql.ResultSet;6import java.sql.SQLException;78/**9 * 实现RowMapper接⼝，返回User对象10 * */11public class MyRowMapper implements RowMapper<User>{1213 @Override14public User mapRow(ResultSet resultSet, int i) throws SQLException { 15// 获取结果集中的数据16 String name = resultSet.getString("name");17 String age = resultSet.getString("age");18// 把数据封装成User对象19 User user = new User();20 user.setName(name);21 user.setAge(age);22return user;23 }24 }JdbcTemplateObject.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.JdbcTemplate;4import org.springframework.jdbc.datasource.DriverManagerDataSource;56/**7 * 功能：设置数据库信息和数据源8 *9 * JdbcTemplat使⽤10 * 1、导⼊jar包；2、设置数据库信息；3、设置数据源；4、调⽤jdbcTemplate对象中的⽅法实现操作11*/12public class JdbcTemplateObject {13 DriverManagerDataSource dataSource;14 JdbcTemplate jdbcTemplate;1516public JdbcTemplateObject() {17// 设置数据库信息18this.dataSource = new DriverManagerDataSource();19this.dataSource.setDriverClassName("com.mysql.jdbc.Driver");20this.dataSource.setUrl("jdbc:mysql://192.168.184.130:3306/gxrdb");21this.dataSource.setUsername("root");22this.dataSource.setPassword("root");2324// 设置数据源25this.jdbcTemplate = new JdbcTemplate(dataSource);2627 }2829public DriverManagerDataSource getDataSource() {30return dataSource;31 }3233public void setDataSource(DriverManagerDataSource dataSource) {34this.dataSource = dataSource;35 }3637public JdbcTemplate getJdbcTemplate() {38return jdbcTemplate;39 }4041public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {42this.jdbcTemplate = jdbcTemplate;43 }44 }User.java1package helloworld.jdbcTemplate;23/**4 * 数据封装类5 * */6public class User {7private String name;8private String age;910public String getName() {11return name;12 }1314public void setName(String name) { = name;16 }1718public String getAge() {19return age;20 }2122public void setAge(String age) {23this.age = age;24 }2526 @Override27public String toString() {28return "User{姓名：" + name + "; 年龄：" + age + "}";29 }30 }。

jdbctemplate调用返游标的存储过程

JdbcTemplate是Spring框架中用于简化数据库操作的一个工具类，通过JdbcTemplate可以方便地进行数据库操作，包括执行SQL语句、调用存储过程等。

在实际应用中，经常需要调用返回游标的存储过程，本文将详细介绍如何使用JdbcTemplate来调用返回游标的存储过程。

存储过程是在数据库中预先编译好的一组SQL语句，通过存储过程可以方便地实现复杂的业务逻辑。

有些存储过程会返回游标，用于返回查询结果集。

在使用JdbcTemplate调用返回游标的存储过程时，需要注意以下几点：1. 编写存储过程需要在数据库中编写一个返回游标的存储过程。

存储过程的语法和数据库的类型有关，这里以Oracle数据库为例，假设有一个名为“get_users”的存储过程，用于返回用户表中的所有用户信息。

```CREATE OR REPLACE PROCEDURE get_users (p_cursor OUTSYS_REFCURSOR) ASBEGINOPEN p_cursor FORSELECT * FROM users;END;```在这个存储过程中，定义了一个输出参数p_cursor，用于返回游标。

游标的类型为SYS_REFCURSOR，可以用于返回查询结果集。

2. 定义JdbcTemplate bean在Spring的配置文件中，需要定义一个JdbcTemplate的bean，并配置数据源等信息。

```<bean id="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"/></bean>```这里假设数据源的名称为dataSource，需要在配置文件中定义数据源的相关信息。

【Spring】利用spring的JdbcTemplate查询返回结果映射到自定义类型

【Spring】利⽤spring的JdbcTemplate查询返回结果映射到⾃定义类型// org.springframework.jdbc.core.JdbcTemplate 中的查询⽅法基本都有⽀持参数RowMapper<T> rowMapper的重载⽅法。

下⾯只是随便举例2个，还有很多public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {...};public <T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {...};//demo01List<Person> person = jdbcTemplate.query(sql, new RowMapper<Person>() {@Overridepublic Person mapRow(ResultSet rs, int i) throws SQLException {Person p = new Person(); //特别需要new，不然如果结果集是list就只有1个对象p.setId(rs.getString("id"));return p;}});//特别如果如demo写，很⿇烦要set很多。

此时spring提供了⼀个RowMapper的实现类BeanPropertyRowMapper//demo02List<Person> person = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Person.class));这篇博客的主要⽬的是分析BeanPropertyRowMapper的实现是怎么样。

java调用存储过程后处理数据的方法

java调用存储过程后处理数据的方法
在Java中调用存储过程后，我们需要对返回的数据进行处理。

以下是一些处理数据的方法：
1. 使用ResultSet对象来获取存储过程返回的结果集。

可以使用ResultSet的getXXX()方法来获取不同类型的数据。

2. 使用CallableStatement对象来调用存储过程，并使用其方法registerOutParameter()来注册输出参数的类型。

然后可以使用getXXX()方法来获取输出参数的值。

3. 使用ORM框架，如Hibernate或MyBatis，可以将存储过程映射为一个Java方法，并使用返回值或输出参数来获取数据。

4. 使用JdbcTemplate（Spring框架中的一个类），可以方便地调用存储过程并获取结果集或输出参数的值。

5. 使用Java8中的Streams API，可以对ResultSet对象进行流式处理，例如使用stream()方法将ResultSet转换为流，然后使用map()、filter()、reduce()等方法来处理数据。

总之，在Java中调用存储过程后，我们有多种处理数据的方式。

我们可以根据具体情况选择最合适的方法。

- 1 -。

SpringJdbcTemplate教程及存储过程

SpringJdbcTemplate教程及存储过程JdbcTemplate主要提供以下五类方法：execute方法：可以用于执行任何SQL语句，一般用于执行DDL 语句；update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；query方法及queryForXXX方法：用于执行查询相关语句；call方法：用于执行存储过程、函数相关语句。

JdbcTemplate类支持的回调类：预编译语句及存储过程创建回调：用于根据JdbcTemplate提供的连接创建相应的语句；PreparedStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的PreparedStatement；CallableStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的CallableStatement；预编译语句设值回调：用于给预编译语句相应参数设值；PreparedStatementSetter：通过回调获取JdbcT emplate提供的PreparedStatement，由用户来对相应的预编译语句相应参数设值；BatchPreparedStatementSetter：；类似于PreparedStatementSetter，但用于批处理，需要指定批处理大小；自定义功能回调：提供给用户一个扩展点，用户可以在指定类型的扩展点执行任何数量需要的操作；ConnectionCallback：通过回调获取JdbcT emplate提供的Connection，用户可在该Connection执行任何数量的操作；StatementCallback：通过回调获取JdbcTemplate提供的Statement，用户可以在该Statement执行任何数量的操作；PreparedStatementCallback：通过回调获取JdbcTemplate提供的PreparedStatement，用户可以在该PreparedStatement执行任何数量的操作；CallableStatementCallback：通过回调获取JdbcT emplate提供的CallableStatement，用户可以在该CallableStatement执行任何数量的操作；结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式；RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。

Oracle存储过程例子返回记录集

Oracle存储过程例⼦返回记录集使⽤多个结果集Oracle 不⽀持批量查询，因此⽆法从⼀个命令返回多个结果集。

使⽤存储过程时，返回多个结果集类似于返回单个结果集；必须使⽤ REF CURSOR 输出参数。

要返回多个结果集，请使⽤多个 REF CURSOR 输出参数。

以下是返回两个结果集（全部 EMPLOYEES 和 JOBS 记录）的包规范：CREATE OR new PACKAGE SELECT_EMPLOYEES_JOBS ASTYPE T_CURSOR IS REF CURSOR;PROCEDURE GetEmployeesAndJobs (cur_Employees OUT T_CURSOR,cur_Jobs OUT T_CURSOR);END SELECT_EMPLOYEES_JOBS;包正⽂如下所⽰：CREATE OR new PACKAGE BODY SELECT_EMPLOYEES_JOBS ASPROCEDURE GetEmployeesAndJobs(cur_Employees OUT T_CURSOR,cur_Jobs OUT T_CURSOR)ISBEGIN-- return all EMPLOYEES recordsOPEN cur_Employees FORSELECT * FROM Employees;-- return all JOBS recordsOPEN cur_Jobs FORSELECT * FROM Jobs;END GetEmployeesAndJobs;END SELECT_EMPLOYEES_JOBS;以下代码显⽰了如何使⽤从上述包中返回的两个结果集来填充 DataSet 中的两个相关表：// create the connectionOracleConnection conn = new OracleConnection("Data Source=oracledb;User Id=UserID;Password=Password;");// define the command for the stored procedureOracleCommand cmd = new OracleCommand();cmd.Connection = conn;mandText = "SELECT_EMPLOYEES_JOBS.GetEmployeesAndJobs";// add the parameters including the two REF CURSOR types to retrieve// the two result setscmd.Parameters.Add("cur_Employees", OracleType.Cursor).Direction =ParameterDirection.Output;cmd.Parameters.Add("cur_Jobs", OracleType.Cursor).Direction =ParameterDirection.Output;mandType = CommandType.StoredProcedure;// create the DataAdapter and map tablesOracleDataAdapter da = new OracleDataAdapter(cmd);da.TableMappings.Add("Table", "EMPLOYEES");da.TableMappings.Add("Table1", "JOBS");// create and fill the DataSetDataSet ds = new DataSet();da.Fill(ds);// create a relationds.Relations.Add("EMPLOYEES_JOBS_RELATION",ds.Tables["JOBS"].Columns["JOB_ID"],ds.Tables["EMPLOYEES"].Columns["JOB_ID"]);// output the second employee (zero-based array) and job title// based on the relationConsole.WriteLine("Employee ID: " +ds.Tables["EMPLOYEES"].Rows[1]["EMPLOYEE_ID"] +"; Job Title: " +ds.Tables["EMPLOYEES"].Rows[1].GetParentRow("EMPLOYEES_JOBS_RELATION")["JOB_TITLE"]);控制台输出显⽰了第⼆个员⼯的职务：Employee ID: 101; Job Title: Administration Vice President。

springjdbc查询结果返回对象、对象列表

springjdbc查询结果返回对象、对象列表⾸先，需要了解spring jdbc查询时，有三种回调⽅式来处理查询的结果集。

可以参考，写得还不错。

1.返回对象(queryForObject)有两种办法，即两个容易混淆的⽅法：//1public Object queryForObject(String sql, Map<String, ?> paramMap, RowMapper rowMapper) {...}//2public Object queryForObject(String sql, Map<String, ?> paramMap, Class requiredType) {...}第⼀种⽅法是需要⼀个实现了RowMapper接⼝的对象实例作为第三个参数，实现RowMapper接⼝的类如下（其中类User.java有id、username、password、dept四个属性。

）：public class UserRowMapper implements RowMapper<User>{@Overridepublic User mapRow(ResultSet rs, int rowNum) throws SQLException {User user = new User();user.setId(rs.getInt(1));user.setUsername(rs.getString(2));user.setPassword(rs.getString(3));user.setDept(4);return user;}}UserRowMapper.java类在dao中使⽤⽅法如下：public User queryForObject(String sql, Map<String, Object> params) {return this.getNamedParameterJdbcTemplate().queryForObject(sql,params,new UserRowMapper());}在JUnit测试，代码如下：@Testpublic void getUser(){String sql = "select * from user where id = :id";Map<String,Object> map = new HashMap<>();map.put("id", 1);User user = dao.queryForObject(sql, map);System.out.println(user.getId());}输出结果为：1。

jdbctemplate.queryforlist 返回对象集合

jdbctemplate.queryforlist 返回对象集合JdbcTemplate 是Spring 框架提供的一个简化数据库操作的工具类，它是对JDBC 进行了封装，提供了许多简单易用的方法。

其中，`queryForList` 方法是JdbcTemplate 中的一个非常重要的查询方法，它用于执行一个SQL 查询，并将结果封装为一个对象集合返回。

在本篇文章中，我们将逐步介绍`queryForList` 方法的使用，包括参数的含义和用法、返回的对象集合类型以及如何进一步处理返回结果。

# 1. queryForList 方法的概述`queryForList` 方法是JdbcTemplate 类中的一个查询方法，它的定义如下：javapublic List<Map<String, Object>> queryForList(String sql, Object... args)该方法接受两个参数：- `sql`：需要执行的SQL 查询语句，通常是一个SELECT 语句。

- `args`：查询语句中的参数，如果有的话。

`queryForList` 方法的返回结果是一个List<Map<String, Object>> 对象，其中每个元素都是一个Map，代表查询结果的一行数据。

Map 的键是列名（类型为String），值为对应的列值（类型为Object）。

# 2. 使用queryForList 方法执行查询操作接下来，我们将演示如何使用`queryForList` 方法来执行一个简单的查询操作。

假设我们有一个名为`employees` 的表，其中包含以下列：`id`、`name`、`age` 和`gender`。

首先，我们需要创建一个JdbcTemplate 实例，并配置数据源。

例如：javaDataSource dataSource = new DriverManagerDataSource(url, username, password);JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);接着，我们可以使用`queryForList` 方法来执行查询操作。

用jdbcTempate调用存储过程

利用spring的jdbcTemplate调用存储过程 假如我们有P_GET_TOPIC_NUM这一个存储过程,有两个参数,第一个参数userId是传进去的,第二个参数是传出来的,举例如下: Java代码 public int getUserTopicNum(final int userId) { &nb sp;    String sql = ";{call P_GET_TOPIC_NUM (?,?)}";;      //使用?   Object execute(String callString, CallableSt atementCallback action)接口      Object obj = getJdbcTemplate().execute(sq l,new CallableStatementCallback(){          public Object doInCall ableStatement(CallableStatement cs) throws SQLException, Dat aAccessException {              cs.setIn t(1,userId);              cs.regis terOutParameter(2, Types.INTEGER);              cs.execu te();              return&n bsp;new Integer(cs.getInt(2));          }          });      return ((Integer)obj).intValue();   }  。

oracle存储过程返回结果集的方法

oracle存储过程返回结果集的方法标题：Oracle存储过程返回结果集的方法摘要：在Oracle数据库中，存储过程是一种强大的特性，用于执行一系列的数据库操作。

本文将介绍如何在Oracle存储过程中返回结果集的方法，包括使用游标、临时表和函数等方式，以及它们的优缺点。

一、使用游标返回结果集1. 定义游标：在存储过程中，可以使用游标来返回结果集。

首先需要声明一个游标变量，并为其提供一个SELECT语句，该SELECT 语句用于生成结果集。

2. 打开游标：在定义游标后，需要使用OPEN语句来打开游标，这样才能开始获取结果集中的数据。

3. 获取数据：通过使用FETCH语句可以逐行获取结果集中的数据，并将其存储到合适的变量中。

可以使用循环控制结构来遍历整个结果集。

4. 关闭游标：在完成结果集的遍历后，需要使用CLOSE语句关闭游标，以释放系统资源。

优点：使用游标返回结果集的方法比较简单直观，适用于结果集较小的情况。

缺点：当结果集较大时，使用游标返回可能会导致性能问题。

二、使用临时表返回结果集1. 创建临时表：在存储过程中，可以创建一个临时表，用于存储结果集中的数据。

临时表可以通过CREATE GLOBAL TEMPORARY TABLE语句来创建，并在存储过程中使用INSERT INTO语句将结果集中的数据插入到临时表中。

2. 查询临时表：在存储过程中，可以使用SELECT语句查询临时表，获取结果集中的数据。

可以使用循环控制结构来遍历整个结果集。

3. 删除临时表：在完成结果集的使用后，需要使用DROP TABLE语句删除临时表，以释放系统资源。

优点：使用临时表返回结果集的方法比较灵活，适用于结果集较大的情况。

缺点：需要额外的空间来存储临时表，比较消耗系统资源。

三、使用函数返回结果集1. 创建函数：在存储过程中，可以创建一个函数，用于返回结果集。

函数可以通过CREATE FUNCTION语句来创建，并在存储过程中使用SELECT语句从函数中获取结果集。

java调用Oracle存储过程方式汇总

spring调用Oracle存储过程，并用cursor返回结果集1. 创建表：Java代码1.create table TEST_USERS2.(3. USER_ID VARCHAR2(10) not null,4. NAME VARCHAR2(10) not null,5. PASSWORD VARCHAR2(20) not null6.)2. 创建存储过程：Java代码1.create or replace package display_users_package is2. type search_results is ref cursor;3. procedure display_users_proc(results_out out search_results, userId in test_er_id%type);4.end display_users_package;5.6.create or replace package body display_users_package is7. procedure display_users_proc(results_out out search_results, userId in test_er_id%type)8. is9. begin10. if userId is not null then11. open results_out for select * from test_users where user_id like userId || '%';12. else13. open results_out for select * from test_users;14. end if;15. end display_users_proc;16.end display_users_package;这个results_out是一个游标类型，用来返回查找的结果集。

jdbctemplate的方法

jdbctemplate的方法jdbcTemplate的方法jdbcTemplate是Spring框架中的一个核心类，用于简化数据库操作。

它提供了一系列方法，用于执行SQL语句、处理结果集、处理事务等操作。

本文将详细介绍jdbcTemplate的常用方法及其使用。

一、execute()方法execute()方法用于执行任意的SQL语句，可以是DDL语句、DML语句或存储过程等。

例如：```String sql = "CREATE TABLE user (id INT PRIMARY KEY, name VARCHAR(50))";jdbcTemplate.execute(sql);```上述代码创建了一个名为user的表。

二、query()方法query()方法用于执行查询操作，并返回结果集。

它接受三个参数：SQL语句、参数数组和RowMapper对象。

参数数组用于传递SQL语句中的参数，RowMapper对象用于将结果集中的每一行映射成Java 对象。

例如：```String sql = "SELECT * FROM user WHERE age > ?";Object[] params = new Object[]{18};RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);List<User> userList = jdbcTemplate.query(sql, params, rowMapper);```上述代码执行了一个带参数的查询操作，并将结果集映射成User对象的List。

三、update()方法update()方法用于执行插入、更新和删除操作，并返回受影响的行数。

它接受两个参数：SQL语句和参数数组。

例如：```String sql = "INSERT INTO user (name, age) VALUES (?, ?)"; Object[] params = new Object[]{"Tom", 20};int rows = jdbcTemplate.update(sql, params);```上述代码插入了一条记录，并返回受影响的行数。

SpringJdbcTemplate操作小结

SpringJdbcTemplate操作⼩结Spring提供了JdbcTemplate 来封装数据库jdbc操作细节：包括：数据库连接[打开/关闭]，异常转义，SQL执⾏，查询结果的转换使⽤模板⽅式封装 jdbc数据库操作-固定流程的动作，提供丰富callback回调接⼝功能，⽅便⽤户⾃定义加⼯细节，更好模块化jdbc操作，简化传统的JDBC操作的复杂和繁琐过程。

1) 使⽤JdbcTemplate 更新(insert /update /delete)Java代码1. int k = jdbcTemplate.update("UPDATE tblname SET prop1=?,prop2=?...", new Object[]{...});Java代码1. jdbcTemplate.update("INSERT INTO tblname VALUES(?,?,..)", new Object[]{...},2. new int[]{Types.VARCHAR,Types.NUMERIC});Java代码1. jdbcTemplate.update("INSERT INTO tblname VALUES(?,?,..)",2. new PreparedStatementSetter(){3. public void setValues(PreparedStatement ps) throws SQLException{4. ps.setLong(1, user.getId(1));5. ps.setString(2, user.getName(2));6. ps.setDate(3, new java.sql.Date(new Date().getTime());7. ps.setTimestamp(4, new Timestamp(new Date().getTime());8. }9. }10. );2) 使⽤JdbcTemplate 查询 (select)Java代码1. final User user = new User();2. jdbcTemplate.query("SELECT id,name,.. FROM tblname WHERE id=1",3. new RowCallbackHandler(){4. public void processRow(ResultSet rs) throws SQLException{5. user.setId(rs.getLong(1));6. user.setName(rs.getString(2));7. }8. }9. );Java代码1. List uGroup = jdbcTemplate.query("SELECT id,name,.. FROM tblname WHERE igroup=1",2. new RowMapper(){3. public Object mapRow(ResultSet rs,int no) throws SQLException{4. User user = new User();5. user.setId(rs.getLong(1));6. user.setName(rs.getString(2));7. return user ;8. }10. };3)使⽤JdbcTemplate 便捷⽅法Java代码1. List uNames = jdbcTemplate.queryForList("SELECT name FROM tblname WHERE id>?",2. new Integer []{5}, String.class);Java代码1. List<Map> uMapList = (List<Map>) jdbcTemplate.queryForList( "SELECT id, name FROM tblname WHERE id>?",2. new Integer []{5});3. for(Map<String,Object> uMap :uMapList){4. Integer id = uMap.get("id");5. String name = uMap.get("name");6. };Java代码1. String user = jdbcTemplate.queryForObject("SELECT name FROM tblname WHERE id=?",2. new Integer []{5}, String.class );Java代码1. int uNum = jdbcTemplate.queryForInt("SELECT count(*) FROM tblname WHERE id>?",2. new Integer []{5});4)使⽤jdbc 操作类a)扩展 MappingSqlQuery类Java代码1. class JdbcQueryObject extends MappingSqlQuery { // extends SqlQuery2. public JdbcQueryObject (DataSource ds,String sql){3. this.setDataSource( ds );4. this.setSql( sql );5. this.declareParameter(new Sqlparameter("propName",6. Types.VARCHAR);// propName 提⽰作⽤7. pile();8. }9. public Object mapRow(ResultSet rs,int p) throws SQLException{10. // ...11. }12. }13. JdbcQueryObject queryObj = new JdbcQueryObject( ds,14. "SELECT .. FROM tblName WHERE param=?");15. List list = queryObj.execute(new Object[]{...});b)使⽤ SqlFunction 类查询单条结果Java代码1. SqlFunction queryFun = new SqlFunction( ds,2. "select count(*) from tblName where ..." ,new int[]{Types.CHAR,...} );3. pile();4. queryFun.run(new Object[]{p1,p2,..});c)使⽤ SqlUpdate 类更新1. SqlUpdate updateFunc = new SqlUpdate(ds ,"INSERT tblName ...");2. updateFunc.declareParameter( new SqlParameter("prop",Types.CHAR) );3. pile();4. updateFunc.update(new String[]{s1,s1});5)⽀持jdbc 事务spring的事务管理有两种⽅式：编程式事务、声明式事务这⾥谈⼀下基于数据库单⼀资源的编程式事务:spring⽤实现TransactionDefinition接⼝的类定义事务的属性：传播⾏为；隔离级别；超时值；只读标志默认实现为：DefaultTransactionDefinition类Java代码1. PlatformTransactionManager tm =2. new DataSourceTransactionManager(3. jdbcTemplate.getDataSource() );4. TransactionStatus status = null;5. try{6. //null 默认事务属性配置DefaultTransactionDefinition7. status = tm.getTransaction(null);8. for(final String wd: words){9. try {10. jdbcTemplate.update( insertWordSql,11. new PreparedStatementSetter(){12.13. public void setValues(PreparedStatement pstate)14. throws SQLException {15. pstate.setString(1, wd) ;16. pstate.setTimestamp(2,17. new Timestamp( new Date().getTime() ));18. }19. }20. );21.22. } catch (DataAccessException e) {23. e.printStackTrace();24. //tm.rollback(status);25. }26. } // end for27. } finally {28. mit(status);29. }30. ------------------------------------------------------------------------------------------------------------------------------------------------31. 当hql等查询⽅式不能满⾜性能或灵活性的要求，必须使⽤SQL时，⼤家有三种选择：第⼀、使⽤Hibernate 的sql 查询函数，将查询结果对象转为Entity对象。

jdbc调用Oracle数据库存储过程

/blog/1582331 Java jdbc调用Oracle数据库存储过程一、了解CallableStatement接口1.callablestatement接口提供了两种调用形式{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} //包含结果参数的调用形式如：函数（funciton）{call <procedure-name>[(<arg1>,<arg2>, ...)]} //不包含结果参数的调用形式如：存储过程（procedure）2.callablestatement接口提供的方法Java代码1.void registerOutParameter(int parameterIndex, int sqlType)2.throws SQLException; //在调用存储过程的时候设置输出参数的类型，用于接收输出结果registerOutParameter接口中有四个该方法的重载实现，具体的可以查看源码了解Java代码1.setXXX(int parameterIndex,XXX x) //主要用于设置过程调用时候需要的输入参数信息其中XXX代表对应类型Java代码1.getXXX(int x) //主要用于获取过程调用后返回的参数的信息3.callablestatement接口产生的异常提示如下源码：Java代码1./*2.* @exception SQLFeatureNotSupportedException if<code>sqlType</code> is3.* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,4.* <code>DATALINK</code>, <code>JAVA_OBJECT</code>,<code>NCHAR</code>,5.* <code>NCLOB</code>, <code>NVARCHAR</code>,<code>LONGNVARCHAR</code>,6.* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>7.* or <code>STRUCT</code> data type and the JDBC driver does notsupport8.* this data type9.* @see Types10.*/11.void registerOutParameter(int parameterIndex, int sqlType)12.ows SQLException;当我们使用registerOutParameter方法设置输出参数类型的时候，需要注意对于某一些类型是不能够进行设置的如上中所以提到的类型都会引发SQLFeatureNotSupportedException异常，对于能够支持的类型可以查看java.sql.Types和oracle.jdbc.OracleTypes如下源码：Java代码1./*2.* java.sql.SQLException: 不允许的操作: Ordinal binding and Namedbinding cannot be3.* combined! at4.*oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:112) at5.*oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:146) at6.* oracle7.* .jdbc.driver.OracleCallableStatement.execute(OracleCallableStatement.java8.* :4219) at9.*org.viancent.call.procedure.CallProcedure.main(CallProcedure.ja va:36)10.*/当我们在给过程设置参数信息的时候，不能够同时使用下标和名称来指定对应参数的。