使用LiteHttp的另一种姿势

2016-04-05 本文已影响1425人 Typer

国际惯例，介绍！

LiteHttp 是一款简单、灵活的 HTTP 框架库，它在请求和响应层面做到了「全自动」构建和解析。
LiteHttp 只需要一行代码即可完美实现网络连接，它全面支持 GET, POST, PUT, DELETE, HEAD, TRACE, OPTIONS 和 PATCH 八种基本类型。 LiteHttp 能将 Java Model 转化为请求参数，也能将响应的 json 语句智能转化为 JavaModel ，这种全自动解析策略将节省你大量的构建请求、解析响应的时间。并且，你能自己继承重新实现 Dataparser 这个抽象类并设置给 Request，来将原始的 InputStream 转化为任何你想要的东西。

前言

好吧，看到今天liter更新了LiteHttp我也耐不住寂寞也出来写一篇我在自己项目中使用的LiteHttp。

Android网络开发我觉得是一件很枯燥的事情，无非就是填充参数->发送请求->等待数据->处理数据->请求结束，的确很枯燥，但又是App中不可或缺的一部分，所以我也一直在寻求最方便和最懒的方式去实现数据请求。之前有看到一篇文章RxJava 与 Retrofit 结合的最佳实践，作者结合了RxJava和Retrofit的特性，将懒进行到底。

本文中我们采用MVP的设计模式，不了解的同学可以到Android MVP 详解（上）了解

如果你还不了解LiteHttp，那么你可以去这个Github去看一看，当然，你也可以去Lite Your Android查看Liter所有的开源项目。Liter有很多关于LiteHttp使用的说明，不，是说明书。

接下来进入正文，会从下面几个角度让你变懒。欢迎大家拍砖。

HttpListener和loading的结合
如何处理header和session
Activity销毁后任务的取消

HttpListener和loading的结合

首先是准备工作，先来看看Presenter

public interface IBasePresenter {

      /** 
       * 当Activity onCreate时调用 
       */
      void onCreate();

      /** 
       * 当Activity onDestory时调用 
       */
      void onDestroy();

      /** 
       * 当前Activity是否destroy
       */
      boolean isDestroy();

      void showWaitDialog(String message, WaitCancelListener listener);

      void dismiss();

      void showToast(String msg);

      /** 
       * 当请求成功时候调用
       */
      void onSuccess(Response response);

      void onNetWorkError();
    
      /** 
       * 将HttpRichParamModel放入线程中执行
       */
      <T> void executeSync(HttpRichParamModel<T> model);

}

WaitCancelListener监听loading

public interface WaitCancelListener {    
      void onDialogCancel();
}

BaseModel，继承liteHttp中的HttpRichParamModel

  public abstract class BaseModel<T> extends HttpRichParamModel<T> {    
      public HttpRichParamModel<T> setMyHttpListener(HttpListener<T> listener) {        
            setHttpListener(listener);        
            return this;    
      }
}

注意：<T> void executeSync(HttpRichParamModel<T> model);必须使用BaseModel<T>的子类，否则会出现转型错误，

然后是MyHttpListener

public class MyHttpListener<Data> extends HttpListener<Data> implements LoadingDialog.WaitCancelListener {

      private IBasePresenter presenter;

      private String title = "请稍候";

      private AbstractRequest<Data> request;

      //任务开始时是否显示等待框
      private boolean isShowWait = true;

      //是否自动显示error为非0时的信息提示
      private boolean isApiShowToast = true;

      //任务结束后是否自动关闭等待框
      private boolean isAutoDismiss = true;

      public MyHttpListener(IBasePresenter presenter) {    
            this.presenter = presenter;
      }

      @Override
      public void onStart(AbstractRequest<Data> request) {
            super.onStart(request);
            this.request = request;
            if (isShowWait) presenter.showWaitDialog(title,this);
      }

      @Override
      public void onEnd(Response<Data> response) {
            super.onEnd(response);
            dismissWait();
      }

      public void dismissWait() {
            if (isShowWait && isAutoDismiss) presenter.dismissWaitDialog();                                                             
      }

      @Override
      public void onDialogCancel() {
            if (request != null) {
                  request.cancel();
            }
      }

