mysql数据库自做简易框架

在这里插入代码片
package org.zdy.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.*;

/**
 * @Author zdy 2020/8/6 11:32
 */
public class DBUtils {
    /** 驱动类路径 */
    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 ;

    static {

        InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
        Properties p = new Properties();
        try {
            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"));
            MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));
            INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
            init();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void init() {
        ds= new DruidDataSource();
        // 设置最大连接数
        ds.setMaxActive(MAX_ACTIVE);
        // 设置最小限制数
        ds.setMinIdle(1);
        // 初始连接个数
        ds.setInitialSize(INIT_SIZE);
        // 设置获取连接最大的等待时间
        ds.setMaxWait(MAX_WAIT);
        ds.setDriverClassName(DRIVER_CLASS);
        ds.setUrl(URL);
        ds.setUsername(USER);
        ds.setPassword(PASSWORD);

    }

    /**
     * 数据库获取连接
     *
     * @return
     */
    public static synchronized Connection getConn() {
        try {
            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
     * @throws SQLException
     */
    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;
    }

    /**
     * 封装通用的查询一条数据
     *
     * @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 = queryMap(sql, params);
        if (list.size() > 0) {
            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 = queryMap(sql, params);
        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）创建对应类型的对象
            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);
                }
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * 执行相关查询之后并将结果返回List<Map<String,Object>> 集合
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> queryMap(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);
                    // 获取列值
                    Object value = rs.getObject(label);
                    // 将取到的没一列的列名列值存储到map集合
                    if (Objects.nonNull(value)) {
                        map.put(key, value);
                    }
                }
                // 将map集合装到list集合中
                list.add(map);
            }

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

    /**
     * 根据提供的sql语句以及查询的参数，返回符合的数目
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static int queryCount(String sql, Objects... 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);
                }
            }
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException e) {

            e.printStackTrace();
        }
        return 0;
    }

    public static void main(String[] args) {

        String sql = "select * from emp";
        DBUtils.queryCount(sql);

    }
}