压缩视频

yzg-util-db/src/main/java/com/yanzuoguang/dao/BaseDao.java

@@ -5,8 +5,6 @@ import com.yanzuoguang.util.vo.DataDaoVo;
 import com.yanzuoguang.util.vo.PageSizeData;
 import com.yanzuoguang.util.vo.PageSizeReqVo;
 
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
@@ -73,11 +71,11 @@ public interface BaseDao {
      *
      * @param model       加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> T load(Object model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> T load(Object model, Class<T> resultClass, QueryPara queryPara);
 
 
     /**
@@ -95,11 +93,11 @@ public interface BaseDao {
      *
      * @param model       加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> List<T> loadList(Object model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> List<T> loadList(Object model, Class<T> resultClass, QueryPara queryPara);
 
     /**
      * 加载分页数据
@@ -116,11 +114,11 @@ public interface BaseDao {
      *
      * @param model       加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass, QueryPara queryPara);
 
     /**
      * 加载分页数据
@@ -139,11 +137,11 @@ public interface BaseDao {
      * @param pageReq     分页数据信息
      * @param model       加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo pageReq, Object model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo pageReq, Object model, Class<T> resultClass, QueryPara queryPara);
 
     /**
      * 加载分页数据
@@ -160,11 +158,11 @@ public interface BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> List<T> loadPageData(PageSizeReqVo model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> List<T> loadPageData(PageSizeReqVo model, Class<T> resultClass, QueryPara queryPara);
 
     /**
      * 加载分页数据
@@ -181,11 +179,11 @@ public interface BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara    查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
-    <T extends Object> List<T> loadPageData(PageSizeReqVo pageReq, Object model, Class<T> resultClass, boolean fullCond);
+    <T extends Object> List<T> loadPageData(PageSizeReqVo pageReq, Object model, Class<T> resultClass, QueryPara queryPara);
 
     /**
      * 修改数据

yzg-util-db/src/main/java/com/yanzuoguang/dao/QueryPara.java

+package com.yanzuoguang.dao;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+/**
+ * 查询参数
+ *
+ * @author　颜佐光
+ */
+@ApiModel(description = "查询参数")
+public class QueryPara {
+
+    /**
+     * 所有条件生效
+     */
+    @ApiModelProperty(notes = "所有条件生效,而不仅仅在主键存在时，通过主键加载")
+    private boolean fullCond;
+
+    /**
+     * 查询删除标记的结果
+     */
+    @ApiModelProperty(notes = "在数据通过删除标记删除时，可以通过该参数查询出来")
+    private boolean loadRemove;
+
+    public QueryPara() {
+    }
+
+    public QueryPara(boolean fullCond) {
+        this.fullCond = fullCond;
+    }
+
+    public QueryPara(boolean fullCond, boolean loadRemove) {
+        this.fullCond = fullCond;
+        this.loadRemove = loadRemove;
+    }
+
+    public boolean isFullCond() {
+        return fullCond;
+    }
+
+    public void setFullCond(boolean fullCond) {
+        this.fullCond = fullCond;
+    }
+
+    public boolean isLoadRemove() {
+        return loadRemove;
+    }
+
+    public void setLoadRemove(boolean loadRemove) {
+        this.loadRemove = loadRemove;
+    }
+}

yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/BaseDaoImpl.java

@@ -2,6 +2,7 @@ package com.yanzuoguang.dao.impl;
 
 import com.yanzuoguang.dao.BaseDao;
 import com.yanzuoguang.dao.DaoConst;
+import com.yanzuoguang.dao.QueryPara;
 import com.yanzuoguang.db.DbExecute;
 import com.yanzuoguang.util.base.ObjectHelper;
 import com.yanzuoguang.util.exception.CodeException;
@@ -391,8 +392,8 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      * @param model 来源对象
      * @return
      */
-    protected Object getLoadFrom(Object model, boolean fullCond) {
-        if (fullCond) {
+    protected Object getLoadFrom(Object model, QueryPara queryPara) {
+        if (queryPara != null && queryPara.isFullCond()) {
             return model;
         }
 
@@ -429,16 +430,16 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> T load(Object model, Class<T> resultClass, boolean fullCond) {
+    public <T extends Object> T load(Object model, Class<T> resultClass, QueryPara queryPara) {
         // 获取来源主键
-        Object from = this.getLoadFrom(model, fullCond);
+        Object from = this.getLoadFrom(model, queryPara);
         // 通过传入数据进行加载
-        T to = this.queryFirst(resultClass, DaoConst.LOAD, from);
+        T to = this.queryFirst(resultClass, DaoConst.LOAD, from, queryPara);
         if (to == null) {
             return null;
         }
@@ -460,7 +461,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> T load(Object model, Class<T> resultClass) {
-        return this.load(model, resultClass, false);
+        return this.load(model, resultClass, null);
     }
 
     /**
@@ -468,17 +469,17 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> List<T> loadList(Object model, Class<T> resultClass, boolean fullCond) {
+    public <T extends Object> List<T> loadList(Object model, Class<T> resultClass, QueryPara queryPara) {
         // 获取来源主键
-        Object from = this.getLoadFrom(model, fullCond);
+        Object from = this.getLoadFrom(model, queryPara);
 
         // 通过传入数据进行加载
-        List<T> to = this.query(resultClass, DaoConst.LOAD, from);
+        List<T> to = this.query(resultClass, DaoConst.LOAD, from, queryPara);
         if (to == null || to.size() == 0) {
             return new ArrayList<>();
         }
@@ -498,7 +499,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> List<T> loadList(Object model, Class<T> resultClass) {
-        return this.loadList(model, resultClass, false);
+        return this.loadList(model, resultClass, null);
     }
 
 
@@ -512,7 +513,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass) {
-        return this.loadPage(model, model, resultClass, false);
+        return this.loadPage(model, model, resultClass, null);
     }
 
     /**
@@ -520,13 +521,13 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass, boolean fullCond) {
-        return this.loadPage(model, model, resultClass, fullCond);
+    public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass, QueryPara queryPara) {
+        return this.loadPage(model, model, resultClass, queryPara);
     }
 
     /**
@@ -539,7 +540,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo pageReq, Object model, Class<T> resultClass) {
-        return this.loadPage(pageReq, model, resultClass, false);
+        return this.loadPage(pageReq, model, resultClass, null);
     }
 
     /**
@@ -547,17 +548,17 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo pageReq, Object model, Class<T> resultClass, boolean fullCond) {
+    public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo pageReq, Object model, Class<T> resultClass, QueryPara queryPara) {
         // 获取来源主键
-        Object from = this.getLoadFrom(model, fullCond);
+        Object from = this.getLoadFrom(model, queryPara);
 
         // 通过传入数据进行加载
-        PageSizeData<T> to = this.queryPage(resultClass, pageReq, DaoConst.LOAD, from);
+        PageSizeData<T> to = this.queryPage(resultClass, pageReq, DaoConst.LOAD, from, queryPara);
         if (to == null || to.getPageTotal() == 0) {
             return to;
         }
@@ -579,7 +580,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> List<T> loadPageData(PageSizeReqVo model, Class<T> resultClass) {
-        return this.loadPageData(model, model, resultClass, false);
+        return this.loadPageData(model, model, resultClass, null);
     }
 
     /**
@@ -587,13 +588,13 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> List<T> loadPageData(PageSizeReqVo model, Class<T> resultClass, boolean fullCond) {
-        return this.loadPageData(model, model, resultClass, fullCond);
+    public <T extends Object> List<T> loadPageData(PageSizeReqVo model, Class<T> resultClass, QueryPara queryPara) {
+        return this.loadPageData(model, model, resultClass, queryPara);
     }
 
 
@@ -607,7 +608,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      */
     @Override
     public <T extends Object> List<T> loadPageData(PageSizeReqVo pageReq, Object model, Class<T> resultClass) {
-        return this.loadPageData(pageReq, model, resultClass, false);
+        return this.loadPageData(pageReq, model, resultClass, null);
     }
 
     /**
@@ -615,19 +616,19 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
      *
      * @param model       加载数据的请求参数
      * @param resultClass 需要加载的数据的类型
-     * @param fullCond    所有条件生效
+     * @param queryPara   查询参数
      * @param <T>         返回数据的类型
      * @return 需要返回的数据
      */
     @Override
-    public <T extends Object> List<T> loadPageData(PageSizeReqVo pageReq, Object model, Class<T> resultClass, boolean fullCond) {
+    public <T extends Object> List<T> loadPageData(PageSizeReqVo pageReq, Object model, Class<T> resultClass, QueryPara queryPara) {
         // 获取来源主键
-        Object from = this.getLoadFrom(model, fullCond);
+        Object from = this.getLoadFrom(model, queryPara);
 
         // 通过传入数据进行加载
-        List<T> to = this.queryPageData(resultClass, pageReq, DaoConst.LOAD, from);
+        List<T> to = this.queryPageData(resultClass, pageReq, DaoConst.LOAD, from, queryPara);
         if (to == null) {
-            return to;
+            return new ArrayList<>();
         }
 
         // 判断来源主键是否存在，不存在则获取加载后的主键

yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/BaseDaoSql.java

 package com.yanzuoguang.dao.impl;
 
 import com.yanzuoguang.dao.DaoConst;
+import com.yanzuoguang.dao.QueryPara;
 import com.yanzuoguang.dao.TableAnnotation;
 import com.yanzuoguang.db.DbExecute;
 import com.yanzuoguang.db.impl.DbRow;
@@ -192,31 +193,36 @@ public abstract class BaseDaoSql {
     }
 
     /**
-     * 根据SQL语句信息查询第一个单元格
+     * 是否需要复制一个新的
      *
-     * @param sqlData SQL语句信息
-     * @param model   前台参数
-     * @return 查询的结果
+     * @param sqlData
+     * @param queryPara
+     * @param copy
      */
-    protected Object queryCell(SqlData sqlData, Object model) {
-        List<Object> paras = new ArrayList<>();
-        String sql = this.getQueryPara(paras, sqlData, model);
-        Object cell = this.queryCellWithCache(sqlData.getName(), sql, paras.toArray());
-        return cell;
+    protected SqlData getSqlQueryPara(SqlData sqlData, QueryPara queryPara, boolean copy) {
+        SqlData copyTo = sqlData;
+        if (queryPara != null && queryPara.isLoadRemove()) {
+            if (copyTo.getField(DaoConst.REMOVE_FLAG_INPUT) != null) {
+                if (copy) {
+                    copyTo = sqlData.copy();
+                }
+                copyTo.removeField(DaoConst.REMOVE_FLAG_INPUT);
+            }
+        }
+        return copyTo;
     }
 
     /**
-     * 根据SQL名称获取第一个单元格
+     * 根据SQL语句信息查询数据
      *
-     * @param sqlName 需要执行的SQL语句的名称
-     * @param model   需要转化的实体
-     * @return 处理参数
+     * @param sqlData SQL语句信息
+     * @param model   前台参数
+     * @return 查询的结果
      */
-    protected Object queryCell(String sqlName, Object model) {
-        return this.queryCell(this.getSql(sqlName), model);
+    protected List<MapRow> queryData(SqlData sqlData, Object model) {
+        return this.queryData(MapRow.class, sqlData, model);
     }
 
-
     /**
      * 根据SQL语句信息查询数据
      *
@@ -248,6 +254,57 @@ public abstract class BaseDaoSql {
         this.getDb().query(this.getClass(), cls, handle, sqlData.getName(), sql, paras.toArray());
     }
 
+    /**
+     * 根据SQL名称获取第一个单元格
+     *
+     * @param sqlName 需要执行的SQL语句的名称
+     * @param model   需要转化的实体
+     * @return 处理参数
+     */
+    protected Object queryCell(String sqlName, Object model) {
+        return this.queryCell(this.getSql(sqlName), model);
+    }
+
+
+    /**
+     * 根据SQL语句信息查询第一个单元格
+     *
+     * @param sqlData SQL语句信息
+     * @param model   前台参数
+     * @return 查询的结果
+     */
+    protected Object queryCell(SqlData sqlData, Object model) {
+        return this.queryCell(sqlData, model, null);
+    }
+
+    /**
+     * 根据SQL语句信息查询第一个单元格
+     *
+     * @param sqlData SQL语句信息
+     * @param model   前台参数
+     * @return 查询的结果
+     */
+    protected Object queryCell(SqlData sqlData, Object model, QueryPara queryPara) {
+        sqlData = getSqlQueryPara(sqlData, queryPara, true);
+
+        List<Object> paras = new ArrayList<>();
+        String sql = this.getQueryPara(paras, sqlData, model);
+        Object cell = this.queryCellWithCache(sqlData.getName(), sql, paras.toArray());
+        return cell;
+    }
+
+
+    /**
+     * 查询不分页数据
+     *
+     * @param sqlName SQL语句名称
+     * @param model   前台参数
+     * @return 查询的结果
+     */
+    protected List<MapRow> query(String sqlName, Object model) {
+        return this.query(MapRow.class, sqlName, model);
+    }
+
     /**
      * 查询不分页数据
      *
@@ -258,7 +315,23 @@ public abstract class BaseDaoSql {
      * @return 查询的结果
      */
     protected <T extends Object> List<T> query(Class<T> cls, String sqlName, Object model) {
+        return this.query(cls, sqlName, model, null);
+    }
+
+    /**
+     * 查询不分页数据
+     *
+     * @param cls     数据结果类型
+     * @param sqlName SQL语句名称
+     * @param model   前台参数
+     * @param <T>     返回数据类型
+     * @return 查询的结果
+     */
+    protected <T extends Object> List<T> query(Class<T> cls, String sqlName, Object model, QueryPara queryPara) {
         SqlData sqlData = this.getSql(sqlName);
+
+        sqlData = getSqlQueryPara(sqlData, queryPara, true);
+
         return queryData(cls, sqlData, model);
     }
 
@@ -272,10 +345,38 @@ public abstract class BaseDaoSql {
      * @return 查询的结果
      */
     protected <T extends Object> void query(Class<T> cls, DbRow<T> handle, String sqlName, Object model) {
+        this.query(cls, handle, sqlName, model, null);
+    }
+
+    /**
+     * 查询不分页数据
+     *
+     * @param cls     数据结果类型
+     * @param handle  需要处理的数据
+     * @param sqlName SQL语句名称
+     * @param model   前台参数
+     * @return 查询的结果
+     */
+    protected <T extends Object> void query(Class<T> cls, DbRow<T> handle, String sqlName, Object model, QueryPara queryPara) {
         SqlData sqlData = this.getSql(sqlName);
+        // 获取查询参数处理后的ＳＱＬ语句
+        sqlData = getSqlQueryPara(sqlData, queryPara, true);
+
         queryData(cls, handle, sqlData, model);
     }
 
+
+    /**
+     * 查询第一条数据
+     *
+     * @param sqlName SQL语句名称
+     * @param model   前台参数
+     * @return 查询的结果
+     */
+    protected MapRow queryFirst(String sqlName, Object model) {
+        return this.queryFirst(MapRow.class, sqlName, model);
+    }
+
     /**
      * 查询第一条数据
      *
@@ -286,14 +387,40 @@ public abstract class BaseDaoSql {
      * @return 查询的结果
      */
     protected <T extends Object> T queryFirst(Class<T> cls, String sqlName, Object model) {
+        return this.queryFirst(cls, sqlName, model, null);
+    }
+
+    /**
+     * 查询第一条数据
+     *
+     * @param cls     数据结果类型
+     * @param sqlName SQL语句名称
+     * @param model   前台参数
+     * @param <T>     返回数据类型
+     * @return 查询的结果
+     */
+    protected <T extends Object> T queryFirst(Class<T> cls, String sqlName, Object model, QueryPara queryPara) {
         PageSizeReq pageSize = new PageSizeReqVo();
         pageSize.setPageIndex(1);
         pageSize.setPageSize(1);
-        List<T> list = this.queryPageData(cls, pageSize, sqlName, model);
+        List<T> list = this.queryPageData(cls, pageSize, sqlName, model, queryPara);
         T retVal = list.size() > 0 ? list.get(0) : null;
         return retVal;
     }
 
+    /**
+     * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
+     *
+     * @param pageSize 分页参数
+     * @param sqlName  SQL语句名称
+     * @param model    前台参数
+     * @return 查询的结果
+     */
+    protected List<MapRow> queryPageData(PageSizeReqVo pageSize, String sqlName, Object model) {
+        return this.queryPageData(MapRow.class, pageSize, sqlName, model);
+    }
+
+
     /**
      * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
      *
@@ -305,14 +432,43 @@ public abstract class BaseDaoSql {
      * @return 查询的结果
      */
     protected <T extends Object> List<T> queryPageData(Class<T> cls, PageSizeReq pageSize, String sqlName, Object model) {
+        return this.queryPageData(cls, pageSize, sqlName, model, null);
+    }
+
+    /**
+     * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
+     *
+     * @param cls      数据结果类型
+     * @param pageSize 分页参数
+     * @param sqlName  SQL语句名称
+     * @param model    前台参数
+     * @param <T>      返回数据类型
+     * @return 查询的结果
+     */
+    protected <T extends Object> List<T> queryPageData(Class<T> cls, PageSizeReq pageSize, String sqlName, Object model, QueryPara queryPara) {
         SqlData from = this.getSql(sqlName);
         // 对SQL语句进行分页处理
         SqlData to = from.copy();
+        // 获取sql语句
+        to = getSqlQueryPara(to, queryPara, false);
+
         to.setSql(from.getSql());
         to.addCode("{LIMIT}", " LIMIT " + pageSize.getPageStart() + "," + pageSize.getPageSize());
         return queryData(cls, to, model);
     }
 
+    /**
+     * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
+     *
+     * @param pageSize 分页参数
+     * @param sqlName  SQL语句名称
+     * @param model    前台参数
+     * @return 查询的结果
+     */
+    protected PageSizeData<MapRow> queryPage(PageSizeReqVo pageSize, String sqlName, Object model) {
+        return this.queryPage(MapRow.class, pageSize, sqlName, model);
+    }
+
     /**
      * 查询分页数据，仅仅只是查询分页中的数据。如：包含的总数据数量
      *
@@ -324,6 +480,20 @@ public abstract class BaseDaoSql {
      * @return 查询的结果
      */
     protected <T extends Object> PageSizeData<T> queryPage(Class<T> cls, PageSizeReqVo pageSize, String sqlName, Object model) {
+        return queryPage(cls, pageSize, sqlName, model, null);
+    }
+
+    /**
+     * 查询分页数据，仅仅只是查询分页中的数据。如：包含的总数据数量
+     *
+     * @param cls      数据结果类型
+     * @param pageSize 分页参数
+     * @param sqlName  SQL语句名称
+     * @param model    前台参数
+     * @param <T>      返回数据类型
+     * @return 查询的结果
+     */
+    protected <T extends Object> PageSizeData<T> queryPage(Class<T> cls, PageSizeReqVo pageSize, String sqlName, Object model, QueryPara queryPara) {
         // 获取需要执行的SQL语句
         SqlData from = this.getSql(sqlName);
 
@@ -334,6 +504,7 @@ public abstract class BaseDaoSql {
 
         // 对SQL语句进行分页处理
         SqlData to = from.copy();
+        to = getSqlQueryPara(to, queryPara, false);
         to.addCode("{LIMIT}", " LIMIT " + pageSize.getPageStart() + "," + pageSize.getPageSize());
 
         // 按照分页查询数据
@@ -360,63 +531,6 @@ public abstract class BaseDaoSql {
         return data;
     }
 
-    /**
-     * 根据SQL语句信息查询数据
-     *
-     * @param sqlData SQL语句信息
-     * @param model   前台参数
-     * @return 查询的结果
-     */
-    protected List<MapRow> queryData(SqlData sqlData, Object model) {
-        return this.queryData(MapRow.class, sqlData, model);
-    }
-
-    /**
-     * 查询不分页数据
-     *
-     * @param sqlName SQL语句名称
-     * @param model   前台参数
-     * @return 查询的结果
-     */
-    protected List<MapRow> query(String sqlName, Object model) {
-        return this.query(MapRow.class, sqlName, model);
-    }
-
-    /**
-     * 查询第一条数据
-     *
-     * @param sqlName SQL语句名称
-     * @param model   前台参数
-     * @return 查询的结果
-     */
-    protected MapRow queryFirst(String sqlName, Object model) {
-        return this.queryFirst(MapRow.class, sqlName, model);
-    }
-
-    /**
-     * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
-     *
-     * @param pageSize 分页参数
-     * @param sqlName  SQL语句名称
-     * @param model    前台参数
-     * @return 查询的结果
-     */
-    protected List<MapRow> queryPageData(PageSizeReqVo pageSize, String sqlName, Object model) {
-        return this.queryPageData(MapRow.class, pageSize, sqlName, model);
-    }
-
-    /**
-     * 查询分页数据，仅仅只是查询分页中的数据，不查询分页信息。如：包含的总数据数量
-     *
-     * @param pageSize 分页参数
-     * @param sqlName  SQL语句名称
-     * @param model    前台参数
-     * @return 查询的结果
-     */
-    protected PageSizeData<MapRow> queryPage(PageSizeReqVo pageSize, String sqlName, Object model) {
-        return this.queryPage(MapRow.class, pageSize, sqlName, model);
-    }
-
 
     /**
      * 获取SQL语句的参数