github
https://github.com/javalong/RetrofitMocker
如何使用
*******
//在开发阶段，会需要一个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;
}
解决的问题
在开发阶段，后台经常会发布，或者接口还未写好，但是格式已经定好，其实这时候完全可以自己先写一个json文件放在assets文件夹中，然后自己使用，不需要一直等待。后台经常时不时的发布，重启。前端只能一直等待。
我自己本身会使用rap来mock数据，但是在发布的时候必须要改回来，也就是需要改动代码。记得某一次，上线，发布。代码中有一处mock数据还是用的rap上的url。这就很操蛋了。这里可以统一配置。
public void init(Context context, String baseUrl, boolean needMock);
最后一个参数可以配置成BuildConfig.DEBUG就再也不会出错了。记得还有一种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
- 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，则不做特殊处理。所以大家不需要怀疑正式发布版上性能上的问题。
- 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去请求接口会发现所有的接口都会先走这里，所以我们在这里进行统一的处理。
- 是否存在MOCK注释
如果存在就继续下一步进行处理，如果不存在，就直接调用boolean isExist = method.isAnnotationPresent(MOCK.class); if (isExist) { MOCK mock = method.getAnnotation(MOCK.class); ... } } else { //如果method有mock注解，就处理下，如果没有，就直接调用后返回 return method.invoke(api, args); }Retrofit原本的动态代理的方法。 - 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个方面的问题
-
String类型的转化 - Observale对象的转化
其实在Retrofit本身呢是做好了这2个方面的支持的，而且是可以配置的，
mRetrofit = new Retrofit.Builder().baseUrl(BASE_URL).
addConverterFactory(TWGsonConverterFactory.create()).
addCallAdapterFactory(RxJava2CallAdapterFactory.create()).
client(mOkHttpClient).
build();
前面对应的2个问题需要用如下2个对象去解决
- ConvertFatory
- CallAdapterFactory
所以
//获取到retrofit中设置的 ConvertFactory，然后得到转化后的类型。
retrofit.nextResponseBodyConverter(null, getReturnTye(method), method.getAnnotations()).convert(ResponseBody.create(MediaType.parse("application/json"), response));
//获取retrofit中对应的CallAdapterFactory，然后适配RxJava
retrofit.nextCallAdapter(null, method.getGenericReturnType(), method.getAnnotations()).adapt(new MockCall(responseObj));
- 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) 。
注意
- assets文件中的mock的数据是json格式，不需要
{ success:true, data:{返回的具体的数据} }
这里就直接用 返回的具体的数据就好了。
- 暂时还没有想到
不足
因为是刚完成的代码，没有经过时间的检验，肯定是由很多不足的地方的。希望有时间能有所改进，下面我列出我自己能想到的几点。
- 当@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赋值，还做了路径的解析。这里可能还存在一点隐患。
功能上还不是很全
目前只能做返回的body数据的mock。希望以后能完善，加上header数据的mock，这样应该更好。代码上
代码上始终觉得有点粗糙，希望能再优化。
