JDBCTool（JDBCTools的更新版，cp30版本）

package DAO;


import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.mchange.v2.c3p0.ComboPooledDataSource;


/*
 * 与JDBCTools不同点：少了很多注释，少了很多落后的方法(Statement)，更新和查询操作使用了连接池技术，优化了速度。
 * 同时因为连接池技术，不用频繁关闭连接,但仍然提供了关闭连接的方法
 */
public class JDBCTool {
	private static Connection connection=getConnection();	//使用单例模式，每个用户使用一个自己的连接
	//开始事务
	public static void begin(Connection connection) {
		try {
			connection.setAutoCommit(false);
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//提交事务
	public static void commit(Connection connection) {
		try {
			connection.commit();
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//回滚事务
	public static void rollback(Connection connection) {
		try {
			connection.rollback();
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//获取连接方法（从连接池里获取连接）
	public static Connection getConnection() {
		try {
			connection=new ComboPooledDataSource().getConnection();
			return connection;
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//关闭连接方法
	//关闭俩个对象方法
	public static void release(Connection connection,Statement statement) {
		try {
			if(connection!=null) {
				connection.close();
			}
			if(statement!=null) {
				statement.close();
			}
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//关闭三个对象方法
	public static void release(Connection connection,Statement statement,ResultSet resultset) {
		try{
			if(connection!=null) {
				connection.close();
			}
			if(statement!=null) {
				statement.close();
			}
			if(resultset!=null) {
				resultset.close();
			}
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//执行sql插入、删除或更新的通用方法(利用PreparedStatement)
	public static void Update(String sql,Object ... obj) {//Object ... agrs表示一个参数列表(Object数组)，
																			//可以为任意类型，任意个数
	    try{
			PreparedStatement preparedstatement=connection.prepareStatement(sql);
			if(obj!=null){
				for(int i=0;i<obj.length;i++) {
					preparedstatement.setObject(i+1,obj[i]);
				}
			}
			preparedstatement.executeUpdate();
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//执行sql查询的通用方法(利用PreparedStatement)
	public static ResultSet Select(String sql,Object ...obj) {
	    try{
			PreparedStatement preparedstatement=connection.prepareStatement(sql);
			if(obj!=null){
				for(int i=0;i<obj.length;i++) {
					preparedstatement.setObject(i+1,obj[i]);
				}
			}
			return preparedstatement.executeQuery();
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		} 
	}
	//查询一条记录
	//传入SQL查询语句和类，返回一个与其一一对应属性的类
	//即返回一个记录类
	public static <T> T get(Class<T> clazz,String sql,Object ...obj) {
	    try{
			T Record=null;
			ResultSet resultset=Select(sql,obj);
			if(resultset.next()) {	//如果查询结果不为空
				Record=clazz.newInstance();	//实例化对象
				ResultSetMetaData resultsetmetadata=resultset.getMetaData();
				Map<String,Object>map=new HashMap<String, Object>();
				for(int i=0;i<resultsetmetadata.getColumnCount();i++) {
					map.put(resultsetmetadata.getColumnName(i+1),resultset.getObject(i+1));
				}
				for(Map.Entry<String,Object> entry:map.entrySet()) {	//取出map里每条记录entry(Key-Value)
					ReflectionUtils.setFieldValue(Record, entry.getKey(),entry.getValue());
				}
			}
			return Record;
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	
	//查询多条记录，返回记录对象的列表
	public static <T> List<T> getList(Class<T> clazz,String sql,Object ...obj) throws Exception{
		ResultSet resultset=Select(sql,obj);
		List<T> list=ListMap_To_List(clazz,Result_To_ListMap(resultset));
		return list;
	}
	//传入ResultSet得到一个记录对象列表(List<Map<String,Object>>类型,Map的键为列名，值为列值)
	public static List<Map<String, Object>> Result_To_ListMap(ResultSet resultset){
	    try{
			List<Map<String,Object>> list=null;
			ResultSetMetaData resultsetmetadata=resultset.getMetaData();
			int columnCount=resultsetmetadata.getColumnCount();
			ArrayList<String>columnName=new ArrayList<String>();
			for(int i=0;i<columnCount;i++) {
				columnName.add(resultsetmetadata.getColumnName(i+1));
			}
			list=new ArrayList<Map<String, Object>>();
			while(resultset.next()) {
				Map<String,Object>map=new HashMap<String, Object>();
				for(int i=0;i<columnCount;i++) {
					map.put(columnName.get(i),resultset.getObject(i+1));
				}
				list.add(map);
				}
			return list;
		} catch (Exception e) {
			//运行时抛出异常
			throw new RuntimeException(e);
		}
	}
	//传入一个ListMap和记录对象类型获得一个对象列表List
	public static <T> List<T> ListMap_To_List(Class<T> clazz, List<Map<String, Object>> listMap)
			throws InstantiationException, IllegalAccessException, InvocationTargetException {
		List<T> list=null;
		T Record=null;
		if(listMap.size()>0) {
			list=new ArrayList<T>();
			for(Map<String,Object>map:listMap) {	//取出listMap里每个map对象
				Record=clazz.newInstance();
				for(Map.Entry<String,Object>entry:map.entrySet()) {//取出map里的每个记录(entry:Key-Value)对象
					ReflectionUtils.setFieldValue(Record,entry.getKey(),entry.getValue());
				}
				list.add(Record);
			}
		}
		return list;
	}
	//返回某条记录的某一字段的值或一个统计的值（一共有多少条记录等）
	public static <E> E getForValue(String sql,Object ...obj) {
		try{
			ResultSet resultset=Select(sql,obj);
			resultset.next();
			return (E) resultset.getObject(1);
		} catch (Exception e) {
		//运行时抛出异常
		throw new RuntimeException(e);
		}
	}
	//批量处理SQL语句(返回的Connection可用来进行事务处理)
	public static void BatchSQL(String sql,int count,Object ...obj) throws Exception{
		try {
			begin(connection);
			PreparedStatement preparedstatement=connection.prepareStatement(sql);
			for(int i=0;i<obj.length;i++) {
				preparedstatement.setObject(i+1,obj[i]);
			}
			for(int i=0;i<count;i++) {
				preparedstatement.addBatch();	//积攒sql语句
			}
			preparedstatement.executeBatch();	//发送sql语句
			preparedstatement.clearBatch();     //清空sql语句
			commit(connection);
		}catch(Exception e) {
			rollback(connection);
			e.printStackTrace();
		}
	}
	//批量处理不同SQL语句(即处理相同Bean结构但数值不同的SQL语句)(返回的Connection可用来进行事务处理)
	public static void BatchSQL(String sql,Object[][]obj){
		try {
			begin(connection);
			PreparedStatement preparedstatement=connection.prepareStatement(sql);
			for(int i=0;i<obj.length;i++) {
				for(int j=0;j<obj[i].length;j++){
					preparedstatement.setObject(j+1,obj[i][j]);
				}
				preparedstatement.addBatch();	//积攒sql语句
			}
			preparedstatement.executeBatch();	//发送sql语句
			preparedstatement.clearBatch();     //清空sql语句
			commit(connection);
		}catch(Exception e) {
			rollback(connection);
			e.printStackTrace();
		}
	}
}
/**
 * 反射的 Utils 函数集合
 * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
 * @author Administrator
 *
 */
class ReflectionUtils {
	
	
	/**
	 * 将反射时的 "检查异常" 转换为 "运行时异常"
	 * @return
	 */
	public static IllegalArgumentException convertToUncheckedException(Exception ex){
		if(ex instanceof IllegalAccessException || ex instanceof IllegalArgumentException
				|| ex instanceof NoSuchMethodException){
			throw new IllegalArgumentException("反射异常", ex);
		}else{
			throw new IllegalArgumentException(ex);
		}
	}
	
	
	/**
	 * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param clazz
	 * @param index
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(Class clazz, int index){
		Type genType = clazz.getGenericSuperclass();
		
		if(!(genType instanceof ParameterizedType)){
			return Object.class;
		}
		
		Type [] params = ((ParameterizedType)genType).getActualTypeArguments();
		
		if(index >= params.length || index < 0){
			return Object.class;
		}
		
		if(!(params[index] instanceof Class)){
			return Object.class;
		}
		
		return (Class) params[index];
	}
	
	/**
	 * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param <T>
	 * @param clazz
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static<T> Class<T> getSuperGenericType(Class clazz){
		return getSuperClassGenricType(clazz, 0);
	}
	
	/**
	 * 循环向上转型, 获取对象的 DeclaredMethod
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @return
	 */
	public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){
		
		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				//superClass.getMethod(methodName, parameterTypes);
				return superClass.getDeclaredMethod(methodName, parameterTypes);
			} catch (NoSuchMethodException e) {
				//Method 不在当前类定义, 继续向上转型
			}
			//..
		}
		
		return null;
	}
	
	/**
	 * 使 filed 变为可访问
	 * @param field
	 */
	public static void makeAccessible(Field field){
		if(!Modifier.isPublic(field.getModifiers())){
			field.setAccessible(true);
		}
	}
	
	/**
	 * 循环向上转型, 获取对象的 DeclaredField
	 * @param object
	 * @param filedName
	 * @return
	 */
	public static Field getDeclaredField(Object object, String filedName){
		
		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				return superClass.getDeclaredField(filedName);
			} catch (NoSuchFieldException e) {
				//Field 不在当前类定义, 继续向上转型
			}
		}
		return null;
	}
	
	/**
	 * 直接调用对象方法, 而忽略修饰符(private, protected)
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @param parameters
	 * @return
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 */
	public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
			Object [] parameters) throws InvocationTargetException{
		
		Method method = getDeclaredMethod(object, methodName, parameterTypes);
		
		if(method == null){
			throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
		}
		
		method.setAccessible(true);
		
		try {
			return method.invoke(object, parameters);
		} catch(IllegalAccessException e) {} 
		
		return null;
	}
	
	/**
	 * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
	 * @param object
	 * @param fieldName
	 * @param value
	 */
	public static void setFieldValue(Object object, String fieldName, Object value){
		Field field = getDeclaredField(object, fieldName);
		
		if (field == null){
			//throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
		}else{
			makeAccessible(field);
			
			try {
				field.set(object, value);
			} catch (IllegalAccessException e) {}
		}
	}
	
	/**
	 * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
	 * @param object
	 * @param fieldName
	 * @return
	 */
	public static Object getFieldValue(Object object, String fieldName){
		Field field = getDeclaredField(object, fieldName);
		
		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
		
		makeAccessible(field);
		
		Object result = null;
		
		try {
			result = field.get(object);
		} catch (IllegalAccessException e) {}
		
		return result;
	}
}