RecyclerView滚动加载分页API数据异常，请求技术帮助

Hey there, let's figure out why your RecyclerView's endless scroll isn't loading the next page of data. I’ve debugged tons of these issues before, so let’s break down the most common pitfalls and fix your listener step by step.

1. Double-Check Core Variable Initialization #

First, make sure your key listener variables are set correctly—this is where most bugs start:

• visibleThreshold: This is how many items need to be left below your current scroll position to trigger loading. For a 10-item page, set this to 2-3 (so it starts loading before the user hits the bottom). If it’s set to 15 or higher, it’ll never trigger since your page only has 10 items.
• currentPage: Start at 0 or 1 depending on your API’s pagination scheme. Most APIs use 1-based indexing, so start at 1; if yours uses 0-based, start at 0.
• previousTotalItemCount: Initialize this to 0, not your initial item count. The listener uses this to detect when new items have been added.

2. Fix Loading State Management #

A super common mistake is forgetting to toggle the loading boolean properly, which causes duplicate requests or no requests at all:

• As soon as you start loading the next page, set loading = true to block further triggers.
• When the API call succeeds (and you’ve added new items to your adapter), set loading = false and increment currentPage.
• If the API call fails, still set loading = false—otherwise the listener will never try to load again.

3. Handle All LayoutManager Types Correctly #

If you’re using a GridLayoutManager or StaggeredGridLayoutManager, calculating the last visible item position works differently than with LinearLayoutManager. Your current code might be using LinearLayout logic, which breaks grids.

Here’s the correct way to get the last visible position for all LayoutManagers:

@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
    int lastVisibleItemPosition = 0;
    int totalItemCount = mLayoutManager.getItemCount();

    if (mLayoutManager instanceof LinearLayoutManager) {
        lastVisibleItemPosition = ((LinearLayoutManager) mLayoutManager).findLastVisibleItemPosition();
    } else if (mLayoutManager instanceof GridLayoutManager) {
        lastVisibleItemPosition = ((GridLayoutManager) mLayoutManager).findLastVisibleItemPosition();
    } else if (mLayoutManager instanceof StaggeredGridLayoutManager) {
        int[] lastVisiblePositions = ((StaggeredGridLayoutManager) mLayoutManager).findLastVisibleItemPositions(null);
        lastVisibleItemPosition = getLastVisibleItem(lastVisiblePositions);
    }

    // Your loading logic goes here...
}

private int getLastVisibleItem(int[] lastVisiblePositions) {
    int maxPosition = 0;
    for (int position : lastVisiblePositions) {
        if (position > maxPosition) maxPosition = position;
    }
    return maxPosition;
}

4. Verify API Pagination Parameters #

Double-check that you’re passing the right page number to your API:

• If your API expects page=2 for the second 10-item set, make sure currentPage increments correctly (from 1 to 2 after the first load).
• Some APIs use offset instead of page numbers. Calculate offset as currentPage * pageSize (e.g., page 1 = offset 0, page 2 = offset 10).
• Make sure you’re not accidentally passing the same page number every time (a common bug if currentPage isn’t being incremented).

5. Reset previousTotalItemCount After Loading #

After adding new items to your adapter, update previousTotalItemCount to the new total item count. If you skip this step, the listener will think no new items were added and won’t trigger future loads.

Here’s the core logic that handles this:

// Reset if dataset is invalidated (e.g., pull-to-refresh)
if (totalItemCount < previousTotalItemCount) {
    this.currentPage = this.startingPageIndex;
    this.previousTotalItemCount = totalItemCount;
    if (totalItemCount == 0) this.loading = true;
}

// Mark loading as done when new items are added
if (loading && (totalItemCount > previousTotalItemCount)) {
    loading = false;
    previousTotalItemCount = totalItemCount;
    currentPage++;
}

// Trigger load if threshold is breached and not already loading
if (!loading && (lastVisibleItemPosition + visibleThreshold) > totalItemCount) {
    onLoadMore(currentPage + 1, totalItemCount);
    loading = true;
}

