关于一些分页的封装和一些DAO的封装

	/**
	 * 查询物流市列表
	 * http://localhost:8080/mall/mallLogisticsCity/getLogisticsCityList.json
	 * @param productName
	 * @return
	 */
	@RequestMapping("/getLogisticsCityList.json")
	public Object getLogisticsCityList(@RequestParam(value="cityCode",required=false)String cityCode,
			@RequestParam(value="provinceId",required=false)String provinceId,Model model) {
		log.info("LogisticsCityController.getLogisticsCityList()");
		try {
			Map<String, Object> cxtj = new HashMap<String, Object>();
			cxtj.put("cityCode", cityCode);
			cxtj.put("provinceId", provinceId);
			PagedListData pm = new PagedListData((PageList) logisticsCityService, cxtj);
			PageUtil page = new PageUtil();
			page.setPageNow(pm.getTotalPage());
			page.setDatas((List<Object>) pm.getData());
			page.setPageCount(pm.getTotalRecords() / pm.getPageSize());
			page.setPageRowCount(pm.getTotalRecords());
			page.setPageSize(pm.getPageSize());
			model.addAttribute("cxtj", cxtj);
			model.addAttribute("page", page);
		} catch (Exception e) {
			e.printStackTrace();
			log.error("getLogisticsCityList error:" + e.getLocalizedMessage());
			return "/operate/config/logistics_template";
		}
		return "/operate/config/logistics_template";
	
	}

　　以上是一个非常简单的Controller，我这里就简单粗暴一点，直接上代码，先把思路搞清楚，然后在想如何写代码！

PagedListData pm = new PagedListData((PageList) logisticsCityService, cxtj);
这句话肯定是调用了PageListData的构造函数，这里是将你需传值进去的参数封装成map集合，另一个就是接口，被强转为PageList类型  

好了，我们看看PageListData是如何写的

package com.maidan.util;


import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.support.AopUtils;
import org.springframework.context.NoSuchMessageException;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.maidan.util.Constants;
import com.maidan.util.StringUtil;

public class PagedListData extends JsonReturn{
    private static Log log = LogFactory.getLog(PagedListData.class);
    private Integer totalRecords;//总记录数
    private Integer totalPage;//当前页
    private Integer pageSize;//页大小
    private Map<String,Object> cxtj;//查询条件
    protected PageList pagelist;//结果集
    //protected Map<String, String> orderMap = new LinkedHashMap<String, String>(); // //排序字段
    private Collection data;
    private String forMethod = "";
    private boolean inited = false;
    protected boolean hasNext = false;
    
    /**
     * 获取HttpServletRequest对象
     * 
     * @return HttpServletRequest
     */
    protected HttpServletRequest getRequest(){
        return ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
    }
    
    /**
     * 从request获取name对应的值
     * 
     * @param name
     * @return
     * @see
     */
    public String getParameter(String name){
        return StringUtil.trim(getRequest().getParameter(name));
    }
    
    /**
     * 为了可以使一个Manager可以进行多个分页添加此方法将count和doPage转换为count*,do**.Page
     * <br/>例如forMethod等于test将调用countTest,doTestPage
     * @param forMethod
     * @return
     */
    public PagedListData forMethod(String forMethod){
        this.forMethod = StringUtil.toUpperCaseAny(forMethod);;
        return this;
    }
    /**
     * 构造一个PagedListDataModel对象
     * @param request
     * @param pagelist
     * @param cxtj
     */
    public PagedListData(PageList pagelist,Map <String,Object>cxtj) {
        this.cxtj = cxtj;
        this.pagelist = pagelist;
        init();
    }
    
