Recyclerview_helper多功能封装，让你的应用更加自如

前言

RecyclerView作为列表使用，在项目中的应用场景实在是太普遍了。针对项目应用，主要使用了RecyclerView的单或多类型Item，点击/长按事件，ItemAnimator动画效果以及上拉加载、下拉刷新。recyclerview_helper就是针对以上应用场景进行的封装与使用，避免在项目使用中重复的敲代码以及依赖多个库或者自定义实现等复杂方式。

介绍

如上所示，recyclerview_helper针对不同应用场景封装了不同的功能。

具体功能如下：

1.封装了ViewHolder以及Adapter,避免每次都要重复写创建ViewHolder以及重写onCreateViewHolder，onBindViewHolder方法，支持单/多类型Item。

2.封装了OnItemClickListener以及OnItemLongClickListener，不必每次写接口，定义回调。仅支持对Item的点击事件。

3.具有各种炫酷的动画效果，功能装饰者模式封装Adapter添加初始化动画效果 ，以及自定义ItemAnimator实现各种炫酷的Item增删动画效果。

4.支持添加头尾布局，以及支持下拉刷新和上拉加载更多功能。同时支持自定义下拉刷新布局及动画，以及上拉加载更多的布局，可实现各种炫酷效果，跟随你的想象放飞。

使用

1.添加依赖

①.在项目的 build.gradle 文件中添加

1. allprojects { 
2.         repositories { 
3.             ... 
4.             maven { url 'https://jitpack.io' } 
5.         } 
6.     }  

②.在 module 的 build.gradle 文件中添加依赖

1. dependencies { 
2.  
3.     compile 'com.github.LRH1993:recyclerview_helper:V1.0.3' 
4.  
5. }  

2.单/多类型Item使用

单类型

1. CommonAdapter<String> mAdapter = new CommonAdapter<String>(this, R.layout.item_common, mDatas) {             
2.                  @Override 
3.             public void convert(BaseViewHolder holder, int position) { 
4.                 holder.setText(R.id.tv_content,mDatas.get(position));                 
5.                         int number = new Random().nextInt(3); 
6.                 holder.setImageResource(R.id.iv_content,mImageRes[number]); 
7.             } 
8.         }; 
9.         mRecyclerView.setAdapter(mAdapter);  

通过实现CommonAdapter，传入context,布局以及数据，然后实现convert方法，设置view的显示数据就完成了。很简洁方便。

多类型

1. MultiItemTypeSupport<String> support = new MultiItemTypeSupport<String>() {             
2.                  @Override 
3.             public int getLayoutId(int itemType) {                 
4.                  if (itemType == TYPE_HEAD) {                     
5.                      return R.layout.item_special; 
6.                 } else {                     
7.                      return R.layout.item_common; 
8.                 } 
9.  
10.             }             
11.             @Override 
12.             public int getItemViewType(int position, String s) {                 
13.                  if (position%3==0&& position>0) {                     
14.                      return TYPE_HEAD; 
15.                 } else {                     
16.                    return TYPE_COMMON; 
17.                 } 
18.             } 
19.         }; 
20. ----------------------------------------------------------------------------------------------------------------------------- 
21.  MultiItemCommonAdapter<String> mAdapter = new MultiItemCommonAdapter<String>(this, mDatas, support) {             
22.             @Override 
23.             public void convert(BaseViewHolder holder, int position) {                 
24.                                  if (position%3==0&& position>0) { 
25.                     holder.setImageResource(R.id.iv_head,R.drawable.multi_image); 
26.                 } else { 
27.                     holder.setText(R.id.tv_content,mDatas.get(position));                     
28.                                  int number = new Random().nextInt(3)+3; 
29.                     holder.setImageResource(R.id.iv_content,mImageRes[number]); 
30.                 } 
31.             } 
32.         }; 
33.         mRecyclerView.setAdapter(mAdapter);  

和单类型的区别就是需要实现MultiItemTypeSupport，在MultiItemCommonAdapter对象中传入实现的该对象，该对象完成两个方法，功能是通过类型判别Item布局以及通过位置和数据判断返回类型。通过这个对象,避免我们在Adapter中进行类别判断的书写。

该部分实现参考了鸿洋大神对RecyclerView的封装。

3.事件监听使用

事件监听的使用就比较简单了，和正常使用一样。

