今天写了一个调用存储过程的方法

1、接口

   /**
 * 调用存储过程
 *
 * @param procName 存储过程名. 如：testProcParam、mypack.testProcParam
 * @param inParams 输入参数映射对象. 格式为：索引号->值
 * @param outTypes 输出参数类型映射对象. 格式为：索引号->类型
 * @return Map<Integer, Object> 输出结果映射对象. 格式为：索引号->值
 */
public Map<Integer, Object> callProcedure(String procName,
        Map<Integer, Object> inParams, Map<Integer, Integer> outTypes);

    /**
	 * 调用存储过程
	 * 
	 * @param procName 存储过程名. 如：testProcParam、mypack.testProcParam
	 * @param inParams 输入参数映射对象. 格式为：索引号->值
	 * @param outTypes 输出参数类型映射对象. 格式为：索引号->类型
	 * @return Map<Integer, Object> 输出结果映射对象. 格式为：索引号->值
	 */
	public Map<Integer, Object> callProcedure(String procName, 
			Map<Integer, Object> inParams, Map<Integer, Integer> outTypes);

2、实现方法

public Map<Integer, Object> callProcedure(final String procName,
        final Map<Integer, Object> inParams, final Map<Integer, Integer> outTypes) {
    return (Map<Integer, Object>) getHibernateTemplate().executeWithNativeSession(new HibernateCallback(){
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            // 输出参数结果
            Map<Integer, Object> resultMap = new HashMap<Integer, Object>();

            // 参数个数
            int paramCount = 0;

            // 存放问号的字符串. 如?或?,?...
            String questionMark = "";

            // 计算问号个数
            if (MapUtils.isNotEmpty(inParams)) {
                paramCount += inParams.size();
            }
            if (MapUtils.isNotEmpty(outTypes)) {
                paramCount += outTypes.size();
            }

            // 设置问号字符串, 以逗号隔开
            for (int i = 0; i < paramCount; i++) {
                questionMark += "?,";
            }
            if (!"".equals(questionMark)) questionMark = questionMark.substring(0, questionMark.length() - 1);

            // 获取数据库连接
            Connection con = session.connection();

            // 创建调用存储过程的CallableStatement对象
            String sql = "{call " + procName + "(" + questionMark + ")}";
            CallableStatement cstmt = con.prepareCall(sql);

            // 设置输入参数
            if (MapUtils.isNotEmpty(inParams))
                for (Map.Entry<Integer, Object> entry : inParams.entrySet()) {
                    cstmt.setObject(entry.getKey(), entry.getValue());
                }

            // 注册输出参数
            if (MapUtils.isNotEmpty(outTypes))
                for (Map.Entry<Integer, Integer> entry : outTypes.entrySet()) {
                    cstmt.registerOutParameter(entry.getKey(), entry.getValue());
                }

            // 执行存储过程
            cstmt.execute();

            // 获取输出参数结果
            if (MapUtils.isNotEmpty(outTypes))
                for (Map.Entry<Integer, Integer> entry : outTypes.entrySet()) {
                    resultMap.put(entry.getKey(), cstmt.getObject(entry.getKey()));
                }

            return resultMap;
        }
    });
}

	public Map<Integer, Object> callProcedure(final String procName,
			final Map<Integer, Object> inParams, final Map<Integer, Integer> outTypes) {
		return (Map<Integer, Object>) getHibernateTemplate().executeWithNativeSession(new HibernateCallback(){
			public Object doInHibernate(Session session) throws HibernateException, SQLException {
				// 输出参数结果
				Map<Integer, Object> resultMap = new HashMap<Integer, Object>();
				
				// 参数个数
				int paramCount = 0;
				
				// 存放问号的字符串. 如?或?,?...
				String questionMark = "";
				
				// 计算问号个数
				if (MapUtils.isNotEmpty(inParams)) {
					paramCount += inParams.size();
				}
				if (MapUtils.isNotEmpty(outTypes)) {
					paramCount += outTypes.size();
				}
				
				// 设置问号字符串, 以逗号隔开
				for (int i = 0; i < paramCount; i++) {
					questionMark += "?,";
				}
				if (!"".equals(questionMark)) questionMark = questionMark.substring(0, questionMark.length() - 1);

				// 获取数据库连接
				Connection con = session.connection();
				
				// 创建调用存储过程的CallableStatement对象
				String sql = "{call " + procName + "(" + questionMark + ")}";
				CallableStatement cstmt = con.prepareCall(sql);
				
				// 设置输入参数
				if (MapUtils.isNotEmpty(inParams))
					for (Map.Entry<Integer, Object> entry : inParams.entrySet()) {
						cstmt.setObject(entry.getKey(), entry.getValue());
					}

				// 注册输出参数
				if (MapUtils.isNotEmpty(outTypes))
					for (Map.Entry<Integer, Integer> entry : outTypes.entrySet()) {
						cstmt.registerOutParameter(entry.getKey(), entry.getValue());
					}
				
				// 执行存储过程
				cstmt.execute();

				// 获取输出参数结果
				if (MapUtils.isNotEmpty(outTypes))
					for (Map.Entry<Integer, Integer> entry : outTypes.entrySet()) {
						resultMap.put(entry.getKey(), cstmt.getObject(entry.getKey()));
					}
				
				return resultMap;
			}
		});
	}

3、使用

String procName = "PACK_TASK.PROC_SOFTWORE_UPDATE_ANALYZE"; // 存储过程名
Map<Integer, Object> inParams = new HashMap<Integer, Object>(); // 输入参数. 格式为：索引号->值
Map<Integer, Integer> outTypes = new HashMap<Integer, Integer>(); // 输出参数类型. 格式为：索引号->类型

// 设置输入参数
inParams.put(1, taskId);

// 设置输出类型
outTypes.put(2, Types.INTEGER);
outTypes.put(3, Types.VARCHAR);

// 调用存储过程
Map<Integer, Object> resultMap = softwareResultRepository.callProcedure(procName, inParams, outTypes);

// 获取输出参数值
resultMap.get(2);
resultMap.get(3);