ORM框架 数据库工具类

/*
 *
 *                                    _oo0oo_
 *                                   088888880
 *                                   88" . "88
 *                                   (| -_- |)
 *                                    0\ = /0
 *                                 ___/'---'\___
 *                               .' \\\\|     |// '.
 *                              / \\\\|||  :  |||// \\
 *                             /_ ||||| -:- |||||- \\
 *                            |   | \\\\\\  -  /// |   |
 *                            | \_|  ''\---/''  |_/ |
 *                            \  .-\__  '-'  __/-.  /
 *                          ___'. .'  /--.--\  '. .'___
 *                       ."" '<  '.___\_<|>_/___.' >'  "".
 *                      | | : '-  \'.;'\ _ /';.'/ - ' : | |
 *                      \  \ '_.   \_ __\ /__ _/   .-' /  /
 *                  ====='-.____'.___ \_____/___.-'____.-'=====
 *                                    '=---='
 *
 *                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *                          佛祖保佑        永无BUG
 *
 */
package com.softeem.utils;

import com.alibaba.druid.pool.DruidDataSource;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;

/**
 * ORM框架 数据库工具类V2.0
 *
 * @author lx
 *
 */
public class DBUtils2{

	/** 驱动类路径 */
	private static String DRIVER_CLASS;
	/** url地址 */
	private static String URL;
	/** 数据库服务器登录用户名 */
	private static String USER;
	/** 数据库服务器登录密码 */
	private static String PASSWORD;
	/** 最大活动连接数 */
	private static int MAX_ACTIVE;
	/** 最长等待连接获取的时间 */
	private static long MAX_WAIT;
	/** 初始连接数 */
	private static int INIT_SIZE;

	private static DruidDataSource ds = new DruidDataSource();

	static {
		try {
			// 读取属性文件获取连接数据库相关的字符串
			InputStream is = DBUtils2.class.getResourceAsStream("/jdbc.properties");
			// 创建属性对象
			Properties p = new Properties();
			// 加载包含属性信息的输入流
			p.load(is);

			// 根据属性名获取属性值
			DRIVER_CLASS = p.getProperty("driver");
			URL = p.getProperty("url");
			USER = p.getProperty("user");
			PASSWORD = p.getProperty("password");

			// 获取连接池相关配置
			MAX_ACTIVE = Integer.parseInt(p.getProperty("pool.maxActive"));
			INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
			MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));

			//初始化连接池
			init();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void init() {

		ds = new DruidDataSource();
		ds.setDriverClassName(DRIVER_CLASS);
		ds.setUrl(URL);
		ds.setUsername(USER);
		ds.setPassword(PASSWORD);
		ds.setMaxActive(MAX_ACTIVE);
		ds.setInitialSize(INIT_SIZE);
		ds.setMaxWait(MAX_WAIT);

	}

	/**
	 * 	获取数据库连接对象
	 * @return
	 */
	public static synchronized Connection getConn() {
		try {
			// 当数据源为null或被关闭时,重新创建
			if (ds == null || ds.isClosed()) {
				init();
			}
			//从连接中获取一个连接并返回
			return ds.getConnection();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 关闭资源
	 *
	 * @param rs
	 * @param stat
	 * @param conn
	 */
	public static void close(ResultSet rs, Statement stat, Connection conn) {

		try {
			if (rs != null){
				rs.close();

			}
			if (stat != null){

				stat.close();
			}
			if (conn != null){

				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 封装通用的更新操作:INSERT UPDATE DELETE
	 *
	 * @param sql
	 * @param params
	 * @return
	 */
	public static boolean exeUpdate(Connection conn,String sql, Object... params) {
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[i]);
				}
			}
			return ps.executeUpdate() > 0;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(null, ps, null);
		}
		return false;
	}

	public static boolean exeUpdate(String sql, Object... params) {
		Connection conn = getConn();
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[i]);
				}
			}
			return ps.executeUpdate() > 0;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(null, ps, conn);
		}
		return false;
	}

	/**
	 * 封装通用查询单条数据的方法
	 *
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> T queryOne(Class<T> t, String sql, Object... params) {
		// 获取查询到的数据集合
		List<Map<String, Object>> list = queryMaps(sql, params);
		if (list.size() > 0) {
			// 获取一个Map对象
			Map<String, Object> map = list.get(0);
			// 将map集合转换为javabean并返回
			return mapToBean(map, t);
		}
		return null;
	}

	/**
	 * 封装通用查询多条数据的方法
	 *
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
		List<T> list = new ArrayList<T>();
		// 获取所有查询到的数据
		List<Map<String, Object>> maps = queryMaps(sql, params);
		// 遍历集合中每一条数据(map)
		maps.forEach(m -> {
			// 将map转换为javabean
			T obj = mapToBean(m, t);
			// 将javabean装入list
			list.add(obj);
		});
		return list;
	}

	/**
	 * 将map集合转为为一个确定的类型
	 *
	 * @param <T>
	 * @param map
	 * @param t
	 * @return
	 */
	private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
		T obj = null;
		try {
			// 根据提供的Class对象创建对应的Object
			obj = t.newInstance();
			// 获取Class中的所有Field
			Field[] fields = t.getDeclaredFields();
			// 遍历获取每一个属性对象
			for (Field field : fields) {
				// 获取属性名
				String fname = field.getName();
				// 获取属性值
				Object value = map.get(fname);
				if (Objects.nonNull(value)) {

					// 设置属性对象的可访问性
					field.setAccessible(true);
					// 将从map中获取的值设置属性
					field.set(obj, value);
				}
			}
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return obj;
	}

	/**
	 * 执行相关查询并将结果返回为List<Map<String,Object>>集合
	 *
	 * @param sql
	 * @param params
	 * @return
	 */
	public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
		// 声明动态数组用于存储每一个查询到的Map对象
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		// 获取连接
		Connection conn = getConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			// 获取预处理sql命令的对象
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					// 对指定位置的占位符填充值(预处理)
					ps.setObject(i + 1, params[i]);
				}
			}
			// 执行查询获取结果
			rs = ps.executeQuery();
			// 获取结果集的元数据对象ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 获取总列数
			int columnCount = rsmd.getColumnCount();
			// 遍历结果集
			while (rs.next()) {
				// 声明map集合存储每一条数据
				Map<String, Object> map = new HashMap<String, Object>();
				// 遍历获取每一列的信息
				for (int i = 1; i <= columnCount; i++) {
					// 获取列名称(作为map集合的键)
					String key = rsmd.getColumnName(i);
					// 获取列标签
					String lable = rsmd.getColumnLabel(i);
					// 获取列值(作为map集合的值)
					Object value = rs.getObject(lable);
					if (Objects.nonNull(value)) {
						// 将取到的每一列的列名与列值存储到map
						map.put(key, value);
					}
				}
				// 将map集合装入list
				list.add(map);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, ps, conn);
		}
		return list;
	}

	public static int queryCount(String sql, Object... params) {
		Connection conn = getConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[1]);
				}
			}
			rs = ps.executeQuery();
			if (rs.next()) {
				return rs.getInt(1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}

		return 0;
	}

}