JDBC工具包

package com.softeem.utils;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;

import com.alibaba.druid.pool.DruidDataSource;

/**
 * 通用数据库工具类，基于Druid连接池实现
 * 包含以下功能：
 * 1、获取连接
 * 2、关闭资源
 * 3、执行通用的更新操作
 * 4、执行通用的查询列表操作
 * 5、执行通用的查询单条记录操作
 * @author dell
 *
 */
public class Util {
	
	private static DruidDataSource pool;
	private static String url;
	private static String username;
	private static String password;
	private static int initialSize;
	private static int maxActive;
	private static int minIdle;
	private static long maxWait;
	private static String fileName="/jdbc.properties";
	
	static{
		init();
	}
	/**
	 * 加载属性文件并读取属性文件的内容将其设置给连接信息
	 * @param propName
	 */
	private static void loadProp(){
		try {
			InputStream is=Util.class.getResourceAsStream(fileName);
			Properties p=new Properties();
			p.load(is);
			
			url=p.getProperty("url");
			username=p.getProperty("username");
			password=p.getProperty("password");
			
			initialSize=Integer.parseInt(p.getProperty("initialSize").trim());
			maxActive=Integer.parseInt(p.getProperty("maxActive").trim());
			minIdle=Integer.parseInt(p.getProperty("minIdle").trim());
			maxWait=Long.parseLong(p.getProperty("maxWait").trim());
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	
	private static void init(){
		pool=new DruidDataSource();
		loadProp();
		pool.setUrl(url);
		pool.setUsername(username);
		pool.setPassword(password);
		//设置连接池中初始连接数
		pool.setInitialSize(initialSize);
		//设置最大连接数
		pool.setMaxActive(maxActive);
		//最小的闲置连接
		pool.setMinIdle(minIdle);
		//设置最大的等待时间（等待获取链接时间）
		pool.setMaxWait(maxWait);
		
		
	}
	
	public static Connection getConn(){
		try {
			return pool.getConnection();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 资源关闭
	 * 
	 * @param stmt
	 * @param conn
	 */
	public static void close(Statement stmt, Connection conn) {
		try {
			if (stmt != null) {
				stmt.close();
			}
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 封装通用的更新操作，对所有更新（INSERT,UPDATE,DELECT）有关操作都能通过该方法实现
	 * 
	 * @param sql
	 * @return
	 */
	public static boolean exeUpdate(Connection conn,String sql, Object... obj) {

		PreparedStatement ps = null;
		try {

			ps = conn.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i + 1, obj[i]);
			}
			return ps.executeUpdate() > 0;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(ps, null);
		}
		return false;
	}

	public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
		List<T> list = new ArrayList<>();
		T obj = null;
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			ResultSet rs = ps.executeQuery();
			// 获取插叙结果集中的元数据(获取列类型，数量以及长度等信息)
			ResultSetMetaData rsmd = rs.getMetaData();
			// 声明一个map集合，用于临时存储查询到的一条数据（key：列名；value：列值）
			Map<String, Object> map = new HashMap<>();
			// 遍历结果集
			while (rs.next()) {
				// 防止缓存上一条数据
				map.clear();
				// 遍历所有的列
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					// 获取列名
					String cname = rsmd.getColumnLabel(i + 1);
					// 获取列值
					Object value = rs.getObject(cname);
					// 将列明与列值存储到map中
					map.put(cname, value);
				}
				// 利用反射将map中的数据注入到Java对象中，并将对象存入集合
				if (!map.isEmpty()) {
					// 获取map集合键集(列名集合)
					Set<String> columnNames = map.keySet();
					// 创建对象
					obj = t.newInstance();
					for (String column : columnNames) {
						// 根据键获取值
						Object value = map.get(column);
						// 获取属性对象
						Field f = t.getDeclaredField(column);
						// 设置属性为可访问状态
						f.setAccessible(true);
						// 为属性设置
						f.set(obj, value);
					}
					list.add(obj);
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 封装查询单个对象的方法
	 */
	public static <T> T queryOne(Class<T> t, String sql, Object... params) {
		T obj = null;
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[1]);
			}
			ResultSet rs = ps.executeQuery();
			ResultSetMetaData rsmd = rs.getMetaData();
			// ORM操作（对象关系映射）
			if (rs.next()) {
				// 创建一个指定类型的实例对象（必须包含默认构造器）
				obj = t.newInstance();
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					// 获取指定列的列名称
					String cname = rsmd.getColumnLabel(i + 1);
					// 获取列值
					Object value = rs.getObject(cname);
					//
					if (Objects.nonNull(value)) {
						Field field = t.getDeclaredField(cname);
						field.setAccessible(true);
						field.set(obj, value);
					}
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}

		return obj;
	}



}