[框架那点事儿-快速开发季]编写自己的数据持久层（4）分页查询

上一章节讲述的查询，都是不带分页的查询，但是在实际应用中，有相当一部分的需求是针对于分页查询的，比如页面的分页功能等。所以，作为底层的API，势必不能缺失针对于分页的查询接口封装。这一章节，我们提供以下几个分页查询，分别针对于：对象查询、部分字段查询两大类。

/**
* 分页查询对象
* <p>
* 	根据指定参数分页查询对象列表
* 	用法示例：
*  ----------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  Paginal p = queryObjectListForPaging(Person.class,params,1,10);
*  ...
* </p>
* @param objectClass 对象类型
* @param params	查询参数
* @param pageNomber	页号
* @param pageSize		分页大小
* @return 分页封装
*/
@SuppressWarnings({ "rawtypes"})
public Paginal queryObjectListForPaging(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize){
return queryObjectListForPagingOrderRow(objectClass,params,pageNomber,pageSize);
}

/**
* 分页-排序查询对象
* <p>
* 	分页查询，结果按照指定的条件排序
*  使用示例
*  ----------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  Paginal p = queryObjectListForPagingOrderRow(Person.class,params,1,10,orderByAge,orderByType);
*  ...
* </p>
* @param objectClass 字段所在类
* @param params 查询参数
* @param pageNomber 页号
* @param pageSize 分页大小
* @param orders 排序字段
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Paginal queryObjectListForPagingOrderRow(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize,Map<String,String>... orders){
//~~~ return value
Paginal<? extends Object> paginal = new Paginal<Object>();

// 初始化分页器
paginal.setPageNomber(pageNomber);
paginal.setPageSize(pageSize);

//获取表名
tableName = getTableConfigName(objectClass);
//组装查询sql语句
String sql = buildQuerySql(null, params, paginal.getOffset(),paginal.getPageSize(),false,orders);
//查询总记录数
int totalCount = queryCount(params,objectClass);

paginal.setTotalCount(totalCount);//总记录数
paginal.setPageNum(totalCount,pageSize);//总页码

//执行查询
List resultList = queryForList(sql,params,objectClass);
paginal.setResultList(resultList);

return paginal;
}

/**
* 分页查询部分字段
* <p>
* 	使用示例
*  -----------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10);
*  ...
* </p>
* @param objectClass 字段所在的类
* @param params 查询参数
* @param returnFields 需要查询的字段列表
* @param pageNomber 页号
* @param pageSize 分页大小
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes"})
public Paginal queryFieldsListForPaging(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize){
return queryFieldsListForPagingOrderRow(objectClass,params,returnFields,pageNomber,pageSize);
}

/**
* 分页-排序查询部分字段
* <p>
* 	使用示例
*  -----------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10,orderByAge,orderByType);
*  ...
* </p>
* @param objectClass 字段所在的类
* @param params 查询参数
* @param returnFields 需要查询的字段列表
* @param pageNomber 页号
* @param pageSize 分页大小
* @param orders 排序字段
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Paginal queryFieldsListForPagingOrderRow(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize,Map<String,String>... orders){
//~~~ return value
Paginal<? extends Object> paginal = new Paginal<Object>();

// 初始化分页器
paginal.setPageNomber(pageNomber);
paginal.setPageSize(pageSize);

//获取表名
tableName = getTableConfigName(objectClass);
//组装查询sql语句
String sql = buildQuerySql(returnFields, params, paginal.getOffset(),paginal.getPageSize(),false,orders);
//查询总记录数
int totalCount = queryCount(params,objectClass);

paginal.setTotalCount(totalCount);//总记录数
paginal.setPageNum(totalCount,pageSize);//总页码

//查询 得到 List<Map<String,Object>>
List resultList = queryForMapList(sql,params,objectClass);
paginal.setResultList(resultList);

return paginal;
}

/**
* 查询总记录数
* <p>
* 	根据指定查询条件查询记录总数，一般用于分页中等
* </p>
* @param params 查询条件参数
* @param objectClass 对象类型
* @return 记录数
*/
@SuppressWarnings({ "rawtypes"})
public int queryCount(Map<String,Object> params,Class objectClass){
//获取表名
tableName = getTableConfigName(objectClass);

//组装查询总记录数sql语句
String countsql = buildQueryConteSql(params);
//查询对象,存储查询条件数组
Object[] queryObject = getQueryObject(params);
//查询总记录数
int totalCount = getJdbcTemplate().queryForInt(countsql, queryObject);

return totalCount;
}

以上提供了几个分页查询api，封装的思路大致是：

分页查询 -> 带排序的分页查询

其实各种查询归根结底就是查询使用的sql的不同，由于之前我们封装的sql的生成方法和采用可编程度参数指定查询排序字段的方式，使得后续的工作变得很顺利。

分页器：

