何为分页？

以QQ好友列表为例：假如你的好友总共有100个，那么考虑性能等因素，第一次只获取并显示前10条数据。当用户加载更多时，再去获取后面的10条数据，并与之前的数据合并一起展示给用户。

让我们看下常见的几种写法（仅关键代码）：

• 写法一：

public class XActivity extends Activity
{
    int currentIndex = -1; // 假设从0开始
    int pageSize = 10;
    
    // 下拉刷新
    public void onPullDown()
    {
        currentIndex = 0;
        // 请求服务器数据
        loadFromServer(currentIndex, pageSize, new Callback(){
               public void onSuccess(List list)
               {}   
               public void onFailure()
               {}
         });
    }

    // 上拉加载更多
    public void onPullUp()
    {
        currentIndex++;
        // 请求服务器数据
        loadFromServer(currentIndex, pageSize, new Callback(){
               public void onSuccess(List list)
               {}               
               public void onFailure()
               {}
         });
    }
}

乍一看似乎没啥问题，仔细一看，如果请求失败了（这里假设：没有数据服务器也会返回失败），会出现这样的问题：

第一次我们从服务器获取10条数据（假设没有网络），那么必定无法获取到数据，此时currentIndex的值变成0了。如果这时候用户“上拉加载更多”（假设有网络），那么currentIndex的值变成1了，此时从服务器获取的数据是“第二页”的，因为第一页数据被我们跳过了~

解决办法是什么呢？我们思考下，出现问题的原因是因为我们“提早”改变currentIndex的值了！那么解决办法就是在“成功”的情况下才去改变currentIndex的值。于是，我们有了第二种写法。

• 写法二

public class XActivity extends Activity
{
    int currentIndex = 0;
    int pageSize = 10;
    
    // 下拉刷新
    public void onPullDown()
    {
        // 请求服务器数据
        loadFromServer(0, pageSize, new Callback(){
               // 请求服务器数据
               public void onSuccess(List list)
               {
                    currentIndex = 0;
               }         
               public void onFailure()
               {}
         });
    }

    // 上拉加载更多
    public void onPullUp()
    {
        // 请求服务器数据
        loadFromServer(currentIndex + 1, pageSize, new Callback(){
               public void onSuccess(List list)
               {
                    currentIndex++;
               } 
               public void onFailure()
               {}
         });
    }
}

你会问：第二种写法没啥问题了吧？嗯~，确实没啥问题。有一天服务器哥们跑来跟你说，分页策略要换一种方式，纳尼？分页还能有啥策略？？？（以上策略为pageIndex, pageSize）

确实还有一种策略，那就是startIndex, endIndex，也就是获取指定区间的数据，万一哪天接口用这种策略来分页，你心里估计有一万个草泥马了。

这种策略现实中是有它存在的场景的，比如说，列表页面需要删除某条数据，但需要保持原位置不动，此时我们如果通过“先删除后刷新”的模式，那么就需要控制列表滚动到刚刚用户浏览的记录的位置。
技术来讲上是可以实现的，但对于用户体验来讲，会有一个加载的过程，显然是不太友好的。

换一种思路，如果采用“先删除服务器后删除本地”，那么就可以避免“再次请求数据并刷新”的过程，对于用户体验来讲，也是非常大的提升。

如果使用pageIndex, pageSize的策略，那么就显然无法满足这种需求。

举个例子，假如目前有10条数据，调接口删除了第10条数据，此时请求下一页数据，会漏掉删除之前原本排在第11位的数据。
而使用startIndex, endIndex策略，可以将startIndex-1之后再去获取下一页数据，这样数据就不会丢失。

既然如此，我们来看下这种策略如何实现吧（伏笔，后面会放大招如何统一处理这两种策略）

• 写法三

public class XActivity extends Activity
{
    final int pageSize = 10; // 固定大小
    int startIndex = -1;  // 起始页（从0开始）
    
    // 下拉刷新
    public void onPullDown()
    {
        // 请求服务器数据
        loadFromServer(0, pageSize - 1, new Callback(){
               // 请求服务器数据
               public void onSuccess(List list)
               {
                    startIndex = 0;
               }         
               public void onFailure()
               {}
         });
    }

