动态SQL数据层框架（3）：BaseDao接口和BaseDaoSupport抽象类

 

这是一个简单的数据层框架，可以实现动态SQL查询、自动化事务管理、IOC和依赖注入，使用了以下技术：

1) Maven管理依赖，Github托管代码　　2) DBUtils框架作为JDBC底层框架　　3) JDK动态代理实现的AOP　　4) 注解　　5) Freemarker来做动态SQL模板的解析　　6) 工厂设计模式　　7) 反射和XML解析

从使用方式开始介绍，逐步深入地去理解框架的各个知识点。

框架主要分为两部分：
1) dynamic-sql-dao是框架主体
2) dynamic-sql-dao-test是一个demo含有测试用例

Github地址

https://github.com/xuguofeng/dynamic-sql-dao
https://github.com/xuguofeng/dynamic-sql-dao-test

 

文章目录

动态SQL数据层框架（0）：一个基于FreeMarker和DBUtils的动态SQL框架
动态SQL数据层框架（1）：DBUtils框架基础
动态SQL数据层框架（2）：框架结构
动态SQL数据层框架（3）：BaseDao接口和BaseDaoSupport抽象类
动态SQL数据层框架（4）：DynamicSQLParser工具类和配置文件
动态SQL数据层框架（5）：AOP事务管理

 

BaseDao接口用于定义最基础的数据操作的方法。BaseDaoSupport抽象类对BaseDao中的方法做了实现。本文将作详细介绍

 

一、BaseDao接口介绍

首先，这是一个泛型接口，实现类需要指定泛型的具体类型。

 

此接口定义了实体操作的通用增删改查方法

 

插入实体数据到数据库并返回插入数据的主键

int addObject(E e);

 

删除指定主键的数据并返回操作是否成功

boolean deleteObject(Integer id);

 

修改指定实体数据并返回操作是否成功

boolean updateObject(E e);

 

根据主键获取一个实体对象

E getObject(Integer id);

 

根据动态查询条件获取一个实体对象

E getObject(Map<String, Object> paramaters);

 

获取全部实体对象的集合

List<E> getObjects();

 

根据动态查询条件获取实体对象的集合

List<E> getObjects(Map<String, Object> paramaters);

 

根据动态查询条件获取分页实体对象的集合

List<E> getObjects(Map<String, Object> paramaters, Integer pageNum, Integer pageSize);

 

根据动态查询条件获取实体对象的数量

int count(Map<String, Object> paramaters);

 

 

二、BaseDaoSupport抽象类详解

该类实现了BaseDao接口。使用DBUtils进行JDBC操作，使用DynamicSQLParser进行动态SQL解析。

 

注意：在使用DynamicSQLParser获取SQL时传入的id需要和sql配置文件中<sql>标签的id属性一致。

 

1、核心字段

// 用于动态SQL解析
private DynamicSQLParser sqlParser = DynamicSQLParser.getDynamicSQLParser();

// 匹配SQL中的#arg#
private static Pattern argPattern = Pattern.compile("#([^\\s]+)#");

// 泛型类型
protected Class<E> entityClass = GenericsUtil.getSuperClassGenricType(getClass());

 

2、增删改方法

addObject方法

首先使用DynamicSQLParser获取SQL（不进行动态解析，所以SQL中不要含有动态标签），然后使用反射技术从参数对象中获取需要注入到SQL中参数，并封装为集合，最后执行SQL。

QueryRunner qr = new QueryRunner();
try {

    Connection conn = TransactionManager.getConnection();

    // 获取插入数据类型的简单名
    String clazzName = this.entityClass.getSimpleName();

    // 保存全部注入参数
    List<Object> l = new ArrayList<Object>();

    // 获取SQL模板
// SQL的key为：数据类型简单名 拼上 _addObject
// 不需要进行动态SQL解析，所以后两个参数分别为null、false
    String sql = this.sqlParser.parseSql(clazzName + "_addObject", null, false);

    // 匹配SQL中全部待赋值的参数
    Matcher m = argPattern.matcher(sql);
    while (m.find()) {
        String arg = m.group(1);
        try {
            PropertyDescriptor pd = new PropertyDescriptor(arg, this.entityClass);
            Method getter = pd.getReadMethod();
            Object ret = getter.invoke(e);
            l.add(ret);
        } catch (Exception e1) {}
    }
// 替换占位符
    sql = sql.replaceAll("#([^\\s]+)#", "?");
    // 执行SQL获取id
    return qr
            .insert(conn, sql, new ScalarHandler<Long>(1), l.toArray())
            .intValue();
} catch (SQLException e1) {
    throw new RuntimeException(e1.getMessage(), e1);
}

 