      /**
       * 成功，但是不保证用户数据正确性。
       * 这里自动处理解析后的数据，不同的code调用不同的方法
       */
      @Override
      public void onSuccess(Data s, Response<Data> response) {
            super.onSuccess(s, response);
            if (presenter.isDestroy()) return;
            if (s instanceof BaseEntity) {
                  BaseEntity ss = (BaseEntity) s;
                  if (ss.getCode() == Constant.ERROR.SUCCESS) {
                        onSuccessOk(s, response);
                  } else {
                        onSuccessNoZero(ss.getMessage(),response);
                  }
          }
            presenter.onSuccess(response);
      }
      /**
       * 自己需要实现的类
       */
      public void onSuccessOk(Data s, Response<Data> response){}

      public void onSuccessNoZero(String reason,Response<Data> response){
            showToast(reason);
      }

      public void showToast(String message) {
            if (isApiShowToast) presenter.showBigErrorToast(message);
      }

      @Override
      public void onFailure(HttpException e, Response<Data> response) {
            super.onFailure(e, response);
            if (e instanceof HttpNetException) {
                  showToast(((HttpNetException) e).getExceptionType().chiReason);
                  onNetWorkError();
            } else if (e instanceof HttpClientException) {
                  showToast(((HttpClientException) e).getExceptionType().chiReason);
                  dismissWait();
            } else if (e instanceof HttpServerException) {
                  return;
            } else {
                  onUnKnowError(e);
            }
            dismissWait();
      }

      public void onUnKnowError(HttpException e) {
            e.printStackTrace();
            presenter.showToast(e.getMessage() == null ? "" : e.getMessage());
      }

      public void onNetWorkError() {
            presenter.onNetWorkError();
      }
}

注意：

自动处理的前提就是数据的格式必须得统一，例如下面的json，如果你是其他类型的返回数据，请自行ThinkInJava。
MyHttpListener中对界面的操作在presenter中实现，并且在这里实现dialog被手动cancel的回调。

{
      "message":"处理成功",
      "code": 0
        ...
}

现在我们来看看MyHttpListener是如何工作的，

onStart -> 根据**isShowWait **决定是否自动显示dialog，
onSuccess -> 分发调用并通知presenter，你要问我这有什么用，请自行脑补。
onSuccessOk -> 成功收到数据
onSuccessNoZero -> 根据isApiShowToast是否显示错误提示
onEnd -> 请求结束，消失dialog，
onFailure() -> 请求失败，因为liteHttp提供了异常类，你可以单独处理，当然也可以统一处理。

最后是void onDialogCancel()，当加载数据时间较长时，可以随时取消当前请求。这样就成了一个非常简单的自动处理dialog的类，省去了许多代码。另外，对上述提到的几个boolean控制类可以这样实现，通过和Builder一样的方式一路点下去，是不是很清爽啊！！！

      public MyHttpListener<Data> setTitle(String title) {
            this.title = title;
            return this;
      }

      public MyHttpListener<Data> disableWait() {
            this.isShowWait = false;
            return this;
      }

      public MyHttpListener<Data> disableToast() {
            this.isApiShowToast = false;
            return this;
      }

      public MyHttpListener<Data> disableAutoDismiss() {
            this.isAutoDismiss = false;
            return this;
      }

      public MyHttpListener<Data> setShowWait(boolean showWait) {
            isShowWait = showWait;
            return this;
      }

      public MyHttpListener<Data> setApiShowToast(boolean apiShowToast) {
            isApiShowToast = apiShowToast;
            return this;
      }

最后是发起请求

public class LoginModel extends BaseModel<BaseEntity> {    
      public String userName;    
      public String pwd;    
      public LoginModel(String userName, String pwd) {        
            this.userName = userName;        
            this.pwd = pwd;    
      }
}

      //在合适的地方调用即可,详见github
      executeSync(new LoginModel(userName,pwd).setMyHttpListener(new MyHttpListener<BaseEntity>(this) {    
      @Override    
      public void onSuccess(BaseEntity s, Response<BaseEntity> response) {        
            super.onSuccess(s, response);        
            //TODO SUCCESS
      }}.disableToast()));

别忘记加权限

<uses-permission android:name="android.permission.INTERNET"/>