    public PagedListData(PageList pagelist,Integer currentPage,Integer pageSize,Map <String,Object> cxtj) {
        this.cxtj =cxtj;
        this.pagelist = pagelist;
        this.pageSize = pageSize;
        this.totalPage =currentPage; //原有类当前页写成了总页
    }
    //初始化分页配置
    private void init(){
        try{
            String rows=this.getParameter("rows");
            this.pageSize =(rows!=null ? Integer.valueOf(rows) : 10);
        }catch(Exception e){
            //log.warn("在request中获取页大小出错将使用默认页大小"+Constants.DEFAULT_PAGESIZE, e);
            this.pageSize = 10;
        }
        if(this.pageSize==null){
            //log.warn("页大小小于1将使用默认页大小"+Constants.DEFAULT_PAGESIZE);
            this.pageSize=10;
        }
        try{
            String currentPage= this.getParameter("page");
            this.totalPage = (currentPage!=null ? Integer.parseInt(currentPage):1);
        }catch(Exception e){
            //log.warn("在request中获取当前页出错将使用默认使用第一页", e);
            this.totalPage =1;
        }
        if(this.totalPage==null){
            //log.warn("当前页小于1将使用默认页大小");
            this.totalPage=1;
        }
    }
    /**
     * 获取分页的数据
     * @return
     */
    public Collection getData() {
        if(!inited){
            initData();
            inited=true;
        }
        return data;
    }
    /**
     * 加载数据
     */
    private void initData(){
        this.data = this.getDatas();
        this.totalRecords =Integer.parseInt(this.getCount().toString());
        if((this.getCount()/this.pageSize)>totalPage){
            hasNext = true;
        }
        
    }
    /**
     * 执行forMethod对应的方法
     * @param method
     * @param param
     * @return
     */
    private Object invoke(Method method,Object []param){
        try {
            if(AopUtils.isJdkDynamicProxy(this.pagelist)){
                return  Proxy.getInvocationHandler(this.pagelist).invoke(this.pagelist, method, param);
            }
            return   AopUtils.invokeJoinpointUsingReflection(this.pagelist, method, param);
        }catch (Throwable e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 返回总记录数
     * @return
     */
    public Integer getTotalRecords() {
        if(!inited){
            initData();
            inited=true;
        }
        return totalRecords;
    }

    

    /**
     * 获取分页的数据
     * @return
     */
    private Collection getDatas() {
        if(this.pagelist!=null){
            Method dompage = null;
            if(StringUtil.isEmpty(this.forMethod)){
                return this.pagelist.doPage(this.totalPage,this.pageSize, cxtj,null,null);
            }else{
                Class temp = AopUtils.getTargetClass(this.pagelist);
                String m = null;
                m = "do"+this.forMethod+"Page";
                while(temp!=null){
                    try {
                        dompage = temp.getDeclaredMethod(m, int.class,int.class,Map.class,String.class);
                        break;
                    } catch (NoSuchMethodException e) {
                        temp = temp.getSuperclass();
                        e.printStackTrace();
                    }
                }
                if(temp==null){
                    throw new NoSuchMessageException(m+"(int start,int pagesize,Map <String,Object>cxtj) 没有该方法");
                }
                return (Collection) this.invoke(dompage,new Object[]{this.totalPage,pageSize,cxtj});
            }
        }
        return null;
    }
    /**
     * 统计总记录数
     * @return
     */
    private Long getCount(){
        if(this.pagelist!=null){
            String m = null;
            if(StringUtil.isEmpty(this.forMethod)){
                return this.pagelist.count(cxtj);
            }else{
                Method count = null;
                Class temp = AopUtils.getTargetClass(this.pagelist);
                m = "count"+this.forMethod;
                while(temp!=null){
                    try {
                        count = temp.getDeclaredMethod(m,Map.class);
                        break;
                    } catch (NoSuchMethodException e) {
                        temp = temp.getSuperclass();
                        e.printStackTrace();
                    }
                }
                if(temp==null){
                    throw new NoSuchMessageException(m+"(int start,int pagesize,Map <String,Object>cxtj) 没有该方法");
                }
                return (Long) this.invoke(count,new Object[]{cxtj});
            }
        }
        return Constants.LONG_ZERO;
    }
    

    /**
     * 返回当前页
     * @return
     */
    public Integer getTotalPage() {
        return totalPage;
    }
    /**
     * 设置当前页在获取总记录数或分页数据前有效
     * @param page
     */
    public void setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
    }
    
    
    /**
     * 获取页大小
     * @return
     */
    public Integer getPageSize() {
        return pageSize;
    }
    /**
     * 设置页大小在获取总记录数或分页数据前有效
     * @param pageSize
     */
    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public boolean isHasNext() {
        return hasNext;
    }

    public void setHasNext(boolean hasNext) {
        this.hasNext = hasNext;
    }
    



/*
    public Map<String, String> getOrderMap() {
        return orderMap;
    }

    *//**
     * 排序
     * @param order 排序条件,map的key为实体的属性名,value可选asc或desc
     *//*
    public void setOrderMap(final Map<String, String> orderMap) {
        this.orderMap = orderMap;
    }*/
    
}

这里我就简单的讲解一下

通过这里我们能清晰的看到 这个类的一些属性

有总记录数   当前页   总页数  查询条件  以及结果集

 

 

这里就是刚刚调用的构造函数

 

这里this,pagelist = pagelist    就是将某个service接口传值进去赋值给pagelist，有什么用呢，我们可以继续往下看

 

他会执行init();方法

进入这个方法，他会通过request域中获取前台穿过来的总行数量，如果值为null那么pageSize默认的设置为10

然后去request域中获取当前的页数，如果是null那么currentPage就是1  他这里变量名称取得不是很对，心里明白就好

 

到这里 PagedListData 中 我们设置了当前页 currentPage  和 每页多少条数  pagesize

 

然后我们看controller  

setPageNow(pm.getTotal);

然后他这里通过pm.getData()这个方法就获取当前所需要的list集合，很厉害，我们看看他是如何完成的

这里然后进入initData()方法

他这里加载数据中干了两件事情

this.getDatas()  和  this.getCount()  

这两个方法是分别获取当前页的List集合  和  总数量

 

我们一个一个看，首先我们看this.getDatas();

这里是通过调用this.pagelist.doPage(........)

 

通过 this.pagelist.count(cxtj);

 

以上这里个方法我圈起来的地方，其他的是通过反射，说实话我是没有看懂，只知道这里是反射通过spring中的AOP工具类反射获取该类class

然后通过class.getDeclaredMethod获取该类的方法 然后 invoke去执行

我问过工资是我两倍的这个，他是这么说的

好吧　说的我无言以对，意思就是就你这技术看这个说明你想多了，我们就把能搞懂的先弄懂吧

 

既然两个方法都是pagelist这里接口调用的方法  我们在去看看Pagelist中写了什么

public interface PageList{

