Retrofit 是一个 RESTful 的 HTTP 网络请求框架的封装，网络请求的工作本质上是 OkHttp 完成，而 Retrofit 仅负责网络请求接口的封装，其内部实现实际上是使用了代理模式，为了更好的学习Retrofit框架，我们先从代理模式开始。
代理模式
代理模式，就是为其他对象提供一种代理以控制对这个对象的访问。如果在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
代理模式的使用
来看一个代理模式的例子。
定义接口：
/**
* 代理抽象角色： 定义了服务的接口
* 代理角色和真实角色对外提供的公共方法，一般为一个接口
*/
public interface Sing{
public void sing();
}
实现接口：
/**
* 实现类： 提供唱歌服务的Jack
* 定义了真是角色所要实现的业务逻辑
*/
public class Jack implements Sing{
@Override
public void sing(){
System.out.println("努力唱歌")
}
}
代理对象：
/**
* 代理对象：演唱代理人
* 是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作
* 将统一的流程控制都放到代理角色中处理。
*/
public class SingAgent implements Sing {
private final Sing sing;
public Agent(Sing Sing) {
this.Sing = sing;
}
//....前置处理
public void before() {
System.out.println("准备");
}
//....后置处理
public void after() {
System.out.println("打分");
}
@Override
public void massage() {
before();
Sing.sing();
after();
}
}
代理模式使用：
public class Main {
public static void main(String[] args) throws Exception {
//静态代理
Sing sing = new Jack();
SingAgent agent = new Agent(sing);
agent.sing();
}
}
在静态代理中，一个代理类可以代理多个真实对象，我们除了定义Jack之外，还可以定义David。如果我们的Jack除了会Sing（唱歌）之外，还会Dance(跳舞)。
public interface Dance{
public void dance();
}
public class Jack implements Sing, Dance{
......
}
但是一个代理，只能实现一个抽象接口，为了能代理Jack对象，必须再创建一个DanceAgent，这样一来，代码中就会有很多代理类。所以我们就必须想办法，通过一个代理类，实现全部的代理功能，这时候就用到了动态代理。
public static void main(String[] args) throws Exception {
//静态代理
Jack jack = new Jack();
Object o = Proxy.newProxyInstance(Main.class.getClassLoader(), //类加载器
new Class[]{ Sing.class, Dance.class }, //代理的接口数组
new InvocationHandler() { //回调方法
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
// System.out.println(o.toString());
return method.invoke(jack, objects);
}
});
Sing sing = (Sing) o;
sing.sing();
}
在这里，使用了Proxy类中的newProxyInstance方法，需要提供三个参数，类加载器、代理的接口数组、回调方法。先创建了一个Jack对象，然后创建了一个动态代理对象o，然后通过类型转换，将o转化成要代理的接口，调用sing()方法的时候，就会触发InvocationHandler.invoke()这个回调。回调方法中也有三个参数，o就是我们的动态对理对象，method就是接口的方法，objects就是方法参数。然后调用method.invoke()真正实现jack的sing()方法
所以，现在我们大概能了解到什么时候使用代理模式了吧。比如在早期网络实现的时候，用的是Volley框架，如果对于每一条网络请求，都是直接用Volley去建立，那么到了后面换成Okhttp框架的时候，就要对每一条网络请求都去修改代码，十分麻烦。而使用代理模式，则可以添加一个服务接口（定义了get和post），把Volley封装，并创建代理类，在代理对象中调用封装层的真实实现。后期切换框架的时候也更方便。
Proxy.newProxyInstance()原理
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone(); //拷贝接口
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs); //获取Class对象
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams); //利用反射获取class 的构造方法
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h}); //对class进行实例化
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
在newProxyInstance方法中，interfaces.clone()先对接口数组进行了拷贝，然后利用getProxyClass0方法创建Class对象，然后通过反射，获得它的构造方法cons，最后利用cons.newInstance()创建该类的实例。
我们的类是怎么来的？我们先来回顾一下类的完整生命周期。
Java源文件(.java) —编译—> Java字节码(.class) —类加载—> Class对象 —实例化—> 实例对象 ———>卸载
而我们的.class文件一般都是一个实实在在的文件，是在硬盘中存在的。但是在动态代理中，他这个Class对象，是在内存中去生成的。我们来看getProxyClass0这个方法
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
return proxyClassCache.get(loader, interfaces);
}
在Proxy里面有一个proxyClassCache对象，该对象是一个WeakCache实例，该缓存可以保存已经生成过的代理类，如果有则直接返回。如果没有的话，则通过ProxyClassFactory去创建代理类对象。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
......
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
......
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
ProxyClassFactory中，通过ProxyGenerator.generateProxyClass创建了代理类数据，返回的是一个byte数组，然后通过defineClass0去解析这个byte数组，并生成一个代理类对象。我们可以把这个byte数组通过数据流的方式输出到文件中。
private static void proxy() throws Exception {
String name = Sing.class.getName() + "$Proxy0";
//生成代理指定接口的Class数据
byte[] bytes = ProxyGenerator.generateProxyClass(name, new Class[]{Sing.class});
FileOutputStream fos = new FileOutputStream("lib/" + name + ".class");
fos.write(bytes);
fos.close();
}
我们来观察它的文件结构。
public final class Sing$Proxy0 extends Proxy implements Sing {
private static Method m3;
//构造方法接受InvocationHandler
public Sing$Proxy0(InvocationHandler var1) throws {
super(var1);
}
......
//在super中，也就是Proxy中，h就是传入的InvocationHandler
public final void sing() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
......
//静态代码块中，利用反射，获得sing()方法
static {
try {
m3 = Class.forName("com.enjoy.lib.Sing").getMethod("sing");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
Retrofit的简单实现
在接下来，我们将利用注解、反射与动态代理，对Retrofit进行一个简单的实现。在此之前，我们先来看一下Retrofit的简单使用。
Retrofit的基本使用
Api定义：
创建接api接口
//这里使用的是高德地图提供的天气api
public interface WeatherApi {
@POST("/v3/weather/weatherInfo")
@FormUrlEncoded
Call<ResponseBody> postWeather(@Field("city") String city, @Field("key") String key);
@GET("/v3/weather/weatherInfo")
Call<ResponseBody> getWeather(@Query("city") String city, @Query("key") String key);
}
Retrofit使用：
创建Retrofit对象，然后利用create()创建了api接口的对象，最后调用api的方法。
Retrofit retrofit = new Retrofit.Builder().baseUrl("https://restapi.amap.com")
.build();
weatherApi = retrofit.create(WeatherApi.class);
Call<ResponseBody> call = weatherApi.getWeather("110101", "ae6c53e2186f33bbf240a12d80672d1b");
call.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
if (response.isSuccessful()){
ResponseBody body = response.body();
try {
String string = body.string();
Log.i(TAG, "onResponse get: " + string);
} catch (IOException e) {
e.printStackTrace();
} finally {
body.close();
}
}
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
}
});
观察上面代码，Retrofit在创建的时候，使用的是构建者模式，它可以将一个复杂对象的构建和它的表示分离，可以让使用者方便使用，不必知道内部的细节。而在创建Api接口对象的时候， 使用的就是动态代理。接下来我们来实现一个自己的Retrofit。
EnjoyRetrofit.java
public class EnjoyRetrofit {
final Map<Method, ServiceMethod> serviceMethodCache = new ConcurrentHashMap<>();
final Call.Factory callFactory;
final HttpUrl baseUrl;
EnjoyRetrofit(Call.Factory callFactory, HttpUrl baseUrl) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
}
public <T> T create(final Class<T> service) {
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[]{service},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//解析这个method 上所有的注解信息
ServiceMethod serviceMethod = loadServiceMethod(method);
//args:
return serviceMethod.invoke(args);
}
});
}
private ServiceMethod loadServiceMethod(Method method) {
//先不上锁，避免synchronized的性能损失
ServiceMethod result = serviceMethodCache.get(method);
if (result != null) return result;
//多线程下，避免重复解析,
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
/**
* 构建者模式，将一个复杂对象的构建和它的表示分离，可以使使用者不必知道内部组成的细节。
*/
public static final class Builder {
private HttpUrl baseUrl;
//Okhttp->OkhttClient
private okhttp3.Call.Factory callFactory; //null
public Builder callFactory(okhttp3.Call.Factory factory) {
this.callFactory = factory;
return this;
}
public Builder baseUrl(String baseUrl) {
this.baseUrl = HttpUrl.get(baseUrl);
return this;
}
public EnjoyRetrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
return new EnjoyRetrofit(callFactory, baseUrl);
}
}
}
ServiceMethod.java
/**
* 记录请求类型 参数 完整地址
*/
public class ServiceMethod {
private final Call.Factory callFactory;
private final String relativeUrl;
private final boolean hasBody;
private final ParameterHandler[] parameterHandler;
private FormBody.Builder formBuild;
HttpUrl baseUrl;
String httpMethod;
HttpUrl.Builder urlBuilder;
public ServiceMethod(Builder builder) {
baseUrl = builder.enjoyRetrofit.baseUrl;
callFactory = builder.enjoyRetrofit.callFactory;
httpMethod = builder.httpMethod;
relativeUrl = builder.relativeUrl;
hasBody = builder.hasBody;
parameterHandler = builder.parameterHandler;
//如果是有请求体,创建一个okhttp的请求体对象
if (hasBody) {
formBuild = new FormBody.Builder();
}
}
public Object invoke(Object[] args) {
/**
* 1 处理请求的地址与参数
*/
for (int i = 0; i < parameterHandler.length; i++) {
ParameterHandler handlers = parameterHandler[i];
//handler内本来就记录了key,现在给到对应的value
handlers.apply(this, args[i].toString());
}
//获取最终请求地址
HttpUrl url;
if (urlBuilder == null) {
urlBuilder = baseUrl.newBuilder(relativeUrl);
}
url = urlBuilder.build();
//请求体
FormBody formBody = null;
if (formBuild != null) {
formBody = formBuild.build();
}
Request request = new Request.Builder().url(url).method(httpMethod, formBody).build();
return callFactory.newCall(request);
}
// get请求, 把 k-v 拼到url里面
public void addQueryParameter(String key, String value) {
if (urlBuilder == null) {
urlBuilder = baseUrl.newBuilder(relativeUrl);
}
urlBuilder.addQueryParameter(key, value);
}
//Post 把k-v 放到 请求体中
public void addFiledParameter(String key, String value) {
formBuild.add(key, value);
}
public static class Builder {
private final EnjoyRetrofit enjoyRetrofit;
private final Annotation[] methodAnnotations;
private final Annotation[][] parameterAnnotations;
ParameterHandler[] parameterHandler;
private String httpMethod;
private String relativeUrl;
private boolean hasBody;
public Builder(EnjoyRetrofit enjoyRetrofit, Method method) {
this.enjoyRetrofit = enjoyRetrofit;
//获取方法上的所有的注解
methodAnnotations = method.getAnnotations();
//获得方法参数的所有的注解 (一个参数可以有多个注解,一个方法又会有多个参数)
parameterAnnotations = method.getParameterAnnotations();
}
public ServiceMethod build() {
/**
* 1 解析方法上的注解, 只处理POST与GET
*/
for (Annotation methodAnnotation : methodAnnotations) {
if (methodAnnotation instanceof POST) {
//记录当前请求方式
this.httpMethod = "POST";
//记录请求url的path
this.relativeUrl = ((POST) methodAnnotation).value();
// 是否有请求体
this.hasBody = true;
} else if (methodAnnotation instanceof GET) {
this.httpMethod = "GET";
this.relativeUrl = ((GET) methodAnnotation).value();
this.hasBody = false;
}
}
/**
* 2 解析方法参数的注解
*/
int length = parameterAnnotations.length;
parameterHandler = new ParameterHandler[length];
for (int i = 0; i < length; i++) {
// 一个参数上的所有的注解
Annotation[] annotations = parameterAnnotations[i];
// 处理参数上的每一个注解
for (Annotation annotation : annotations) {
//todo 可以加一个判断:如果httpMethod是get请求,现在又解析到Filed注解,可以提示使用者使用Query注解
if (annotation instanceof Field) {
//得到注解上的value: 请求参数的key
String value = ((Field) annotation).value();
parameterHandler[i] = new ParameterHandler.FiledParameterHandler(value);
} else if (annotation instanceof Query) {
String value = ((Query) annotation).value();
parameterHandler[i] = new ParameterHandler.QueryParameterHandler(value);
}
}
}
return new ServiceMethod(this);
}
}
}
ParameterHandler.java
public abstract class ParameterHandler {
abstract void apply(ServiceMethod serviceMethod, String value);
static class QueryParameterHandler extends ParameterHandler {
String key;
public QueryParameterHandler(String key) {
this.key = key;
}
//serviceMethod: 回调
@Override
void apply(ServiceMethod serviceMethod, String value) {
serviceMethod.addQueryParameter(key,value);
}
}
static class FiledParameterHandler extends ParameterHandler {
String key;
public FiledParameterHandler(String key) {
this.key = key;
}
@Override
void apply(ServiceMethod serviceMethod, String value) {
serviceMethod.addFiledParameter(key,value);
}
}
}
定义注解：
Field.java
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Field {
String value();
}
GET.java
@Target(METHOD)
@Retention(RUNTIME)
public @interface GET {
String value() default "";
}
POST.java
@Target(METHOD)
@Retention(RUNTIME)
public @interface POST {
String value() default "";
}
Query.java
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Query {
String value();
}
最后，我们来看如何使用自定义的Retrofit。
public class MainActivity extends AppCompatActivity {
private WeatherApi weatherApi;
private static final String TAG = "MainActivity";
private EnjoyWeatherApi enjoyWeatherApi;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
EnjoyRetrofit enjoyRetrofit = new EnjoyRetrofit.Builder().baseUrl("https://restapi.amap.com").build();
enjoyWeatherApi = enjoyRetrofit.create(EnjoyWeatherApi.class);
}
public void enjoyGet(View view) {
okhttp3.Call call = enjoyWeatherApi.getWeather("110101", "ae6c53e2186f33bbf240a12d80672d1b");
call.enqueue(new okhttp3.Callback() {
@Override
public void onFailure(okhttp3.Call call, IOException e) {
}
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {
Log.i(TAG, "onResponse enjoy get: " + response.body().string());
response.close();
}
});
}
public void enjoyPost(View view) {
okhttp3.Call call = enjoyWeatherApi.postWeather("110101", "ae6c53e2186f33bbf240a12d80672d1b");
call.enqueue(new okhttp3.Callback() {
@Override
public void onFailure(okhttp3.Call call, IOException e) {
}
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {
Log.i(TAG, "onResponse enjoy post: " + response.body().string());
response.close();
}
});
}
}
网友评论