这一部分就基本上完了，需要大家注意的是，由于笔者采用的是mvp的设计模式，因此MyHttpListener中持有了presenter的对应，这不是必须的，你也可以在MyHttpListener中通过其他方式实现。
放上源码LiteHttpDemo TAG 选择setup1

如何处理header和session(token)

其实在App的接口访问中使用session的并不多见，但是还是会由于种种原因，某些App会使用到session。然而这给App带来了一些麻烦，尤其是你在考虑到有以下情况时，服务器crsf保护和session过期需要自动登录两重校验时你就头大了，实现他们并不需要多么高超的技术，问题在于如果你有强迫症，要使用优雅而快速的方式去实现就是一件很虐心的事情。

因为在请求数据时刚好你的session过期了，就会打断用户当前的操作，对用户体验是及其糟糕的，在这种情况下如何连续而又优雅的解决这个问题就是我们接下来要讨论的。当然，我说了，这只是实现自动处理session的一种姿势而已。

首先来说一说思路，当本地保存的session过期后继续访问服务器，一般会抛出服务器内部错误，没错就是万恶是500，这就是我们的切入点。没当发起一个http请求时，我们将这个请求对象保存在队列中，如果这个请求成功了，就从队列中取出来，如果请求失败并且抛出500错误，我们就让队列保持不变，另外生成一个更新session的请求，当更新session成功后在从队列中取出之前的请求继续执行，因为我们保存了它的对象，里面的任何设置并不会有任何影响。

好了，开始贴代码了。

因为我们要统一管理所有的请求，所有我们得先有个管理类，我们就叫
MyHttp吧,代码太多，只贴关键部分。

//初始化，MyHttp需要继承GlobalHttpListenter
public MyHttp() {    
      HttpConfig config = new HttpConfig(null);    
      //设置litehttp的globalHttpListener，方便监听token过期。           
      config.setGlobalHttpListener(this);    
      mLiteHttp =  LiteHttp.newApacheHttpClient(config);    
      mTask = new LinkedList<>();
}

@Override
public void onSuccess(Object o, Response<?> response) {    
try { 
       //检查一下链接，如果是更新token的链接接继续之前的任务        
      String url = response.getRequest().getFullUri();        
      String fullUrl = TOKEN_URL;        
      if (TextUtils.equals(url, fullUrl)) {            
            //TODO GET TOKEN SUCCESS            
            if (o instanceof TokenEntity) {                
                  Log.i(TAG,"token获取成功:"+((TokenEntity) o).getToken());           
             }                  
            toContinueTask();        
      } else {           
             //TODO        
      }    
      } catch (HttpClientException e) {        
            e.printStackTrace();    
      }
}

/** 
* 继续上次一次任务
 */
public void toContinueTask() {    
      if (mTask.isEmpty()) return;    
      AbstractRequest request = mTask.poll();    
      executeSync(request);    
      Log.i(TAG,"继续任务:" + request.getUri());
}

/**     
* 因为难得搞500错误，就用ClientException代替了，     
* BaseEntity中的code为int，使用Integer.parseInt(code)随机产生异常
* @param e     
* @param response     
*/    
@Override    
public void onFailure(HttpException e, Response<?> response) {       
       try {           
      //检查一下链接，如果是更新token的链接就不用处理了，直接找后台吧。             
      String url = response.getRequest().getFullUri();            
      String fullUrl = TOKEN_URL;           
      if (TextUtils.equals(url, fullUrl)) return;       
      } catch (HttpClientException e1) {            
            e.printStackTrace();        
      }       
       if (e instanceof HttpClientException) {           
             if (((HttpClientException) e).getExceptionType() == ClientException.SomeOtherException) {                
doUpdateSession();       
      //将失败的任务添加到队列中        
                  mTask.offer(response.getRequest());           
       }       
 }
//        if (e instanceof HttpServerException) {
//            if (((HttpServerException) e).getExceptionType() == ServerException.ServerInnerError) {
//                doUpdateSession();
//                mTask.offer(response.getRequest());
//            }
//        }    
}

public void doUpdateSession() {    
      Log.i(TAG,"开始获取token");    
      JsonRequest<TokenEntity> request = new JsonRequest<>(TOKEN_URL,TokenEntity.class);    
      request.setMethod(HttpMethods.Get);    
      executeSync(request);
}

