JDBC——封装工具

JDBC

JDBC(Java Database Connectivity)，即java 连接数据库技术，是由java.sql包中提供的一系列接口构成，通过这些接口结合不同的数据库管理系统的驱动包，可以非常轻松的实现java访问数据库。

JDBC连接数据库步骤

jdbc连接数据库有六个步骤：
1.加载数据库驱动（JDBC4之后无需编写）
2.获取连接
3.获取执行SQL语句命令的对象
4.执行SQL语句
5.处理结果
6.关闭资源

JDBC封装

在用jdbc连接数据库进行操作时，每次都得进行上面的六个步骤，会造成有很多的重复代码，为了减少工作量，使代码看起来更简洁，故尝试对这些重复代码进行封装。在封装过程中使用到了反射、泛型、数据库连接池（Druid）等技术。
获取连接

    /**
     * 声明连接池
     */
    private static DruidDataSource ds;

    public static synchronized Connection getconn() {
        try {
            //当连接池为null或被关闭时，重新初始化
            if (ds == null || ds.isClosed()) {
                init();
            }
            //重连接池中获取一个连接并返回
            return ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

关闭资源

    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操作

    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;
    }

	/**
	* 用于事务的处理
	*/
    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;
    }

将一个map集合转换为指定对象

    private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
        T obj = null;
        try {
            obj = t.newInstance();
            //获取类中的所有属性
            Field[] fields = t.getDeclaredFields();
            //获取map集合中的键集
            Set<String> strings = map.keySet();
            for (Field field : fields) {
                //修改属性为可访问
                field.setAccessible(true);
                //获取属性值
                Object value = map.get(field.getName());
                if (value != null) {
                    //为属性赋值
                    field.set(obj, value);
                }
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;
    }

执行相关查询并将结果返回为List<Map<String, Object>>

    public static List<Map<String, Object>> queryMaps(String sql, Object... params) {

        //声明一个动态数组用于去存储每一个查询到的Map对象
        List<Map<String, Object>> list = new ArrayList<>();

        //获取连接
        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 rsmd = rs.getMetaData();
            //获取总查询列数
            int columncount = rsmd.getColumnCount();
            //遍历结果集
            while (rs.next()) {
                //声明一个map集合用于存储每一条数据
                Map<String, Object> map = new HashMap<>();
                //遍历获取每一列的信息
                for (int i = 1; i <= columncount; i++) {
                    //获取列名称(作为map的键)
                    String key = rsmd.getColumnName(i);
                    //获取列标签
                    String label = rsmd.getColumnLabel(i);
                    //获取列值(作为map的值)
                    Object value = rs.getObject(label);
                    //将取到的每一列的列名和列值存储到map集合中
                    map.put(key, value);
                }
                //将map集合装入list集合中
                list.add(map);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return list;
    }

封装通用查询单条数据的方法

    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;
    }

封装通用查询多条数据的方法

    public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {

        List<T> list = new ArrayList<>();

        //获取所有查询到的数据
        List<Map<String, Object>> maps = queryMaps(sql, params);
        //遍历集合中的每一条map集合对象
        for (Map<String, Object> map : maps) {
            //将map装换为JavaBean
            T obj = mapToBean(map, t);
            //将JavaBean装入list
            list.add(obj);
        }
        return list;
    }