    /**
     * 根据查询条件查询统计符合条件的数据的总数
     * 
     * @param cxtj 查询条件
     * @return 返回统计总数
     */
    Long count(Map<String,Object> cxtj);
    

    /**
     * 分页查询
     * 
     * @param start 开始记录数
     * @param pagesize 分页大小
     * @param cxtj 查询条件
     * @return 返回符合条件的数据从start开始最多pagesize条数据
     */
    List<?> doPage(int start,int pagesize,Map<String,Object> cxtj,String sort, String dir);

这里分装了就是刚刚所需要查的两个方法

 

刚刚我们将某个接口赋值给pagelist，而这个pagelist中只有连个方法，他的实现类在哪里呢？

下面我们来看

这里logisticsCityService接口里面干了什么 ，大家都知道web传统的MVC模式流程   首先是经过controller 层 然后是service层 最后是和数据库打交道的dao层

这个接口继承了一个公共接口

这个公共接口又继承了父类的接口，

这个父类接口阐明了许多CRUD方法  

package com.maidan.mall.base.service.interfaces;

import java.io.Serializable;
import java.util.List;
import java.util.Map;


/**
 * @param <T>实体的类型
 * @param <PK>实体主键类型
 */
public interface BaseManager<T,PK extends Serializable>{

    /**
     * 保存（持久化）对象 
     * 默认的sqlId=insert
     * @param o 要持久化的对象
     * @return 执行成功的记录个数
     */
    void save(T ob);
    /**
     * 保存（持久化）对象 
     * 默认的sqlId=insertSelective
     * @param o 要持久化的对象
     * @return 执行成功的记录个数
     */
    void saveSelective(T ob);

    /**
     * 更新（持久化）对象
     * 默认的sqlId=updateByPrimaryKey
     * @param o 要持久化的对象
     * @return 执行成功的记录个数
     */
    Integer update(T ob);
    
    /**
     * 更新（持久化）对象
     * 默认的sqlId=updateByPrimaryKey
     * @param o 要持久化的对象
     * @return 执行成功的记录个数
     */
    Integer updateBlob(T ob);
    
     /**
     * 更新（持久化）对象
     * 默认的sqlId=updateByPrimaryKeySelective
     * @param o 要持久化的对象
     * @return 执行成功的记录个数
     */
    Integer updateSelective(T ob);

    /**
     * 获取指定的唯一标识符对应的持久化对象
     * 默认的sqlId=selectByPrimaryKey
     * @param id 指定的唯一标识符
     * @return 指定的唯一标识符对应的持久化对象，如果没有对应的持久化对象，则返回null。
     */
    T getById(Long id);

    /**
     * 删除指定的唯一标识符对应的持久化对象
     * 默认的sqlId=deleteByPrimaryKey
     * @param id 指定的唯一标识符
     * @return 删除的对象数量
     */
    Integer deleteById(PK id);

    /**
     * 删除指定的唯一标识符数组对应的持久化对象
     * 默认的sqlId=deleteByIds
     * @param ids 指定的唯一标识符数组
     * @return 删除的对象数量
     */
    Integer deleteByIds(String ids);

    /**
     * 分页查询
     * 默认的sqlId=findPageBy
     * @param param 查询参数
     * @param pageNo 要查询的页号
     * @param pageSize 每页数据个数
     * @param sort 排序字段名
     * @param dir 排序方式（升序(asc)或降序(desc)
     * @return 查询结果分页数据
     */
    List<T> findPageBy(
            T param, int pageNo, int pageSize, String sort, String dir);
    
