基于反射实现DBUtils封装（读取数据库数据生成对象或对象集合以及对数据库的CRUD）version2.0

DBUtils version2.0 附带jdbc.properties配置文件

支持操作：

1.加载驱动
2.获取数据库连接对象
3.关闭资源
4.封装通用的更新操作：INSERT UPDATE DELETE
5.封装通用查询单条数据的方法
(JDBC，反射，集合框架，lambda表达式，新增Objects类)
6.封装通用查询多条数据的方法
7.将Map集合转换为一个确定的类型
8.执行相关查询并将结果返回为List<Map<String,Object>>集合
9.根据提供的查询语句以及查询参数，返回符合条件的数目

Resul

/*
 * Copyright (c) 2020. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 * Morbi non lorem porttitor neque feugiat blandit. Ut vitae ipsum eget quam lacinia accumsan.
 * Etiam sed turpis ac ipsum condimentum fringilla. Maecenas magna.
 * Proin dapibus sapien vel ante. Aliquam erat volutpat. Pellentesque sagittis ligula eget metus.
 * Vestibulum commodo. Ut rhoncus gravida arcu.
 */
package com.softeem.lesson51.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;

/**
 * ORM框架（Mybatis,Hibernate,spring Data JPA）
 * 数据库工具类V2.0 将访问数据库的公共代码抽取: 1.加载驱动 2.获取连接 6.关闭资源
 * @author 洲小徐
 *
 */
public class DBUtils {

    /** 驱动类路径 */
    private static String DRIVER_CLASS;
    /** url地址 */
    private static String URL;
    /** 数据库服务器登录用户名 */
    private static String USER;
    /** 数据库服务器登录密码 */
    private static String PASSWORD;

    static {
        try {
            //读取属性文件获取连接数据库相关的字符串
            InputStream is = DBUtils.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");

//			 1.加载驱动
            Class.forName(DRIVER_CLASS);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 2. 获取数据库连接对象
     *
     * @return
     */
    public static synchronized Connection getConn() {
        try {
            return DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 6.关闭资源
     *
     * @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 Object[] 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;
    }

    /**
     * 封装通用查询单条数据的方法
     * JDBC，反射，集合框架，lambda表达式，新增Objects类
     *
     * @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
            T 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中获取的值设置给属性  obj.name=XX
//					field.set(obj, value);
//				}
//			}
            map.forEach((k, v) -> {
                try {
                    // 根据Field名称获取字段对象
                    Field field = t.getDeclaredField(k);
                    // 设置字段的可访问性
                    field.setAccessible(true);
                    // 为字段设置值
                    field.set(obj, v);
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            return obj;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        // 返回对象
        return null;
    }

    /**
     * 执行相关查询并将结果返回为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 label = rsmd.getColumnLabel(i);
                    // 获取列值（作为map集合的值）
                    Object value = rs.getObject(label);
                    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;
    }

    /**
     * 根据提供的查询语句以及查询参数，返回符合条件的数目
     *
     * @param sql
     * @param params
     * @return
     */
    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[i]);
                }
            }
            rs = ps.executeQuery();
            if(rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            close(rs, ps, conn);
        }
        return 0;
    }
}

jdbc.properties（配置文件）

#
# Copyright (c) 2020. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
# Morbi non lorem porttitor neque feugiat blandit. Ut vitae ipsum eget quam lacinia accumsan.
# Etiam sed turpis ac ipsum condimentum fringilla. Maecenas magna.
# Proin dapibus sapien vel ante. Aliquam erat volutpat. Pellentesque sagittis ligula eget metus.
# Vestibulum commodo. Ut rhoncus gravida arcu.
#

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/homework?character=utf8
user=root
password=zhouzhou

# connection pool settings
pool.maxActive=10
pool.initSize=5
pool.maxWait=30000