Java 通用数据库连接类［支持存储过程 参数自动识别］

package com.hospital.dao.tools;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.log4j.Logger;

/**
 * 数据库操作管理类
 * 
 * @author Harlyhood
 * 
 */
public class DBManager {

	// --------------------------------------------------------- Instance
	private static Logger logger = Logger.getLogger(DBManager.class);
	// --------------------------------------------------------- Methods

	// 数据库连接对象
	private Connection con;
	// SQL语句对象
	private Statement stmt;
	// 带参数的Sql语句对象
	private PreparedStatement pstmt;
	// 记录集对象
	private ResultSet rs;
	// 数据连接管理（连接池对象）
	private DBConnectionManager dcm = null;

	/** ***********************手动设置的连接参数********************************* */
	@SuppressWarnings("unused")
	private static String _DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
	@SuppressWarnings("unused")
	private static String _URL = "jdbc:sqlserver://localhost:1433;database=Hospital_AI_DB;characterEncoding=gb2312";
	@SuppressWarnings("unused")
	private static String _USER_NA = "sa";
	@SuppressWarnings("unused")
	private static String _PASSWORD = "";

	/** ********************************************************************** */

	// 默认构造
	public DBManager() {
	}

	/** ****************************************************************************************** */
	/**
	 * **************************************** 数据库连接初始化
	 * ***********************************
	 */
	/** ****************************************************************************************** */

	/**
	 * 得到一个默认的数据库连接[从 com.hospital.dao.tools.db.properties文件初始化]
	 * 
	 * @throws Exception
	 */
	private void getConnection() {
		logger.info("###############open:::::从默认的配置文件得到一个数据库连接");
		// 获取一个连接池管理类的实例
		dcm = DBConnectionManager.getInstance();
		// 得到一个数据库连接
		con = dcm.getConnection("mysql");

		try {
			con.setAutoCommit(false);
		} catch (SQLException e) {

			e.printStackTrace();
		}
	}