deleteObject方法

首先使用DynamicSQLParser获取SQL（不进行动态解析，所以SQL中不要含有动态标签），传入id参数后即执行SQL。

QueryRunner qr = new QueryRunner();
try {
    Connection conn = TransactionManager.getConnection();
    // 获取插入数据类型的简单名
    String clazzName = this.entityClass.getSimpleName();

    // 获取SQL模板
// SQL的key为：数据类型简单名 拼上 _deleteObject
// 不需要进行动态SQL解析，所以后两个参数分别为null、false
    String sql = this.sqlParser.parseSql(clazzName + "_deleteObject", null, false);

    // 执行SQL获取影响的行数
    int rows = qr.update(conn, sql, id);
    return rows == 1;
} catch (SQLException e1) {
    throw new RuntimeException(e1.getMessage(), e1);
}

 

updateObject方法

QueryRunner qr = new QueryRunner();
try {
    Connection conn = TransactionManager.getConnection();

    // 获取插入数据类型的简单名
    String clazzName = this.entityClass.getSimpleName();

    // 保存全部注入参数
    List<Object> l = new ArrayList<Object>();

    // 获取SQL模板
// SQL的key为：数据类型简单名 拼上 _updateObject
// 不需要进行动态SQL解析，所以后两个参数分别为null、false
    String sql = this.sqlParser.parseSql(clazzName + "_updateObject", null, false);
    // 匹配SQL中待赋值的参数
    Matcher m = argPattern.matcher(sql);
    while (m.find()) {
        String arg = m.group(1);
        try {
            PropertyDescriptor pd = new PropertyDescriptor(arg, this.entityClass);
            Method getter = pd.getReadMethod();
            Object ret = getter.invoke(e);
            l.add(ret);
        } catch (Exception e1) {}
    }
// 替换占位符
    sql = sql.replaceAll("#([^\\s]+)#", "?");
    // 执行SQL获取影响的行数
    int rows = qr.update(conn, sql, l.toArray());
    return rows == 1;
} catch (SQLException e1) {
    throw new RuntimeException(e1.getMessage(), e1);
}

 

3、查询方法

getObject(int)方法

首先使用DynamicSQLParser获取SQL（不需要动态解析），然后获取ResultSetHandler，子类可以重写getResultSetHandler()进行自定义，传入id参数后执行SQL并返回结果。

QueryRunner qr = new QueryRunner();
try {
    Connection conn = TransactionManager.getConnection();
    // 获取插入数据类型的简单名
    String clazzName = this.entityClass.getSimpleName();
    // 获取SQL模板
// SQL的key为：数据类型简单名 拼上 _getObject_int
// 不需要进行动态SQL解析，所以后两个参数分别为null、false
    String sql = this.sqlParser.parseSql(clazzName + "_getObject_int", null, false);
    // 执行SQL获取返回对象
    ResultSetHandler<E> rsh = getResultSetHandler();
    E e = (E) qr.query(conn, sql, rsh, id);
    return e;
} catch (SQLException e1) {
    throw new RuntimeException(e1.getMessage(), e1);
}

 

getObject(Map)方法

首先使用DynamicSQLParser获取SQL（需要根据Map条件进行动态解析），然后从Map中获取注入到SQL中的参数，并封装为集合，获取ResultSetHandler，子类可以重写getResultSetHandler()进行自定义，最后执行SQL并返回结果。

