Retrofit2实现Mock数据

如何使用

*******//在开发阶段，会需要一个enable开关，可以关闭mock数据
  @MOCK(value = "", enable = false)    @GET("http://**mock2")    Observable<String> mock1();   //直接使用文件名，会从assets文件夹中读取文件，直接mock数据返回
    @MOCK("mockdata.json")    @GET("http://**mock2")    Observable<MockBean> mock2();  //支持暂时访问某个http地址
    @MOCK("http://***mock1")    @GET("http://***mock2")    Observable<String> mock3();

**********public class MockBean {    private String test;    public String getTest() {        return test;
    }    public void setTest(String test) {        this.test = test;
    }    @Override
    public String toString() {        return "MockBean{" +                "test='" + test + '\'' +                '}';
    }
}

总结：原本自己本地的Retrofit2如何使用，现在还是如何使用，只是在需要mock的接口上面添加注释@MOCK。

@Target(METHOD)@Retention(RUNTIME)public @interface MOCK {    //可以直接是assets文件夹中的一个json文件，也可以是一个暂时的mock地址
    String value() default "";    //提供一个开关，自己debug的时候使用
    boolean enable() default true;
}

解决的问题

1. 在开发阶段，后台经常会发布，或者接口还未写好，但是格式已经定好，其实这时候完全可以自己先写一个json文件放在assets文件夹中，然后自己使用，不需要一直等待。后台经常时不时的发布，重启。前端只能一直等待。

2. 我自己本身会使用rap来mock数据，但是在发布的时候必须要改回来，也就是需要改动代码。记得某一次，上线，发布。代码中有一处mock数据还是用的rap上的url。这就很操蛋了。这里可以统一配置。
   public void init(Context context, String baseUrl, boolean needMock);
   最后一个参数可以配置成BuildConfig.DEBUG 就再也不会出错了。

3. 记得还有一种mock方式是直接在代码里面一个个创建对象，然后塞入不同数据，相对来说会比较麻烦，而且也是存在2的问题的。

实现的原理

大家都知道Retrofit的主要的一段代码就是

 public <T> T create(final Class<T> service) {
    Utils.validateServiceInterface(service);    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },        new InvocationHandler() {          private final Platform platform = Platform.get();          @Override public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {              return method.invoke(this, args);
            }            if (platform.isDefaultMethod(method)) {              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod serviceMethod = loadServiceMethod(method);
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

使用了动态代理模式，当我们调用**Api方法时，其实就是进入了这里，然后它会进行解析。
为了不影响Retrofit之前的使用，我这里也决定采用动态代理的方式。也就是在这一层动态代理的外面再包一层动态代理。

既然使用到了动态代理，那么也会使用到反射。

当调用**Api里面的方法时，首先会进入我的动态代理，反射获取这个方法是否有@MOCK注释，有就自己进行处理，没有就传递给Retrofit的动态代理。

总结：使用到了反射，动态代理。

源码解析

由于这个mock的使用是基于我之前写的Retrofit-RxJava的框架，如果还不太了解的人，可以先简单了解下。
https://www.jianshu.com/p/17e3e3102c1f

1. needMock的使用

 public void init(Context context, String baseUrl, boolean needMock)... public <T> void registerApi(Class<T> cls) {        if (mContext == null) {            throw new RuntimeException("need to run init method!");
        }        if (cls != null && !apiMap.containsKey(cls)) {
            T api = mRetrofit.create(cls);            if (needMock) {
                apiMap.put(cls, Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{cls}, new MockHandler(mRetrofit, mContext, api)));
            } else {
                apiMap.put(cls, api);
            }
        }
    }
..

如果 needMock=true，那么apiMap中存的就是Retrofit.create得到的动态代理的动态代理。也就是双重代理。如果为false，则不做特殊处理。所以大家不需要怀疑正式发布版上性能上的问题。

1. MockHandler
   当needMock=true，我们设置了自己的动态代理，这里的关键代码是

 Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{cls}, new MockHandler(mRetrofit, mContext, api))

可以看到MockHandler就是用来处理主要逻辑的类，是InvocationHandler的子类

public class MockHandler<T> implements InvocationHandler{
...public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
...

}

MockHandler其实就是这个mock数据的框架中最重要的类了，其中最重要的方法也就是invoke方法。
如果我们使用了Retrofit去请求接口会发现所有的接口都会先走这里，所以我们在这里进行统一的处理。

1. 是否存在MOCK注释

     boolean isExist = method.isAnnotationPresent(MOCK.class);  if (isExist) {
         MOCK mock = method.getAnnotation(MOCK.class);
        ...
         }
     } else {      //如果method有mock注解，就处理下，如果没有，就直接调用后返回
         return method.invoke(api, args);
     }

   如果存在就继续下一步进行处理，如果不存在，就直接调用  Retrofit原本的动态代理的方法。

