依靠JDBC和反射写的工具类

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;


import javax.sql.DataSource;


import org.slf4j.LoggerFactory;


import com.test.domain.CusBase;
import com.xeon.pool.c3p0.C3P0Util;


public class DBUtilCSDN {
	/**
	 * 连接池
	 */
	private DataSource dataSource = null;
	/**
	 * 是否替换所有下划线(true:替换;false:否,默认否)
	 */
	private boolean replace_flag = false;
	/**
	 * Statement和PreparedStateme不能提前关闭，会报错,只能在最后调用线程关闭
	 */
	private ThreadLocal<Statement> threadLocal = new ThreadLocal<Statement>();


	public DBUtilCSDN() {
	}


	/**
	 * 
	 * @param dataSource
	 *            ：连接池
	 */
	public DBUtilCSDN(DataSource dataSource) {
		this.dataSource = dataSource;
	}


	/**
	 * 
	 * @param dataSource
	 *            : 数据源
	 * @param replace_flag
	 *            : true=将字段所有下划线去掉,并经后一个字符大写
	 */
	public DBUtilCSDN(DataSource dataSource, boolean replace_flag) {
		this.dataSource = dataSource;
		this.setReplace_flag(replace_flag);
	}


	/**
	 * 是否替换所有下划线(true:替换;false:否,默认否)
	 * 
	 * @return
	 */
	public boolean isReplace_flag() {
		return replace_flag;
	}


	/**
	 * 是否替换所有下划线(true:替换;false:否,默认否)
	 * 
	 * @param replace_flag
	 */
	public void setReplace_flag(boolean replace_flag) {
		this.replace_flag = replace_flag;
	}


	/**
	 * 通过连接池获取Connection
	 * 
	 * @return
	 */
	public Connection getConnection() {
		if (dataSource == null) {
			LoggerFactory.getLogger(this.getClass()).error(
					"DataSource == null , 可能是没有传入连接池, 请检查");
			throw new RuntimeException("DataSource == null , 可能是没有传入连接池, 请检查");
		}
		try {
			return dataSource.getConnection();
		} catch (SQLException e) {
			e.printStackTrace();
			LoggerFactory.getLogger(this.getClass()).error(
					"dataSource.getConnection() Exception, 请检查");
			throw new RuntimeException(
					"dataSource.getConnection() Exception , please check it !!!");
		}


	}


	/**
	 * 执行方法
	 * 
	 * @param domain
	 *            : 实体类
	 * @param fieldName
	 *            : 字段名
	 * @param value
	 *            : 字段对应值
	 * @return : 封装后的实体类
	 */
	public <E> E executeMethod(E domain, String fieldName, Object value) {
		Method method = qualMethod(domain.getClass(), replace_(fieldName));
		if (method == null) {
			return domain;
		}
		try {
			method.invoke(domain, value);
		} catch (IllegalAccessException | IllegalArgumentException
				| InvocationTargetException e) {
			e.printStackTrace();
		}
		return domain;
	}


	/**
	 * 获取当前方法(Method)
	 * 
	 * @param clazz
	 * @param fieldName
	 * @return
	 */
	public <E> Method qualMethod(Class<E> clazz, String fieldName) {
		String fieldMethod = null;
		String fieldType = null;
		Method temMethod = null;
		Field field = null;
		try {
			/**
			 * 通过属性生成setField()
			 */
			field = clazz.getDeclaredField(fieldName);
			fieldMethod = "set"
					+ String.valueOf(fieldName.charAt(0)).toUpperCase()
					+ fieldName.substring(1);
			fieldType = field.getType().getName();// 如java.lang.String,
													// getName()不包含前面的class
			switch (fieldType) {
			case "boolean":
				temMethod = clazz.getMethod(fieldMethod, boolean.class);
				break;
			case "int":
				temMethod = clazz.getMethod(fieldMethod, int.class);
				break;
			case "char":
				temMethod = clazz.getMethod(fieldMethod, char.class);
				break;
			case "double":
				temMethod = clazz.getMethod(fieldMethod, double.class);
				break;
			case "float":
				temMethod = clazz.getMethod(fieldMethod, float.class);
				break;
			case "byte":
				temMethod = clazz.getMethod(fieldMethod, byte.class);
				break;
			case "long":
				temMethod = clazz.getMethod(fieldMethod, long.class);
				break;
			case "short":
				temMethod = clazz.getMethod(fieldMethod, short.class);
				break;
			default:
				temMethod = clazz.getMethod(fieldMethod,
						Class.forName(fieldType));
				break;
			}
		} catch (NoSuchFieldException | SecurityException
				| NoSuchMethodException | ClassNotFoundException e) {
			return temMethod;
		}


		return temMethod;
	}


