1 简述

A type-safe HTTP client for Android and Java.
Retrofit 是基于RESTful风格的 HTTP 网络请求框架的封装。它的底层仍然基于OkHttp实现，算是OkHttp在Android上使用的改良。

// 这是一个例子
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

GitHubService service = retrofit.create(GitHubService.class);
Call<List<Repo>> repos = service.listRepos("halloayu");

repos.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
        Log.e("Main", response.body().get(0).toString());
    }
    
    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
    }
});

2 为什么会有Retrofit框架

OkHttp是安卓官方认证的网络请求框架，非常强大，但是它也有不少缺点，如下。

OkHtt配置网络请求是非常繁琐的，尤其是配置复杂网络请求body、请求头、参数的时候。
数据解析过程需要用户手动拿到ResponseBody进行解析，难以复用。
无法自动进行线程切换。
万一我们存在嵌套网络请求，就会陷入“回调地狱”。

所以为了解决这些缺点，让网络请求在Android开发上易用，诞生了Retrofit框架，它本质上就也就是在OkHttp上套了层“壳子”，里面的请求还是基于OkHttp实现。
同时Retrofit设计的目的有两个方面。

请求前
- 可以统一配置网络请求头
- 可以很方便得复用Request，或创建request
请求后
- 子线程需切换到UI线程，便于界面刷新
- 返回数据可以解析为Java Bean，方便使用

3 主要封装的点

retrofit封装OkHttp主要是以下几点：

build模式创建网络请求基本配置
用注解类组合HTTP网络请求
提供Gson解析返回的json数据
Executor完成线程切换

它请求实现的核心在于“注解”、“动态代理”、“反射”。

4 注解

Http有8种网络请求：GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS、HTTP

Retrofit通过20多个注解的组合实现了这几种请求。企业微信截图_bbd04297-5bd9-4f56-910b-8d60d495ecb3.png

5 动态代理

熟悉设计模式的都知道，代理模式的思想是通过一个“代理商”，让”用户“通过它处理难以处理的”事情“。
在最上面Retrofit的使用例子中，先是通过建造者模式创建了一个retrofit实例，然后走GitHubService service = retrofit.create(GitHubService.class)，这里面就是一个动态代码，我们来具体看看做了什么。

public <T> T create(final Class<T> service) {
    // 验证接口
    validateServiceInterface(service);
    // 动态代理
    return (T)
        Proxy.newProxyInstance(
        service.getClassLoader(),
        new Class<?>[] {service},
        new InvocationHandler() {
            private final Platform platform = Platform.get();
            private final Object[] emptyArgs = new Object[0];
            
            @Override
            public @Nullable Object invoke(Object proxy, Method method, @Nullable 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);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
            }
        });
}

从代码中我们可以看出，它代理了传入接口类中的所有接口方法，当我们调，service.listRepos("halloayu")，就会走InvocationHandler中的invoke方法。

// 从缓存中拿，没拿到，ServiceMethod进行处理
ServiceMethod<?> loadServiceMethod(Method method) {
    ServiceMethod<?> result = serviceMethodCache.get(method);
    if (result != null) return result;
    
    synchronized (serviceMethodCache) {
        result = serviceMethodCache.get(method);
        if (result == null) {
            result = ServiceMethod.parseAnnotations(this, method);
            serviceMethodCache.put(method, result);
        }
    }
    return result;
}

ServiceMethod就像是一个中央处理器，传入Retrofit对象和Method对象，调用各个接口和解析器，最终生成一个Request，包含api 的域名、path、http请求方法、请求头、是否有body、是否是multipart等等。最后返回一个Call对象，Call接口的默认实现是OkHttpCall，它默认使用OkHttp3作为底层http请求client。

@Override
final @Nullable ReturnT invoke(Object[] args) {
    Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    // 使用适配器去转换返回数据
    return adapt(call, args);
}

使用Java动态代理的目的就要拦截被调用的Java方法，然后解析这个Java方法的注解，最后生成Request由OkHttp发送。

// 异步请求源码
@Override
public void enqueue(final Callback<T> callback) {
    Objects.requireNonNull(callback, "callback == null");
    
    ...
    
    call.enqueue(
        new okhttp3.Callback() {
            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
                Response<T> response;
                try {
                    // 解析返回数据，里面用我们配置的GSON解析
                    response = parseResponse(rawResponse);
                } catch (Throwable e) {
                    throwIfFatal(e);
                    callFailure(e);
                    return;
                }
                
                try {
                    // 先走我们定义适配器转换数据，然后走自定义callback
                    callback.onResponse(OkHttpCall.this, response);
                } catch (Throwable t) {
                    throwIfFatal(t);
                    t.printStackTrace(); // TODO this is not great
                }
            }
            
            @Override
            public void onFailure(okhttp3.Call call, IOException e) {
                callFailure(e);
            }
            
            private void callFailure(Throwable e) {
                try {
                    callback.onFailure(OkHttpCall.this, e);
                } catch (Throwable t) {
                    throwIfFatal(t);
                    t.printStackTrace(); // TODO this is not great
                }
            }
        });
}

6 线程切换

Retrofit实现子线程到主线程的切换也是基于Handler。

static final class Android extends Platform {
    Android() {
        super(Build.VERSION.SDK_INT >= 24);
    }
    
    @Override
    public Executor defaultCallbackExecutor() {
        return new MainThreadExecutor();
    }
    
    @Nullable
    @Override
    Object invokeDefaultMethod(
        Method method, Class<?> declaringClass, Object object, Object... args) throws Throwable {
        if (Build.VERSION.SDK_INT < 26) {
            throw new UnsupportedOperationException(
                "Calling default methods on API 24 and 25 is not supported");
        }
        return super.invokeDefaultMethod(method, declaringClass, object, args);
    }
    
    static final class MainThreadExecutor implements Executor {
        // Handler
        private final Handler handler = new Handler(Looper.getMainLooper());
        
        @Override
        public void execute(Runnable r) {
            handler.post(r);
        }
    }
  }

请求后，先走默认的线程切换适配器DefaultCallAdapterFactory，然后走自定义的callback。

@Override
public void enqueue(final Callback<T> callback) {
    Objects.requireNonNull(callback, "callback == null");
    
    // 切换线程
    delegate.enqueue(
        new Callback<T>() {
            @Override
            public void onResponse(Call<T> call, final Response<T> response) {
                callbackExecutor.execute(
                    () -> {
                        if (delegate.isCanceled()) {
                            // Emulate OkHttp's behavior of throwing/delivering an IOException on
                            // cancellation.
                            callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
                        } else {
                            callback.onResponse(ExecutorCallbackCall.this, response);
                        }
                    });
            }
            
            @Override
            public void onFailure(Call<T> call, final Throwable t) {
                callbackExecutor.execute(() -> callback.onFailure(ExecutorCallbackCall.this, t));
            }
        });
}

7 总结

Retrofit的源码十分优秀，用注解的形式组合HTTP请求，通过代理接口，处理请求的逻辑，最后再执行请求。里面也大量使用反射，工厂方法，抽象接口来实现低耦合和高扩展，非常值得一读的开源框架！

Android开源框架：Retrofit