手写DAO框架（五）-DAO层实现

-------前篇：手写DAO框架（四）-SQL执行---------

前言

通过上一篇，可以通过传入sql和对应的参数，可以执行sql并返回结果。但是对于一个DAO框架来说，要尽量的面向对象编程，也就是要实现ORM功能。所以本篇主要介绍DAO层的实现，主要是实现ORM。

主要涉及技术

反射

反射

Class<T> entityClass = (Class<T>) ((ParameterizedType)this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];

这一段代码位于BaseDao中，相当于是整个ORM的开端，目的是获取子类通过泛型制定的具体类型。

举个例子：

//父类
package me.lovegao.gdao.demo;
import java.lang.reflect.ParameterizedType;
public class ParentDemo<T> {
    private Class<T> entityClass;

    protected ParentDemo() {
        entityClass = (Class<T>) ((ParameterizedType)this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
    public Class<T> getEntityClass() {
        return entityClass;
    }
}

//子类
package me.lovegao.gdao.demo;
public class ChildDemo extends ParentDemo<Integer> {
    public static void main(String[] args) {
        ParentDemo p = new ChildDemo();
        System.out.println(p.getEntityClass());
    }
}

运行代码，就可以得到子类在继承父类时泛型定义的类型。

本例结果：

class java.lang.Integer

BaseDao实现

 package me.lovegao.gdao.orm;

 import java.io.Serializable;
 import java.lang.reflect.ParameterizedType;
 import java.util.List;

 import me.lovegao.gdao.bean.GTableClassParseInfo;
 import me.lovegao.gdao.bean.TwoTuple;
 import me.lovegao.gdao.sqlexecute.ISqlExecutor;
 import me.lovegao.gdao.util.GDaoCommonUtil;
 import me.lovegao.gdao.util.GDaoOrmUtil;
 import me.lovegao.gdao.util.GenerateSqlUtil;

 /**
  * 操作对象的dao
  * @author simple
  *
  * @param <T>
  * @param <PK>
  */
 public class BaseDao<T, PK extends Serializable> {
     private Class<T> entityClass;
     private GTableClassParseInfo entityClassParseInfo;
     private ISqlExecutor sqlExecutor;

     @SuppressWarnings("unchecked")
     protected BaseDao(ISqlExecutor sqlExecutor) {
             entityClass = (Class<T>) ((ParameterizedType)this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
             this.sqlExecutor = sqlExecutor;
             entityClassParseInfo = GDaoCommonUtil.parseClass(entityClass);
     }

     /**
      * 新增
      * @param entity
      * @return
      * @throws Exception
      */
     public PK add(T entity) throws Exception {
             PK id = null;
             if(entity != null) {
                 TwoTuple<String, Object[]> sqlResult = GenerateSqlUtil.addSql(entityClassParseInfo, entity);
                 id = sqlExecutor.insert(sqlResult.a, sqlResult.b);
             }
             return id;
     }

     /**
      * 批量新增
      * @param list
      * @throws Exception
      */
     public void addBatch(List<T> list) throws Exception {
             if(!GDaoCommonUtil.checkCollectionEmpty(list)) {
                 TwoTuple<String, List<Object[]>> sqlList = GenerateSqlUtil.addBatchSql(entityClassParseInfo, list);
                 sqlExecutor.insertOrUpdateBatch(sqlList.a, sqlList.b);
             }
     }

     /**
      * 根据主键删除数据
      * @param id
      * @throws Exception
      */
     public void deleteByPK(PK id) throws Exception {
             TwoTuple<String, PK> sqlIdEntity = GenerateSqlUtil.deleteByPKSql(entityClassParseInfo, id);
             sqlExecutor.update(sqlIdEntity.a, new Object[] {sqlIdEntity.b});
     }

     /**
      * 更新
      * @param entity
      * @throws Exception
      */
     public void update(T entity) throws Exception {
             TwoTuple<String, Object[]> tuple = GenerateSqlUtil.updateSql(entityClassParseInfo, entity);
             sqlExecutor.update(tuple.a, tuple.b);
     }

     /**
      * 根据主键查找
      * @param id
      * @return
      * @throws Exception
      */
     public T queryByPK(PK id) throws Exception {
             TwoTuple<String, Object[]> tuple = GenerateSqlUtil.queryByPKSql(entityClassParseInfo, id);
             TwoTuple<List<Object[]>, String[]> resultTuple = sqlExecutor.queryValueAndColumn(tuple.a, tuple.b);
             List<T> list = GDaoOrmUtil.convertObject2T(resultTuple.a, resultTuple.b, entityClassParseInfo);
             if(!GDaoCommonUtil.checkCollectionEmpty(list)) {
                 return list.get(0);
             }
             return null;
     }

     /**
      * 查询对象列表
      * @param sql 查询sql
      * @param replaceValues sql中对应?的值
      * @return 包装类列表
      * @throws Exception
      */
     public List<T> list(String sql, Object... replaceValues) throws Exception {
             TwoTuple<List<Object[]>, String[]> resultTuple = sqlExecutor.queryValueAndColumn(sql, replaceValues);
         List<T> list = GDaoOrmUtil.convertObject2T(resultTuple.a, resultTuple.b, entityClassParseInfo);
             return list;
     }

     /**
      * 普通查询，结果需要自己转义
      * @param sql 查询sql
      * @param replaceValues sql中对应?的值
      * @return List<{列1, 列2}>
      * @throws Exception
      */
     public List<Object[]> normalList(String sql, Object... replaceValues) throws Exception {
             List<Object[]> list = sqlExecutor.query(sql, replaceValues);
             return list;
     }

     /**
      * 统计个数
      * @param sql 有且仅有count()的sql
      * @param replaceValues sql中对应?的值
      * @return
      * @throws Exception
      */
     public long count(String sql, Object... replaceValues) throws Exception {
             List<Object[]> list = sqlExecutor.query(sql, replaceValues);
             if(!GDaoCommonUtil.checkCollectionEmpty(list)) {
                 return (long) list.get(0)[0];
             }
             return 0;
     }

 }

BaseDao的定义主要是用于被其他类继承的。后期会有示例代码。

GTableClassParseInfo实现

在子类继承BaseDao之后，进行初始化的时候，需要对定义的类进行解析，为了避免每次都解析类，所以对类的解析结果进行了一个保存，通过GTableClassParseInfo这个类来保存的。具体定义如下。

 package me.lovegao.gdao.bean;

 import java.lang.reflect.Field;
 import java.util.Map;

 /**
  * 被GTable注解的类解析后的信息
  * @author simple
  *
  */
 public class GTableClassParseInfo {
     /**类**/
     private Class<?> clazz;
     /**表名**/
     private String tableName;
     /**主键名称**/
     private String pkName;
     /**主键的变量**/
     private Field pkField;
     /**主键自动生成**/
     private boolean pkAutoGenerate;
     /**声明了表字段的变量名列表，不含主键**/
     private Field[] fields;
     /**声明的数据库表字段名列表，和fields顺序对应，不含主键**/
     private String[] tableColumnNames;
     /**数据库字段和field对应关系，包含主键和非主键<columnName, Field>**/
     private Map<String, Field> allColumnFieldMap;

     public Class<?> getClazz() {
         return clazz;
     }
     public void setClazz(Class<?> clazz) {
         this.clazz = clazz;
     }
     public String getTableName() {
         return tableName;
     }
     public void setTableName(String tableName) {
         this.tableName = tableName;
     }
     public Field[] getFields() {
         return fields;
     }
     public void setFields(Field[] fields) {
         this.fields = fields;
     }
     public String[] getTableColumnNames() {
         return tableColumnNames;
     }
     public void setTableColumnNames(String[] tableColumnNames) {
         this.tableColumnNames = tableColumnNames;
     }
     public String getPkName() {
         return pkName;
     }
     public void setPkName(String pkName) {
         this.pkName = pkName;
     }
     public boolean isPkAutoGenerate() {
         return pkAutoGenerate;
     }
     public void setPkAutoGenerate(boolean pkAutoGenerate) {
         this.pkAutoGenerate = pkAutoGenerate;
     }
     public Field getPkField() {
         return pkField;
     }
     public void setPkField(Field pkField) {
         this.pkField = pkField;
     }
     public Map<String, Field> getAllColumnFieldMap() {
         return allColumnFieldMap;
     }
     public void setAllColumnFieldMap(Map<String, Field> allColumnFieldMap) {
         this.allColumnFieldMap = allColumnFieldMap;
     }

 }

GDaoCommonUtil实现

为了把子类通过泛型定义的类转化为GTableClassParseInfo，需要通过一个转换的方法。

 package me.lovegao.gdao.util;

 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import me.lovegao.gdao.bean.GTableClassParseInfo;
 import me.lovegao.gdao.bean.annotation.GColumn;
 import me.lovegao.gdao.bean.annotation.GId;
 import me.lovegao.gdao.bean.annotation.GTable;

 public class GDaoCommonUtil {
     ……
     /**
      * 解析被表注解的类
      * @param clazz
      * @return
      */
     public static GTableClassParseInfo parseClass(Class<?> clazz) {
         GTable table = clazz.getAnnotation(GTable.class);
         if(table == null) {
             throw new NullPointerException("类没有声明GTable注解");
         }
         String tableName = table.value();
         Field[] fields = clazz.getDeclaredFields();
         List<Field> fieldList = new ArrayList();
         List<String> fieldNames = new ArrayList();
         Map<String, Field> allColumnFieldMap = new HashMap();
         String pkName = "";
         Field pkField = null;
         boolean pkAutoGenerate = false;
         for(Field field : fields) {
             if(field.isAnnotationPresent(GColumn.class)) {
                 GColumn column = field.getAnnotation(GColumn.class);
                 //主键声明
                 if(field.isAnnotationPresent(GId.class)) {
                     if(pkField != null) {
                         throw new RuntimeException("=====错误：一个数据库对象做多只能定义一个主键======");
                     }
                     GId pkColumn = field.getAnnotation(GId.class);
                     pkName = column.name();
                     pkField = field;
                     pkAutoGenerate = pkColumn.isAutoIncrease();
                 } else {
                     fieldList.add(field);
                     fieldNames.add(column.name());
                 }
                 allColumnFieldMap.put(column.name(), field);
             }
         }
         GTableClassParseInfo tableInfo = new GTableClassParseInfo();
         tableInfo.setClazz(clazz);
         tableInfo.setTableName(tableName);
         tableInfo.setPkName(pkName);
         tableInfo.setPkField(pkField);
         tableInfo.setPkAutoGenerate(pkAutoGenerate);
         tableInfo.setFields(fieldList.toArray(new Field[0]));
         tableInfo.setTableColumnNames(fieldNames.toArray(new String[0]));
         tableInfo.setAllColumnFieldMap(allColumnFieldMap);
         return tableInfo;
     }
 }

至此，整个DAO框架基本完成。

完整代码参见git：https://github.com/shuimutong/gdao.git  欢迎关注

下期：手写DAO框架（六）-框架使用示例