JDBC的简单封装

Posted 2020-10-02 诺-诺

 

　　JDBC的简单封装

　　使用JDBC来处理数据库的接口主要有三个，即Connection，PreparedStatement和ResultSet这三个，而对于这三个接口，还可以获取不同类型的元数据，通过这些元数据类获得一些数据库的信息。
元数据(MetaData)，即定义数据的数据。打个比方，就好像我们要想搜索一首歌(歌本身是数据)，而我们可以通过歌名，作者，专辑等信息来搜索，那么这些歌名，作者，专辑等等就是这首歌的元数据。因此数据库的元数据就是一些注明数据库信息的数据。

　　① 由Connection对象的getMetaData()方法获取的是DatabaseMetaData对象。

　　② 由PreparedStatement对象的getParameterMetaData ()方法获取的是ParameterMetaData对象。

　　③由ResultSet对象的getMetaData()方法获取的是ResultSetMetaData对象。

　　今天仅仅使用第二点，所以就解释一下第二点
　　　　ParameterMetaData是由PreparedStatement对象通过getParameterMetaData方法获取而来，主要是针对PreparedStatement对象和其预编译的SQL命令语句提供一些信息，比如像”insert into account(id,name,money) values(?,?,?)”这样的预编译SQL语句，ParameterMetaData能提供占位符参数的个数，获取指定位置占位符的SQL类型等等，功能也比较多，这里不列举完，详细请看有关ParameterMetaData的API文档。
Eg: getParameterCount：获取预编译SQL语句中占位符参数的个数

下面就是贴代码了：封装了几个类（类中对功能做了详细的说明）

第一个类：CommonDao  封装了对JDBC的获取连接和连接关闭， 查询和更新功能

