基于jdbc的增删改查封装方法

package project_test.test;

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

import com.alibaba.druid.pool.DruidDataSource;

/**
 * 通用数据库工具类，基于Druid连接池实现
 * 包含以下功能：
 * 1.获取连接
 * 2.关闭资源
 * 3.执行通用的更新操作
 * 4.执行通用的查询操作
 * 5.执行通用的查询单挑记录操作
 * @author 我的好伙伴
 *
 */
public class DBUtils {

    // 声明druid连接池
    private static DruidDataSource pool;
    // 数据库链接URL地址
    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;
    // 属性文件位于src根目录时，加“/”则不要使用ClassLoader；如果使用ClassLoader则无需“/”
    private static String fileName = "/jdbc";

    static {
        init();
    }

    /**
     * 加载获取属性文件信息并设置给连接信息
     * 
     * @param propName
     */
    private static void loadProp(String propName) {
        fileName = propName;
        try {
            InputStream is = DBUtils.class.getResourceAsStream(fileName);
            Properties p = new Properties();
            p.load(is);

            url = p.getProperty("jdbc.url");
            username = p.getProperty("jdbc.username");
            password = p.getProperty("jdbc.password");

            initialSize = Integer.parseInt(p.getProperty("initialSize"));
            maxActive = Integer.parseInt(p.getProperty("maxActive"));
            minIdle = Integer.parseInt(p.getProperty("minIdle"));
            maxWait = Integer.parseInt(p.getProperty("maxWait"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private static void init() {
        pool = new DruidDataSource();
        loadProp(fileName);
        pool.setUrl(url);
        pool.setUsername(username);
        pool.setPassword(password);
        // 设置连接池中初始连接数
        pool.setInitialSize(initialSize);
        // 设置最大连接数
        pool.setMaxActive(maxActive);
        // 最小闲置连接
        pool.setMinIdle(minIdle);
        // 设置最大等待时间（等待获取连接的时间）
        pool.setMaxWait(maxWait);
    }

    public static Connection getCon() {
        try {
            // 若连接池为空或者异常关闭，则重新初始化一个
            if (pool == null || pool.isClosed()) {
                init();
            }
            return pool.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 资源关闭
     * 
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt, Connection con) {
        try {
            if (stmt != null) {
                stmt.close();
            }
            if (con != null) {
                con.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 更新方法
     * 
     * @param sql
     * @param obj
     * @return
     */
    public static boolean exeUpdate(Connection con,String sql, Object... obj) {
    
        PreparedStatement ps = null;
        try {
            
            ps = con.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;
    }

    /**
     * 查询多行
     * 
     * @param args
     */
    public static <T> List<T> selectListAll(Class<T> t, String sql, Object... params) {
        Connection con = null;
        PreparedStatement ps = null;
        List<T> list = new ArrayList<>();
        T obj = null;
        try {
            con = getCon();
            ps = con.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集合，临时存储一行数据
            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对象中，并存入list集合
                if (!map.isEmpty()) {
                    // 获取map集合键值集（列名集合）
                    Set<String> columnNames = map.keySet();
                    // 创建对象
                    obj = t.newInstance();
                    for (String column : columnNames) {
                        // 根据键获取值
                        Object value = map.get(column);
                        if (Objects.nonNull(value)) {
                            // 获取属性对象
                            Field f = t.getDeclaredField(column);
                            // 设置属性为可访问状态
                            f.setAccessible(true);
                            // 为属性设值
                            f.set(obj, value);

                        }
                    }
                    list.add(obj);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();

        }
        return list;
    }

    /**
     * 查询一个
     * 
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> T selectListOne(Class<T> t, String sql, Object... params) {
        Connection con = null;
        PreparedStatement ps = null;
        T obj = null;
        try {
            con = getCon();
            ps = con.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
            ResultSet rs = ps.executeQuery();
            // 获取结果集中的数据列，类型等
            ResultSetMetaData rsmd = rs.getMetaData();
            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 f = t.getDeclaredField(cname);
                        // 设置属性为可访问状态
                        f.setAccessible(true);
                        // 为属性设值
                        f.set(obj, value);
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();

        }
        return obj;
    }

    public static void main(String[] args) {
        System.out.println(getCon());
    }

}