    /**
     * 分页查询
     * 
     * @param param 查询参数
     * @param sqlId sql ID
     * @param pageNo 要查询的页号
     * @param pageSize 每页数据个数
     * @param sort 排序字段名
     * @param dir 排序方式（升序(asc)或降序(desc)
     * @return 查询结果分页数据
     */
    List<T> findPageBy(
            T param, String sqlId,int pageNo, int pageSize, String sort, String dir);
    
    /**
     * 获取满足查询参数条件的数据总数
     * 默认的sqlId=getCountBy
     * @param param 查询参数
     * @return 数据总数
     */
    Long getCountBy(T param);
    
    Long getCountBy(Map<String,Object> param);

    /**
     * 不分页查询
     *  默认的sqlId=findListBy
     * @param param 查询参数
     * @param sort 排序字段名
     * @param dir 排序方式（升序(asc)或降序(desc)
     * @return 查询结果列表
     */
    List<T> findListBy(T param, String sort, String dir);
    List<T> findListBy(Map<String,Object> param, String sort, String dir);
    
    /**
     * 不分页查询
     * 
     * @param param 查询参数
     * @param sqlId sql ID
     * @param sort 排序字段名
     * @param dir 排序方式（升序(asc)或降序(desc)
     * @return 查询结果列表
     */
    List<T> findListBy(T param,String sqlId, String sort, String dir);
    List<T> findListBy(Map<String,Object> param,String sqlId, String sort, String dir);
    List<T> queryByIds(String ids);
    //查询表中主键的最大值
    Integer queryMaxId(String sqlId);
    
}

 

父类接口有自己的实现类 

package com.maidan.mall.base.service.implement;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.maidan.mall.base.persistence.dao.interfaces.IBaseDao;
import com.maidan.mall.base.service.interfaces.BaseManager;
public class BaseManagerImpl<T,PK extends Serializable> implements BaseManager<T,PK>{

    protected final Log log = LogFactory.getLog(getClass());
    protected IBaseDao<T,PK> dao;

    public BaseManagerImpl(IBaseDao<T, PK> genericDao) {
        this.dao = genericDao;
    }
    
    public BaseManagerImpl() {
    }

    @Override
    public void save(T ob) {
        dao.save(ob);
    }

    @Override
    public void saveSelective(T ob) {
        dao.saveSelective(ob);
    }

    @Override
    public Integer update(T ob) {
        return dao.update(ob);
    }

    @Override
    public Integer updateBlob(T ob) {
        return dao.updateBlob(ob);
    }

    @Override
    public Integer updateSelective(T ob) {
        return dao.updateSelective(ob);
    }

    @Override
    public T getById(Long id) {
        return dao.getById(id);
    }

    @Override
    public Integer deleteById(PK id) {
        return dao.deleteById(id);
    }

    @Override
    public Integer deleteByIds(String ids) {
        return dao.deleteByIds(ids);
    }

    @Override
    public List<T> findPageBy(T param, int pageNo, int pageSize,
            String sort, String dir) {
        return dao.findPageBy(param, pageNo, pageSize, sort, dir);
    }

    @Override
    public List<T> findPageBy(T param, String sqlId, int pageNo,
            int pageSize, String sort, String dir) {
        return dao.findPageBy(param, sqlId, pageNo, pageSize, sort, dir);
    }

    @Override
    public Long getCountBy(T param) {
        return dao.getCountBy(param);
    }

    @Override
    public Long getCountBy(Map<String, Object> param) {
        return dao.getCountBy(param);
    }

    @Override
    public List<T> findListBy(T param, String sort, String dir) {
        return dao.findListBy(param, sort, dir);
    }
    
    public List<T> findListBy(Map<String, Object> param, String sort, String dir) {
        return dao.findListBy(param, sort, dir);
    }

    @Override
    public List<T> findListBy(T param, String sqlId, String sort, String dir) {
        return dao.findListBy(param, sqlId, sort, dir);
    }
    @Override
    public List<T> findListBy(Map<String, Object> param, String sqlId, String sort, String dir) {
        return dao.findListBy(param, sqlId, sort, dir);
    }
    @Override
    public List<T> queryByIds(String ids) {
        // TODO Auto-generated method stub
        return dao.queryByIds(ids);
    }

