介绍

如上所示，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支持下。