	/**
	 * 获取当前结果集所有的表头 [已经全部转化为小写]
	 * 
	 * @param rs
	 * @return
	 */
	public String[] getMetaData(ResultSetMetaData rm) {
		String[] ret = null;
		if (rm == null) {
			ret = new String[0];
			return ret;
		}
		try {
			ret = new String[rm.getColumnCount()];
			for (int i = 0; i < ret.length; i++) {
				ret[i] = rm.getColumnLabel(i + 1).toLowerCase();
			}
			/**
			 * 将字段转换为小写,替换所有下划线
			 */
			// if (replace_flag) {
			// for (int i = 0; i < ret.length; i++) {
			// ret[i] = replace_(ret[i]);
			// }
			// }
		} catch (SQLException e) {
			e.printStackTrace();
			ret = new String[0];
		} finally {
		}


		return ret;


	}


	/**
	 * <pre>
	 * 在所有的下划线前加下划线
	 * </pre>
	 * 
	 * @param fieldName
	 * @return
	 */
	public String replaceU(String fieldName) {
		if (fieldName == null) {
			return fieldName;
		}
		char ch;
		int fieldSize = fieldName.length();
		String column = "";
		for (int i = 0; i < fieldSize; i++) {
			ch = fieldName.charAt(i);
			if (Character.isUpperCase(ch)) {// 检测到大写
				column += "_".concat(String.valueOf(ch).toLowerCase());
			} else {
				column += String.valueOf(ch);
			}
		}
		return column;
	}


	/**
	 * <pre>
	 * 将所有下划线去掉,并经下划线的后一位转换为大写
	 * </pre>
	 * 
	 * @param columnName
	 * @return
	 */
	public String replace_(String columnName) {
		if (columnName == null || !replace_flag) {
			return columnName;
		}


		columnName = columnName.toLowerCase();
		char ch;
		String column = "";
		int columnCount = columnName.length();
		String tem;
		for (int i = 0; i < columnCount; i++) {
			ch = columnName.charAt(i);
			if (ch == '_') {
				if ((i + 1) < columnCount) {
					ch = columnName.charAt(++i);
					tem = String.valueOf(ch).toUpperCase();
					if ("_".equals(tem)) {
						continue;
					}
					column += tem;
				}
			} else {
				column += String.valueOf(ch);
			}
		}


		return column;
	}


	/**
	 * 获取ResultSet
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	private ResultSet getResultSet(Connection connection, String sql,
			Object... params) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = connection.prepareStatement(sql);
			if (params != null && params.length > 0) {
				int i = 0;
				while (i < params.length) {
					ps.setObject(i + 1, params[i]);
					i++;
				}
			}
			rs = ps.executeQuery();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			closeOrSet(null, ps, null);
		}
		return rs;
	}


	// @Override
	// public ResultSet getResultSet(String sql, Object... params) {
	// return getResultSet(getConnection(), sql, params);
	// }
	/**
	 * 获取DataSource
	 * 
	 * @return
	 */
	public DataSource getDataSource() {
		return dataSource;
	}