Full Working EndlessScrollListener Example #

Here’s a complete, tested version you can use as a reference:

public abstract class EndlessRecyclerViewScrollListener extends RecyclerView.OnScrollListener {
    private int visibleThreshold = 5;
    private int currentPage = 0;
    private int previousTotalItemCount = 0;
    private boolean loading = true;
    private int startingPageIndex = 0;

    RecyclerView.LayoutManager mLayoutManager;

    public EndlessRecyclerViewScrollListener(LinearLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
    }

    public EndlessRecyclerViewScrollListener(GridLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
        visibleThreshold *= layoutManager.getSpanCount();
    }

    public EndlessRecyclerViewScrollListener(StaggeredGridLayoutManager layoutManager) {
        this.mLayoutManager = layoutManager;
        visibleThreshold *= layoutManager.getSpanCount();
    }

    private int getLastVisibleItem(int[] lastVisiblePositions) {
        int maxPosition = 0;
        for (int position : lastVisiblePositions) {
            if (position > maxPosition) maxPosition = position;
        }
        return maxPosition;
    }

    @Override
    public void onScrolled(RecyclerView view, int dx, int dy) {
        int lastVisibleItemPosition = 0;
        int totalItemCount = mLayoutManager.getItemCount();

        if (mLayoutManager instanceof StaggeredGridLayoutManager) {
            int[] positions = ((StaggeredGridLayoutManager) mLayoutManager).findLastVisibleItemPositions(null);
            lastVisibleItemPosition = getLastVisibleItem(positions);
        } else if (mLayoutManager instanceof GridLayoutManager) {
            lastVisibleItemPosition = ((GridLayoutManager) mLayoutManager).findLastVisibleItemPosition();
        } else if (mLayoutManager instanceof LinearLayoutManager) {
            lastVisibleItemPosition = ((LinearLayoutManager) mLayoutManager).findLastVisibleItemPosition();
        }

        // Reset logic
        if (totalItemCount < previousTotalItemCount) {
            this.currentPage = this.startingPageIndex;
            this.previousTotalItemCount = totalItemCount;
            if (totalItemCount == 0) this.loading = true;
        }

        // Mark loading complete
        if (loading && (totalItemCount > previousTotalItemCount)) {
            loading = false;
            previousTotalItemCount = totalItemCount;
            currentPage++;
        }

        // Trigger load more
        if (!loading && (lastVisibleItemPosition + visibleThreshold) > totalItemCount) {
            onLoadMore(currentPage + 1, totalItemCount);
            loading = true;
        }
    }

    public abstract void onLoadMore(int page, int totalItemsCount);

    // Add this to manually reset loading state on errors
    public void setLoading(boolean loading) {
        this.loading = loading;
    }
}

How to Implement It #

Attach the listener to your RecyclerView and handle the API call:

LinearLayoutManager layoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);

EndlessRecyclerViewScrollListener scrollListener = new EndlessRecyclerViewScrollListener(layoutManager) {
    @Override
    public void onLoadMore(int page, int totalItemsCount) {
        loadNextPage(page);
    }
};
recyclerView.addOnScrollListener(scrollListener);

Then your loadNextPage method:

private void loadNextPage(int page) {
    yourApiService.getItems(page, 10).enqueue(new Callback<List<Item>>() {
        @Override
        public void onResponse(Call<List<Item>> call, Response<List<Item>> response) {
            if (response.isSuccessful() && response.body() != null) {
                yourAdapter.addAll(response.body());
                yourAdapter.notifyDataSetChanged();
                // The listener will auto-reset loading state when it detects item count increase
            } else {
                scrollListener.setLoading(false); // Reset on failure
            }
        }

        @Override
        public void onFailure(Call<List<Item>> call, Throwable t) {
            scrollListener.setLoading(false); // Reset on failure
        }
    });
}

内容的提问来源于stack exchange，提问作者Aashutosh Poudel