1. adapter.setOnItemClickListener(new CommonAdapter.OnItemClickListener() {             
2.                 @Override 
3.             public void onItemClick(View view, RecyclerView.ViewHolder holder, int position) { 
4.                 System.out.println("点击"); 
5.                 showMyDialog("响应点击事件"); 
6.             } 
7.         }); 
8.         adapter.setOnItemLongClickListener(new CommonAdapter.OnItemLongClickListener() {             
9.                  @Override 
10.             public boolean onItemLongClick(View view, RecyclerView.ViewHolder holder, int position) { 
11.                 showMyDialog("响应长按事件");                 
12.                         return false; 
13.             } 
14.         });  

4.动画使用

gif录制效果不太明显，实际手机上看着效果还是不错的。

1. mRecyclerView.setItemAnimator(new LandingAnimator()); 
2.         ScaleInAnimationAdapter scaleAdapter = new ScaleInAnimationAdapter(adapter); 
3.         scaleAdapter.setFirstOnly(false); 
4.         scaleAdapter.setDuration(500); 
5.         mRecyclerView.setAdapter(scaleAdapter);  

动画效果分两种：

第一种：adapter初始化item的动画效果

第二种:ItemAnimator定义的动画效果

第一种动画效果使用了装饰者模式，需要再封装一层，然后通过setAdapter添加进去。

第二种直接和平时使用一样。

除此之外，ItemAnimator还有以下高级功能：

设置动画时长

1. mRecyclerView.getItemAnimator().setAddDuration(1000); 
2. mRecyclerView.getItemAnimator().setRemoveDuration(1000); 
3. mRecyclerView.getItemAnimator().setMoveDuration(1000); 
4. mRecyclerView.getItemAnimator().setChangeDuration(1000);  

插值器

1. SlideInLeftAnimator animator = new SlideInLeftAnimator(); 
2.  
3. animator.setInterpolator(new OvershootInterpolator()); 
4.  
5. mRecyclerView.setItemAnimator(animator);  

也可以通过自定义AnimateViewHolder实现类，实现其他动画效果。

Adapter也有一些高级功能：

动画时长

1. AlphaInAnimationAdapter alphaAdapter = new AlphaInAnimationAdapter(adapter); 
2. alphaAdapter.setDuration(1000); 
3. mRecyclerView.setAdapter(alphaAdapter);  

插值器

1. AlphaInAnimationAdapter alphaAdapter = new AlphaInAnimationAdapter(adapter); 
2.  
3. alphaAdapter.setInterpolator(new OvershootInterpolator()); 
4.  
5. mRecyclerView.setAdapter(alphaAdapter);  

是否仅显示一次动画效果

1. AlphaInAnimationAdapter alphaAdapter = new AlphaInAnimationAdapter(adapter); 
2.  
3. scaleAdapter.setFirstOnly(false); 
4.  
5. recyclerView.setAdapter(alphaAdapter);  

设置成true，则动画效果只在第一次创建Item使用，设置成false，则每次上下滑动都带动画效果。

复杂情况下，可以设置成true。

复合动画

1. AlphaInAnimationAdapter alphaAdapter = new AlphaInAnimationAdapter(adapter); 
2. recyclerView.setAdapter(new ScaleInAnimationAdapter(alphaAdapter));  

recyclerview_helper中已经自定义了各种动画效果，如果有好的实现动画，可以通过自定义实现。

该部分实现参考了recyclerview-animators这个动画库。

5.添加头/尾布局

自定义头/尾布局，随意添加。

1. View headView = LayoutInflater.from(MainActivity.this).inflate(R.layout.item_head,null,false); 
2.  
3. View footView = LayoutInflater.from(MainActivity.this).inflate(R.layout.item_foot,null,false); 
4.  
5. mRecyclerView.addHeaderView(headView); 
6.  
7. mRecyclerView.addFooterView(footView);  

几行代码搞定。

6.下拉刷新/上拉加载

布局设置

1. <com.lvr.library.recyclerview.HRecyclerView 
2.         app:loadMoreEnabled="true" 
3.         app:loadMoreFooterLayout="@layout/layout_hrecyclerview_load_more_footer" 
4.         app:refreshEnabled="true" 
5.         app:refreshHeaderLayout="@layout/layout_hrecyclerview_refresh_header" 
6.         android:id="@+id/list" 
7.         android:layout_width="match_parent" 
8.         android:layout_height="match_parent"/>  

其中头/尾布局需要自定义View实现。在例子中已经分别实现了一种

