salesforce 零基础学习（四十八）自定义列表分页之Pagination基类封装 ※※※

我们知道，salesforce中系统标准列表页面提供了相应的分页功能，如果要使用其分页功能，可以访问http://www.cnblogs.com/zero-zyq/p/5343287.html查看相关实现。

现在很多的sfdc项目都是重构页面进行开发，所以很多系统分装的功能用不上，但是很多确实很常见的功能，比如分页，这时候就有必要自己封装一套翻页基类，子类继承父类并实现相关方法以后，前台通过封装的翻页类实现翻页功能。

根据系统的分页功能可以想象到我们设计的分页类应该满足以下简单的功能：

1.相关sObject的数据列表，用于显示数据；

2.首页，尾页；

3.上一页，下一页；

4.总页数，当前页数；

5.是否还有上一页，下一页；

6.每页显示条数（可动态显示）。

MyPagination类封装如下：

 public virtual without sharing class MyPagination {
     //默认值，如果不设置每页显示的数量，则默认数量为20
     public static final Integer DEFAULT_PAGE_SIZE=20;

     public MyPagination() {

     }

     public MyPagination(ApexPages.StandardController controller) {

     }

     public MyPagination(ApexPages.StandardSetController controller) {

     }

     //结果集
     private List<sObject> sObjectList;   

     //查询条数的SQL
     private String countStr;

     //查询结果集的SQL
     private String queryStr;

     //查询结果集的条件 where 部分
     private String queryCondition;

     //查询结果集的group by部分
     private String groupBy;

     //查询结果集的order by 部分
     private String orderBy;

     //查询结果集的offset部分，offset最大值为2000，salesforce的限制
     private Integer offset=0;

     public List<sObject> resultList{
         get {
             if(sObjectList == null){
                 return new List<sObject>();
             }
             return sObjectList;
         }
         set;
     }

     public virtual void setQueryCondition(String countStr,String queryStr){
         setQueryCondition(countStr,queryStr,null,null,null);
     }

     public virtual void setQueryCondition(String countStr,String queryStr,String queryCondition){
         setQueryCondition(countStr,queryStr,queryCondition,null,null);
     }

     public virtual void setQueryCondition(String countStr,String queryStr,String queryCondition,String groupBy,String orderBy){
         this.countStr=countStr;
         this.queryStr=queryStr;
         this.queryCondition=queryCondition;
         this.groupBy=groupBy;
         this.orderBy=orderBy;
         buildQuery();
     }

     private void buildQuery(){
         List<String> queryArgs = new List<String>();
         List<String> countArgs= new List<String>();
         if(String.isNotBlank(countStr)){
             countArgs.add(countStr);
         }
         if(String.isNotBlank(queryStr)){
             queryArgs.add(queryStr);
         }
         if(String.isNotBlank(queryCondition)){
             queryArgs.add(queryCondition);
             countArgs.add(queryCondition);
         }
         if(String.isNotBlank(groupBy)){
             queryArgs.add(groupBy);
             countArgs.add(groupBy);
         }
         if(String.isNotBlank(orderBy)){
             queryArgs.add(orderBy);
         }
         initTotalNum(countArgs);
         queryStr=String.join(queryArgs,' ');
         offset=0;
     }    

     private void initTotalNum(List<String> countArgs){
        String countqueryStr=String.join(countArgs,' ');
        if(String.isNotBlank(countqueryStr)){

            totalNumber=Database.countquery(countqueryStr);
        } else {
             totalNumber=0;
        }
        if(totalNumber != null) {
             pageNumber=1;
        }
     } 

     public virtual List<sObject> getQueryResult(){
         if(String.isBlank(queryStr)){
             sObjectList = new List<sObject>();
         }else{
             String querySql=queryStr+' limit '+pageSize+' offset '+offset;
             sObjectList = Database.query(querySql);
         }
         return sObjectList;
     }

     public virtual Integer getCountResult(){
         return totalNumber;
     }

     //改变每页显示的数量
     public virtual void changePageSize(Integer pageSize) {
         if (pageSize!=null){
             this.pageSize=pageSize;
         }
     }    

     //是否有下一页
     public Boolean hasNext {
         get {
             return pageSize*pageNumber<totalNumber;
         }
         set;
     } 

      //是否有前一页
     public Boolean hasPrevious {
         get {
             return pageSize*(pageNumber-1)>0;
         }
         set;
     } 

     public Integer pageNumber {
         get {
             if(pageNumber==null){
                 pageNumber=0;
             }
             return pageNumber;
         }
         set;
     }

     //每页显示页数
     public Integer pageSize{
         get{
             if(pageSize==null){
                 pageSize=DEFAULT_PAGE_SIZE;
             }
             return pageSize;
         }
         set;
     }

     //结果集总数
     public Integer totalNumber{
         get{
             if(totalNumber==null){
                 totalNumber=0;
             }
             return totalNumber;
         }
         set;
     }

     //总页数
     public Integer totalPage{
         get{
                 if(totalNumber==0 || math.mod(totalNumber,pageSize)!=0){
                     return totalNumber/pageSize+1;
                 }else{
                     return totalNumber/pageSize;
                 }
         }
         set;
     }

     //是否有记录集
     public Boolean hasRecord{
         get {
             if(totalNumber!=0){
                 return true;
             }else{
                 return false;
             }
         }
         set;
     } 

     //首页
     public virtual void  first() {
         offset=0;
         pageNumber=1;
     } 

     //尾页
     public virtual  void  last() {
         offset=(totalPage-1)*pageSize;
         pageNumber=totalPage;
     } 

    //上一页
     public virtual void  previous() {
         pageNumber--;
         if(pageNumber<0){
             pageNumber=0;
             offset=0;
         }else{
             offset=(pageNumber-1)*pageSize;
         }
     } 

    //下一页
     public virtual void  next() {
         pageNumber++;
         if(pageNumber>totalPage){
             pageNumber=totalPage;
         }
         offset=(pageNumber-1)*pageSize;
     }

     //指定页
     public virtual void specifiedPage(Integer pageNumber) {
         this.pageNumber = pageNumber;
         if(pageNumber < 0) {
             pageNumber = 0;
             offset = 0;
         } else {
             offset = (pageNumber - 1) * pageSize;
         }
     }

     //获取偏移量
     public virtual Integer getOffset(){
             return offset;
     }

     //获取每页显示条数
     public virtual Integer getSize(){
             return pageSize;
     }    

 }