---

 

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class CommonDAO {
    // 数据库连接url
    private static final String url = "jdbc:mysql://localhost:3306/test?Unicode=true&characterEncoding=UTF-8";
    // 数据库连接用户名
    private static final String username = "root";
    // 数据库连接密码
    private static final String password = "root";
    // 数据库驱动
    private static final String jdbcDriver = "com.mysql.jdbc.Driver";

    // 调用 ParameterMetaData.getParameterType(i + 1) 是否会抛出异常
    protected boolean pmdKnownBroken = false;

    public CommonDAO() {
    }

    public CommonDAO(boolean pmdKnownBroken) {
        this.pmdKnownBroken = pmdKnownBroken;
    }

    // 获取连接
    public Connection getConnetion() {
        Connection conn = null;
        try {
            Class.forName(jdbcDriver);
            conn = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * @Title: executeQuery
     * @Description: 执行Sql 查询语句，把结果集合放在一个 List<Map<String,Object>> 里面
     * @param sql
     * @param parmas
     * @return
     * @return List<Map<String,Object>>
     */

    @SuppressWarnings("unchecked")
    public List<Map<String, Object>> executeQuery(String sql, Object[] params) {
        return (List<Map<String, Object>>) this.excuteQuery(sql, params, new ListMapHander());
    }

    /**
     * @Title: excuteQuery
     * @Description: 查询给定的SQL语句，并且自定义的处理结果集。 调用者需要自己手动实现
     *               接口<code>ResultSetHander.doHander(ResultSet rs)</code>
     *               方法以得结果集里面的数据
     * @param sql
     * @param params
     * @param rsh
     * @return
     * @return Object
     */

    @SuppressWarnings("unchecked")
    private List<Map<String, Object>> excuteQuery(String sql, Object[] params, ResultSetHander rsh) {
        PreparedStatement stmt = null;
        ResultSet rs = null;
        Connection con = this.getConnetion();
        List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
        try {
            // 预编译sql
            stmt = con.prepareStatement(sql);
            System.out.println("SQL:" + sql + "; Parameters:" + Arrays.deepToString(params));

            // 填充Statement的参数
            fillStatement(stmt, params);
            // 执行查询
            rs = stmt.executeQuery();

            List<Map<String, Object>> list = (List<Map<String, Object>>) rsh.doHander(rs);
            return list;

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            close(con, stmt, rs);
        }
        return resultList;
    }

    public int executeUpdate(String sql, Object[] params) {
        PreparedStatement stmt = null;
        Connection con = this.getConnetion();

        int rs = 0;
        try {
            con.setAutoCommit(false);
            // 创建PreparedStatement对象
            stmt = con.prepareStatement(sql);
            // 填充Statement的参数
            fillStatement(stmt, params);
            System.out.println("SQL:" + sql + "; Parameters:" + Arrays.deepToString(params));
            // 执行查询
            rs = stmt.executeUpdate();
            // 提交事务
            con.commit();
            // 把事务设置为原来的
            con.setAutoCommit(true);
        } catch (SQLException e) {
            // 在捕获到异常的时候事务回滚
            try {
                con.rollback();
                if (!con.getAutoCommit()) {
                    con.setAutoCommit(true);
                }
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            close(con, stmt, null);
        }
        return rs;
    }

    /**
     * @Title: fillStatement
     * @Description: 填充SQL参数
     * @param stmt
     * @param params
     * @throws SQLException
     * @return void
     */
    private void fillStatement(PreparedStatement stmt, Object[] params) throws SQLException {

        // 检测参数的个数是否合法，但是有的数据库驱动不支持 stmt.getParameterMetaData()这个方法。
        // 因此我们有一个一个pmdKnownBroken 变量来标识当前数据驱动是否支持该方法的调用。
        ParameterMetaData pmd = null;
        if (!pmdKnownBroken) {
            pmd = stmt.getParameterMetaData();
            int stmtCount = pmd.getParameterCount();
            int paramsCount = params == null ? 0 : params.length;

            if (stmtCount != paramsCount) {
                System.out.println("stmtCount:" + stmtCount + ",paramsCount:" + paramsCount);
                throw new SQLException(
                        "Wrong number of parameters: expected " + stmtCount + ", was given " + paramsCount);
            }
        }

        // 如果 params 为 null 直接返回
        if (params == null) {
            return;
        }

        // 应用元数据解析填充参数
        for (int i = 0; i < params.length; i++) {
            if (params[i] != null) {
                stmt.setObject(i + 1, params[i]);
            } else {
                int sqlType = Types.VARCHAR;
                if (!pmdKnownBroken) {
                    try {
                        sqlType = pmd.getParameterType(i + 1);
                    } catch (SQLException e) {
                        pmdKnownBroken = true;
                    }
                }
                stmt.setNull(i + 1, sqlType);
            }
        }
    }

    /**
     * @Title: close
     * @Description: 关闭数据库连接
     * @param con
     * @param stmt
     * @param rs
     * @return void
     */
    private void close(Connection con, Statement stmt, ResultSet rs) {

        if (rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (stmt != null) {
                    try {
                        stmt.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    } finally {
                        if (con != null) {
                            try {
                                con.close();
                            } catch (SQLException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        } else {
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    if (con != null) {
                        try {
                            con.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } else {
                if (con != null) {
                    try {
                        con.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }
}

View Code

 第一个接口：添加了一个数据处理接口

---

 

package jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;

public interface ResultSetHander {
    //自定义处理结果集
    public Object doHander(ResultSet rs) throws SQLException;
}

View Code

实现上面的接口类：

---

 

package jdbc;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ListMapHander implements ResultSetHander {

    @Override
    public List<Map<String, Object>> doHander(ResultSet rs) throws SQLException {
        List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
        ResultSetMetaData rsmd = rs.getMetaData();
        int cols = rsmd.getColumnCount();

        HashMap<String, Object> m = null;

        // System.out.println("list 结果：");
        // 遍历结果集
        while (rs.next()) {
            m = new HashMap<String, Object>();
            // 将结果集中的数据保存到HashMap中
            for (int i = 1; i <= cols; i++) {
                System.out.println("Label:" + rsmd.getColumnLabel(i));
                System.out.println(rsmd.getColumnName(i) + "," + rs.getObject(i));
                m.put(rsmd.getColumnLabel(i), rs.getObject(i));
            }
            resultList.add(m);
        }
        return resultList;
    }

}

View Code

 下面是测试类：数据以Objcet对象数组的形式传入， 利用占位符。

---

 

package jdbc;

public class Test {
    public static void main(String[] args) {
        CommonDAO commonDAO = new CommonDAO();
        String sql = "select * from student";
        commonDAO.executeQuery(sql, null);
        /*commonDAO.executeUpdate("insert into student values (?,?,?,?,?)",
                new Object[] { "210", "彭宇", "男", "1995-02-02", "955330" });*/
        
    }
}