JDBC基本简易封装代码

代码如下（示例）：

public class DBUtils2 {
    /**驱动类路径*/
    private  static final String Driver_CLASS ="com.mysql.jdbc.Driver";
    /**URL地址*/
    private static final String URL="jdbc:mysql://localhost:3306/test";
    /**登录数据库服务器的账号*/
    private static final String USER="root";
    static{
        try {
            //1.加载驱动
            Class.forName(Driver_CLASS);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**登录数据库服务器的密码*/
    private static final String PASSWORD="123456";

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

    public static void close(ResultSet rs, Statement stat,Connection con)
    {
        try {
            if(rs!=null){
                rs.close();
            }
            if(stat!=null){
                stat.close();
            }
            if(con!=null){
                con.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 封装通用的更新操作
     * @param sql   需要被执行sql语句
     * @param params 执行sql语句时需要传递的参数
     * @return   执行结果
     */
    public static boolean exeUpdate(String sql,Object...params){
        Connection con=getcon();
        PreparedStatement ps=null;
        try {
           ps=con.prepareStatement(sql);
           //当传入的参数不为空时执行预处理
           if(Objects.nonNull(params)){
               for (int i = 0; i <params.length ; i++) {
                   ps.setObject(i+1,params[i]);
               }
           }
           //执行更新
            return ps.executeUpdate()>0;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            DBUtils2.close(null,ps,con);
        }
        return false;
    }

    public static boolean exeUpdate(Connection conn,String sql,Object...params) throws SQLException {
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            //当传入的参数不为空时执行预处理
            if (Objects.nonNull(params)) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            //执行更新
            return ps.executeUpdate() > 0;
        } finally {
            DBUtils2.close(null, ps, null);
        }
    }

        public static Object queryOne(String sql, Callback call, Object...params){
        Connection con=getcon();
            PreparedStatement ps=null;
            ResultSet rs=null;
            try {
                ps=con.prepareStatement(sql);
                if(Objects.nonNull(params)){
                    for(int i=0;i<params.length;i++){
                        ps.setObject(i+1,params[i]);
                    }
                    rs=ps.executeQuery();
                    //将结果集转为object返回
                    return call.toObject(rs);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                DBUtils.close(rs,ps,con);
            }
            return null;
        }
        public interface  Callback{
            /**
             * 将结果集转换为object对象
             * @param rs
             * @return
             */
         default Object toObject(ResultSet rs){
             return null;
         }

            /**
             * 将结果转为个List集合,查询多条记录
             * @param rs
             * @return
             */
         default List toList(ResultSet rs){
             return null;
         }
        }
    public static List<Map<String,Object>> queryToMap(String sql,Object...params) {
        //先申明一个List集合存储查询到的所有数据(内部的每一条数据使用一个Mao对象表示)
        List<Map<String,Object>> list=new ArrayList<>();
        Connection con= DBUtils2.getcon();
        PreparedStatement ps=null;
        ResultSetMetaData rsmd=null;
        try {
             ps=con.prepareStatement(sql);
            if(Objects.nonNull(params)){
                for(int i=0;i<params.length;i++){
                    ps.setObject(i+1,params[i]);
                }
            }
            ResultSet rs=ps.executeQuery();
            //获取结果集元数据对象
           rsmd=rs.getMetaData();
            //获取总的查询列数
            int columnCount =rsmd.getColumnCount();
            while(rs.next()){
                Map<String,Object> map=new HashMap<>();
                //获取每一列的列标签
                for(int i=1;i<=columnCount;i++){
                    //获取指定的列标签
                    String cname=rsmd.getColumnLabel(i);
                    //根据列标签获取列值
                    Object value=rs.getObject(i);
                    //将一个查询列表装入map
                    map.put(cname,value);
                }
                //将map集合(javabean) 存储到List
                list.add(map);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
        }

        return list;
    }
    /**
     * 封装通用查询单条数据的方法
     *
     * 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 = queryToMap(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 = queryToMap(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) {
        try {
            // 根据提供的Class对象创建对应类型的Object
            T obj = t.newInstance();
            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;
    }