MyPaginationEnhance类：

 public without sharing class MyPaginationEnhancement{

     public static final Integer DEFAULT_PAGE_SIZE=20;

     public MyPaginationEnhancement() {
     }

     public MyPaginationEnhancement(ApexPages.StandardSetController controller) {
     }

     public MyPaginationEnhancement(ApexPages.StandardController controller) {
     }

     private List<sObject> sObjectList;

     private String countStr;

     private String queryStr;

     private String queryCondition;

     private String groupBy;

     private String orderBy;

     private Integer offset=0;

     public List<sObject> resultList{
         get {
             if(sObjectList == null){
                 return new List<sObject>();
             }
             return sObjectList;
         }
         set;
     }

     public List<sObject> getQueryResult(String countStr,String queryStr,String queryCondition){
         setQueryCondition(countStr,queryStr,queryCondition,null,null);
         buildAndQuery();
         return sObjectList;
     }

     public List<sObject> getQueryResult(String countStr,String queryStr,String queryCondition,String groupBy,String orderBy){
         setQueryCondition(countStr,queryStr,queryCondition,groupBy,orderBy);
         buildAndQuery();
         return sObjectList;
     }

     public List<sObject> updateQueryResult(String queryStr,String queryCondition,String groupBy,String orderBy){
         String querySql = queryStr;
         if(queryCondition!=null){
             querySql += queryCondition;
         }
         if(groupBy!=null){
             querySql +=groupBy;
         }
         if(orderBy!=null){
             querySql +=orderBy;
         }
         sObjectList = Database.query(querySql);
         return sObjectList;
     }

     private void setQueryCondition(String countStr,String queryStr,String queryCondition,String groupBy,String orderBy){
         this.countStr=countStr;
         this.queryStr=queryStr;
         this.queryCondition=queryCondition;
         this.groupBy=groupBy;
         this.orderBy=orderBy;
     }

     private void buildAndQuery(){
         List<String> queryArgs = new List<String>();
         List<String> countArgs= new List<String>();
         if(String.isNotBlank(countStr)){
             countArgs.add(countStr);
         }
         if(String.isNotBlank(queryStr)){
             queryArgs.add(queryStr);
         }
         if(String.isNotBlank(queryCondition)){
             queryArgs.add(queryCondition);
             countArgs.add(queryCondition);
         }
         if(String.isNotBlank(groupBy)){
             queryArgs.add(groupBy);
             countArgs.add(groupBy);
         }
         if(String.isNotBlank(orderBy)){
             queryArgs.add(orderBy);
         }
         initTotalNum(countArgs);
         queryResult(queryArgs);
     }    

     private void initTotalNum(List<String> countArgs){
        String countqueryStr=String.join(countArgs,' ');

        if(String.isNotBlank(countqueryStr)){

            totalNumber=Database.countquery(countqueryStr);
        } else {
             totalNumber=0;
        }

        if(totalNumber !=0 && pageNumber==0){
            pageNumber = 1;
        }
     }     

     private List<sObject> queryResult(List<String> queryArgs){
         queryStr=String.join(queryArgs,' ');
         if(String.isBlank(queryStr)){
             sObjectList = new List<sObject>();
         }else{
             String querySql=queryStr+' limit '+pageSize+' offset '+offset;            

             sObjectList = Database.query(querySql);
         }
         return sObjectList;
     }

     public void changePageSize(Integer pageSize) {
         if (pageSize!=null){
             this.pageSize=pageSize;
         }
     }    

     public Boolean hasNext {
         get {
             return pageSize*pageNumber<totalNumber;
         }
         set;
     } 

     public Boolean hasPrevious {
         get {
             return pageSize*(pageNumber-1)>0;
         }
         set;
     } 

     public Integer pageNumber {
         get {
             if(pageNumber==null){
                 pageNumber=0;
             }
             return pageNumber;
         }
         set;
     }

     public Integer pageSize{
         get{
             if(pageSize==null){
                 pageSize=DEFAULT_PAGE_SIZE;
             }
             return pageSize;
         }
         set;
     }

     public Integer totalNumber{
         get{
             if(totalNumber==null){
                 totalNumber=0;
             }
             return totalNumber;
         }
         set;
     }

     public Integer totalPage{
         get{
             if(totalNumber==0 || math.mod(totalNumber,pageSize)!=0){
                 return totalNumber/pageSize+1;
             }else{
                 return totalNumber/pageSize;
             }
         }
         set;
     }

     public Boolean hasRecord{
         get {
             if(totalNumber!=0){
                 return true;
             }else{
                 return false;
             }
         }
         set;
     } 

     public void  first() {
         offset=0;
         pageNumber=1;
     } 

     public void  last() {
         offset=(totalPage-1)*pageSize;
         pageNumber=totalPage;
     } 

     public void  previous() {
         pageNumber--;
         if(pageNumber<0){
             pageNumber=0;
             offset=0;
         }else{
             offset=(pageNumber-1)*pageSize;
         }
     } 

     public void  next() {
         pageNumber++;
         if(pageNumber>totalPage){
             pageNumber=totalPage;
         }
         offset=(pageNumber-1)*pageSize;
     }

      //指定页
     public virtual void specifiedPage(Integer pageNumber) {
         this.pageNumber = pageNumber;
         if(pageNumber < 0) {
             pageNumber = 0;
             offset = 0;
         } else {
             offset = (pageNumber - 1) * pageSize;
         }
     }

     public Integer getOffset(){
             return offset;
     }

     public Integer getSize(){
             return pageSize;
     }    

 }