package com.netease.space.dao.base;
import java.io.Serializable;
import java.util.List;
/**
* 分页器
* <p>
* 	mysql的分页机制：limit offset,pagesize [] 从0开始计数偏移offset位的pagesize条数据
*  比如：
*  pagesize = 10;
*  -------------------------------------------------
*  | 页号  | 起始地址  | 结束地址  | 包含记录ID   |offset|
*  -------------------------------------------------
*  | 1    |    0    |    9    |0,1,2...9     |  0   |
*  | 2    |    10   |    19   |10,11,12...19 |  10  |
*  | 3    |    20   |    29   |20,22,23...29 |  20  |
*  --------------------------------------------------
*
*  用法示例：
*   limit getOffset(),pagesize;
* </p>
* @author quzishen
* @param <T> 查询结果的具体类型
*/
public class Paginal<T extends Object> implements Serializable{
private static final long serialVersionUID = -5159256681785242925L;
// 分页大小
private int pageSize;
// 页号，从1开始
private int pageNomber;
// 总记录数
private int totalCount;
// 总页数
private int pageNum;
// 查询对象列表
private List<T> resultList;

/**
* 获取当前页的起始地址
* @return 起始地址
*/
protected int getBeginIndex(){
return (pageNomber - 1)*pageSize;
}

/**
* 获取当前页的结束地址
* @return 结束地址
*/
protected int getEndIndex(){
return pageNomber*pageSize - 1;
}

/**
* 获取当前页的偏移量
* @return 偏移量
*/
protected int getOffset(){
if(pageNomber == 1){
return 0;
} else {
return (pageNomber-1)*pageSize;
}
}

/**
* 根据总记录数和分页大小设置总页数
* @param totalCount 总记录数
* @param pagesize 分页大小
*/
public void setPageNum(int totalCount,int pagesize){
int num = totalCount / pagesize;
if(0 != totalCount % pagesize){
num += 1;
}

pageNum = num;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getPageNomber() {
return pageNomber;
}
public void setPageNomber(int pageNomber) {
this.pageNomber = pageNomber;
}
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
public List<T> getResultList() {
return resultList;
}
public void setResultList(List<T> resultList) {
this.resultList = resultList;
}
}

请看详细代码：

package com.netease.space.dao.base;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
/**
* DAO抽象父类，提供针对于数据库的基本操作
* 工程名称：NormandyPosition
* 类型名称：AbstractBaseDAO
* 概要：
* <p>
* 	提供针对于DAO基础操作服务
* 	注意使用该类提供的API，必须保证DO类的属性名称，与对应数据库表的名称相同，不区分大小写
* </p>
* 创建时间：2010-7-27 上午12:58:42
* 创建人：quzishen
* 最后修改时间：2010-7-27 上午12:58:42
* 最后修改内容：
* @version 1.0
*/
public abstract class AbstractBaseDAO extends JdbcDaoSupport implements InitializingBean{
//~~~ instance fields

// table name
private String tableName;
//used for insert
SimpleJdbcInsert inserActor;
//default getter method prefix
public String GET_METHOD_PRE = "get";
//default setter method prefix
public String SET_METHOD_PRE = "set";
//default key name
public String DEFAULT_ID_NAME = "id";
//default serialVersionUID name
public String DEFAULT_SERIALVERSIONUID_NAME = "serialVersionUID";

//~~~ static final fields start ****************//
private final static String SQL_SELECT = " select ";
private final static String SQL_FROM = " from ";
private final static String SQL_WHERE = " where ";
private final static String SQL_AND = " and ";
private final static String SQL_UPDATE = " update ";
private final static String SQL_SET = " set ";
private final static String SQL_ORDER_BY = " order by ";
private final static String SQL_LIMIT = " limit ";
private final static String SQL_COUNT = " count(*) ";

private final static String SQL_EQUAL = " = ";
private final static String SQL_SPLIT = " , ";
private final static String SQL_PLACE_HOLDER = " ? ";
//~~~ static final fields end ****************//

/**************************************///public method begin /*******************************/
/**
* 新增一条记录
* <p>
* 	要求DO：遵循spring风格的getter和setter方法
* 			属性的名称和数据库的名称要对应，大小写不区分
*  示例:
*  -----------------------------------------------------
*  TABLE Person{
*  	ID  BIGINT NOT NULL,
*  	NAME VARCHAR(16) ....
*  }//数据库中字段为大写
*  -----------------------------------------------------
*  class Person{
*  	private long id;
*  	private String name;
*  }//DO类中的字段为小写
*  -----------------------------------------------------
*  Person person = new Person();
*  person.setName("quzishen");
*  long id = insertObject(person);
*
* </p>
* @param 插入对象
* @return 主键ID
* @throws RuntimeException
*/
public int insertObject(Object object) throws RuntimeException{
// 获取类型
@SuppressWarnings("rawtypes")
Class objectClass = object.getClass();
//获取表名
tableName = getTableConfigName(objectClass);
// 使用SimpleJdbcInsert完成插入的动作
inserActor = new SimpleJdbcInsert(getJdbcTemplate()).withTableName(tableName);

// 获取该对象的所有的private protected publick的属性
Field[] fields = getFieldsFromClass(objectClass);
// 将属性名字保存下来
List<String> fieldNameSet = getFiledNameList(fields);
// 设置需要更新的字段以及主键
setUsingListFromNameSet(fieldNameSet);
// 获取插入数据库sql需要的参数Map
Map<String, Object> paramMap = getParamMap(object, fields);
//简便起见，可以使用SqlParameterSource parameters = new BeanPropertySqlParameterSource(Actor);
// 获取到的参数为空
if(null == paramMap){
throw new RuntimeException("can not insert a null value!");
}

//执行插入并返回主键
return inserActor.executeAndReturnKey(paramMap).intValue();
}

/**
* 查询单一对象
* <p>
* 	要求：遵循spring风格的getter和setter方法
* 		    属性的名称和数据库的名称要对应，大小写不区分
* 		    这里一定要注意，如果属性的大小写有点个性非常强的个人色彩，
* 		    那么相应的setter方法要保证'set'后的属性首字母大写，其他字母大小写保持不变
* 		   如：pArAm ---->  getPArAm  &  setPArAm
*  示例：
*   -------------------------------------------------------------
*   class Person{
*   	private long id;
*   }
*   -------------------------------------------------------------
*   Map<String,Object> params = new HashMap<String,Object>();
*   params.put("id","10000");
*   Person person = (Person) queryForObject(params,Person.class);
*
* </p>
* @param params 查询条件map,key 属性名字 大小写无所谓
* @param returnClass 对象类型
* @return 查询结果
*/
public Object queryForObject(Map<String,Object> params,@SuppressWarnings("rawtypes") final Class returnClass) throws RuntimeException{
// 组装查询sql，参数使用占位符
String sql = buildQuerySql(null,params,-1,-1,false);

//获取表名
tableName = getTableConfigName(returnClass);

// 查询对象,存储查询条件数组
Object[] queryObject = getQueryObject(params);

//调用queryForObject并且重新RowMapper回调方法
return getJdbcTemplate().queryForObject(sql, queryObject,new RowMapper() {
public Object mapRow(ResultSet resultSet, int rowNum) throws SQLException {
if(1 < rowNum){
throw new RuntimeException("query result is more than one!");
}
//~~~ return value 组装返回对象
Object object = getObjectFromResultSet(resultSet,returnClass);

return object;
}
});
}

/**
* 查询对象列表结果
* <p>
* 	要求：遵循spring风格的getter和setter方法
* 		    属性的名称和数据库的名称要对应，大小写不区分
* 		    这里一定要注意，如果属性的大小写有点个性非常强的个人色彩，
* 		    那么相应的setter方法要保证'set'后的属性首字母大写，其他字母大小写保持不变
* 		   如：pArAm ---->  getPArAm  &  setPArAm
*  示例：
*   -------------------------------------------------------------
*   class Person{
*   	private String desc;
*   }
*   -------------------------------------------------------------
*   Map<String,Object> params = new HashMap<String,Object>();
*   params.put("desc","10000");
*   List<Person> persons = (List<Person>) queryForList(params,Person.class);
*
* </p>
* @param params 参数Map
* @param returnClass 返回列表中的对象类型
* @return
*/
@SuppressWarnings("rawtypes")
public List queryForObjectList(Map<String,Object> params,final Class returnClass){
return queryForObjectListOrderRow(params,returnClass);
}
/**
* 查询对象列表结果，查询按照指定列排序
* <p>
*  关于排序列（可变长度参数部分）：
*  根据排序的列的次序依次排列，每个Map中存放一个键值对，允许指定的排序为 asc || desc
*
*  示例：
*  Map<String,String> orderByName = new HashMap<String,String>();
*  orderByName.put("name","asc");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  queryForListOrderRow(params,returnClass,orderByName,orderByAge,orderByType)
* </p>
* @param params
* @param returnClass
* @param orders
* @return
*/
@SuppressWarnings("rawtypes")
public List queryForObjectListOrderRow(Map<String,Object> params,
final Class returnClass,
Map<String,String>... orders){
// 组装查询sql，参数使用占位符替代
String sql = buildQuerySql(null,params,-1,-1,false,orders);
if(logger.isDebugEnabled()){
logger.debug("RUN SQL:"+sql);
}
//执行查询
return queryForList(sql,params,returnClass);
}

/**
* 查询部分字段
* <p>
*  根据指定的属性名称查询特定字段，返回一个List<Map<属性名称，属性值>>
*
*  使用示例：
*  ---------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  List<Map<String,Object>> resultList = queryFieldsList(Person.class,params,fields);
*  ...
*
* </p>
* @param objectClass 返回属性所在的类
* @param objectClass
* @param params 查询参数map
* @param returnFields 返回字段列表
* @return 返回值，用map保存每一列的结果
*/
public List<Map<String,Object>> queryFieldsList(@SuppressWarnings("rawtypes")final Class objectClass,Map<String,Object> params,List<String> returnFields){
return queryFieldsListOrderRow(objectClass,params,returnFields);
}

/**
* 查询部分字段,查询结果根据指定列排序
* <p>
* 	根据指定的属性名称查询特定字段，并且根据指定的列排序，返回一个List<Map<属性名称，属性值>>
*	使用示例：
*  ---------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  List<Map<String,Object>> resultList = queryFieldsList(Person.class,params,fields,orderByAge,orderByType);
*  ...
*
* </p>
* @param objectClass 返回属性所在的类
* @param params 查询参数map
* @param returnFields 返回字段列表
* @param orders 查询语句排序指定字段
* @return 返回值，用map保存每一列的结果
*/
@SuppressWarnings("unchecked")
public List<Map<String,Object>> queryFieldsListOrderRow(@SuppressWarnings("rawtypes")final Class objectClass,
Map<String,Object> params,List<String> returnFields,Map<String,String>... orders){
// 组装查询sql，参数使用占位符替代
String sql = buildQuerySql(returnFields,params,-1,-1,false,orders);

//获取表名
tableName = getTableConfigName(objectClass);

return queryForMapList(sql,params,objectClass);
}

/**
* 分页查询对象
* <p>
* 	根据指定参数分页查询对象列表
* 	用法示例：
*  ----------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  Paginal p = queryObjectListForPaging(Person.class,params,1,10);
*  ...
* </p>
* @param objectClass 对象类型
* @param params	查询参数
* @param pageNomber	页号
* @param pageSize		分页大小
* @return 分页封装
*/
@SuppressWarnings({ "rawtypes"})
public Paginal queryObjectListForPaging(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize){
return queryObjectListForPagingOrderRow(objectClass,params,pageNomber,pageSize);
}

/**
* 分页-排序查询对象
* <p>
* 	分页查询，结果按照指定的条件排序
*  使用示例
*  ----------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  Paginal p = queryObjectListForPagingOrderRow(Person.class,params,1,10,orderByAge,orderByType);
*  ...
* </p>
* @param objectClass 字段所在类
* @param params 查询参数
* @param pageNomber 页号
* @param pageSize 分页大小
* @param orders 排序字段
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Paginal queryObjectListForPagingOrderRow(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize,Map<String,String>... orders){
//~~~ return value
Paginal<? extends Object> paginal = new Paginal<Object>();

// 初始化分页器
paginal.setPageNomber(pageNomber);
paginal.setPageSize(pageSize);

//获取表名
tableName = getTableConfigName(objectClass);
//组装查询sql语句
String sql = buildQuerySql(null, params, paginal.getOffset(),paginal.getPageSize(),false,orders);
//查询总记录数
int totalCount = queryCount(params,objectClass);

paginal.setTotalCount(totalCount);//总记录数
paginal.setPageNum(totalCount,pageSize);//总页码

//执行查询
List resultList = queryForList(sql,params,objectClass);
paginal.setResultList(resultList);

return paginal;
}

/**
* 分页查询部分字段
* <p>
* 	使用示例
*  -----------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10);
*  ...
* </p>
* @param objectClass 字段所在的类
* @param params 查询参数
* @param returnFields 需要查询的字段列表
* @param pageNomber 页号
* @param pageSize 分页大小
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes"})
public Paginal queryFieldsListForPaging(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize){
return queryFieldsListForPagingOrderRow(objectClass,params,returnFields,pageNomber,pageSize);
}

/**
* 分页-排序查询部分字段
* <p>
* 	使用示例
*  -----------------------------------------------------------------
*  //设置查询参数
*  Map<String,Object> params = new HashMap();
*  params.put("city","hangzhou");
*
*  //设置需要查询的字段名称，名称使用DO中的即可
*  List<String> fields = new ArrayList<String>();
*  fields.add("id");
*  fields.add(name);
*  fields.add("address");
*
*  Map<String,String> orderByAge = new HashMap<String,String>();
*  orderByName.put("age","desc");
*
*  Map<String,String> orderByType = new HashMap<String,String>();
*  orderByName.put("type","asc");
*
*  Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10,orderByAge,orderByType);
*  ...
* </p>
* @param objectClass 字段所在的类
* @param params 查询参数
* @param returnFields 需要查询的字段列表
* @param pageNomber 页号
* @param pageSize 分页大小
* @param orders 排序字段
* @return 查询结果
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Paginal queryFieldsListForPagingOrderRow(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize,Map<String,String>... orders){
//~~~ return value
Paginal<? extends Object> paginal = new Paginal<Object>();

// 初始化分页器
paginal.setPageNomber(pageNomber);
paginal.setPageSize(pageSize);

//获取表名
tableName = getTableConfigName(objectClass);
//组装查询sql语句
String sql = buildQuerySql(returnFields, params, paginal.getOffset(),paginal.getPageSize(),false,orders);
//查询总记录数
int totalCount = queryCount(params,objectClass);

paginal.setTotalCount(totalCount);//总记录数
paginal.setPageNum(totalCount,pageSize);//总页码

//查询 得到 List<Map<String,Object>>
List resultList = queryForMapList(sql,params,objectClass);
paginal.setResultList(resultList);

return paginal;
}

/**
* 查询总记录数
* <p>
* 	根据指定查询条件查询记录总数，一般用于分页中等
* </p>
* @param params 查询条件参数
* @param objectClass 对象类型
* @return 记录数
*/
@SuppressWarnings({ "rawtypes"})
public int queryCount(Map<String,Object> params,Class objectClass){
//获取表名
tableName = getTableConfigName(objectClass);

//组装查询总记录数sql语句
String countsql = buildQueryConteSql(params);
//查询对象,存储查询条件数组
Object[] queryObject = getQueryObject(params);
//查询总记录数
int totalCount = getJdbcTemplate().queryForInt(countsql, queryObject);

return totalCount;
}

/*****************************///private methods begin .../*****************************/

/**
* 查询列表
* @param sql 查询sql，其中参数部分使用占位符？代替具体的值
* @param params 查询条件值的map
* @param returnClass 返回值类型
* @return 查询列表
*/
@SuppressWarnings("rawtypes")
private List queryForList(String sql,Map<String,Object> params,final Class returnClass){
//获取表名
tableName = getTableConfigName(returnClass);

// 查询对象,存储查询条件数组
Object[] queryObject = getQueryObject(params);
//执行查询，设置rowMapper进行结果从List<Map> -->  List<Object>的转换
return getJdbcTemplate().query(sql, queryObject,new RowMapper(){
public Object mapRow(ResultSet resultSet, int rowNum) throws SQLException {
//~~~ return value 组装返回对象
Object object = getObjectFromResultSet(resultSet,returnClass);

return object;
}
});
}

@SuppressWarnings({ "rawtypes","unchecked" })
private List queryForMapList(String sql,Map<String,Object> params,final Class objectClass){
//获取查询参数
Object[] queryObject = getQueryObject(params);
//获取对象声明的属性
final Field[] fields = getFieldsFromClass(objectClass);
return (List<Map<String,Object>>)getJdbcTemplate().query(sql, queryObject, new RowMapper(){
public Object mapRow(ResultSet resultSet, int count) throws SQLException {
try{
Map<String,? extends Object> resultMap = getResultMapFromResultSet(resultSet,fields);
return resultMap;
}catch(Exception e){
throw new RuntimeException("can not get result from resultSet!");
}
}
});
}

/**
* 获取注解中配置的表名称
* @param Class 注解所添加位置的类
* @return String 注解中配置的tablename
*/
protected String getTableConfigName(@SuppressWarnings("rawtypes") Class objectClass){
@SuppressWarnings("unchecked")
Table tableAnnotation = (Table)objectClass.getAnnotation(Table.class);
String tableName = tableAnnotation.tableName();
return tableName;
}

/**
* 根据class和resultSet填充对象
* 通过反射，调用setter方法设置DO
* @param resultSet 查询返回值
* @param returnClass 返回值类型
*/
private Object getObjectFromResultSet(ResultSet resultSet,@SuppressWarnings("rawtypes") Class returnClass) throws RuntimeException{
// ~~~ return value
Object object = getInstanceByClass(returnClass);

if(null != object){
if(null == resultSet){
return null;
}

// 根据返回类型获取fields
Field[] fields = getFieldsFromClass(returnClass);
try{
//获取结果map<属性名,属性值>,用于方便的获取属性对应的值
Map<String,? extends Object> resultMap = getResultMapFromResultSet(resultSet,fields);

//遍历列表设置值,通过反射调用setter方法设置
for(Field field : fields){
if(checkIsSerivalVersioinUID(field.getName())){
//如果是序列ID，掠过
continue;
}
// 获取方法名
String methodName = getSetMethod(field.getName());
// 获取方法
Method method = object.getClass().getMethod(methodName, field.getType());
// 获取参数
Object param = resultMap.get(field.getName());//不能直接从resultSet中取值，因为其中的name是数据库的列名
// 执行setter方法
method.invoke(object, param);
}
}catch(Exception e){
logger.error("queryForObject exception!",e);
throw new RuntimeException(e);
}
}else {
//获取实例失败，这里抛出异常
throw new RuntimeException("build result object failed!");
}

return object;
}

/**
* 根据传入Map获取查询参数数组对象
* @param params 参数Map
* @return Object[]
*/
private Object[] getQueryObject(Map<String,Object> params){
// 查询对象,存储查询条件数组
Object[] queryObject = new Object[params.size()];

// 获取查询参数
int index = 0;
// 初始化查询对象
for(String param : params.keySet()){
queryObject[index++] = params.get(param);
}

return queryObject;
}

/**
* 组装查询语句
* <p>
* 	目前只支持了全部列查询
* 	关于排序列（可变长度参数部分）：
*  @see queryForListOrderRow
* </p>
* @param rows 需要查找的列，如果null，则全字段
* @param params 参数map
* @param offset 偏移量，-1标示不分页
* @param pagesize 分页大小，-1标示不分页
* @param useValue 是否使用参数值作为搜索条件的值，若false，则使用？代替
* @return string 查询sql
*/
private String buildQuerySql(List<String> rows,Map<String,Object> params,int offset,int pagesize,
boolean useValue,Map<String,String>... orders){
// 获取需要查找的列
String listStr = getSelecteKeyFromList(rows);
// 组装sql
String sql = SQL_SELECT+listStr+ SQL_FROM + tableName;

//如果后面不含有查询条件，则直接返回
if(null!=params && 0 < params.size()){
sql = getSqlCondition(sql,params, useValue);
}

if(-1 != offset || -1 != pagesize){
// limit offset,pagesize
sql += (SQL_LIMIT+offset+SQL_SPLIT+pagesize+" ");
}

return getSqlOrder(sql,orders);
}

/**
* 组装根据条件查询总记录数的sql
* @param params 条件
* @return sql语句
*/
private String buildQueryConteSql(Map<String,Object> params){
// 获取需要查找的列
String sql = SQL_SELECT+SQL_COUNT+SQL_FROM+ tableName;

//如果后面不含有查询条件，则直接返回
if(null!=params && 0 < params.size()){
sql = getSqlCondition(sql,params, false);
}

return sql;
}

/**
* 从查询列的列表中取出列名，并按照sql的要求逗号隔开，如 a,b,c,d
* 如果传入查询列的列表为空，或者长度为0，怎返回 * ，代表全部字段都查询
* @param rows
* @return
*/
private static String getSelecteKeyFromList(List<String> rows){
if(null == rows || 0 == rows.size()){
return "*";
}
String listStr = rows.toString();
listStr = getSubString(listStr, 1, 1);
return listStr;
}

/**
* 组装更新语句
* 除了主键外的全字段更新，限制条件可以自由设定
* @param object
* @param useValue
* @param conditions
* @return
*/
private String buildUpdateObjectSql(Object object,boolean useValue,Map<String,Object> conditions){
//组装更新sql
String sql = SQL_UPDATE + tableName + SQL_SET;

//获取域数组
Field[] fields = getFieldFromObject(object);

//获取属性和值的map，不包括主键和序列ID
Map<String, Object> params = getParamMap(object, fields);

//更新sql必须含有需要修改的字段的内容，否则抛出异常
if(null == params || 0 >= params.size()){
throw new RuntimeException("can not update without values!");
}

//添加修改字段的sql片段
for(String key : params.keySet()){
sql += (key + SQL_EQUAL +(useValue? params.get(key):SQL_PLACE_HOLDER));
sql += SQL_SPLIT;
}

sql = getSubString(sql,0,1);//去掉最后的一个逗号

return getSqlCondition(sql,conditions, useValue);
}

/**
* 获取sql语句的后半部分，从where开始的条件设定部分
* @param sql sql前半部分，可以是select或者update或者delte，不限
* @param conditions 条件map
* @param useValue 是否使用具体值替代占位符？
* @return
*/
private static String getSqlCondition(String sql,Map<String,Object> conditions,boolean useValue){
//开始组装条件
sql += SQL_WHERE;

for(String key : conditions.keySet()){
sql += (key+SQL_EQUAL);
sql += useValue? conditions.get(key):SQL_PLACE_HOLDER;
sql += SQL_AND;
}

return getSubString(sql,0, 5);//取消最后的" and ";
}

/**
* 获取sql的后半order by的部分，如果没有指定排序，那么直接返回sql
* @param sql sql前半部分，通常截止于where语句
* @param orders 排序列的map，按照排序的次序依次排列
* @return 转换后的sql
*/
private static String getSqlOrder(String sql,Map<String,String>... orders){
if(null == orders || 0 == orders.length){
return sql;
}else {
sql += SQL_ORDER_BY;
}

//遍历order组，添加附加的排序条件
for(int i = 0; i < orders.length; i++){
//获取其中的每一组，并获取其中的key和value
Map<String,String> orderItem = orders[i];
if(!orderItem.keySet().isEmpty()){
//使用迭代器取出map中的第一个键值对，通常也是当前map中的唯一一对
Iterator<String> index = orderItem.keySet().iterator();
if(index.hasNext()){
String key = index.next();
sql += (" " + key + " "+orderItem.get(key));//like  name desc
sql += SQL_SPLIT;//like name desc,
}
}
}
int splitPoint = sql.lastIndexOf(',');
sql = getSubString(sql,0, sql.length()-splitPoint);//去掉最后一个逗号

return sql;
}

/**
* 获取部分字符串
* @param str
* @param begin 起始位数，从首位开始计数，0开始
* @param end 从末尾开始计数的，截止位
* @return
*/
private static String getSubString(String str,int begin,int end){
return str.substring(begin, str.length()-end);
}

/**
* 从对象中获取Field数组
* @param object
* @return
*/
private Field[] getFieldFromObject(Object object){
@SuppressWarnings("rawtypes")
Class objectclass = object.getClass();
Field[] fields = getFieldsFromClass(objectclass);
return fields;
}

/**
* 获取结果的map<fieldName,fieldValue>
* <p>
* 	从数据库中获取而来的ResultSet，类型为 <数据库字段相同大小写的字符串，数据库字段类型>
*  我们需要转换成：<对象中的属性名称大小写的字符串，对象中的属性的类型>
* </p>
* @param resultSet 结果set
* @param fields 属性数组
* @throws Exception
*/
private Map<String,? extends Object> getResultMapFromResultSet(ResultSet resultSet,Field[] fields) throws Exception{
//~~~ return value
Map<String,Object> map = new HashMap<String,Object>();

//获取元数据
ResultSetMetaData setMetaData = resultSet.getMetaData();
//遍历各列，获取各列的值和在DO类中对应的属性的名称
for(int i=1;i<=setMetaData.getColumnCount();i++){
//获得列名称
String columnName = setMetaData.getColumnName(i);//特别注意，这里的下标从1开始
if(logger.isDebugEnabled()){
logger.debug("get column:"+columnName);
}

//获得当前列的值
Object rowObject = resultSet.getObject(columnName) == null ? "":resultSet.getObject(columnName);

//获取当前列对应的属性在属性组中的下标
int index = getFieldIndexOfObject(fields,columnName);
if(-1 == index){
throw new Exception("can not find index of column :"+columnName+" in fields.");
}

//将当前字段从数据库类型转换成DO中的类型
rowObject = ConvertUtils.convert(rowObject.toString(), fields[index].getType());

//获得当前列在对象中对应的属性名
String realName = getFieldRealNameOfObject(fields,columnName);
if(null == realName || "".equals(realName)){
logger.error("no field match the name:"+columnName);
throw new Exception();
}

map.put(realName, rowObject);
}

return map;
}

/**
* 用于获取fields中当前数据库列对应的名字
* @param fields 属性域数组
* @param rowNameInResultSet
* @return
*/
private String getFieldRealNameOfObject(Field[] fields,String rowNameInResultSet){
List<String> fieldNameSet = getFiledNameList(fields);
//一次遍历，不分大小写，用于解决DO和数据库字段的属性名字大小写不一致的问题
for(String s:fieldNameSet){
if(StringUtils.equalsIgnoreCase(s, rowNameInResultSet)){
return s;
}
}
return null;
}
/**
* 返回当前列对应的属性在field数组中的下标
* @param fields
* @param rowNameInResultSet
* @return
*/
private int getFieldIndexOfObject(Field[] fields,String rowNameInResultSet){
List<String> fieldNameSet = getFiledNameList(fields);
//一次遍历，不分大小写，用于解决DO和数据库字段的属性名字大小写不一致的问题
int index = 0;
for(String s:fieldNameSet){
if(StringUtils.equalsIgnoreCase(s, rowNameInResultSet)){
return index;
}
index++;
}
return -1;
}

/**
* 根据class获取一个实例对象
* @param class
* @return null 或者对象实例
*/
private Object getInstanceByClass(@SuppressWarnings("rawtypes") Class className){
Object object = null;
try {
object = className.newInstance();//new 一个对象

//把产生的异常都吃掉，这里返回null可以触发上层抛出异常
} catch (InstantiationException e) {
logger.error("new instance exception!",e);
} catch (IllegalAccessException e) {
logger.error("can not access the instance method!",e);
}
//return null or a object
return object;
}

/**
* 根据类名获取所有声明的属性列表
* 注意其中也包含了不属于数据库对应字段的属性，比如序列号ID
* @param className 类名称
* @return field数组
*/
private Field[] getFieldsFromClass(@SuppressWarnings("rawtypes") Class className){
Field[] fields = className.getDeclaredFields();
return fields;
}

/**
* 根据属性数组获取属性名称的set
* 这里必须使用list，以保持次序
* @param fields
* @return
*/
private List<String> getFiledNameList(Field[] fields) {
//~~~ return value
List<String> fieldNameSet = new ArrayList<String>();

// get the name of each
for (int i = 0; i < fields.length; i++) {
fieldNameSet.add(fields[i].getName());
}
return fieldNameSet;
}
/**
* 设置需要增加的属性以及主键
* 针对于insert方法，提供需要插入的字段名称，其中不包括主键ID和序列号SerivalVserionId
* @param fieldNameSet
*/
private void setUsingListFromNameSet(List<String> fieldNameSet) {
//~~~ return value
List<String> usingColums = new ArrayList<String>();

// 使用所有的除了主键和序列号的字段名称
for (String field : fieldNameSet) {
if (StringUtils.equalsIgnoreCase(field,
DEFAULT_SERIALVERSIONUID_NAME)) {
//序列号掠过
continue;
}
if (!StringUtils.equalsIgnoreCase(field, DEFAULT_ID_NAME)) {
//不是主键，放入字段列表
usingColums.add(field);
} else {
//主键作为返回字段
inserActor = inserActor.usingGeneratedKeyColumns(field);
}
}
inserActor.setColumnNames(usingColums);
}

/**
* 检查是否是序列号ID
* @param field
* @return
*/
private boolean checkIsSerivalVersioinUID(String field){
return StringUtils.equalsIgnoreCase(field,DEFAULT_SERIALVERSIONUID_NAME);
}
/**
* 获取插入数据库中的sql需要的参数Map
* 其中不包括主键和序列号
* @param object 实例化后的对象
* @param fields 对象类包含的class
* @return <属性名称，属性值>
* @throws SecurityException
*/
private Map<String, Object> getParamMap(Object object, Field[] fields) throws SecurityException{
//~~~ return value
Map<String, Object> paramMap = new HashMap<String, Object>();
//依次遍历对象的get方法，获取对象的属性值，放入map中
for (int i = 0; i < fields.length; i++) {
if (!checkIsNeedField(fields[i].getName())) {
continue;
} else {
String methodName = getGetMethod(fields[i].getName());
if(logger.isDebugEnabled()){
logger.debug("run method:" + methodName);
}
try {
// 通过代理执行访问器
Method method = object.getClass().getMethod(methodName); // get方法没有参数，不需要获取参数类型，fields[i].getGenericType().getClass()
Object result = method.invoke(object, new Object[] {});//调用get方法获取属性值
String value = null==result? "":result.toString();
paramMap.put(fields[i].getName(), value);

} catch (SecurityException e) {
// 由安全管理器抛出的异常，指示存在安全侵犯
throw e;
} catch (NoSuchMethodException e) {
// 没有该方法
logger.error("There is no method '"+methodName+"' in Class "+object.getClass()+"! Check your getter method name!",e);
return null;
}catch (IllegalArgumentException e) {
// 参数不正确
logger.error("IllegalArgumentException happend because the method '"+methodName+"'"+"' in Class "+object.getClass()+ "has some parameters!",e);
return null;
} catch (IllegalAccessException e) {
// 访问的方法不能被访问，一般是由于private等权限问题
logger.error("The method '"+methodName+"' in Class "+object.getClass()+"can not be accessed!Check your getter method whether it is private of protected!",e);
return null;
} catch (InvocationTargetException e) {
// 映射目标异常
logger.error("The invoke method '"+methodName+"' in Class "+object.getClass()+"is not right!Check your getter method name!",e);
return null;
}
}
}
return paramMap;
}

/**
* 获取默认的get方法的名字,根据spring的默认规则
* @param fieldName
* @return
*/
private String getGetMethod(String fieldName){
//生成诸如getParam1的方法名称
String methodName = GET_METHOD_PRE + changeFirstChar2upper(fieldName);
return methodName;
}

private String getSetMethod(String fieldName){
//生成诸如setParam1的方法名称
String methodName = SET_METHOD_PRE + changeFirstChar2upper(fieldName);
return methodName;
}
/**
* 将字符串的首字母大写
* @param fieldName
* @return
*/
private static String changeFirstChar2upper(String fieldName){
return fieldName.toUpperCase().charAt(0) + fieldName.substring(1, fieldName.length());
}

/**
* 检查是否是必要的需要修改的字段
* @param fieldName
* @return
*/
private boolean checkIsNeedField(String fieldName){
if (StringUtils.equalsIgnoreCase(fieldName, DEFAULT_SERIALVERSIONUID_NAME)
|| StringUtils.equalsIgnoreCase(fieldName, DEFAULT_ID_NAME)) {
return false;
}
return true;
}
/***************************************///getter & setter //***********************************************
public String getTableName() {
return tableName;
}
public void setTableName(String tableName) {
this.tableName = tableName;
}
}

可以看到，正如我之前所讲，这几种不同的查询全部依赖于底层的几个基础方法：

封装查询sql的方法：buildQuerySql

查询对象列表方法：queryForList

查询map列表方法：queryForMapList 即部分属性查询方法

通过这几个方法的组合以及可变长度参数的使用，可以灵活封装不同的api。

----------------------------------------------

从下一章节，我们开始讲述 修改 相关的操作。