数据库编程【二】封装数据库工具类

小灰灰 2022-05-22 06:24 195阅读 0赞

本章节主要介绍一下JDBC的使用流程，以及一个封装好的工具类。

## 一、JDBC使用基本流程 ##

Java建立一个数据库连接并对数据库进行访问需要进行以下几个步骤：

（1）加载数据库驱动程序。

（2）创建数据库的连接。

（3）使用SQL语句对数据库进行操作。

（4）对数据库操作的结果进行处理。

（5）关闭相关资源对象和数据库连接，释放资源。

## 二、封装好的工具类代码 ##

import java.sql.*;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * 数据库抽象工厂(提供执行增删改查的静态方法)
     * 在调用其静态方法时,最好用try/catch块包括起来,执行SQL语句的静态方法都进行了抛出异常的处理。
     * 此类为final类。直接调用其静态方法即可。
     *
     * @version 1.0.0
     * @日期 2018.6.16
     * @author charlie
     */
    
    public final class DBUtils {
    
        public static void main(String[] args) {
            try {
                testInsert();
                testGetScalar();
            } catch (Exception e) {
                System.out.println("异常:"+e.getMessage());
            }
        }
    
        /**
         * 插入数据
         */
        public static void testInsert()throws Exception{
            String sql="insert into user(name,account,password) values( ?, ?,? )";
            int nResult=executeUpdate(sql,new Object[]{"charlie","charlie","charlie"});
            if(nResult > 0){
                System.out.println("插入数据成功");
            }else{
                System.out.println("插入数据失败");
            }
        }
    
    
        /**
         * 测试获取第一行第一列
         * @throws Exception
         */
        public static void testGetScalar() throws Exception{
            String sql ="select count(*) from user";
            long count=(long)getScalar(sql, new Object[]{});
            System.out.println("count="+count);
        }
    
    
        /**
         * 加载数据库驱动程序字符串
         * SQL Server:com.microsoft.sqlserver.jdbc.SQLServerDriver
         * MySQL:com.mysql.jdbc.Driver
         */
        private static final String JDriver = "com.mysql.jdbc.Driver";
        /**
         * 数据库连接字符串
         * SQL Server连接字符串:jdbc:sqlserver://127.0.0.1:1433;DatabaseName=DB_MyShare
         * MySQL连接字符串:jdbc:mysql://localhost:3306/testmybatis
         */
        private static final String connectionString = "jdbc:mysql://localhost:3306/testmysql";
    
        /**
         * 数据库登录账号
         */
        private static final String USER="root";
    
        /**
         * 数据库登录密码
         */
        private static final String PASSWORD="root";
    
        /**
         * 获取数据库连接对象
         * @return 数据库连接对象
         * @throws Exception
         */
        public static Connection getConnection() throws Exception{
            Connection connection;
            try {
                try {
                    //加载数据库驱动程序
                    Class.forName(JDriver);
                }
                catch (ClassNotFoundException e) {
                    // e.printStackTrace();
                    throw new Exception("加载数据库驱动程序失败...");
                }
                //获取数据库连接
                connection= DriverManager.getConnection(connectionString,USER,PASSWORD);
            } catch (Exception e) {
                // TODO: handle exception
                throw new Exception("建立数据库连接失败...");
            }
            return connection;
        }
    
        /**
         * 提供往数据库添加、删改和修改的功能
         * @param sql 一条有效的SQL语句
         * @param params 以数组形式提供SQL语句中用到的参数列表
         * @return 受影响行数
         * @throws Exception
         */
        public static int executeUpdate(String sql,Object[] params) throws Exception{
            //初始化数据库连接对象
            Connection connection=getConnection();
            //创建预编译的SQL语句的对象,即SQL命令对象
            PreparedStatement ps=null;
            //方法返回值
            int value=-1;
            try {
                //初始化命令对象
                ps=connection.prepareStatement(sql);
                if(params!=null){
                    //绑定参数到命令对象
                    for (int i = 0; i < params.length; i++) {
                        ps.setObject(i + 1, params[i]);
                    }
                }
    
                //执行命令,返回结果
                value=ps.executeUpdate();
                //关闭命令对象
                ps.close();
            } catch (Exception e) {
                // TODO: handle exception
                throw e;
            }finally{
                if(ps!=null){
                    //关闭命令对象
                    ps.close();
                }
                if(connection!=null){
                    //关闭数据库连接
                    connection.close();
                }
            }
            return value;
        }
    
    
        /**
         * 获取结果集表,即将结果集的数据存放List对象中
         * @param sql 一条有效的SQL语句
         * @param params 以数组形式提供SQL语句中用到的参数列表
         * @return List对象
         * @throws Exception
         */
        @SuppressWarnings({ "unchecked", "rawtypes" })
        public static List getList(String sql, Object[] params) throws Exception {
            //初始化数据库连接对象
            Connection connection=getConnection();
            //创建命令对象
            PreparedStatement ps = null;
            //创建结果集对象
            ResultSet rs = null;
            //创建List对象
            List list = new ArrayList();
            try {
                //初始化命令对象
                ps=connection.prepareStatement(sql);
                if(params!=null){
                    //绑定参数到命令对象
                    for (int i = 0; i < params.length; i++) {
                        ps.setObject(i + 1, params[i]);
                    }
                }
    
                /*
                 * 注意:获取结果集之时,不能关闭命令对象和数据库连接,否则结果集就读取不到数据
                 * 在使用结果集完毕后再关闭数据库连接即可
                 */
                //获取结果集
                rs = ps.executeQuery();
                ResultSetMetaData resultSetMetaData =rs.getMetaData();
                int columns =resultSetMetaData.getColumnCount();
                while (rs.next()) {
                    Map m = new HashMap();
                    for (int i = 0; i < columns; i++) {
                        Object obj = null;
                        int type = resultSetMetaData.getColumnType(i+ 1);
                        int scale = resultSetMetaData.getScale(i + 1);
                        String columnName =resultSetMetaData.getColumnName(i + 1);
                        switch (type) {
                            case -1:
                                obj =rs.getObject(columnName);
                                break;
                            case 1:
                                obj =rs.getCharacterStream(columnName);
                                break;
                            case -5:
                                obj = Long.valueOf(rs.getLong(columnName));
                                break;
                            case 2:
                                switch (scale) {
                                    case 0:
                                        obj = Integer.valueOf(rs.getInt(columnName));
                                        break;
                                    case -127:
                                        obj = Float.valueOf(rs.getFloat(columnName));
                                        break;
                                    default:
                                        obj = Integer.valueOf(rs.getInt(columnName));
                                }
                                break;
                            case 12:
                                obj =rs.getString(columnName);
                                break;
                            case 91:
                                obj =rs.getDate(columnName);
                                break;
                            case 93:
                                obj =rs.getTimestamp(columnName);
                                break;
                            case 2004:
                                obj =rs.getBlob(columnName);
                                break;
                            default:
                                obj =rs.getString(columnName);
                        }
                        m.put(columnName.toUpperCase(), obj);
                    }
                    list.add(m);
                }
            } catch (Exception e) {
                throw e;
            } finally {
                if(rs!=null){
                    //关闭结果集
                    rs.close();
                }
                if(ps!=null){
                    //关闭命令对象
                    ps.close();
                }
                if(connection!=null){
                    //关闭数据库连接
                    connection.close();
                }
            }
            return list;
        }
    
    
        /**
         * 获取第一行第一列
         * @param sql 一条有效的SQL语句
         * @param params 以数组形式提供SQL语句中用到的参数列表
         * @return Object对象
         * @throws Exception
         */
        public static Object getScalar(String sql,Object[] params) throws Exception{
            //初始化数据库连接对象
            Connection connection=getConnection();
            //创建预编译的SQL语句的对象,即SQL命令对象
            PreparedStatement ps=null;
            //创建结果集对象
            ResultSet rs=null;
            //创建Object对象
            Object obj=null;
            try {
                //初始化命令对象
                ps=connection.prepareStatement(sql);
                if(params!=null){
                    //绑定参数到命令对象
                    for (int i = 0; i < params.length; i++) {
                        ps.setObject(i + 1, params[i]);
                    }
                }
    
                //执行命令
                rs=ps.executeQuery();
                while(rs.next()){
                    obj=rs.getObject(1);
                }
            } catch (Exception e) {
                // TODO: handle exception
                throw e;
            }finally{
                if(rs!=null){
                    //关闭结果集
                    rs.close();
                }
                if(ps!=null){
                    //关闭命令对象
                    ps.close();
                }
                if(connection!=null){
                    //关闭数据库连接
                    connection.close();
                }
            }
            return obj;
        }
    
        /**
         * 获取数据表的某一行数据
         * @param sql 一条有效的SQL语句
         * @param params 以数组形式提供SQL语句中用到的参数列表
         * @return map键值对对象
         * @throws Exception
         */
        @SuppressWarnings("rawtypes")
        public static Map uniqueQuery(String sql, Object[] params) throws Exception {
            Map m = null;
            List list = getList(sql, params);
            if ((list != null) && (list.size() > 0)) {
                m = (Map) list.get(0);
            }
            return m;
        }
    
    }