    // 上拉加载更多
    public void onPullUp()
    {
        // 防止第一页直接“上拉加载更多”
        int tempStartIndex = startIndex + pageSize;
        if (startIndex == -1)
        {  
            tempStartIndex = 0;
        }
        // 请求服务器数据
        loadFromServer(tempStartIndex, tempStartIndex + pageSize - 1, new Callback(){
               public void onSuccess(List list)
               {
                    startIndex = tempStartIndex;
               } 
               public void onFailure()
               {}
         });
    }
}

以上代码概括来讲可以这样表示：[0, 9]、[10, 19]、[20, 29]...

分页为何如此重要？

对于一个App来说，界面基本可以归结为两种：列表和单页面。如果团队开发，每个列表界面都让开发去写一套分页的逻辑（都按照标准就谢天谢地了，见过copy都能漏的），难免会有出错的时候（代码丛中走，哪有不湿鞋~）。

遇到这种情况，直觉上告诉我，有必要来一次封装了。我们思考下，这两种策略的共同之处有哪些？

共同之处.png

共同之处应该比较好理解，不同之处主要是什么呢？
那就是分页需要的两个参数param1和param2，计算方式如下：

• param1
  • pageIndex, pagSize：param1 = ++currPageIndex
  • startIndex, endIndex：param1 = currPageIndex + pageSize
• param2
  • pageIndex, pagSize：param2 = pageSize
  • startIndex, endIndex：param2 = currPageIndex + pageSize - 1

注：currPageIndex表示当前页下标。

具体实现看下面代码，不同之处会定义为两个抽象方法，交给不同策略去实现（仅贴出了关键代码并作了一定裁剪）。

共同之处实现

public abstract class IPage {
    // 默认起始页下标
    public static final int DEFAULT_START_PAGE_INDEX = 0;
    // 默认分页大小
    public static final int DEFAULT_PAGE_SIZE = 10;

    protected int currPageIndex; // 当前页下标
    int lastPageIndex; // 记录上一次的页下标
    int pageSize; // 分页大小
    boolean isLoading; // 是否正在加载
    Object lock = new Object(); // 锁

    public IPage()
    {
        initPageConfig();
    }

    /**
     * 加载分页数据
     * 分页策略1:[param1, param2] = [pageIndex, pageSize]
     * 分页策略2:[param1, param2] = [startIndex, endIndex]
     * @param param1
     * @param param2
     */
    public abstract void load(int param1, int param2);

    /**
     * 根据分页策略,处理第一个分页参数
     * @param currPageIndex
     * @param pageSize
     * @return
     */
    public abstract int handlePageIndex(int currPageIndex, int pageSize);

    /**
     * 根据分页策略,处理第二个分页参数
     * @param currPageIndex
     * @param pageSize
     * @return
     */
    protected abstract int handlePage(int currPageIndex, int pageSize);

    /**
     * 初始化分页参数
     */
    private void initPageConfig()
    {
        currPageIndex = DEFAULT_START_PAGE_INDEX - 1;
        lastPageIndex = currPageIndex;
        pageSize = DEFAULT_PAGE_SIZE;
        isLoading = false;
    }

    /**
     * 分页加载数据
     * [可能会抛出异常，请确认数据加载结束后，你已经调用了finishLoad(boolean success)方法]
     * @param isFirstPage true: 第一页  false: 下一页
     */
    public void loadPage()
    {
        synchronized (lock)
        {
            if (isLoading) // 如果正在加载数据，则抛出异常
            {
                throw new RuntimeException();
            }
            else
            {
                isLoading = true;
            }
        }
        if (isFirstPage) // 加载第一页数据
        {    
            currPageIndex = getStartPageIndex();
        }
        else
        {
            currPageIndex = handlePageIndex(currPageIndex, pageSize);
        }
        load(currPageIndex, handlePage(currPageIndex, pageSize));
    }

    /**
     * 加载结束
     * @param success true：加载成功  false：失败(无数据)
     */
    public void finishLoad(boolean success)
    {
        synchronized (lock)
        {
            isLoading = false;
        }
        if (success)
        {
            lastPageIndex = currPageIndex;
        }
        else
        {
            currPageIndex = lastPageIndex;
        }
    }
}