    @Override
    public Integer queryMaxId(String sqlId) {
        
        // TODO Auto-generated method stub
        return dao.queryMaxId(sqlId);
    }
}

 

他这里的实现类是通过

IBaseDao与数据库交互的 首先看他这里构造函数，意思就是将传进来某个Dao赋值给这个IBaseDao<T,PK>dao,当然了 你传进来的这个dao也必须继承这个IBaseDao

 

我们先来看看IBaseDao的实现类

package com.maidan.mall.base.persistence.dao.implementes;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.annotation.Autowired;

import com.maidan.mall.base.constants.Constants;
import com.maidan.mall.base.exception.SystemException;
import com.maidan.mall.base.persistence.dao.interfaces.IBaseDao;
import com.maidan.util.BeanMapUtil;
import com.maidan.util.ReflectGeneric;
import com.maidan.util.StringUtil;

public class BaseDaoImpl<T, ID extends Serializable>  extends SqlSessionDaoSupport  implements IBaseDao<T, ID> {
    
    @Autowired
    public void setSqlSessionFactory(SqlSessionFactory mall_SqlSessionFactory) {
        super.setSqlSessionFactory(mall_SqlSessionFactory);
    }
    
    public static final String SQLNAME_SEPARATOR = ".";
    
    
    //默认的sql id
    public static final String SQL_SAVE = "insert";   
    public static final String SQL_SAVE_SELECTIVE = "insertSelective";   
    public static final String SQL_UPDATE = "updateByPrimaryKey";
    public static final String SQL_UPDATE_BLOBS = "updateByPrimaryKeyWithBLOBs"; 
    public static final String SQL_UPDATE_SELECTIVE = "updateByPrimaryKeySelective"; 
    public static final String SQL_GETBYID = "selectByPrimaryKey";
    public static final String SQL_DELETEBYID = "deleteByPrimaryKey";
    public static final String SQL_DELETEBYIDS = "deleteByIds";
    public static final String SQL_FINDPAGEBY = "findPageBy"; 
    public static final String SQL_FINDPAGEBYCOUNT = "findPageByCount";
    public static final String SQL_FINDLISTBY = "findListBy";
    public static final String SQL_GETCOUNTBY = "getCountBy";
    public static final String SQL_GETlISTByIDS = "getListByIds";
    //排序 字段
    private static final String SORT_NAME = "sorts";
    //排序字段 asc desc
    private static final String DIR_NAME = "dir";
    /** 不能用于SQL中的非法字符（主要用于排序字段名） */
    public static final String[] ILLEGAL_CHARS_FOR_SQL = {",", ";", " ", "\"", "%"};
    
    /**
     * SqlMapping命名空间
     */
    private String sqlNamespace = getDefaultSqlNamespace();
    
    
    /**
     * 获取默认SqlMapping命名空间。
     * 使用泛型参数中业务实体类型的类名作为默认的命名空间。
     * 如果实际应用中需要特殊的命名空间，可由子类重写该方法实现自己的命名空间规则。
     * com.wetools.emalls.model.ShoppingCart===>>ShoppingCart
     * @return 返回命名空间字符串
     */
    @SuppressWarnings("unchecked")
    protected String getDefaultSqlNamespace() {
        Class<T> clazz = ReflectGeneric.getClassGenricType(this.getClass());
        String nameSpace =clazz.getName().substring(clazz.getName().lastIndexOf(".")+1) ;
        return nameSpace;
    }
    /**
     * 将SqlMapping命名空间与给定的SqlMapping名组合在一起。
     * @param sqlName SqlMapping名
     * @return 组合了SqlMapping命名空间后的完整SqlMapping名
     */
    protected String getSqlName(String sqlName) {
        return sqlNamespace + SQLNAME_SEPARATOR + sqlName;
    }


    /**
     * 获取SqlMapping命名空间
     * @return SqlMapping命名空间
     */
    public String getSqlNamespace() {
        return sqlNamespace;
    }

    /**
     * 设置SqlMapping命名空间。
     * 此方法只用于注入SqlMapping命名空间，以改变默认的SqlMapping命名空间，
     * 不能滥用此方法随意改变SqlMapping命名空间。
     * @param sqlNamespace SqlMapping命名空间
     */
    public void setSqlNamespace(String sqlNamespace) {
        this.sqlNamespace = sqlNamespace;
    }
    /**
     * 生成主键值。
     * 默认情况下什么也不做；
     * 如果需要生成主键，需要由子类重写此方法根据需要的方式生成主键值。
     * @param ob 要持久化的对象
     */
    protected void generateId(T ob) {
        
    }

    @Override
    public void save(T ob) {
        generateId(ob);
         this.getSqlSession().insert(
                getSqlName(SQL_SAVE), ob);
    }
    