QueryRunner qr = new QueryRunner();
try {
    Connection conn = TransactionManager.getConnection();

    // 获取插入数据类型的简单名
    String clazzName = this.entityClass.getSimpleName();

    // 保存全部注入参数
    List<Object> l = new ArrayList<Object>();

    // 获取SQL模板
// SQL的key为：数据类型简单名 拼上 _getObject_map
    String sql = this.sqlParser.parseSql(clazzName + "_getObject_map", paramaters, true);

    // 匹配SQL中待赋值的参数
    Matcher m = argPattern.matcher(sql);
    while (m.find()) {
        String arg = m.group(1);
        Object val = paramaters.get(arg);
        if (val instanceof List) {
            StringBuilder sb = new StringBuilder();
            List v = (List) val;
            int iMax = v.size() - 1;
            for (int i = 0;; i++) {
                sb.append("?");
                l.add(v.get(i));
                if (i == iMax) {
                    break;
                }
                sb.append(", ");
            }
            sql = sql.replace("#" + arg + "#", sb.toString());
        } else {
            l.add(val);
        }
    }
// 替换占位符
    sql = sql.replaceAll("#([^\\s]+)#", "?");
    ResultSetHandler<E> rsh = getResultSetHandler();
    // 执行SQL获取返回对象
    E e = (E) qr.query(conn, sql, rsh, l.toArray());
    return e;
} catch (SQLException e1) {
    throw new RuntimeException(e1.getMessage(), e1);
}

 

4、其他方法

execute(String sqlId, Object... args)方法

根据指定sqlId从模板中获取SQL执行，此方法不支持动态SQL解析。通常用于执行一些维护关联关系的添加、更新和删除语句。

protected boolean execute(String sqlId, Object... args) {
    QueryRunner qr = new QueryRunner();
    try {
        Connection conn = TransactionManager.getConnection();
        // 获取SQL模板
        String sql = this.sqlParser.parseSql(sqlId, null, false);
        return qr.update(conn, sql, args) > 0;
    } catch (SQLException e1) {
        throw new RuntimeException(e1.getMessage(), e1);
    }
}

 

selectColumn(String sqlId, Map<String, Object> paramaters)方法

根据指定sqlId从模板中获取SQL，使用Map为查询条件赋值，返回某一列数据的集合。通常可以用于执行获取count、sum值的语句。

protected <T> List<T> selectColumn(String sqlId, Map<String, Object> paramaters) {
    QueryRunner qr = new QueryRunner();
    try {
        Connection conn = TransactionManager.getConnection();

        // 保存全部注入参数
        List<Object> l = new ArrayList<Object>();

        // 获取SQL模板
        String sql = this.sqlParser.parseSql(sqlId, paramaters, true);

        // 匹配SQL中待赋值的参数
        Matcher m = argPattern.matcher(sql);
        while (m.find()) {
            String arg = m.group(1);
            Object val = paramaters.get(arg);
            if (val instanceof List) {
                StringBuilder sb = new StringBuilder();
                List v = (List) val;
                int iMax = v.size() - 1;
                for (int i = 0;; i++) {
                    sb.append("?");
                    l.add(v.get(i));
                    if (i == iMax) {
                        break;
                    }
                    sb.append(", ");
                }
                sql = sql.replace("#" + arg + "#", sb.toString());
            } else {
                l.add(val);
            }
        }
        sql = sql.replaceAll("#([^\\s]+)#", "?");
        // 执行SQL获取返回指定列的集合
        return qr
                .query(conn, sql, new ColumnListHandler<T>(1), l.toArray());
    } catch (SQLException e1) {
        throw new RuntimeException(e1.getMessage(), e1);
    }
}

 

selectColumns(String sqlId, Map<String, Object> paramaters)方法

与selectColumn方法类似，不做介绍了

 

5、获取ResultSetHandler对象

以下两个方法用于获取解析结果集的ResultSetHandler对象，如果子类需要使用不同的方式解析ResultSet就要重写这两个方法

protected ResultSetHandler<E> getResultSetHandler() {
    return new BeanHandler<E>(this.entityClass);
}

protected ResultSetHandler<List<E>> getResultSetListHandler() {
    return new BeanListHandler<E>(this.entityClass);
}