MyPaginationEnhancement

部分变量解释：

1.sObjectList：封装SOQL查询出来的sObject的结果集；

2.countStr：SOQL查询条数的SQL语句；

3.queryStr：SOQL查询结果集的SQL语句；

4.queryCondition：SOQL中查询结果集条件部分语句（where xxx）；

5.groupBy:如果SOQL需要用到分组或者聚合函数等，则设置此变量group by语句；

6.orderBy:如果SOQL需要按照某个或者某些字段进行升序或者降序排列，则设置此变量order by语句；

7.offset：偏移量，SOQL中对于偏移量最大设置的值为2000，超过2000则抛出异常；

8.hasNext：数据当前页是否还有下一页；

9.hasPrevious ：数据当前页是否还有上一页；

10.pageNumber：当前页数；

11.pageSize：每页显示条数；

12.totalNumber：结果集总数；

13.totalPage：总页数；

14.hasRecord：结果集是否为空。

部分方法解释：

1.setQueryCondition：设置查询条件，通过子类的SQL查询条件拼装成需要执行的SQL，此方法有三种重构函数，涵盖了主要的SQL查询条件的用法，如果有其他需求，可以继续重构；

2.initTotalNum：获取结果集总数；

3.buildQuery：通过基础SQL以及query condition将其拼装成一个完整的SQL语句；

4.getQueryResult：通过拼装成完整的SQL语句进行查询，返回查询出来的结果列表；

5.changePageSize：改变每页显示的数据条数；

6.first：跳转到首页；

7.last：跳转到尾页；

8.previous：跳转到上一页；

9.next：跳转到下一页；

10.specifiedPage：跳转到指定页数。

总结：对于一般的分页功能，此基类基本封装，故项目要求没有特别高情况下可以直接使用此基类，有的人会说offset最大限制是2000，如果超过2000基类中没有处理会不会不好。这个觉得因设计而异，controller层使用pagination后，执行sql查询列表前应先查一下offset是否已经超过了2000，如果超过2000可以给前台抛出自定义友好的异常或者设置offset为2000，这样做法会比在基类中强制写死比较好。篇中如果有错误地方欢迎指正，如果有不懂地方欢迎留言。