	/**
	 * 从指定参数得到一个连接对象
	 * 
	 * @param driver
	 * @param url
	 * @param user_na
	 * @param password
	 * @throws Exception
	 */
	public void getConnection(String driver, String url, String user_na,
			String password) throws Exception {
		try {
			logger.info("###############open:::::从指定配置中得到一个数据库连接");
			Class.forName(driver);
			con = DriverManager.getConnection(url, user_na, password);
		} catch (ClassNotFoundException ex) {
			logger
					.info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]找不到类驱动类: "
							+ driver);
			throw ex;
		} catch (SQLException ex) {
			logger
					.info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]加载类: "
							+ driver + " 时出现 SQLException 异常");
			throw ex;
		}
	}

	/** ****************************************************************************************** */
	/**
	 * **************************************** 数据库操作方法
	 * ***********************************
	 */
	/** ****************************************************************************************** */

	/**
	 * 执行SQL语句操作(更新数据 无参数)
	 * 
	 * @param strSql
	 *            SQL语句
	 * @throws Exception
	 */
	public boolean executeUpdate(String strSql) throws SQLException {
		getConnection();
		// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
		boolean flag = false;
		stmt = con.createStatement();
		logger.info("###############::执行SQL语句操作(更新数据 无参数):" + strSql);
		try {
			if (0 < stmt.executeUpdate(strSql)) {
				close_DB_Object();
				flag = true;
				con.commit();
			}
		} catch (SQLException ex) {
			logger
					.info("###############Error DBManager Line126::执行SQL语句操作(更新数据 无参数):"
							+ strSql + "失败!");
			flag = false;
			con.rollback();
			throw ex;
		}
		return flag;

	}

	/**
	 * 执行SQL语句操作(更新数据 有参数)
	 * 
	 * @param strSql
	 *            sql指令
	 * @param prams
	 *            参数列表
	 * @return
	 * @throws SQLException
	 */
	public boolean executeUpdate(String strSql, HashMap<Integer, Object> prams)
			throws SQLException, ClassNotFoundException {
		getConnection();
		// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
		boolean flag = false;
		try {
			pstmt = con.prepareStatement(strSql);
			setParamet(pstmt, prams);
			logger.info("###############::执行SQL语句操作(更新数据 有参数):" + strSql);

			if (0 < pstmt.executeUpdate()) {
				close_DB_Object();
				flag = true;
				con.commit();
			}
		} catch (SQLException ex) {
			logger
					.info("###############Error DBManager Line121::执行SQL语句操作(更新数据 无参数):"
							+ strSql + "失败!");
			flag = false;
			con.rollback();
			throw ex;
		} catch (ClassNotFoundException ex) {
			logger
					.info("###############Error DBManager Line152::执行SQL语句操作(更新数据 无参数):"
							+ strSql + "失败! 参数设置类型错误!");
			con.rollback();
			throw ex;
		}
		return flag;

	}

	/**
	 * 执行SQL语句操作(查询数据 无参数)
	 * 
	 * @param strSql
	 *            SQL语句
	 * @return 数组对象列表
	 * @throws Exception
	 */
	public ArrayList<HashMap<Object, Object>> executeSql(String strSql)
			throws Exception {
		getConnection();
		// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
		stmt = con.createStatement();
		logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
		rs = stmt.executeQuery(strSql);
		con.commit();
		if (null != rs) {
			return convertResultSetToArrayList(rs);
		}
		close_DB_Object();
		return null;
	}

	/**
	 * 执行SQL语句操作(查询数据 有参数)
	 * 
	 * @param strSql
	 *            SQL语句
	 * @param prams
	 *            参数列表
	 * @return 数组对象列表
	 * @throws Exception
	 */
	public ArrayList<HashMap<Object, Object>> executeSql(String strSql,
			HashMap<Integer, Object> prams) throws Exception {
		getConnection();
		// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
		pstmt = con.prepareStatement(strSql);
		setParamet(pstmt, prams);
		logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
		rs = pstmt.executeQuery();
		con.commit();
		if (null != rs) {
			return convertResultSetToArrayList(rs);
		}
		return null;
	}

	/**
	 * 执行存储过程(查询数据 无参数)
	 * 
	 * @param procName
	 *            存储过程名称
	 * @return 数组列表对象
	 * @throws Exception
	 */
	public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
			String procName) throws Exception {
		getConnection();// 获取连接
		String callStr = "{call " + procName + "}";// 构造执行存储过程的sql指令
		CallableStatement cs = con.prepareCall(callStr);
		logger.info("###############::执行存储过程(查询数据):" + procName);
		rs = cs.executeQuery();
		con.commit();
		cs.close();
		close_DB_Object();
		return convertResultSetToArrayList(rs);
	}

	/**
	 * 执行存储过程(查询数据,带参数)返回结果集合
	 * 
	 * @param procName
	 *            存储过程名称
	 * @param parameters
	 *            参数对象数组
	 * @param al
	 *            数组列表对象
	 * @return 数组列表对象
	 * @throws Exception
	 */
	public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
			String procName, Object[] parameters) throws Exception {
		int parameterPoint = 0;
		// 获取存储过程信息列表集合
		ArrayList<HashMap<Object, Object>> procedureInfo = getProcedureInfo(procName);
		// 获取存储过程的完全名称
		String procedureCallName = getProcedureCallName(procName,parameters.length);
		// 获取连接对象
		getConnection();
		// 初始化 存储过程 执行对象
		CallableStatement cs = con.prepareCall(procedureCallName);
		// 参数下标变量
		int index = 0;
		// 获取 存储过程信息列表集合的 迭代器 对象
		Iterator<HashMap<Object, Object>> iter = procedureInfo.iterator();
		// 遍历存储过程信息列表集合
		while (iter.hasNext()) {
			HashMap<Object, Object> hm = iter.next();

			parameterPoint++;
			// 如果参数是输入参数 way = 0
			if (hm.get("WAY").equals("0")) {
				// 设置参数到cs
				cs.setObject(parameterPoint, parameters[index]);
				// 参数下标+1
				index++;
			}
		}
		// 释放这个对象,做为第二次使用
		procedureInfo = null;
		logger.info("###############::执行存储过程(查询数据):::::" + procedureCallName);
		rs = cs.executeQuery();
		con.commit();
		procedureInfo = convertResultSetToArrayList(rs);
		cs.close();
		close_DB_Object();
		return procedureInfo;

	}

	/**
	 * 执行存储过程(更新，查询数据[简单查询、非纪录集]，返回输出参数[非纪录集])
	 * 
	 * @param procName
	 *            存储过程名称
	 * @param parameters
	 *            参数对象数组
	 * @param os
	 *            输出参数对象数组
	 * @return 输出参数对象数组
	 * @throws Exception
	 */
	public Object[] executeProcedureUpdate(String procName, Object[] parameters)
			throws Exception {
		logger.info("------------------------------------------------------------------------------------------------------");
		logger.info(" Run --> executeProcedureUpdate ##############   正在执行 存储过程: " + procName +"   ##############");
		CallableStatement cs = null;
		Object []returnVal = null;
		try {
		// 获取 存储过程 调用全名
		String fullPCallName = getProcedureCallName(procName,parameters.length);
		logger.info(" Run --> executeProcedureUpdate #   存储过程命令: " + fullPCallName +"   #");
		//获取存储过程参数信息
		ArrayList<HashMap<Object, Object>> p_Call_Info_List = getProcedureInfo(procName);
		//获取连接
		getConnection();
		//创建 存储过程 执行对象
		cs = con.prepareCall(fullPCallName);
		//数组下标
		int index = 1;
		//输出参数下标 纪录
        ArrayList<Integer> outPutIndexList = new ArrayList<Integer>();
        logger.info(" Run --> executeProcedureUpdate #   参数个数是: " + parameters.length +"   #");
		for(HashMap<Object,Object> tempHash:p_Call_Info_List)
		{
			if("0".equals(tempHash.get("WAY")))
		    {
				//设置输入参数
				cs.setObject(index, parameters[index-1]);
				logger.info(" Run --> executeProcedureUpdate #   输入 Input: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
			}
			else
			{
				//注册输出参数
				cs.registerOutParameter(index, getDataType(tempHash.get("TYPENAME").toString()));
				//纪录输出参数的下标
				outPutIndexList.add(index);
				logger.info(" Run --> executeProcedureUpdate #   输出 OutPut: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
			}
			index++;
		}
		logger.info(" Run --> executeProcedureUpdate #   参数设置完毕,正在执行中 ... :   #");

		//-------------------- 执行 -----------------
		if(!cs.execute())
		{
			returnVal = new Object[outPutIndexList.size()];
			logger.info(" Run --> executeProcedureUpdate #   执行成功! :   #");
			//取输 出参数的 返回值
			for(int i = 0 ;i<outPutIndexList.size();i++)
			{
				returnVal[i] = cs.getObject(outPutIndexList.get(i));
				logger.info(" Run --> executeProcedureUpdate #   返回值 "+(i+1)+" "+returnVal[i]+"   #");
			}
			con.commit();//提交
		}
		} catch (Exception e) {
			logger.info(" Run --> executeProcedureUpdate #   执行失败!事务回滚中... :   #");
			con.rollback();
			throw e;
		} 
		logger.info("------------------------------------------------------------------------------------------------------");
		return returnVal;
	}

	/** ****************************************************************************************** */
	/**
	 * ********************************* 小工具
	 * ************************************************
	 */
	/** ****************************************************************************************** */

	/**
	 * 关闭数据对象
	 */
	public void close_DB_Object() {
		logger.info("###############close:::::关闭连接对象，语句对象，记录集对象");
		if (null != rs) {
			try {
				rs.close();
			} catch (SQLException ex) {
				rs = null;
			}
		}
		if (null != stmt) {
			try {
				stmt.close();
			} catch (SQLException ex) {
				stmt = null;
			}
		}
		if (null != pstmt) {
			try {
				pstmt.close();
			} catch (SQLException ex) {
				pstmt = null;
			}
		}
		if (con != null) {
			dcm.freeConnection("mysql", con);
		}
	}


	/**
	 * 设置Sql 指令参数
	 * 
	 * @param p_stmt
	 *            PreparedStatement
	 * @param pramets
	 *            HashMap
	 */
	private PreparedStatement setParamet(PreparedStatement p_stmt,
			HashMap<Integer, Object> pramets) throws ClassNotFoundException,
			SQLException {
		// 如果参数为空
		if (null != pramets) {
			// 如果参数个数为0
			if (0 <= pramets.size()) {
				for (int i = 1; i <= pramets.size(); i++) {
					try {
						// 字符类型 String
						if (pramets.get(i).getClass() == Class
								.forName("java.lang.String")) {
							p_stmt.setString(i, pramets.get(i).toString());
						}
						// 日期类型 Date
						if (pramets.get(i).getClass() == Class
								.forName("java.sql.Date")) {
							p_stmt.setDate(i, java.sql.Date.valueOf(pramets
									.get(i).toString()));
						}
						// 布尔类型 Boolean
						if (pramets.get(i).getClass() == Class
								.forName("java.lang.Boolean")) {
							p_stmt.setBoolean(i, (Boolean) (pramets.get(i)));
						}
						// 整型 int
						if (pramets.get(i).getClass() == Class
								.forName("java.lang.Integer")) {
							p_stmt.setInt(i, (Integer) pramets.get(i));
						}
						// 浮点 float
						if (pramets.get(i).getClass() == Class
								.forName("java.lang.Float")) {
							p_stmt.setFloat(i, (Float) pramets.get(i));
						}
						// 双精度型 double
						if (pramets.get(i).getClass() == Class
								.forName("java.lang.Double")) {
							p_stmt.setDouble(i, (Double) pramets.get(i));
						}

					} catch (ClassNotFoundException ex) {
						throw ex;
					} catch (SQLException ex) {
						throw ex;
					}
				}
			}
		}
		return p_stmt;
	}

	/**
	 * 转换记录集对象为数组列表对象
	 * 
	 * @param rs
	 *            纪录集合对象
	 * @return 数组列表对象
	 * @throws Exception
	 */
	private ArrayList<HashMap<Object, Object>> convertResultSetToArrayList(
			ResultSet rs) throws Exception {
		logger.info("###############::转换记录集对象为数组列表对象");
		// 获取rs 集合信息对象
		ResultSetMetaData rsmd = rs.getMetaData();
		// 创建数组列表集合对象
		ArrayList<HashMap<Object, Object>> tempList = new ArrayList<HashMap<Object, Object>>();
		HashMap<Object, Object> tempHash = null;
		// 填充数组列表集合
		while (rs.next()) {
			// 创建键值对集合对象
			tempHash = new HashMap<Object, Object>();
			for (int i = 0; i < rsmd.getColumnCount(); i++) {
				// 遍历每列数据，以键值形式存在对象tempHash中
				tempHash.put(rsmd.getColumnName(i + 1).toUpperCase(), rs
						.getString(rsmd.getColumnName(i + 1)));
			}
			// 第一个键值对，存储在tempList列表集合对象中
			tempList.add(tempHash);
		}
		close_DB_Object();// 关闭相关链接
		return tempList;// 返回填充完毕的数组列表集合对象
	}

	/**
	 * 从数据库得到存储过程信息
	 * 
	 * @param procName
	 *            存储过程名称
	 * @return 数组列表对象
	 * @throws Exception
	 */
	private ArrayList<HashMap<Object, Object>> getProcedureInfo(String procName)
			throws Exception {
		return this.executeSql("select Syscolumns.isoutparam as Way,systypes.name as TypeName from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
				+ procName + "' order by Syscolumns.isoutparam");
	}

	/**
	 * 从数据库得到存储过程参数个数
	 * 
	 * @param procName
	 *            存储过程名称
	 * @return 数组列表对象
	 * @throws Exception
	 */
	@SuppressWarnings("unused")
	private int getParametersCount(String procName) throws Exception {
		int returnVal = 0;
		for (HashMap<Object, Object> tempHas : this
				.executeSql("select count(*) as RowsCount from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
						+ procName + "'")) {
			returnVal = Integer.parseInt(tempHas.get("ROWSCOUNT").toString());
		}
		return returnVal;
	}

	/**
	 * 得到调用存储过程的全名
	 * 
	 * @param procName
	 *            存储过程名称
	 * @return 调用存储过程的全名
	 * @throws Exception
	 */
	private String getProcedureCallName(String procName, int prametCount)
			throws Exception {
		String procedureCallName = "{call " + procName;
		for (int i = 0; i < prametCount; i++) {
			if (0 == i) {
				procedureCallName = procedureCallName + "(?";
			}
			if (0 != i) {
				procedureCallName = procedureCallName + ",?";
			}
		}
		procedureCallName = procedureCallName + ")}";
		return procedureCallName;
	}

	/**
	 * 得到数据类型的整型值
	 * 
	 * @param typeName
	 *            类型名称
	 * @return 数据类型的整型值
	 */
	private int getDataType(String typeName) {
		if (typeName.equals("varchar"))
			return Types.VARCHAR;
		if (typeName.equals("int"))
			return Types.INTEGER;
		if (typeName.equals("bit"))
			return Types.BIT;
		if (typeName.equals("float"))
			return Types.FLOAT;
		return 0;
	}

	// 设置驱动路径
	@SuppressWarnings("static-access")
	public void set_DRIVER(String _DRIVER) {
		this._DRIVER = _DRIVER;
	}

	// 设置数据库密码
	@SuppressWarnings("static-access")
	public void set_PASSWORD(String _PASSWORD) {
		this._PASSWORD = _PASSWORD;
	}

	// 设置数据库连接字符串
	@SuppressWarnings("static-access")
	public void set_URL(String _URL) {
		this._URL = _URL;
	}

	// 设置数据库用户名
	@SuppressWarnings("static-access")
	public void set_USER_NA(String _USER_NA) {
		this._USER_NA = _USER_NA;
	}

}