    @Override
    public void saveSelective(T ob) {
        generateId(ob);
         this.getSqlSession().insert(
                getSqlName(SQL_SAVE_SELECTIVE), ob);
    }

    @Override
    public Integer update(T ob) {
        return this.getSqlSession().update(
                getSqlName(SQL_UPDATE), ob);
    }
    
    @Override
    public Integer updateSelective(T ob) {
        return this.getSqlSession().update(
                getSqlName(SQL_UPDATE_SELECTIVE), ob);
    }
    

    @SuppressWarnings("unchecked")
    @Override
    public T getById(Long id) {
        return (T) this.getSqlSession().selectOne(
                getSqlName(SQL_GETBYID), id);
    }

    @Override
    public Integer deleteById(ID id) {
        return this.getSqlSession().delete(
                getSqlName(SQL_DELETEBYID), id);
    }

    @Override
    public Integer deleteByIds(String ids) {
        return this.getSqlSession().delete(
                getSqlName(SQL_DELETEBYIDS), StringUtil.splitLongArray(ids, Constants.COMMA_SEPARATOR));
    }

    @Override
    public List<T> findPageBy(T param, int pageNo, int pageSize,
            String sort, String dir) {
        return findPageBy(param, null ,pageNo, pageSize, sort, dir);
    }
    public List<T> findPageBy(Map<String, Object> param, int pageNo, int pageSize,
            String sort, String dir) {
        return findPageBy(param, null ,pageNo, pageSize, sort, dir);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> findPageBy(T param, String sqlId, int pageNo,
            int pageSize, String sort, String dir) {
        
        
                Map<String, Object> paramMap = null;
                try{
                    paramMap = BeanMapUtil.bean2Map(param);
                }catch(Exception e){
                    throw new SystemException("获取参数失败", e);
                }
                // Where过滤条件
//                paramMap.put("param", param);
                // 排序条件
                if (sort != null) {
                    // 排序字段不为空，过滤其中可能存在的非法字符
                    sort = filterIllegalChars(sort, ILLEGAL_CHARS_FOR_SQL);
                }
                if (StringUtils.isEmpty(sort) || StringUtils.isEmpty(dir)) {
                    paramMap.put("sort", null);
                    paramMap.put("dir", null);
                } else {
                    paramMap.put(SORT_NAME, sort);
                    paramMap.put(DIR_NAME, dir);
                }
                // 分页条件
                int start = (pageNo -1)*pageSize;
                RowBounds rowBound = new RowBounds(pageNo, pageSize);
                List<T> lst = this.getSqlSession().selectList(
                        getSqlName(sqlId == null ? SQL_FINDPAGEBY : sqlId),
                        paramMap, rowBound);
                return lst;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public List<T> findPageBy(Map<String, Object> param, String sqlId, int pageNo,
            int pageSize, String sort, String dir) {
            
                // 排序条件
                if (sort != null) {
                    // 排序字段不为空，过滤其中可能存在的非法字符
                    sort = filterIllegalChars(sort, ILLEGAL_CHARS_FOR_SQL);
                }
                if (StringUtil.isEmpty(sort) || StringUtil.isEmpty(dir)) {
                    param.put(SORT_NAME, sort);
                    param.put(DIR_NAME, dir);
                }
                // 分页条件
                int start = (pageNo -1)*pageSize;
                RowBounds rowBound = new RowBounds(start, pageSize);
                List<T> lst = this.getSqlSession().selectList(
                        getSqlName(sqlId == null ? SQL_FINDPAGEBY : sqlId),
                        param, rowBound);
                return lst;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public Long getCountBy(T param) {
        Map<String, Object> paramMap = null;
        try{
            paramMap = BeanMapUtil.bean2Map(param);
        }catch(Exception e){
            throw new SystemException("获取参数失败", e);
        }
        return (Long)this.getSqlSession().selectOne(
                getSqlName(SQL_GETCOUNTBY), paramMap);
    }
    
    @Override
    public Long getCountBy(Map<String,Object> param) {
        return (Long)this.getSqlSession().selectOne(
                getSqlName(SQL_GETCOUNTBY), param);
    }
    @Override
    public List<T> findListBy(T param, String sort, String dir) {
        return findListBy(param,null, sort, dir);
    }
    public List<T> findListBy(Map<String,Object> param, String sort, String dir) {
        return findListBy(param,null, sort, dir);
    }
    @SuppressWarnings("unchecked")
    @Override
    public List<T> findListBy(T param,String sqlId, String sort, String dir) {
        Map<String, Object> paramMap = null;
        try{
            paramMap = BeanMapUtil.bean2Map(param);
        }catch(Exception e){
            throw new SystemException("获取参数失败", e);
        }

        // 排序条件
        if (sort != null) {
            // 排序字段不为空，过滤其中可能存在的非法字符
            sort = filterIllegalChars(sort, ILLEGAL_CHARS_FOR_SQL);
        }
        if (StringUtils.isEmpty(sort) || StringUtils.isEmpty(dir)) {
            paramMap.put("sort", null);
            paramMap.put("dir", null);
        } else {
            paramMap.put(SORT_NAME, sort);
            paramMap.put(DIR_NAME, dir);
        }
        List<T> lst = this.getSqlSession().selectList(
                getSqlName(sqlId==null ? SQL_FINDLISTBY : sqlId), paramMap);
        return lst;
    }
    
    public List<T> findListBy(Map<String,Object> paramMap,String sqlId, String sort, String dir) {
        // 排序条件
        if (sort != null) {
            // 排序字段不为空，过滤其中可能存在的非法字符
            sort = filterIllegalChars(sort, ILLEGAL_CHARS_FOR_SQL);
        }
        if (StringUtils.isEmpty(sort) || StringUtils.isEmpty(dir)) {
//            paramMap.put("sort", null);
//            paramMap.put("dir", null);
        } else {
            paramMap.put(SORT_NAME, sort);
            paramMap.put(DIR_NAME, dir);
        }
        List<T> lst = this.getSqlSession().selectList(
                getSqlName(sqlId==null ? SQL_FINDLISTBY : sqlId), paramMap);
        return lst;
    }
    
    /**
     * 从给定字符串中将指定的非法字符串数组中各字符串过滤掉。
     * @param str 待过滤的字符串
     * @param filterChars 指定的非法字符串数组
     * @return 过滤后的字符串
     */
    protected String filterIllegalChars(String str, String[] filterChars) {
        String rs = str;
        if (rs != null && filterChars != null) {
            for (String fc : filterChars) {
                if (fc != null && fc.length() > 0) {
                    str = str.replaceAll(fc, ""); 
                }
            }
        }
        return rs;
    }

    
    
    //=========================以下是对statement进行的简单封装供子类调用start==================================================================
    /**
     * 对{@link org.apache.ibatis.session.SqlSession#insert(java.lang.String, java.lang.Object)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 执行结果——插入成功的记录数
     * @see org.apache.ibatis.session.SqlSession#insert(java.lang.String, java.lang.Object)
     */
    public int insert(String statement, Object parameter) {
        return this.getSqlSession().insert(
                getSqlName(statement), parameter);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#insert(java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @return 执行结果——插入成功的记录数
     * @see org.apache.ibatis.session.SqlSession#insert(java.lang.String)
     */
    protected int insert(String statement) {
        return this.getSqlSession().insert(
                getSqlName(statement));
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#update(java.lang.String, java.lang.Object)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 执行结果——更新成功的记录数
     * @see org.apache.ibatis.session.SqlSession#update(java.lang.String, java.lang.Object)
     */
    protected int update(String statement, Object parameter) {
        return this.getSqlSession().update(
                getSqlName(statement), parameter);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#update(java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 执行结果——更新成功的记录数
     * @see org.apache.ibatis.session.SqlSession#update(java.lang.String)
     */
    protected int update(String statement) {
        return this.getSqlSession().update(
                getSqlName(statement));
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#delete(java.lang.String, java.lang.Object)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 执行结果——删除成功的记录数
     * @see org.apache.ibatis.session.SqlSession#delete(java.lang.String, java.lang.Object)
     */
    protected int delete(String statement, Object parameter) {
        return this.getSqlSession().delete(
                getSqlName(statement), parameter);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#delete(java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @return 执行结果——删除成功的记录数
     * @see org.apache.ibatis.session.SqlSession#delete(java.lang.String)
     */
    protected int delete(String statement) {
        return this.getSqlSession().delete(
                getSqlName(statement));
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @param rowBounds 用于分页查询的记录范围
     * @return 查询结果列表
     * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)
     */
    @SuppressWarnings("rawtypes")
    protected List selectList(
            String statement, Object parameter, RowBounds rowBounds) {
        return this.getSqlSession().selectList(
                getSqlName(statement), parameter, rowBounds);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 查询结果列表
     * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object)
     */
    @SuppressWarnings("rawtypes")
    protected List selectList(String statement, Object parameter) {
        return this.getSqlSession().selectList(
                getSqlName(statement), parameter);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectList(java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @return 查询结果列表
     * @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String)
     */
    @SuppressWarnings("rawtypes")
    protected List selectList(String statement) {
        return this.getSqlSession().selectList(
                getSqlName(statement));
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectOne(java.lang.String, java.lang.Object)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @return 查询结果对象
     * @see org.apache.ibatis.session.SqlSession#selectOne(java.lang.String, java.lang.Object)
     */
    public Object selectOne(String statement, Object parameter) {
        return this.getSqlSession().selectOne(
                getSqlName(statement), parameter);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectOne(java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @return 查询结果对象
     * @see org.apache.ibatis.session.SqlSession#selectOne(java.lang.String)
     */
    protected Object selectOne(String statement) {
        return this.getSqlSession().selectOne(
                getSqlName(statement));
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.Object, java.lang.String, org.apache.ibatis.session.RowBounds)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @param mapKey 数据mapKey
     * @param rowBounds 用于分页查询的记录范围
     * @return 查询结果Map
     * @see org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.Object, java.lang.String, org.apache.ibatis.session.RowBounds)
     */
    @SuppressWarnings("rawtypes")
    protected Map selectMap(
            String statement, Object parameter, String mapKey,
            RowBounds rowBounds) {
        return this.getSqlSession().selectMap(
                getSqlName(statement),
                parameter, mapKey, rowBounds);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.Object, java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @param mapKey 数据mapKey
     * @return 查询结果Map
     * @see org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.Object, java.lang.String)
     */
    @SuppressWarnings("rawtypes")
    protected Map selectMap(
            String statement, Object parameter, String mapKey) {
        return this.getSqlSession().selectMap(
                getSqlName(statement), parameter, mapKey);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.String)}的代理。
     * @param statement 映射的语句ID
     * @param mapKey 数据mapKey
     * @return 查询结果Map
     * @see org.apache.ibatis.session.SqlSession#selectMap(java.lang.String, java.lang.String)
     */
    @SuppressWarnings("rawtypes")
    protected Map selectMap(String statement, String mapKey) {
        return this.getSqlSession().selectMap(
                getSqlName(statement), mapKey);
    }
    
    
    /**
     * 对{@link org.apache.ibatis.session.SqlSession#select(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @param rowBounds 用于分页查询的记录范围
     * @param handler 结果集处理器
     * @see org.apache.ibatis.session.SqlSession#select(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)
     */
    protected void select(
            String statement, Object parameter, RowBounds rowBounds,
            ResultHandler handler) {
        this.getSqlSession().select(
                getSqlName(statement),
                parameter, rowBounds, handler);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#select(java.lang.String, java.lang.Object, org.apache.ibatis.session.ResultHandler)}的代理。
     * @param statement 映射的语句ID
     * @param parameter 参数
     * @param handler 结果集处理器
     * @see org.apache.ibatis.session.SqlSession#select(java.lang.String, java.lang.Object, org.apache.ibatis.session.ResultHandler)
     */
    protected void select(
            String statement, Object parameter, ResultHandler handler) {
        this.getSqlSession().select(
                getSqlName(statement), parameter, handler);
    }

    /**
     * 对{@link org.apache.ibatis.session.SqlSession#select(java.lang.String, org.apache.ibatis.session.ResultHandler)}的代理。
     * @param statement 映射的语句ID
     * @param handler 结果集处理器
     * @see org.apache.ibatis.session.SqlSession#select(java.lang.String, org.apache.ibatis.session.ResultHandler)
     */
    protected void select(String statement, ResultHandler handler) {
        this.getSqlSession().select(
                getSqlName(statement), handler);
    }

    @Override
    public Integer updateBlob(T ob) {
        // TODO Auto-generated method stub
        return this.getSqlSession().update(
                getSqlName(SQL_UPDATE_BLOBS), ob);
    }
    @Override
    public List<T> queryByIds(String ids) {
    /*    return this.getSqlSession().delete(
                getSqlName(SQL_DELETEBYIDS), StringUtil.splitLongArray(ids, Constants.COMMA_SEPARATOR));*/
        return this.getSqlSession().selectList(getSqlName(SQL_GETlISTByIDS), StringUtil.splitLongArray(ids, Constants.COMMA_SEPARATOR));
    }
    @Override
    public Integer queryMaxId(String sqlId) {
        // TODO Auto-generated method stub
        return this.getSqlSession().selectOne(getSqlName(sqlId));
    }


}

 

 

然后在看看LogisticsCityService的实现类 

 

 

注意 他将自己的dao传入到父类的构造函数中

在将这个参数传递到父类构造函数中

 

 

然后自己的DAO去继承IBaseDao   这样大家就可以公用所有的方法

 

IBaseDao通过反射获取该类的类名

也就是说他们在这里封装的namespace就是自己的类名

 

 

 

 

 大家也可以百度查询关键词  “mybatis通用DAO”