如果想实现不同的加载图片以及动画效果，可以对比实现。

首先设置监听

1. mRecyclerView.setOnRefreshListener(this); 
2.  
3. mRecyclerView.setOnLoadMoreListener(this);  

实现回调方法

1. @Override 
2.     public void onLoadMore() {         
3.              if(mLoadMoreFooterView.canLoadMore()){ 
4.             mLoadMoreFooterView.setStatus(LoadMoreFooterView.Status.LOADING);             
5.                  new Thread(new Runnable() {                 
6.                       @Override 
7.                 public void run() {                     
8.                              //假装加载耗时数据 
9.                     SystemClock.sleep(1000); 
10.                     Message message = Message.obtain(); 
11.                     message.what =count; 
12.                     count++; 
13.                     mHandler.sendMessage(message); 
14.                 } 
15.             }).start(); 
16.         } 
17.  
18.     }     
19.      @Override 
20.     public void onRefresh() {         
21.          new Thread(new Runnable() {             
22.                  @Override 
23.             public void run() {                 
24.                      //假装加载耗时数据 
25.                 SystemClock.sleep(1000); 
26.                 Message msg = Message.obtain(); 
27.                 msg.what=0; 
28.                 mHandler.sendMessage(msg); 
29.             } 
30.         }).start(); 
31.  
32.     }  

开启刷新/关闭刷新

1. mRecyclerView.setRefreshing(true); 

根据不同情况设置不同加载状态：

1. //正在加载 
2.  
3. mLoadMoreFooterView.setStatus(LoadMoreFooterView.Status.LOADING); //没有更多数据mLoadMoreFooterView.setStatus(LoadMoreFooterView.Status.THE_END);//加载完毕mLoadMoreFooterView.setStatus(LoadMoreFooterView.Status.GONE);//出现错误mLoadMoreFooterView.setStatus(LoadMoreFooterView.Status.ERROR); 

出现错误，还可以通过实现onRetry方法，实现再次加载。

以上两部分效果参考了IRecyclerView实现。

原理

上面介绍了使用，那么下面就介绍下实现原理，如果需要自定义实现，可以参考完成。

1.ViewHolder及Adapter封装

针对ViewHolder的功能：实现View缓存，避免重复findViewById，进行封装。针对Adapter在实际项目中重复书写onCreateViewHolder，onBindViewHolder方法，进行封装处理。

ViewHolder

1. private SparseArray<View> viewArray;     
2.    private View mItemView;     
3.    /** 
4.     * 构造ViewHolder 
5.     * 
6.     * @param parent 父类容器 
7.     * @param resId  布局资源文件id 
8.     */ 
9.    public BaseViewHolder(Context context, ViewGroup parent, @LayoutRes int resId) {         
10.        super(LayoutInflater.from(context).inflate(resId, parent, false)); 
11.        viewArray = new SparseArray<>(); 
12.    }     
13.     /** 
14.     * 获取ItemView 
15.     * @return ItemView 
16.     */ 
17.     public View getItemView(){          
18.            return this.itemView; 
19.     }     
20.      /** 
21.     * 获取布局中的View 
22.     * 
23.     * @param viewId view的Id 
24.     * @param <T>    View的类型 
25.     * @return view 
26.     */ 
27.    public <T extends View> T getView(@IdRes int viewId) { 
28.        View view = viewArray.get(viewId);         
29.    if (view == null) { 
30.            view = itemView.findViewById(viewId); 
31.            viewArray.put(viewId, view); 
32.        }        return (T) view; 
33.    }  

将View存放在集合类中，进行缓存，getView方法可以在Adapter中直接调用，避免每次创建不同类型的ViewHolder,一个BaseViewHolder搞定一切情况。

Adapter

基类CommonAdapter

