万能设配器代码 带加载更多

public abstract class MyBaseAdapter<T> extends BaseAdapter {
   protected List<T> list;
   //普通条目
   private static final int LIST_ITEM=0;
   //加载更多条目
   private static final int LOAD_MODR=1;
   private MoreHolder moreholder;
   public MyBaseAdapter(List<T> list) {
      this.list = list;
   }
   public List<T> getList(){
      return list;
   }
   @Override
   public int getCount() {
      return list.size()+1;
   }
   public int getListSize(){
      return list.size();
   }
   @Override
   public Object getItem(int position) {
      return list.get(position);
   }

   @Override
   public long getItemId(int position) {
      return position;
   }
   @Override
   public int getViewTypeCount() {
      return super.getViewTypeCount()+1;
   }
   @Override
   public int getItemViewType(int position) {
      if(position==getCount()-1){
         return LOAD_MODR;
      }else {
         return getInnerItemType(position);
      }
   }
   /**
    * 子类可覆盖此方法用于listitem有多个 条目的情况
    */
   public int getInnerItemType(int position) {
      return LIST_ITEM;
   }

   @Override
   public View getView(int position, View convertView, ViewGroup parent) {
      BaseHolder holder = null;
      if (convertView == null) {
         if(getItemViewType(position)==LOAD_MODR){
            holder=getMoreHolder();
         }else{
            holder=getHolder();
         }
       }else{
          holder=(BaseHolder)convertView.getTag();//固定的
       }
      if(getItemViewType(position)==LIST_ITEM){
         holder.setData(list.get(position));
      }
      return holder.getRootView();
   }

   /**
    * 返回加载更多的holder
    * @return
*/
   private MoreHolder getMoreHolder() {
      if(moreholder==null) //避免重复创建对象
         moreholder = new MoreHolder(isHasMore(),this);
      return moreholder;
   }
   /**
    * 设置是否还有数据的状态 默认有数据  可以给子类覆盖 如果不需要从服务器获取数据的话
    * @return
*/
   public Boolean isHasMore() {
      return true;
   }

   public abstract BaseHolder<T> getHolder();
   /**
    * 根据访问网络获取的结果改变MoreHolder的状态  此处处理业务逻辑 具体的访问网络的请求地址..不确定 所以使用抽象 让子类去实现
    */
   public void loadMore() {
      ThreadManager.getThreadPoolProxy().execute(new RunnableTask());
   }
   class RunnableTask implements Runnable{

      @Override
      public void run() {
         //访问网络返回的数据  是一般条目
         final List<T> more_list=onLoad();//加载网络获取的路径未知所有抽象
         // 如果假定服务器一次返回的数据是二十条
         //那么就有三种状态 1服务器返回少于20条 那么代表服务器没有更多数据了 将状态置为NO_MORE
         //2服务器返回20 条 那么还有更多数据 HAS_MORE
         //3服务器请求失败 LOAD_ERROR
         //更新ui在使用UIUTils
         UIUtils.runInMainThread(new Runnable() {

            @Override
            public void run() {
               if (more_list != null) {
                  if (more_list.size() == 20) {
                     moreholder.setData(MoreHolder.LOAD_MORE);
                  }
                  if (more_list.size() < 20) {
                     moreholder.setData(MoreHolder.NO_MORE);
                  }
               } else {
                  moreholder.setData(MoreHolder.LOAD_ERROR);
               }
               if (more_list != null) {
                  //将数据加入到当前listview的集合中 
                  list.addAll(more_list);
                  notifyDataSetChanged();//更新ListView
               }

            }
         });
      } 
   }
   
   /**
    * 访问网络获取更多的数据
    * @return
*/
   public abstract List<T> onLoad();
}

public abstract class BaseHolder<T> {
   private View view;
   private T data;

   protected BaseHolder() {
      view = initView();
      view.setTag(this);
   }

   public void setData(T data) {
      this.data = data;
      setData2View();
   }

   public T getData() {
      return data;
   }
   public View getRootView() {
      return view;
   }
   public abstract void setData2View();

   public abstract View initView();
}