自己实现一个DB工具类实现ResultSet解析成List<T>

今天无聊，然后封装了一下DB的工具类，这个工具类主要作用就是解析ResultSet然后通过反射封装成List<T>

我们来看看效果吧 

这就是最终的结果

我们传入数据库配置信息，然后传sql和类来获得一个List

我们来看看代码吧

首先是构造方法，

//加载配置文件，获得链接
    public DBUtil(String propertiesPath, String usernameName, String passwordName, String urlName, String driverClassName) {
        Properties properties = new Properties();
        try {
            System.out.println("加载properties");
            properties.load(new FileInputStream(propertiesPath));
            System.out.println("properties加载完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("初始化连接池");
        druidDataSource=new DruidDataSource();
        druidDataSource.setUsername(properties.getProperty(usernameName));
        druidDataSource.setPassword(properties.getProperty(passwordName));
        druidDataSource.setUrl(properties.getProperty(urlName));
        druidDataSource.setDriverClassName(properties.getProperty(driverClassName));
        System.out.println("连接池初始化成功");
    }
           

这里我用到了德鲁伊连接池，获得properties文件在项目中的相对路径后，然后设置参数到德鲁伊

加载配置文件后，我们看看关键的代码

@Override
    public <T> List<T> getResult(String sql, Class c) {
        List<T> result = new ArrayList<T>();
        ResultSet resultSet = getResultSet(sql);
        inflateToResult(resultSet, result, c);
        return result;
    }
           

逻辑很清晰，获得ResultSet，然后解析并返回

/**
     * 获得ResultSet
     * @param sql
     * @return
     */
    private ResultSet getResultSet(String sql) {
        try {
            return getStatement().executeQuery(sql);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 获得Statement
     * @return
     */
    private Statement getStatement() {
        try {
            DruidPooledConnection connection = druidDataSource.getConnection();
            return connection.createStatement();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
           

我们再来看一下inflateToResult

/**
     * 解析ResultSet，然后把结果通过反射封装到list
     *
     * @param resultSet
     * @param result
     * @param c
     * @param <T>
     */
    private <T> void inflateToResult(ResultSet resultSet, List<T> result, Class c) {
        try {
            while (resultSet.next()) {
                result.add((T) inflateBean(resultSet, c));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
           

代码逻辑也很清晰，遍历ResultSet，然后把解析之后的Bean放到List再返回

/**
     * 解析resultset并且通过反射弄出来对象
     *
     * @param resultSet
     * @param c
     * @param <T>
     * @return
     */
    private <T> T inflateBean(ResultSet resultSet, Class c) {
        Object o = null;
        //遍历这个类的所有字段
        try {
            o = c.newInstance();
            for (Field f : c.getDeclaredFields()) {
                f.setAccessible(true);
                f.set(o, parseValueFromResultSetAndField(resultSet, f));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) o;
    }
           

这里就是通过反射创建对象，然后为每个字段设置属性进去

这里又调用了一个方法来从ResultSet来获得值

private Object parseValueFromResultSetAndField(ResultSet resultSet, Field f) {
        String colName = f.getName();

        if (f.isAnnotationPresent(Column.class)) {
            colName = f.getAnnotation(Column.class).name();
        }

        try {
            if (f.getType() == int.class || f.getType() == Integer.class) {
                return resultSet.getInt(colName);
            }
            if (f.getType() == String.class) {
                return resultSet.getString(colName);
            }
            if (f.getType() == Double.class || f.getType() == double.class) {
                return resultSet.getDouble(colName);
            }
            if (f.getType() == Date.class) {
                return resultSet.getDate(colName);
            }
            if (f.getType() == Float.class || f.getType() == float.class) {
                return resultSet.getFloat(colName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("类型为判断");
        return null;
    }
           

这里就是各种类型判断，然后从ResultSet获得值