	/**
	 * 设置DataSource
	 * 
	 * @param dataSource
	 */
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}


	/**
	 * 执行sql,将数据封装到Bean，并将Bean封装到List
	 * 
	 * @param <E>
	 * 
	 * @param connection
	 * @param sql
	 * @param clazz
	 * @param params
	 * @return
	 */
	public <E> List<E> queryListDomain(Connection connection, String sql,
			Class<E> clazz, Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		String[] array = new String[0];
		E domain = null;
		List<E> retList = new LinkedList<E>();
		try {
			array = getMetaData(rs.getMetaData());
			while (rs.next()) {
				domain = clazz.newInstance();
				for (String column : array) {
					domain = executeMethod(domain, column, rs.getObject(column));
				}
				retList.add(domain);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}
		return retList;
	}


	/**
	 * 执行sql,将数据封装到Bean，并将Bean封装到List
	 * 
	 * @param sql
	 * @param clazz
	 * @param params
	 * @return
	 */
	public <E> List<E> queryListDomain(String sql, Class<E> clazz,
			Object... params) {
		return queryListDomain(getConnection(), sql, clazz, params);
	}


	/**
	 * 执行sql，将查询出的数据取一条封装到Domain
	 * 
	 * @param connection
	 * @param sql
	 * @param clazz
	 * @param params
	 * @return
	 */
	public <E> E queryDomain(Connection connection, String sql, Class<E> clazz,
			Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		String[] array = new String[0];
		E domain = null;
		try {
			domain = clazz.newInstance();
			array = getMetaData(rs.getMetaData());
			if (rs.next()) {
				for (String column : array) {
					domain = executeMethod(domain, column, rs.getObject(column));
				}
			}
		} catch (SQLException | InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}
		return domain;
	}


	/**
	 * 执行sql，将查询出的数据取一条封装到Domain
	 * 
	 * @param sql
	 * @param clazz
	 * @param params
	 * @return
	 */
	public <E> E queryDomain(String sql, Class<E> clazz, Object... params) {
		return queryDomain(getConnection(), sql, clazz, params);
	}


	/**
	 * 执行sql，将返回数据封装到Map，再将Domain封装到List
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<Map<String, Object>> queryListKeyed(Connection connection,
			String sql, Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		List<Map<String, Object>> retList = new ArrayList<Map<String, Object>>();
		Map<String, Object> map = null;
		String[] array = new String[0];
		try {
			array = getMetaData(rs.getMetaData());
			while (rs.next()) {
				map = new LinkedHashMap<String, Object>();
				for (String arr : array) {
					map.put(replace_(arr), rs.getObject(arr));
				}
				retList.add(map);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}
		return retList;
	}


	/**
	 * 执行sql，将返回数据封装到Map，再将Domain封装到List
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<Map<String, Object>> queryListKeyed(String sql,
			Object... params) {
		return queryListKeyed(getConnection(), sql, params);
	}


	/**
	 * 取多条记录，每一条记录封装到一个Map中，再把这个Map封装到另外一个Map中，key为指定的字段值。
	 * 
	 * @param connection
	 * @param sql
	 * @param key
	 * @param params
	 * @return
	 */


	public Map<Object, Map<String, Object>> queryKeyedHandler(
			Connection connection, String sql, String key, Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		Map<Object, Map<String, Object>> retMap = new LinkedHashMap<Object, Map<String, Object>>();
		Map<String, Object> map = null;
		String[] array = null;
		try {
			array = getMetaData(rs.getMetaData());
			while (rs.next()) {
				map = new LinkedHashMap<String, Object>();
				for (int i = 0; i < array.length; i++) {
					map.put(replace_(array[i]), rs.getObject(array[i]));
				}
				retMap.put(rs.getObject(key), map);
			}
		} catch (SQLException e) {
			e.printStackTrace();
			array = new String[0];
		} finally {
			close(rs, null, connection);
		}
		return retMap;
	}


	/**
	 * 取多条记录，每一条记录封装到一个Map中，再把这个Map封装到另外一个Map中，key为指定的字段值。
	 * 
	 * @param sql
	 * @param key
	 * @param params
	 * @return
	 */
	public Map<Object, Map<String, Object>> queryKeyedHandler(String sql,
			String key, Object... params) {
		return queryKeyedHandler(getConnection(), sql, key, params);
	}


	/**
	 * 将查询出来的数据拿出一条，封装到Object[]
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	public Object[] queryArray(Connection connection, String sql,
			Object... params) {
		ResultSet rs = null;
		Object[] retObj = null;
		try {
			rs = getResultSet(connection, sql, params);
			if (!rs.next()) {
				return new Object[0];
			}
			retObj = new Object[rs.getMetaData().getColumnCount()];
			for (int i = 0; i < retObj.length; i++) {
				retObj[i] = rs.getObject(i + 1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
			retObj = new Object[0];
		} finally {
			close(rs, null, connection);
		}


		return retObj;
	}


	/**
	 * 将查询出来的数据拿出一条，封装到Object[]
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public Object[] queryArray(String sql, Object... params) {
		return queryArray(getConnection(), sql, params);
	}


	/**
	 * 将查询出的数据封装到Object[]，并将Object[]封装到ArrayList
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<Object[]> queryArrayList(Connection connection, String sql,
			Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		List<Object[]> retList = new ArrayList<Object[]>();
		Object[] objs = null;
		int columnCount = 0;
		try {
			columnCount = rs.getMetaData().getColumnCount();
			while (rs.next()) {
				objs = new Object[columnCount];
				for (int i = 0; i < columnCount; i++) {
					objs[i] = rs.getObject(i + 1);
				}
				retList.add(objs);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}
		return retList;
	}


	/**
	 * 将查询出的数据封装到Object[]，并将Object[]封装到ArrayList
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public List<Object[]> queryArrayList(String sql, Object... params) {
		return queryArrayList(getConnection(), sql, params);
	}


	/**
	 * <pre>
	 * 将查询数据的其中一列封装到List,columnName只能是String或int
	 * 如果是行号则是从1开始
	 * </pre>
	 * 
	 * @param connection
	 * @param sql
	 * @param columnName
	 * @param params
	 * @return
	 */
	public List<Object> queryColumnList(Connection connection, String sql,
			Object columnName, Object... params) {
		List<Object> retList = new ArrayList<Object>();
		// Object obj = null;
		String keyStr = null;
		Integer keyInt = null;
		if (columnName instanceof String) {
			keyStr = String.valueOf(columnName);
		} else if (columnName instanceof Integer) {
			keyInt = (Integer) columnName;
		} else {
			try {
				LoggerFactory.getLogger(DBUtilsImpl.class).error(
						"columnName参数为空,无法继续");
				throw new Exception("columnName参数为空,无法继续");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		ResultSet rs = getResultSet(connection, sql, params);
		try {
			while (rs.next()) {
				if (keyStr != null) {
					retList.add(rs.getObject(keyStr));
				} else {
					retList.add(rs.getObject(keyInt));
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}


		return retList;
	}


	/**
	 * <pre>
	 * 将查询数据的其中一列封装到List,columnName只能是String或int
	 * 如果是行号则是从1开始
	 * </pre>
	 * 
	 * @param sql
	 * @param columnName
	 * @param params
	 * @return
	 */
	public List<Object> queryColumnList(String sql, Object columnName,
			Object... params) {
		return queryColumnList(getConnection(), sql, columnName, params);
	}


	/**
	 * 执行CUD操作,需要手动提交数据
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	public int update(Connection connection, String sql, Object... params) {
		PreparedStatement ps;
		int ret = 0;
		try {
			connection.setAutoCommit(false);
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
		try {
			ps = connection.prepareStatement(sql);
			if (params.length > 0) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[i]);
				}
			}
			ret = ps.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// close(null, null, connection);
		}


		return ret;
	}


	/**
	 * 执行CUD操作，自动提交数据
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public int update(String sql, Object... params) {
		int retCount = 0;
		Connection connection = getConnection();
		try {
			// connection.setAutoCommit(false);
			retCount = update(connection, sql, params);
			connection.commit();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(null, null, connection);
		}


		return retCount;
	}


	/**
	 * 关闭连接或者关闭rs和Connection,并ThreadLocal.set(st)
	 * 
	 * @param rs
	 * @param st
	 * @param connection
	 */
	public void closeOrSet(ResultSet rs, Statement st, Connection connection) {
		if (rs != null) {
			try {
				rs.close();
				rs = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if (st != null) {
			threadLocal.set(st);
		}
		if (connection != null) {
			try {
				connection.close();
				connection = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}


	/**
	 * 关闭连接
	 * 
	 * @param rs
	 * @param connection
	 */
	public void close(ResultSet rs, Statement ps, Connection connection) {
		ps = threadLocal.get();
		threadLocal.remove();
		if (ps != null) {
			try {
				ps.close();
				ps = null;
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		closeOrSet(rs, null, connection);
	}


	/**
	 * 执行sql,将返回数据封装到Map<String,Object>中
	 * 
	 * @param connection
	 * @param sql
	 * @param params
	 * @return
	 */
	public Map<String, Object> queryKeyed(Connection connection, String sql,
			Object... params) {
		ResultSet rs = getResultSet(connection, sql, params);
		String[] array = null;
		Map<String, Object> retMap = new LinkedHashMap<String, Object>();
		try {
			array = getMetaData(rs.getMetaData());
			if (rs.next()) {
				for (String arr : array) {
					retMap.put(replace_(arr), rs.getObject(arr));
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, null, connection);
		}
		return retMap;
	}


	/**
	 * 执行sql,将返回数据封装到Map<String,Object>中
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public Map<String, Object> queryKeyed(String sql, Object... params) {
		return queryKeyed(getConnection(), sql, params);
	}


	/**
	 * 随机测试2个
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		DataSource dataSource = C3P0Util.getDataSource();//	获取连接池
		/**
		 * 后面的true为将查询出的字段作去下划线处理
		 * (如数据库字段:cus_name,实体类字段:cusName,就会导致查询出的数据无法set到实体类中)
		 */
		DBUtilCSDN dut = new DBUtilCSDN(dataSource,true);
		System.out.println("-----------------------------------------");
		CusBase user=dut.queryDomain("select * from cus_base where cus_name=? and cus_id=?", CusBase.class,"admin",2);
		System.out.println(user);
		System.out.println("-----------------------------------------");
		List<CusBase> users=dut.queryListDomain("select * from cus_base", CusBase.class);
		for(CusBase u:users){
			System.out.println(u);
		}
	}
}

控制台输出为:



-----------------------------------------
CusBase [cusId=2, cusName=admin, cusCreatetime=2017-12-21 16:50:14.0, cusRoot=1, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=dbutils, cusPassword=Xdapp1012, cusPhone=, cusPhoneCode=]
-----------------------------------------
CusBase [cusId=1, cusName=huoshengxin, cusCreatetime=2017-12-21 14:59:11.0, cusRoot=2, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=myBatis, cusPassword=qqq, cusPhone=, cusPhoneCode=]
CusBase [cusId=2, cusName=admin, cusCreatetime=2017-12-21 16:50:14.0, cusRoot=1, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=dbutils, cusPassword=Xdapp1012, cusPhone=, cusPhoneCode=]
CusBase [cusId=3, cusName=hushulin, cusCreatetime=2018-01-09 10:45:49.0, cusRoot=2, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=null, cusPassword=hushulinadmin, cusPhone=, cusPhoneCode=]
CusBase [cusId=4, cusName=chenyonghua, cusCreatetime=2018-01-09 10:46:00.0, cusRoot=2, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=null, cusPassword=chenyonghuaadmin, cusPhone=, cusPhoneCode=]
CusBase [cusId=5, cusName=root, cusCreatetime=2018-01-09 10:46:18.0, cusRoot=1, cusGender=, cusBirthday=null, cusUpdatename=null, cusNameCn=null, cusPassword=rootroot, cusPhone=, cusPhoneCode=]

连接池代码及jar包将在稍后贴出

自己写业余时间写的, 难免出现错误. 如有错误, 请指出, 我看到后会修改 !