1. public abstract class CommonAdapter<T> extends RecyclerView.Adapter<BaseViewHolder> {     
2.     protected Context mContext;     
3.     protected int mLayoutId;     
4.     protected List<T> mDatas;     
5.     protected OnItemClickListener mOnItemClickListener;     
6.     protected OnItemLongClickListener mOnItemLongClickListener;     
7.     public CommonAdapter(Context context, int layoutId, List<T> datas) 
8.     { 
9.         mContext = context; 
10.         mLayoutId = layoutId; 
11.         mDatas = datas; 
12.     }     
13.       @Override 
14.     public BaseViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {         
15.             final BaseViewHolder viewHolder = new BaseViewHolder(mContext,parent,mLayoutId);         
16.                 return viewHolder; 
17.     }     
18.       @Override 
19.     public void onBindViewHolder(final BaseViewHolder holder, final int position) { 
20.         convert(holder, position); 
21.     }    public abstract void convert(BaseViewHolder holder, int position);     
22.       @Override 
23.     public int getItemCount() {         
24.             return mDatas.size(); 
25.     } 
26. .........  

封装实现onCreateViewHolder方法，并把convert方法抽象出去，实现数据绑定工作。使得结构简单。

针对多类型情况，需要判断类型，设置不同布局，所以需要个帮助类：

1. public interface MultiItemTypeSupport<T>{ 
2.  
3. int getLayoutId(int itemType); 
4. int getItemViewType(int position, T t); 
5.  
6. }  

剩下来基础CommonAdapter实现MultiItemCommonAdapter来应对多类型Item。

1. public abstract class MultiItemCommonAdapter<T> extends CommonAdapter<T>{     
2.     protected MultiItemTypeSupport<T> mMultiItemTypeSupport;     
3.     public MultiItemCommonAdapter(Context context, List<T> datas, 
4.         MultiItemTypeSupport<T> multiItemTypeSupport) 
5.     {    super(context, -1, datas); 
6.         mMultiItemTypeSupport = multiItemTypeSupport; 
7.     }     
8.      @Override 
9.     public int getItemViewType(int position) 
10.     {         
11.             return mMultiItemTypeSupport.getItemViewType(position, mDatas.get(position)); 
12.     }     
13.      @Override 
14.     public BaseViewHolder onCreateViewHolder(ViewGroup parent, int viewType) 
15.     {         
16.             int layoutId = mMultiItemTypeSupport.getLayoutId(viewType); 
17.          BaseViewHolder holder = new BaseViewHolder(mContext, parent, layoutId);         
18.             return holder; 
19.     } 
20. }  

整个实现很简单，但是效果不错。关于事件点击监听，很简单，就不介绍了。

2.动画效果实现

先介绍个简单的，Adapter的动画效果：

1. @Override public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) { 
2.    mAdapter.onBindViewHolder(holder, position);     
3.         int adapterPosition = holder.getAdapterPosition();     
4.         if (!isFirstOnly || adapterPosition > mLastPosition) {       
5.             for (Animator anim : getAnimators(holder.itemView)) { 
6.            anim.setDuration(mDuration).start(); 
7.            anim.setInterpolator(mInterpolator); 
8.      } 
9.      mLastPosition = adapterPosition; 
10.    } else { 
11.      ViewHelper.clear(holder.itemView); 
12.    } 
13.  }  

其实就是实现一个包装类AnimationAdapter，在其中onBindViewHolder方法中添加了动画效果。

下面继续介绍ItemAnimator的实现。关于这部分实现，实际代码比较长。就简要介绍下实现主要流程，具体实现可以看下这篇文章：recyclerview-animators,让你的RecyclerView与众不同。

其实RecyclerView中已经为我们默认提供了Item动画效果，就是通过这个类：DefaultItemAnimator,而这个类又从哪来?

1. public class DefaultItemAnimator extends SimpleItemAnimator 

搞清楚源头，那么我们也可以 比照着进行实现动画效果，所以通过继承SimpleItemAnimator实现自定义动画类。

主要针对对animateRemove, animateAdd, animateMove, animateChange 这4个方法的实现，增加数据增、删、动、改的动画效果。

3.头布局/尾布局实现

其实头布局，尾布局的添加和上面实现Adapter动画效果的方式一致，都是通过装饰者模式。

因为下面要实现上拉加载/下拉刷新，所以这两部分布局也像添加.头布局/尾布局一样实现。

先定义一个WrapperAdapter。

