本文已参与「新人创作礼」活动，一起开启掘金创作之路。

最近帮一个朋友整他的课设，要求使用jsp和servlet以及mysql实现一个系统，Dao层的部分如果不借助Hibernate或者mybatis框架的话，就需要写很多的原生SQL，而且还需要处理ResultSet，最主要的是，每一个功能都需要写一个Dao文件，里面有很多需求相似的语句，可能会重复很多遍差不多的SELECT、UPDATE、DELETE语句，作为完成任务这样写肯定没问题，但是略枯燥，正好最近又看了看反射，决定用反射加原生SQL实现一个最简单的ORM框架，能够解决基本需求就够了。

1.命名约定

为了简化问题，首先表和实体类命名必须遵守某种规范，否则需要自己写一些配置的注解等去进行映射，这样会增加通用性但是没有必要，够用就行了。这里描述一下实体类和表的命名约定。

1.1.表名

表名采用小写字母加下划线的方式，多个单词之间用下划线隔开，如user_group这样，其中的字段也这么命名。

1.2.实体类名

实体类名使用驼峰式命名法，以Entity结尾，实体类命名与对应的表的名称有关，就是将各单词之间用大写的方式分隔开，如user_group表对应的实体类为userGroupEntity，类成员也按驼峰式命名。

2.声明Dao层抽象父类

这里我声明了一个拥有泛型的抽象父类BaseDao，泛型以后会指明为对应的实体类

public abstract class BaseDao<T> {}

使用泛型的好处是可以通过反射等操作获取实体类名，可以在类中定义一个Class对象保存实体类并在构造方法中获取实体类的值

private Class<T> entityClass;
    public BaseDao() {
        this.entityClass = null;
        Class<?> c = getClass();
        Type type = c.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
            this.entityClass = (Class<T>) parameterizedType[0];
        }
    }

3.编写辅助方法

根据之前定义的命名方式，我们需要编写一个变量名从java方式到sql方式转换的方法：

/**
     * 获取sql形式的变量名
     * @param str Java格式变量名
     * @return
     */
    public String getSqlFieldName(String str){
        for(int i=0;i<str.length();i++){
            if(i!=0 && str.charAt(i) > 'A' && str.charAt(i) < 'Z'){
                str = str.replace(""+str.charAt(i),"_" + (char)(str.charAt(i) - 'A' + 'a'));
            }
        }
        return str.toLowerCase();
    }

获取实体类表名的方法，通过实体类和刚才的转换方法可以轻松完成：

/**
     * 获取表名
     * @return
     */
    private String getTableName(){
        String tableNames[] = entityClass.getTypeName().split("\\.");
        String tableName = tableNames[tableNames.length-1];
        tableName = tableName.substring(0,tableName.length()-6);
        tableName = getSqlFieldName(tableName);
        return tableName;
    }

最后实现一个获取数据库连接的方法：