2. MOCK注释是否是以http开头

      if (mock.value().startsWith("http")) {         //如果是http的 就尝试自己去请求,就自己修改下url 然后请求
           preLoadServiceMethod(method, mock.value());        return method.invoke(api, args);
      } 
         ...     private void preLoadServiceMethod(Method method, String relativeUrl) {      try {
             Method m = Retrofit.class.getDeclaredMethod("loadServiceMethod", Method.class);
             m.setAccessible(true);
             Object serviceMethod = m.invoke(retrofit, method);
             Field field = serviceMethod.getClass().getDeclaredField("relativeUrl");
             field.setAccessible(true);
             field.set(serviceMethod, relativeUrl);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

如果是http开头的，就是要网络请求。看过Retrofit源码的都知道每个请求方法都会被解析成一个ServiceMethod方法，然后缓存起来。然后请求的地址呢，其实就是ServiceMethod中的一个参数，就是relativeUrl。这里直接反射进行修改。修改后，还是继续调用Retrofit的动态代理。这时候会发现方法对应的ServiceMethod对象已经存在了，就不会再解析，而是拿过来直接使用。

    if (mock.value().startsWith("http")) {
                  ...
              } else {                  //认为是在assets中
                  String response = readAssets(mock.value());
                  
                  Object responseObj = retrofit.nextResponseBodyConverter(null, getReturnTye(method), method.getAnnotations()).convert(ResponseBody.create(MediaType.parse("application/json"), response));
                  Object obj = retrofit.nextCallAdapter(null, method.getGenericReturnType(), method.getAnnotations()).adapt(new MockCall(responseObj));                  return obj;
              }

这里一共3行代码 ，第一行就不说了。后面2行代码，我想了很久。因为我不能去修改Retrofit本身的代码，也尽量要满足他现有的一些功能，比如返回值是Observale<MockBean>类型的。
这里就涉及到了2个方面的问题

1. String类型的转化

2. Observale对象的转化

其实在Retrofit本身呢是做好了这2个方面的支持的，而且是可以配置的，

 mRetrofit = new Retrofit.Builder().baseUrl(BASE_URL).
                addConverterFactory(TWGsonConverterFactory.create()).
                addCallAdapterFactory(RxJava2CallAdapterFactory.create()).
                client(mOkHttpClient).
                build();

前面对应的2个问题需要用如下2个对象去解决

1. ConvertFatory

2. CallAdapterFactory

所以

//获取到retrofit中设置的 ConvertFactory，然后得到转化后的类型。
 retrofit.nextResponseBodyConverter(null, getReturnTye(method), method.getAnnotations()).convert(ResponseBody.create(MediaType.parse("application/json"), response));//获取retrofit中对应的CallAdapterFactory，然后适配RxJavaretrofit.nextCallAdapter(null, method.getGenericReturnType(), method.getAnnotations()).adapt(new MockCall(responseObj));

1. MockCall
   由于CallAdapter的adapt需要传入Call对象，这里只能自己构造一个

class MockCall<R> implements Call<R> {

    Object data;    public MockCall(Object data) {        this.data = data;
    }    private Response getResponse() {        return Response.success(data);
    }    @Override
    public Response<R> execute() throws IOException {        return getResponse();
    }    @Override
    public void enqueue(Callback<R> callback) {
        callback.onResponse(null, getResponse());
    }    @Override
    public boolean isExecuted() {        return false;
    }    @Override
    public void cancel() {

    }    @Override
    public boolean isCanceled() {        return false;
    }    @Override
    public Call<R> clone() {        return this;
    }    @Override
    public Request request() {        return null;
    }
}

构造的很简单，从assets中读取文件返回数据，就直接返回 Response.success(data) 。

注意

1. assets文件中的mock的数据是json格式，不需要

    {   success:true,
      data:{返回的具体的数据}
    }

这里就直接用 返回的具体的数据就好了。

1. 暂时还没有想到

不足

因为是刚完成的代码，没有经过时间的检验，肯定是由很多不足的地方的。希望有时间能有所改进，下面我列出我自己能想到的几点。

1. 当@MOCK value是“http”开头时，直接修改ServiceMethod的relativeUrl，可能存在隐患。因为他本身的代码是这样的

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {      if (this.httpMethod != null) {        throw methodError("Only one HTTP method is allowed. Found: %s and %s.",            this.httpMethod, httpMethod);
      }      this.httpMethod = httpMethod;      this.hasBody = hasBody;      if (value.isEmpty()) {        return;
      }      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');      if (question != -1 && question < value.length() - 1) {        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);        if (queryParamMatcher.find()) {          throw methodError("URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }      this.relativeUrl = value;      this.relativeUrlParamNames = parsePathParameters(value);
    }

不仅仅只是给relativeUrl赋值，还做了路径的解析。这里可能还存在一点隐患。

1. 功能上还不是很全
   目前只能做返回的body数据的mock。希望以后能完善，加上header数据的mock，这样应该更好。

2. 代码上
   代码上始终觉得有点粗糙，希望能再优化。

作者：javalong
链接：https://www.jianshu.com/p/ef445d5e9be0