1. @Override 
2.    public int getItemCount() {         
3.         return mAdapter.getItemCount() + 4; 
4.    }     
5.     @Override 
6.    public int getItemViewType(int position) {         
7.         if (position == 0) {             
8.                  return REFRESH_HEADER; 
9.        } else if (position == 1) {             
10.                  return HEADER; 
11.        } else if (1 < position && position < mAdapter.getItemCount() + 2) {            return mAdapter.getItemViewType(position - 2); 
12.        } else if (position == mAdapter.getItemCount() + 2) {            return FOOTER; 
13.        } else if (position == mAdapter.getItemCount() + 3) {            return LOAD_MORE_FOOTER; 
14.        }         
15.                 throw new IllegalArgumentException("Wrong type! Position = " + position); 
16.    }     
17.     @Override 
18.    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {        if (viewType == REFRESH_HEADER) {            return new RefreshHeaderContainerViewHolder(mRefreshHeaderContainer); 
19.        } else if (viewType == HEADER) {             
20.                 return new HeaderContainerViewHolder(mHeaderContainer); 
21.        } else if (viewType == FOOTER) {             
22.                 return new FooterContainerViewHolder(mFooterContainer); 
23.        } else if (viewType == LOAD_MORE_FOOTER) {             
24.                 return new LoadMoreFooterContainerViewHolder(mLoadMoreFooterContainer); 
25.        } else {             
26.                 return mAdapter.onCreateViewHolder(parent, viewType); 
27.        } 
28.    }     
29.     @Override 
30.    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {        if (1 < position && position < mAdapter.getItemCount() + 2) { 
31.            mAdapter.onBindViewHolder(holder, position - 2); 
32.        } 
33.    } 

主要是针对上拉加载/下拉刷新，头布局/尾布局进行特殊处理。

其次，由于上面四部分都要独占一行，在LinearLayoutManager下没问题，但是在StaggeredGridLayoutManager以及GridLayoutManager要特殊处理。

GridLayoutManager

1. @Overridepublic void onAttachedToRecyclerView(final RecyclerView recyclerView) { 
2.     RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();         
3.           if (layoutManager instanceof GridLayoutManager) {             
4.                final GridLayoutManager gridLayoutManager = (GridLayoutManager) layoutManager;             
5.                final GridLayoutManager.SpanSizeLookup spanSizeLookup = gridLayoutManager.getSpanSizeLookup(); 
6.            gridLayoutManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {                 
7.                       @Override 
8.                 public int getSpanSize(int position) { 
9.                     WrapperAdapter wrapperAdapter = (WrapperAdapter) recyclerView.getAdapter();                     
10.                             if (isFullSpanType(wrapperAdapter.getItemViewType(position))) {                         
11.                                     return gridLayoutManager.getSpanCount(); 
12.                     } else if (spanSizeLookup != null) {                         
13.                                     return spanSizeLookup.getSpanSize(position - 2); 
14.                     }                     
15.                                 return 1; 
16.                 } 
17.             }); 
18.         } 
19.     }  

StaggeredGridLayoutManager

1. @Override 
2.  public void onViewAttachedToWindow(RecyclerView.ViewHolder holder) {         
3.        super.onViewAttachedToWindow(holder);         
4.        int position = holder.getAdapterPosition();         
5.        int type = getItemViewType(position);         
6.             if (isFullSpanType(type)) { 
7.            ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();             
8.                    if (layoutParams instanceof StaggeredGridLayoutManager.LayoutParams) { 
9.                 StaggeredGridLayoutManager.LayoutParams lp = (StaggeredGridLayoutManager.LayoutParams) layoutParams; 
10.                 lp.setFullSpan(true); 
11.             } 
12.         } 
13.     }  

最后可以放心的添加了，通过自定义RecyclerView，重写setAdapter()方法

1. @Override 
2.     public void setAdapter(Adapter adapter) { 
3.         mOriginAdapter =adapter; 
4.         ensureRefreshHeaderContainer(); 
5.         ensureHeaderViewContainer(); 
6.         ensureFooterViewContainer(); 
7.         ensureLoadMoreFooterContainer();         
8.            super.setAdapter(new WrapperAdapter(adapter, mRefreshHeaderContainer, mHeaderViewContainer, mFooterViewContainer, mLoadMoreFooterContainer)); 
9.     }  

这样就加入了头/尾布局以及上拉加载/下拉刷新布局。

总结

文章篇幅所限，“上拉加载/下拉刷新”等其他操作可点击左下角“阅读原文”查看。目前由于多类型+头尾以及上拉刷新/下拉加载，判断类型过多，在头布局会出现卡顿，所以在使用多类型的情况下，不建议加入头尾布局，可以考虑重写setAdapter方法，去掉不需要的布局。

从效果，到使用，最后到原理，加深了对RecyclerView的理解，recyclerview_helper可以应对一般的使用场景，不过如有特殊应用场景，也可进行比对自定义实现。

Github地址：https://github.com/LRH1993/recyclerview_helper，给个star支持下。

作者：Ruheng

来源：51CTO