public <T extends AbstractRequest> void executeSync(T request) {        
      mLiteHttp.executeAsync(request);
}
public <T> AbstractRequest executeSync(HttpRichParamModel<T> model) {    
      return mLiteHttp.executeAsync(model);
}

代码中主要看几个地方，一是onFailure，在失败时候如果异常（因为无法模拟500错误，顾在解析json的通过mock随机抛出httpClientException来当作是500错误，生成环境请自行脑补）是我们预期的错误就会进行更新token的操作，当token更新完成以后在继续之前的任务，下面我以登录为例，通过log来看具体的流程。

登录Log日志.png

Myhttp会一直去更新token直到成功为止，当然你也可以自己设定更新次数，避免某些情况下的无限更新。

现在，自动更新token已经ok了，貌似已经可以工作了，但是还有一个小小问题就是，因为中间有更新token的请求，在更新操作之间的请求实际上已经结束了，dialog也已经dismiss，在此发起请求又会重新调起dialog，看起来有点小小的不爽，于是我们可以这样

在MyHTTpListener中增加private boolean isInternalError
于是MyHTTpListener变成了这样。

@Override    
public void onFailure(HttpException e, Response<Data> response) {        
      super.onFailure(e, response);       
       if (e instanceof HttpNetException) {            
            showToast(((HttpNetException) e).getExceptionType().chiReason);            
            onNetWorkError();        
      } else if (e instanceof HttpClientException) {        
            //标记错误，避免dialog自动dimiss    
            isInternalError = true;            
            Log.i(MyHttp.TAG,"请求token过期:"+ "service internal error");
//            showToast(((HttpClientException) e).getExceptionType().chiReason);
//            dismissWait();        
      } else if (e instanceof HttpServerException) {            
            return;        
      } else {            
            onUnKnowError(e);        
      }        
      dismissWait();   
 }

@Override
public void onSuccess(Data s, Response<Data> response) {        
      super.onSuccess(s, response);    
      isInternalError = false;    
      if (presenter.isDestroy()) return;    
      if (s instanceof BaseEntity) {        
            BaseEntity ss = (BaseEntity) s;        
      } if (ss.getCode() == 0) {            
            onSuccessOk(s, response);        
      } else {            
            onSuccessNoZero(ss.getMessage(),response);       
      }    
      presenter.onSuccess(response);
}

//dismiss dialog
public void dismissWait() {    
      if (isShowWait && isAutoDismiss && !isInternalError) presenter.dismiss();
}

注意isInternalError的变化

Activity销毁后任务的取消

Activity中同时进行多个任务是常有的事情，上面我们有一个boolean isDestroy();的方法判断当前的activity是否被销毁，但问题是，这个时候任务其实是一件请求完毕，如果activity已经销毁，在返回数据就没有任何意义，除非你真的想那么做。

所以，要在activity销毁的时候将正在运行和即将要允许的任务取消掉，我们可以这样做。

前面我们提到有这个方法

public <T> AbstractRequest executeSync(HttpRichParamModel<T> model) {    
      return mLiteHttp.executeAsync(model);
}

实现IBasePresenter中的方法

/** * 获取网络数据 
* 
* @param model 请求 
*/
      public <T> void executeSync(HttpRichParamModel<T> model) {    
            mTask.add(http.executeSync(model));
      }

      @Override
      public void onSuccess(Response response) {    
            if (mIBaseView != null) {        
                  mIBaseView.onSuccess();    
            }    
            mTask.remove(response.getRequest());
      }

      @Overridepublic void onDestroy() {    
      this.isOnCreate = false;    
      if (mTask == null) return;
      for (AbstractRequest item : mTask) {    
            item.cancel();
      }
      mTask.clear();
}

在presenter中新增一个队列，成功后移出队列，onDestory后取消所有任务。

如果你正是用LiteHttp，以上1和3将会很适合你，如果你有遇到session或token的困扰，2将会给你很好的解答。

好了，欢迎拍砖。
奉上GitHub

使用LiteHttp的另一种姿势

前言

HttpListener和loading的结合

如何处理header和session(token)

Activity销毁后任务的取消

猜你喜欢

热点阅读