十分钟教你手撸一个简单的Retrofit demo
众所周知，retrofit框架是square公司旗下的著名的http请求框架，今天我们来理一理它的主要逻辑，并写一个demo，这里涉及到java中注解，反射，泛型等知识点和构建者模式、动态代理，和我一起来一探究竟吧。
Retrofit的具体用法请自行百度，下面是关键的三行代码
//利用构建者模式实例化Retrofit
Retrofit retrofit = new Retrofit.Builder().baseUrl("https://restapi.amap.com/").build();
//通过动态代理生成接口的实例对象，并实现接口中定义的方法；
apiService = (ApiService) retrofit.create(ApiService.class);
//代理对象去做http请求
Call call = (Call) apiService.get("110101","ae6c53e2186f33bbf240a12d80672d1b");
先想一想做http请求，我们需要什么？需要域名，请求方式，请求参数，嗯，还需要Okhttp
实现Retrofit第一步
构建MyRetrofit类，在里边儿定义一个内部Builder类,构建者模式是将一个复杂的对象一步一步建立起来。然后在Builder类型中baseUrl方法准备好域名，callFactory准备好OKHttp ,build()方法将获得的参数传入MyRetrofit构造方法，返回MyRetrofit实例对象。
public class MyRetrofit {
public final HttpUrl baseUrl;
public final Call.Factory factory;
public MyRetrofit(HttpUrl baseUrl, Call.Factory factory){
this.baseUrl = baseUrl;
this.factory = factory;
}
public static final class Builder{
private HttpUrl baseUrl;
private Call.Factory factory;
public Builder baseUrl(String url){
if(url != null){
baseUrl = HttpUrl.get(url);
}
return this;
}
public Builder callFactory(Call.Factory factory){
if(factory != null){
this.factory = factory;
}
return this;
}
public MyRetrofit build(){
if(this.factory == null){
this.factory = new OkHttpClient();
}
return new MyRetrofit(baseUrl,factory);
}
}
}实现Retrofit第二步
通过接口创建代理对象, 并在invoke的回调中实现apiService中定义的方法。代理模式是类似于中介代理的某项服务，类似于租房，你不需要知道房东是谁，只需要找中介就能租，静态代理是租房找租房中介，留学找留学中介，相亲找媒婆；而动态代理就很牛了，不管是租房，留学还是相亲都可以找这个中介，即静态代理是一个代理功能对应一个代理类，动态代理是多个代理功能对应一个代理类。下面是生成http请求的动态代理类，Proxy.newProxyInstance()中通过接口生成动态代理类，newProxyInstance()方法中先对interfaces接口做拷贝，再根据拷贝的接口和类加载器生成代理类，最后获取代理类的构造方法，再返回由构造方法实例化的代理对象。在InvocationHandler回调的invoke方法中实现http请求逻辑，具体的实现方式交给ServiceMethod。
public <T> T create(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 {
ServiceMethod serviceMethod = loadServiceMethod(method);
return serviceMethod.invoke(args);
}
});
}
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//对interfaces接口做拷贝
final Class<?>[] intfs = interfaces.clone();
// Android-removed: SecurityManager calls
/*
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);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
// Android-removed: SecurityManager / permission checks.
/*
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
*/
//获取代理类的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
// BEGIN Android-changed: Excluded AccessController.doPrivileged call.
/*
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
*/
cons.setAccessible(true);
// END Android-removed: Excluded AccessController.doPrivileged call.
}
//返回由构造方法实例化的代理对象
return cons.newInstance(new Object[]{h});
} 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);
}
}实现Retrofit第三步
在第二步利用动态代理获取代理对象的create方法回调中的invoke方法中实现http请求，这一步讲讲ServiceMethod如何实现http请求；
ServiceMethod要根据create传入的api请求接口
public interface Apitest1 {
@POST("/v3/weather/weatherInfo")
Call postTest1(@Field("city") String city, @Field("key") String key);
@GET("/v3/weather/weatherInfo")
Call getTest1(@Query("city") String city, @Query("key") String key);
}通过反射获取Apitest1接口中声明方法的注解和方法参数上的注解获得请求方式，请求url,请求参数等，利用OkHttp发送这次请求。
ServiceMethod类的对象也是通过构建者模式建立起来的，在ServiceMethod类中定义内部类Builder。
定义Builder的构造方法，传参Method和MyRetrofit 在构造方法中做两件事情
第一 ，通过反射method.getDeclaredAnnotations()获取方法上的注解，得到请求方式（post or get）,请求url。
第二，通过method.getParameterAnnotations()获得方法参数的注解，得到请求参数（这里的请求参数是 @Query("city")中的city），然后根据不同注解类型将获取的注解值放入不同的ParamHandler中，Field类型放FieldParamHandler，Query类型放QueryParamHandler中。
最后build()方法返回ServiceMethod实例。
在invoke方法中传入参数为Apitest1声明的函数中的参数，再将参数和ParamHandler数组构建成请求体formBody，最后由url,formBody和请求方式创建request请求，最后用OKhttp框架中factory.newCall(request)执行请求。
public class ServiceMethod {
private static HttpUrl.Builder formBuilder;
private static FormBody.Builder formBodyBuilder;
private Call.Factory factory;
private HttpUrl baseUrl;
private String relativeUrl;
private Boolean hasBody;
private String httpMethod;
private ParamHandler[] paramHandlers;
public ServiceMethod(Builder builder){
this.factory = builder.factory;
this.baseUrl = builder.baseUrl;
this.relativeUrl = builder.relativeUrl;
this.hasBody = builder.hasBody;
this.httpMethod = builder.httpMethod;
this.paramHandlers = builder.methodParamHandler;
}
public Object invoke(Object[] args) {
for (int i = 0; i < paramHandlers.length; i++) {
paramHandlers[i].apply(this, (String) args[i]);
}
if(formBuilder == null){
formBuilder = baseUrl.newBuilder(relativeUrl);
}
HttpUrl url = formBuilder.build();
if(formBodyBuilder == null){
formBodyBuilder = new FormBody.Builder();
}
FormBody formBody = null;
if(hasBody){
formBody = formBodyBuilder.build();
}
Request request = new Request.Builder().url(url).method(httpMethod,formBody).build();
return factory.newCall(request);
}
public static void addParamToFormBody(String key,String value){
if(formBodyBuilder == null){
formBodyBuilder = new FormBody.Builder();
}
formBodyBuilder.add(key,value);
}
public void addParamToQueryFormBody(String key, String value){
if(formBuilder == null){
formBuilder = baseUrl.newBuilder(relativeUrl);
}
formBuilder.addQueryParameter(key,value);
}
public static class Builder{
private ParamHandler[] methodParamHandler;
private Annotation[] methodOverAnnotations;
private Annotation[][] methodAnnotations;
private Call.Factory factory;
private HttpUrl baseUrl;
private String relativeUrl;
private Boolean hasBody;
private String httpMethod;
public Builder(Method method,MyRetrofit myRetrofit){
this.methodOverAnnotations = method.getDeclaredAnnotations();
this.methodAnnotations = method.getParameterAnnotations();
this.factory = myRetrofit.factory;
this.baseUrl = myRetrofit.baseUrl;
for (Annotation methodOverAnnotation : methodOverAnnotations) {
if(methodOverAnnotation instanceof POST){
this.hasBody = true;
this.httpMethod = "POST";
this.relativeUrl = ((POST) methodOverAnnotation).value();
}else if(methodOverAnnotation instanceof GET){
this.httpMethod = "GET";
this.hasBody = false;
this.relativeUrl = ((GET) methodOverAnnotation).value();
}
}
int length = methodAnnotations.length;
methodParamHandler = new ParamHandler[length];
for (int i = 0; i < length; i++) {
Annotation[] annotations = methodAnnotations[i];
for (Annotation annotation : annotations) {
if(annotation instanceof Field){
methodParamHandler[i] = new ParamHandler.FieldParamHandler(((Field) annotation).value());
} else if(annotation instanceof Query){
methodParamHandler[i] = new ParamHandler.QueryParamHandler(((Query) annotation).value());
}
}
}
}
public ServiceMethod build(){
return new ServiceMethod(this);
}
}
}
