`
jitaguizhao
  • 浏览: 150834 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

spring jdbc 调用存储过程

JDBCSpringJavaSQLjunit 
阅读更多
Java代码 复制代码
  1. create table TEST_USERS    
  2. (    
  3.   USER_ID  VARCHAR2(10) not null,    
  4.   NAME     VARCHAR2(10) not null,    
  5.   PASSWORD VARCHAR2(20) not null    
  6. )  
create table TEST_USERS 
( 
  USER_ID  VARCHAR2(10) not null, 
  NAME     VARCHAR2(10) not null, 
  PASSWORD VARCHAR2(20) not null 
)



2. 创建存储过程：

Java代码 复制代码
  1. create or replace package display_users_package is    
  2.      type search_results is ref cursor;    
  3.      procedure display_users_proc(results_out out search_results, userId in test_users.user_id%type);    
  4. end display_users_package;    
  5.   
  6. create or replace package body display_users_package is    
  7.      procedure display_users_proc(results_out out search_results, userId in test_users.user_id%type)    
  8.           is    
  9.           begin    
  10.           if userId is not null then    
  11.               open results_out for select * from test_users where user_id like userId || '%';    
  12.           else    
  13.               open results_out for  select * from test_users;    
  14.           end if;    
  15.       end display_users_proc;    
  16. end display_users_package;  
create or replace package display_users_package is 
     type search_results is ref cursor; 
     procedure display_users_proc(results_out out search_results, userId in test_users.user_id%type); 
end display_users_package; 

create or replace package body display_users_package is 
     procedure display_users_proc(results_out out search_results, userId in test_users.user_id%type) 
          is 
          begin 
          if userId is not null then 
              open results_out for select * from test_users where user_id like userId || '%'; 
          else 
              open results_out for  select * from test_users; 
          end if; 
      end display_users_proc; 
end display_users_package;



这个results_out是一个游标类型，用来返回查找的结果集。

3.　完整实现代码：

Java代码 复制代码
  1. import java.sql.CallableStatement;   
  2. import java.sql.Connection;   
  3. import java.sql.ResultSet;   
  4. import java.sql.SQLException;   
  5. import java.util.ArrayList;   
  6. import java.util.HashMap;   
  7. import java.util.List;   
  8. import java.util.Map;   
  9.   
  10. import javax.sql.DataSource;   
  11.   
  12. import oracle.jdbc.OracleTypes;   
  13.   
  14. import org.springframework.dao.DataAccessException;   
  15. import org.springframework.jdbc.core.CallableStatementCallback;   
  16. import org.springframework.jdbc.core.CallableStatementCreator;   
  17. import org.springframework.jdbc.core.JdbcTemplate;   
  18.   
  19. import com.spring.stored.procedure.util.DataContextUtil;   
  20.   
  21. /**  
  22.  * @author Jane Jiao  
  23.  *  
  24.  */  
  25. public class SpringStoredProce {   
  26.        
  27.     public List<Map> execute(String storedProc, String params){   
  28.         List<Map> resultList = null;   
  29.         try{   
  30.             final DataSource ds = DataContextUtil.getInstance().getDataSource();   
  31.             final JdbcTemplate template = new JdbcTemplate(ds);   
  32.             resultList = (List<Map>)template.execute(new ProcCallableStatementCreator(storedProc, params),   
  33.                                                      new ProcCallableStatementCallback());   
  34.         }catch(DataAccessException e){   
  35.             throw new RuntimeException("execute method error : DataAccessException " + e.getMessage());   
  36.         }   
  37.          return resultList;   
  38.     }   
  39.        
  40.        
  41.     /**  
  42.      * Create a callable statement in this connection.  
  43.      */  
  44.     private class ProcCallableStatementCreator implements CallableStatementCreator {   
  45.         private String storedProc;   
  46.         private String params;   
  47.            
  48.        
  49.         /**  
  50.          * Constructs a callable statement.  
  51.          * @param storedProc                  The stored procedure's name.  
  52.          * @param params                      Input parameters.  
  53.          * @param outResultCount              count of output result set.  
  54.          */  
  55.         public ProcCallableStatementCreator(String storedProc, String params) {   
  56.             this.params = params;   
  57.             this.storedProc = storedProc;   
  58.         }   
  59.            
  60.         /**  
  61.          * Returns a callable statement  
  62.          * @param conn          Connection to use to create statement  
  63.          * @return cs           A callable statement  
  64.          */  
  65.         public CallableStatement createCallableStatement(Connection conn) {   
  66.             StringBuffer storedProcName = new StringBuffer("call ");   
  67.             storedProcName.append(storedProc + "(");   
  68.             //set output parameters   
  69.             storedProcName.append("?");   
  70.             storedProcName.append(", ");   
  71.                
  72.             //set input parameters   
  73.             storedProcName.append("?");   
  74.             storedProcName.append(")");   
  75.   
  76.             CallableStatement cs = null;   
  77.             try {   
  78.                 // set the first parameter is OracleTyep.CURSOR for oracel stored procedure   
  79.                 cs = conn.prepareCall(storedProcName.toString());   
  80.                 cs.registerOutParameter (1, OracleTypes.CURSOR);   
  81.                // set the sencond paramter   
  82.                 cs.setObject(2, params);   
  83.             } catch (SQLException e) {   
  84.                 throw new RuntimeException("createCallableStatement method Error : SQLException " + e.getMessage());   
  85.             }   
  86.             return cs;   
  87.         }   
  88.            
  89.     }   
  90.        
  91.     /**  
  92.      *   
  93.      * The ProcCallableStatementCallback return a result object,   
  94.      * for example a collection of domain objects.  
  95.      *  
  96.      */  
  97.     private class ProcCallableStatementCallback implements CallableStatementCallback {   
  98.            
  99.         /**  
  100.          * Constructs a ProcCallableStatementCallback.  
  101.          */  
  102.         public ProcCallableStatementCallback() {   
  103.         }   
  104.   
  105.         /**  
  106.          * Returns a List(Map) collection.  
  107.          * @param cs                       object that can create a CallableStatement given a Connection  
  108.          * @return resultsList             a result object returned by the action, or null  
  109.          */  
  110.         public Object doInCallableStatement(CallableStatement cs){   
  111.             List<Map> resultsMap =  new ArrayList<Map>();   
  112.             try {   
  113.                 cs.execute();    
  114.                 ResultSet rs = (ResultSet) cs.getObject(1);   
  115.                 while (rs.next()) {   
  116.                     Map<String, String> rowMap = new HashMap<String, String>();   
  117.                     rowMap.put("userId", rs.getString("USER_ID"));   
  118.                     rowMap.put("name", rs.getString("NAME"));   
  119.                     rowMap.put("password", rs.getString("PASSWORD"));   
  120.                     resultsMap.add(rowMap);   
  121.                 }      
  122.                 rs.close();   
  123.             }catch(SQLException e) {   
  124.                 throw new RuntimeException("doInCallableStatement method error : SQLException " + e.getMessage());   
  125.             }   
  126.             return resultsMap;   
  127.        }   
  128.     }   
  129. }  
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import oracle.jdbc.OracleTypes;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.CallableStatementCallback;
import org.springframework.jdbc.core.CallableStatementCreator;
import org.springframework.jdbc.core.JdbcTemplate;

import com.spring.stored.procedure.util.DataContextUtil;

/**
 * @author Jane Jiao
 *
 */
public class SpringStoredProce {
	
	public List<Map> execute(String storedProc, String params){
		List<Map> resultList = null;
		try{
			final DataSource ds = DataContextUtil.getInstance().getDataSource();
			final JdbcTemplate template = new JdbcTemplate(ds);
			resultList = (List<Map>)template.execute(new ProcCallableStatementCreator(storedProc, params),
					                                 new ProcCallableStatementCallback());
	    }catch(DataAccessException e){
	    	throw new RuntimeException("execute method error : DataAccessException " + e.getMessage());
	    }
	     return resultList;
	}
	
	
	/**
	 * Create a callable statement in this connection.
	 */
	private class ProcCallableStatementCreator implements CallableStatementCreator {
		private String storedProc;
		private String params;
		
	
		/**
		 * Constructs a callable statement.
		 * @param storedProc                  The stored procedure's name.
		 * @param params                      Input parameters.
		 * @param outResultCount              count of output result set.
		 */
		public ProcCallableStatementCreator(String storedProc, String params) {
			this.params = params;
			this.storedProc = storedProc;
		}
		
		/**
		 * Returns a callable statement
		 * @param conn          Connection to use to create statement
		 * @return cs           A callable statement
		 */
		public CallableStatement createCallableStatement(Connection conn) {
			StringBuffer storedProcName = new StringBuffer("call ");
			storedProcName.append(storedProc + "(");
			//set output parameters
			storedProcName.append("?");
			storedProcName.append(", ");
			
			//set input parameters
			storedProcName.append("?");
			storedProcName.append(")");

			CallableStatement cs = null;
			try {
		        // set the first parameter is OracleTyep.CURSOR for oracel stored procedure
				cs = conn.prepareCall(storedProcName.toString());
				cs.registerOutParameter (1, OracleTypes.CURSOR);
			   // set the sencond paramter
		    	cs.setObject(2, params);
			} catch (SQLException e) {
				throw new RuntimeException("createCallableStatement method Error : SQLException " + e.getMessage());
			}
		    return cs;
		}
		
	}
	
	/**
	 * 
	 * The ProcCallableStatementCallback return a result object, 
	 * for example a collection of domain objects.
	 *
	 */
	private class ProcCallableStatementCallback implements CallableStatementCallback {
		
		/**
		 * Constructs a ProcCallableStatementCallback.
		 */
		public ProcCallableStatementCallback() {
		}

		/**
		 * Returns a List(Map) collection.
		 * @param cs                       object that can create a CallableStatement given a Connection
		 * @return resultsList             a result object returned by the action, or null
		 */
		public Object doInCallableStatement(CallableStatement cs){
			List<Map> resultsMap =  new ArrayList<Map>();
			try {
				cs.execute(); 
				ResultSet rs = (ResultSet) cs.getObject(1);
	            while (rs.next()) {
	            	Map<String, String> rowMap = new HashMap<String, String>();
	            	rowMap.put("userId", rs.getString("USER_ID"));
	            	rowMap.put("name", rs.getString("NAME"));
	            	rowMap.put("password", rs.getString("PASSWORD"));
	            	resultsMap.add(rowMap);
	            }	
	    		rs.close();
	        }catch(SQLException e) {
	        	throw new RuntimeException("doInCallableStatement method error : SQLException " + e.getMessage());
	        }
            return resultsMap;
	   }
	}
}



4.　测试代码，在这里使用了Junit4测试：

Java代码 复制代码
  1. import static org.junit.Assert.assertNotNull;    
  2. import static org.junit.Assert.assertTrue;    
  3.   
  4. import java.util.List;    
  5. import java.util.Map;    
  6.   
  7. import org.junit.After;    
  8. import org.junit.Before;    
  9. import org.junit.Test;    
  10.   
  11. /**   
  12.  * @author Jane Jiao   
  13.  *   
  14.  */    
  15. public class SpringStoredProceTest {    
  16.        
  17.    private SpringStoredProce springStoredProce;    
  18.   
  19.    /**   
  20.     * @throws java.lang.Exception   
  21.     */    
  22.    @Before    
  23.    public void setUp() throws Exception {    
  24.       springStoredProce = new SpringStoredProce();    
  25.    }    
  26.   
  27.    /**   
  28.     * @throws java.lang.Exception   
  29.     */    
  30.    @After    
  31.    public void tearDown() throws Exception {    
  32.       springStoredProce = null;    
  33.    }    
  34.   
  35.    /**   
  36.     * Test method for {@link com.hactl.listingframework.dao.SpringStoredProce#execute(java.lang.String, java.lang.String)}.   
  37.     */    
  38.    @Test    
  39.    public void testExecute() {    
  40.       final String storedProcName = "display_users_package.display_users_proc";    
  41.       final String param = "test";    
  42.       List<Map> resultList = springStoredProce.execute(storedProcName, param);    
  43.       assertNotNull(resultList);    
  44.       assertTrue(resultList.size() > 0);    
  45.       for (int i = 0; i < resultList.size(); i++) {    
  46.          Map rowMap = resultList.get(i);    
  47.          final String userId = rowMap.get("userId").toString();    
  48.          final String name = rowMap.get("name").toString();    
  49.          final String password = rowMap.get("password").toString();    
  50.          System.out.println("USER_ID=" + userId + "\t name=" + name + "\t password=" + password);    
  51.       }    
  52.           
  53.    }    
  54. }  
分享到：
| svhost病毒处理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring JdbcTemplate调用Oracle存储过程实现CRUD

    对于 `P_EMP_SELECT` 存储过程，我们使用 `CallableStatementCallback` 对象调用存储过程，并将结果集处理到 `List` 集合中。 对于 `P_EMP_ADD` 存储过程，我们使用 `CallableStatementCallback` 对象调用存储过程...

    Spring+Jdbc scott用户的调用存储过程

    压缩包中的“Spring10SpringJDBC2”文件名可能暗示包含的是关于Spring JDBC的第十章内容或者是关于Spring JDBC的进阶部分，可能包括了如何调用存储过程的示例代码或更详细的教程。 综上所述，本主题涵盖的知识点...

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

    Spring jdbcTemplate 调用 Oracle 存储过程...我们创建了一个简单的存储过程，用于查询员工信息，并使用 Spring jdbcTemplate 调用存储过程来获取结果集。这种方法可以帮助我们简化数据库操作，并提高应用程序的性能。

    spring_JDBC整合包

    此外，Spring JDBC也支持存储过程的调用，以及批量更新操作。在处理大量数据时，还可以通过分页查询来优化性能。在分布式环境下，Spring JDBC配合Spring的事务管理功能，可以实现跨数据库操作的事务一致性。 这个...

    SpringJDBC.rar_SpringJDBC_spring jdbc

    `SimpleJdbcInsert`和`SimpleJdbcCall`则分别用于简化插入操作和调用存储过程。 1. **JdbcTemplate使用**： - **连接管理**：Spring JDBC通过DataSource来管理数据库连接，DataSource是一个接口，实现了数据库连接...

    spring-jdbc jar包.rar

    1. **JdbcTemplate**：这是Spring JDBC的核心类，它通过模板方法模式将常见的JDBC操作进行了封装，如执行SQL查询、更新、调用存储过程等。开发者只需要关注SQL语句和参数，而无需处理连接创建、关闭、异常处理等繁琐...

    spring对jdbc的支持jar包

    2. **SimpleJdbcInsert** 和 **SimpleJdbcCall**：这两个类分别简化了插入操作和调用存储过程的过程。SimpleJdbcInsert可以自动计算生成主键值，而SimpleJdbcCall则允许开发者方便地定义和执行数据库的存储过程。 3...

    Spring JDBC应用实例讲解

    Spring JDBC同样支持存储过程的调用。我们可以通过SimpleJdbcCall类来定义并执行存储过程，同样可以设置入参和出参，处理复杂的数据交互场景。 **8. 异常处理** Spring JDBC将数据库异常转换为Spring的...

    SpringJDBC训练素材.zip

    此外，Spring JDBC还支持CallableStatement，用于调用数据库的存储过程。通过JdbcTemplate的call()方法，你可以传入CallableStatementCreator，然后执行存储过程并获取结果。 总之，Spring JDBC是一个强大且灵活的...

    Spring事务管理和SpringJDBC思维导图

    此外，SimpleJdbcInsert、SimpleJdbcCall等辅助类进一步简化了插入和调用存储过程的操作。 Spring JDBC还引入了RowMapper接口，这是一个回调接口，用于将数据库结果集中的每一行映射为一个Java对象。此外，...

    SpringMVC+SpringJDBC

    2. **SimpleJdbcInsert** 和 **SimpleJdbcCall**：简化插入记录和调用存储过程的操作。 3. **Transaction Management**：SpringJDBC支持声明式和编程式事务管理，使得事务控制更加简洁和健壮。 4. **DataSource**...

    SpringJDBC.rar_jdbc spring_spring jd_spring jdbc_spring使用JDBC进行数

    2. **JdbcTemplate**：这是Spring JDBC最常用的工具类，提供了大量的模板方法，用于执行SQL查询、更新、调用存储过程等操作，大大减少了手动处理结果集和异常的情况。 3. **SimpleJdbcTemplate**：这是JdbcTemplate...

    Spring Jdbc的jar包

    此外，Spring JDBC的`JdbcOperations`接口扩展了`JdbcTemplate`，提供了一组通用的JDBC操作，包括执行SQL查询、调用存储过程等。`NamedParameterJdbcTemplate`则是另一个扩展，它支持命名参数的SQL查询，使得查询...

    Spring JDBC相关jar包：spring_jdbc_4.0.0.zip

    7. **存储过程**：通过`call`方法，`JdbcTemplate`也可以调用数据库中的存储过程，支持输入、输出和InOut参数。 8. **自定义SQL执行**：除了提供预定义的方法，`JdbcTemplate`还允许开发人员自定义SQL执行逻辑，...

    SpringJDBC工程对应Jar包

    其次，Spring JDBC还引入了`SimpleJdbcInsert`和`SimpleJdbcCall`，分别用于简化插入操作和调用存储过程。`SimpleJdbcInsert`可以根据表结构自动生成INSERT语句，而`SimpleJdbcCall`则可以方便地调用数据库中的存储...

    springboot整合mybatis调用oracle存储过程

    本文将深入探讨如何在Spring Boot项目中整合MyBatis，实现调用Oracle存储过程并处理游标返回的数据。 首先，我们需要在Spring Boot项目中引入相关的依赖。在`pom.xml`文件中添加Oracle JDBC驱动（ojdbc66-oracle...

    SpringMVC+Spring+SpringJDBC

    SpringMVC、Spring和SpringJDBC是Spring框架的三个重要组成部分，它们协同工作，提供了从用户接口到数据存储的完整解决方案。下面将详细介绍这三个组件及其整合方式。 **1. SpringMVC** SpringMVC（Model-View-...

    Spring Data JDBC与JDBC的区别

    7. **CallableStatement**: 用于调用数据库存储过程。 8. **ResultSet**: 存储查询结果，包含多条记录，可以迭代遍历。 而Spring Data JDBC是Spring框架的一部分，它简化了数据库操作，提供了更高层次的抽象。相比...

    Spring mvc、 Spring、 Spring jdbc 整合 demo

    本示例"Spring mvc、Spring、Spring jdbc 整合 demo"着重展示了Spring框架的三大关键模块：Spring MVC（模型-视图-控制器）、Spring Core以及Spring JDBC的集成与应用。 1. **Spring MVC** Spring MVC是Spring框架...

Magicbox
Global site tag (gtag.js) - Google Analytics