handlePageIndex和handlePage两个抽象方法分别用来计算param1和param2，需要具体分页策略（子类）来实现。

关键方法loadPage：
首先，判断是否是第一页，来计算第一个参数param1：

if (isFirstPage) // 加载第一页数据
{
    currPageIndex = getStartPageIndex();
}
else
{
    currPageIndex = handlePageIndex(currPageIndex, pageSize);
}

紧接着，计算第二个参数param2，并调用抽象方法load(int param1, int param2)回调给调用者：

load(currPageIndex, handlePage(currPageIndex, pageSize));

不同之处的实现

• pageIndex, pageSize策略

public abstract class Page1 extends IPage
{
    @Override
    public int handlePageIndex(int currPageIndex, int pageSize) {
        return ++currPageIndex;
    }

    @Override
    protected int handlePage(int currPageIndex, int pageSize) {
        return pageSize;
    }
}

• startIndex, endIndex策略

public abstract class Page2 extends IPage
{
    @Override
    public int handlePageIndex(int currPageIndex, int pageSize) {
         if (currPageIndex == getStartPageIndex() - 1) // 加载第一页数据(防止第一页使用"上拉加载更多")
         {    
            return getStartPageIndex();
         }
         return currPageIndex + pageSize;
    }

    @Override
    protected int handlePage(int currPageIndex, int pageSize) {
        return currPageIndex + pageSize - 1;
    }

    /**
     * 起始下标递减
     */
    public void decreaseStartIndex()
    {
        currPageIndex--;
        checkBound();
    }

    /**
     * 起始下标递减
     */
    public void decreaseStartIndex(int size)
    {
        currPageIndex -= size;
        checkBound();
    }

    /**
     * 边界检测
     */
    private void checkBound()
    {
        if (currPageIndex < getStartPageIndex() - pageSize)
        {
            currPageIndex = getStartPageIndex() - pageSize;
        }
    }
}

这两种策略的算法应该不用多讲，其实就是我们在前面几种写法中提到过的。

封装好了之后，我们看下如何使用吧。

public class XActivity extends Activity
{
    IPage page; 
    void init()
    {
        page = new Page1() { // pageIndex, pageSize策略
            @Override
            public void load(int param1, int param2) {
                // 请求服务器数据
                loadFromServer(param1, param2, new Callback(){
                    public void onSuccess(List list)
                    {
                       // 一定要调用，加载成功
                       page.finishLoad(true);
                    }   
                    public void onFailure()
                    {
                       // 一定要调用，加载失败
                       page.finishLoad(false);
                    }
               });
            }
        };
    }
    
    // 下拉刷新
    public void onPullDown()
    {
        page.loadPage(true);
    }

    // 上拉加载更多
    public void onPullUp()
    {
        page.loadPage(false);
    }
}

是不是瞬间感觉世界如此之清净，万物归于平静。如果如要使用startIndex, endIndex策略，只需这样做：

page = new Page1() {
}

替换为

page = new Page2() {
}

注意：不管成功还是失败，最后一定要调用page.finishLoad(true or false)，否则你再次调用page.loadPage(boolean isFirstPage)会抛出一个异常。

这里的设计思路，一方面出于加载失败回滚分页，一方面为了控制IPage的并发访问（实际情况，我们使用的上拉和下拉组件，不会同时触发上拉和下拉回调函数的）。

拓展：
我们一般是用ListView或者ExpandableListView去实现列表，而这二者都是需要使用适配器去显示数据，那么我们是不是可以把IPage封装到我们的“基类”适配器呢？这样，使用者甚至都不知道IPage的存在，而只需要关心非常熟悉的适配器Adapter。
思路已经很明显，具体的实现各位可以去试试看。

写在最后
本文所讲解的分页实现方式，包括拓展中如何与适配器结合的思考，其实是Android-BaseLine框架中的一个模块而已。

另外，Android-BaseLine还提供了很多其他模块的封装（比如网络请求模块、异步任务的封装、数据层和UI层的通信方式统一、key-value数据库存储、6.0动态权限申请、各种适配器（普通、分页、单选、多选）等），后续有机会跟大家作进一步的介绍。

当然，框架的好坏各有各的见解，我只想说，适合当下的才是最好的。