/**获得数据库的连接，以进行其他操作
     *
     * @return 数据库连接
     */
    protected Connection getConnect(){
        Connection connection=null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            connection = DriverManager.getConnection(URL+DATEBASE,USERNAME,PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

4.编写根据sql执行的方法

这里的方法有三个，一个是直接执行无返回值的execute，一个查询返回一个对象queryOne，一个查询返回对象列表queryList，他们参数都有两个，一个是设置了占位符的字符串类型SQL语句，一个是Object类型的参数数组。 既然使用了占位符，肯定要使用PreparedStatement语句，这三个方法都需要给它设置参数，所以我抽象出一个方法获取设置好了参数的PreparedStatement对象，只需要根据参数的类型调用对应的set方法即可：

    protected PreparedStatement getPreparedStatement(Connection connection,String sql,Object [] params) throws SQLException {

        // 预准备语句
        PreparedStatement ps = connection.prepareStatement(sql);
        if(params == null)
            return ps;
        int index = 1;
        // 设置参数
        for(int i=0;i<params.length;i++){

            Object param = params[i];
            if(param == null)
                continue;
            if(param.getClass() == Integer.class){
                ps.setInt(index++, (Integer) param);
            }else if(param.getClass() == Double.class){
                ps.setDouble(index++, (Double) param);
            }else if(param.getClass() == String.class){
                ps.setString(index++, (String) param);
            }else if(param.getClass() == Long.class){
                ps.setLong(index++,(Long)param);
            }
        }
        return ps;
    }

之后就可以实现execute方法了，只需要获取连接，获取预处理语句，最后关闭连接即可：

/**
     * 执行sql
     * @param sql SQL语句
     * @param params  参数
     * @throws SQLException
     */
    protected void execute(String sql,Object[] params) throws Exception {
        // 获取连接
        Connection connection = getConnect();
        // 设置准备语句
        PreparedStatement ps = getPreparedStatement(connection,sql,params);
        // 执行
        ps.execute();
        // 关闭
        connection.close();
    }

接下来是两个略微复杂的查询方法，之所以查询，是因为要处理ResultSet，于是这里我实现了一个根据ResultSet直接自动填充获取实体类的方法：

/**
     * 根据result获取实体
     * @param resultSet
     * @return
     */
    public Object getEntity(ResultSet resultSet) throws IllegalAccessException, InstantiationException, SQLException {
        // 新建实体类
        Object object = entityClass.newInstance();
        // 获取成员变量
        Field fields[] = entityClass.getDeclaredFields();
        // 处理所有成员变量
        for(Field field:fields){
            // 设置可访问
            field.setAccessible(true);

            if(field.getType().equals(int.class)){
                // 设置int型变量
                field.setInt(object,resultSet.getInt(getSqlFieldName(field.getName())));
            }else if(field.getType().equals(String.class)){
                // 设置String型变量
                field.set(object,resultSet.getString(getSqlFieldName(field.getName())));
            }else if(field.getType().equals(double.class)){
                // 设置String型变量
                field.set(object,resultSet.getDouble(getSqlFieldName(field.getName())));
            }else if(field.getType().equals(Timestamp.class)){
                // 设置timestamp型变量
                field.set(object,resultSet.getTimestamp(getSqlFieldName(field.getName())));
            }else if(field.getType().equals(long.class)){
                field.set(object,resultSet.getLong(getSqlFieldName(field.getName())));
            }
        }
        return object;
    }

有了这个方法查询一个对象就会变得简单不少，查询多个对象只需要解析多次获取多个实体类即可，于是可以实现两个query方法：

/**
     * 查询一个列表
     * @param sql SQL语句
     * @param params 参数列表
     * @return 返回结果
     * @throws SQLException
     */
    protected List<T> queryList(String sql,Object...params) throws Exception {
        // 获取连接
        Connection connection = getConnect();
        // 设置准备语句
        PreparedStatement ps = getPreparedStatement(connection,sql,params);
        // 获取结果集
        ResultSet res = ps.executeQuery();
        // 新建结果列表
        List<T> list = new ArrayList<>();
        while(res.next()){
            T t = (T) getEntity(res);
            list.add(t);
        }
        // 关闭
        connection.close();
        // 返回结果
        return list;
    }

    /**
     * 查询一条
     * @param sql SQL语句
     * @param params 参数列表
     * @return 执行结果
     * @throws SQLException
     */
    protected T queryOne(String sql,Object...params) throws Exception {
        // 获取连接
        Connection connection = getConnect();
        // 设置准备语句
        PreparedStatement ps = getPreparedStatement(connection,sql,params);
        // 获取结果集
        ResultSet res = ps.executeQuery();
        T t;
        if(res.next()){
            t = (T) getEntity(res);
        }else {
            t = null;
        }
        // 关闭
        connection.close();
        // 返回结果
        return t;
    }

有了这些方法，我们便可以在子类中简化SQL的编写填充，此外后面的增删改查也是基于这些方法的。

5.编写实体类的增删查改方法

首先是增的save方法，这里我动态构造了SQL语句与参数列表，然后调用execute方法进行实际的执行，而构造的原理也是基于反射的：

   /**
     * 常规保存方式
     * @param t
     */
    public void save(T t) throws Exception{
        String tableName = getTableName();
        // 构造SQL语句
        StringBuilder sqlBuilder = new StringBuilder();
        sqlBuilder.append("INSERT INTO ").append(tableName).append("(");
        Field[] fields = entityClass.getDeclaredFields();
        Object params[] = new Object[fields.length];
        for(int i=0;i<fields.length;i++){
            fields[i].setAccessible(true);

            params[i] = fields[i].get(t);
        }
        for(int i=0;i<fields.length;i++){
            if(params[i] != null)
                sqlBuilder.append(getSqlFieldName(fields[i].getName())).append(",");
        }
        sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
        sqlBuilder.append(")");
        sqlBuilder.append(" VALUES(");
        for(int i=0;i<fields.length;i++){
            if(params[i] != null)
                sqlBuilder.append("?,");
        }
        sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
        sqlBuilder.append(")");


        execute(sqlBuilder.toString(),params);
    }

删除和查询方法就更简单了，甚至不需要使用反射，只需要拿到主键的值即可，构造sql语句后分别调用execute方法和queryOne方法：

    /**
     * 根据主键获取某个对象
     * @param id 主键
     * @return
     * @throws Exception
     */
    public T get(Object id) throws Exception {
        String tableName = getTableName();
        String sql = "SELECT * FROM " + tableName + " WHERE id=?";
        return queryOne(sql,id);
    }
    
    /**
     * 删除表中某一个数据
     * @param id 主键
     */
    public void delete(Object id) throws Exception {
        String tableName = getTableName();
        StringBuilder sqlBuilder = new StringBuilder();
        sqlBuilder.append("DELETE FROM ").append(tableName).append(" WHERE id=?");
        Object[] params = {id};
        execute(sqlBuilder.toString(),params);
    }

对于更改，本来我想直接传入实体类对象作为参数，但因为没有缓存的缘故，要么就把一个记录所有的字段都更新了，要么就查询找出发生变化的字段更新。但这两种的代价都太大，所以我决定传入发生变化成员-值映射字典进行更新，当然更新还需要指明主键，同样需要动态构造SQL语句：

    /**
     * 更新数据库中某一个对象
     * @param id 对象主键
     * @param paramMap 需要进行改变的成员-成员值映射
     */
    public void update(Object id, Map<String,Object> paramMap) throws Exception {
        String tableName = getTableName();
        // 构造SQL语句
        StringBuilder sqlBuilder = new StringBuilder();
        sqlBuilder.append("UPDATE ").append(tableName).append(" SET ");
        // 获取Map的键集合
        Set<String> set = paramMap.keySet();

        for(String key:set){
            sqlBuilder.append(key).append("=").append("?,");
        }
        sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
        sqlBuilder.append(" WHERE id=?");

        Object params[] = new Object[set.size()+1];
        int index = 0;
        for(String key:set){
            params[index++] = paramMap.get(key);
        }
        params[index] = id;
        execute(sqlBuilder.toString(),params);
    }

最后是一个多条记录的查询，利用lastId和length来实现分页：

/**
     * 获取下一页的对象列表
     * @param lastId
     * @param length
     */
    public List<T> getNextPage(Object lastId,int length) throws Exception {
        String tableName = getTableName();
        StringBuilder sqlBuilder = new StringBuilder().append("SELECT * FROM " + tableName + " WHERE id>? LIMIT ");
        sqlBuilder.append(length);
        Object params[] = {lastId};
        return queryList(sqlBuilder.toString(),params);
    }

到这里，所有基本方法都已经实现了。

6.使用

BaseDao虽然很复杂，但是好处也很明显，就是子类基本上不需要增加什么方法就能实现大部分的业务，当然如果实在是查询过于复杂，也可以自己编写SQL语句，然后调用execute和query那三个方法来执行，但目前为止，还没有那么复杂的业务逻辑，所以基本上Dao层只需要继承一下BaseDao就可以交给Service层使用了：

public class EmployerDao extends BaseDao<EmployerEntity> {

    public static void main(String args[]){
        EmployerDao employerDao = new EmployerDao();
        EmployerEntity employerEntity = null;
        try {
            employerEntity = employerDao.get("zhang3");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(employerEntity.getName());
    }
}

可见运行正常。