源码：Retrofit

深藏阁楼爱情的钟 2024-03-25 21:46 24阅读 0赞

## 一、Okhttp ##

### 使用总结 ###

OkHttpClient client = new OkHttpClient.Builder().readTimeout(5,TimeUnit.SECONDS).build();
    Request request = new Request.Builder().url("http://www.baidu.com").get().build();
    
    okhttp3.Call call = client.newCall(request);
    call.enqueue(new okhttp3.CallBack(){
        @Override
        pubkic void onFailure(okhttp3.Call call, IOException e){
            e.printstackTrace();
        }
        @Override
        pubkic void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException{
            if(response.isSuccessful()){
                sysout.out.println("success")
            }
        }
    })

1.  创建OkHttpClient实例

1.  构建Request请求参数

1.  构建请求call

1.  创建网络请求对象

1.  发送网络请求

1.  添加适配数据 -- 解析数据

1.  线程切换 -- 处理数据并显示

### 存在的问题： ###

*  用户网络请求的接口配置繁琐，尤其是需要配置复杂的请求头，请求body，参数的时候;

*  数据解析过程需要手动解析；

*  无法自动进行线程的切换；

*  多个嵌套网络请求就会陷入“回调陷阱’。

## 二、Retrofit ##

Retrofit是一个RESTful的http网络请求框架的封装，是基于OkHttp框架来实现请求的，对OkHttp框架的一套封装

### Retrofit和Okhtpp的分工： ###

App应用程序进行网络请求，实际上是使用Retrofit接口层封装网络请求接口参数、Header、Url等信息，然后由Okhttp完成后续的请求操作。在服务端返回数据之后，Okhttp将原始的结果交给Retrofit，Retrofit根据用户需求对结果进行解析，然后进行线程切换。

*  请求前：

*  统一配置网络请求头

*  适配请求request

*  返回结果

*  线程切换

*  数据适配

### **Retrofit的使用** ###

1.  ##### 定义Retrofit接口: #####

@GET("data/list")
 Observable<byte[]> getDataList(@Query("id") int id);

1.  ##### 定义基础请求URL: #####

public class BaseRequest {
       public static final String BaseURL = "https://test.com/";
    }

1.  ##### Retrofit的使用： #####

//Retrofit 实例的创建
 Retrofit retrofit = new Retrofit.Builder()
                //创建baseUrl
 .baseUrl(BaseRequest.BaseURL)
                //添加GsonConverterFactory,网络转换器工厂
 .addConverterFactory(GsonConverterFactory.create())
                //添加RxJava的RxJavaCallAdapterFactory，网络请求适配器工厂
 .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                //构建Retrofit的实例
 .build();
 
 // 创建请求接口类
 GetRequestInterface request = retrofit.create(GetRequestInterface.class);
 // ---1.普通网络请求--- 
 // 获取请求对象Call
 Call<ResponseBody> call = request.getCall();
 // 执行网络请求
 call.enqueue(new Callback<ResponseBody>() {
 @Override
 public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
 ResponseBody body = response.body();
 Log.i("TAG", "MainActivity onResponse response:" + response.toString());
 Log.i("TAG", "MainActivity onResponse body:" + (body == null ? "null" : body.toString()));
 }
 
 @Override
 public void onFailure(Call<ResponseBody> call, Throwable t) {
 Log.i("TAG", "MainActivity onFailure t:" + t.toString());
 }
 });
 
 // ---2.RxJava网络请求--- 
 Observable<ResultData> observableCall = request.getObservableCall();
 
 observableCall.subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new Observer<ResultData>() {
 @Override
 public void onSubscribe(Disposable d) {
 
 }
 
 @Override
 public void onNext(ResultData resultData) {
 Log.i("TAG", "retrofit onNext resultData:" + resultData.toString());
 
 }
 
 @Override
 public void onError(Throwable e) {
 
 }
 
 @Override
 public void onComplete() {
 Log.i("TAG", "retrofit onComplete ");
 }
 });

**步骤分解**：

1.  创建Retrofit实例：通过构造者模式创建 new Retrofit.Builder()

1.  通过Retrofit实例来创建接口实例：通过动态代理来创建 retrofit.create(GetRequestInterface.class)

1.  通过接口实例获取到网络请求的操作类Call；request.getCall() | request.getObservableCall()

1.  通过Call来执行网络请求来获取Response。call.enqueue | observableCall.subscribeOn

### **Retrofit源码分析** ###

1.  #### **Retrofit的变量** ####

Retrofit的构建使用了建造者模式，可以构造复杂的对象，方便扩展，代码简洁

public final class Retrofit {
     //方法的缓存类
     //key:网络请求的Method,如GET,POST等
     //value:ServiceMethod,动态代理解析后的方法类
 private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
 
     //创建OkHttp的工厂类
 final okhttp3.Call.Factory callFactory;
     //基础URL
 final HttpUrl baseUrl;
     //Converter.Factory的集合,将返回的数据通过这个工厂转化为对应的数据，如Gson的GsonConverterFactory工厂类，也就是数据转化器工厂
 final List<Converter.Factory> converterFactories;
     //CallAdapter.Factory的集合，网络请求的适配器工厂，比如把Call转化为RxJava请求的RxJavaCallAdapterFactory工厂，也就是Call转化工厂；
 final List<CallAdapter.Factory> callAdapterFactories;
     //用于回调网络请求
 final @Nullable Executor callbackExecutor;
     //用于判断是否需要立即解析方法
 final boolean validateEagerly;
     
   ……
 }

1.  #### **Retrofit.Builder的创建** ####

public static final class Builder {
 private final Platform platform;
 private @Nullable okhttp3.Call.Factory callFactory;
 private @Nullable HttpUrl baseUrl;
 private final List<Converter.Factory> converterFactories = new ArrayList<>();
 private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
 private @Nullable Executor callbackExecutor;
 private boolean validateEagerly;
 
     ……
 }

##### platform类： #####

通过Platform.get()方法获取的，最终调用findPlatform()，这个方法会返回Android，Java，Platform等类，用来判断对应的平台，然后获取对应的Platform

class Platform {
      private static final Platform PLATFORM = findPlatform();
    
      static Platform get() {
        return PLATFORM;
      }
    
      private static Platform findPlatform() {
        try {
          Class.forName("android.os.Build");
            //判断从系统获取的SKD不为0的时候，则为Android平台
          if (Build.VERSION.SDK_INT != 0) {
            return new Android();
          }
        } catch (ClassNotFoundException ignored) {
        }
        try {
          Class.forName("java.util.Optional");
          //非Android平台，就返回Java平台
          return new Java8();
        } catch (ClassNotFoundException ignored) {
        }
        return new Platform();
      }
    
        ……
    }
    
        //硬件上运行的软件的SDK版本
     public static final int SDK_INT = SystemProperties.getInt(
                    "ro.build.version.sdk", 0);

##### Android类 #####

static class Android extends Platform {
 @IgnoreJRERequirement // Guarded by API check.
 @Override boolean isDefaultMethod(Method method) {
 if (Build.VERSION.SDK_INT < 24) {
 return false;
 }
 return method.isDefault();
 }
 
     //默认的 线程执行器Executor
 @Override public Executor defaultCallbackExecutor() {
 return new MainThreadExecutor();
 }
 
     //获取默认的CallAdapter.Factory，用于创建CallAdapter；
 @Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
 @Nullable Executor callbackExecutor) {
 if (callbackExecutor == null) throw new AssertionError();
 ExecutorCallAdapterFactory executorFactory = new ExecutorCallAdapterFactory(callbackExecutor);
 return Build.VERSION.SDK_INT >= 24
 ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
 : singletonList(executorFactory);
 }
 
     //
 @Override int defaultCallAdapterFactoriesSize() {
 return Build.VERSION.SDK_INT >= 24 ? 2 : 1;
 }
 
     //获取默认的数据转换工厂ConverterFactory，用于创建转换器Converter；
 @Override List<? extends Converter.Factory> defaultConverterFactories() {
 return Build.VERSION.SDK_INT >= 24
 ? singletonList(OptionalConverterFactory.INSTANCE)
 : Collections.<Converter.Factory>emptyList();
 }
 
 @Override int defaultConverterFactoriesSize() {
 return Build.VERSION.SDK_INT >= 24 ? 1 : 0;
 }
 
     //主线程的Hander，execute的时候，会post到主线程执行
 static class MainThreadExecutor implements Executor {
 private final Handler handler = new Handler(Looper.getMainLooper());
 
 @Override public void execute(Runnable r) {
 handler.post(r);
 }
 }
 }

##### **baseUrl** #####

网络请求的基础URL

1.  通过解析这个baseUrl并返回一个HttpUrl对象；

1.  将创建的HttpUrl对象赋值给Builder。

##### **Converter.Factory** #####

用于创建Converter的工厂，使用了抽象工厂的设计模式

Converter是用来将请求返回的数据，转化为对应平台的数据

public interface Converter<F, T> {
     //用于将返回的数据转换为对应的类型
 @Nullable T convert(F value) throws IOException;
 
     //Converter.Factory是Converter的内部类
 abstract class Factory {
 
     //用于将返回的返回体ResponseBody转换为对应的转换器Converter；
 public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
 Annotation[] annotations, Retrofit retrofit) {
 return null;
 }
 
     //用于将请求的RequestBody转换为对应的转换器Converter
 public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
 Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
 return null;
 }
 
 public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
 Retrofit retrofit) {
 return null;
 }
 
 protected static Type getParameterUpperBound(int index, ParameterizedType type) {
 return Utils.getParameterUpperBound(index, type);
 }
 
 protected static Class<?> getRawType(Type type) {
 return Utils.getRawType(type);
 }
 }
 }

###### GsonConverterFactory ######

通过GsonConverterFactory.create()来创建对应的转换器工厂

public final class GsonConverterFactory extends Converter.Factory {
 
     //简单的创建一个Gson
 public static GsonConverterFactory create() {
 return create(new Gson());
 }
 
 @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
 public static GsonConverterFactory create(Gson gson) {
 if (gson == null) throw new NullPointerException("gson == null");
 return new GsonConverterFactory(gson);
 }
 
 private final Gson gson;
 
 private GsonConverterFactory(Gson gson) {
 this.gson = gson;
 }
 
     //通过class的Type类型，创建Gson的TypeAdapter
 @Override
 public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
 Retrofit retrofit) {
 TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
     通过TypeAdapter和gson的参数创建了GsonResponseBodyConverter对象
 return new GsonResponseBodyConverter<>(gson, adapter);
 }
 
     //通过class的Type类型，创建Gson的TypeAdapter:gson解析用到的类
 @Override
 public Converter<?, RequestBody> requestBodyConverter(Type type,
 Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
 TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
     //通过TypeAdapter和gson的参数创建了GsonRequestBodyConverter对象
 return new GsonRequestBodyConverter<>(gson, adapter);
 }
 }

###### GsonRequestBodyConverter ######

final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
 private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
 private static final Charset UTF_8 = Charset.forName("UTF-8");
 
 private final Gson gson;
 private final TypeAdapter<T> adapter;
 
 GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
 this.gson = gson;
 this.adapter = adapter;
 }
     //将传进来的value值通过TypeAdapter将其转化为ByteString，然后再传进RequestBody作为参数来构建RequestBody对象；
 @Override public RequestBody convert(T value) throws IOException {
 Buffer buffer = new Buffer();
 Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
 JsonWriter jsonWriter = gson.newJsonWriter(writer);
 adapter.write(jsonWriter, value);
 jsonWriter.close();
 return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
 }
 }

###### GsonResponseBodyConverter ######

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
 private final Gson gson;
 private final TypeAdapter<T> adapter;
 
 GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
 this.gson = gson;
 this.adapter = adapter;
 }
 
     // 通过TypeAdapter读取JsonReader的数据，返回对应的数据类型
 @Override public T convert(ResponseBody value) throws IOException {
 JsonReader jsonReader = gson.newJsonReader(value.charStream());
 try {
 T result = adapter.read(jsonReader);
 if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
 throw new JsonIOException("JSON document was not fully consumed.");
 }
 return result;
 } finally {
 value.close();
 }
 }
 }

##### **CallAdapter.Factory** #####

用来创建CallAdapter的工厂类，使用了抽象工厂的设计模式

CallAdapter是用来将Call转化为所需要的请求类型，如将Call转化为RxJava的调用类型；

public interface CallAdapter<R, T> {
 
 Type responseType();
 
     //通过adapt方法来进行转换,接口的一个方法，交给子类去实现
 T adapt(Call<R> call);
 
 abstract class Factory {
 
     //抽象方法，交给子类实现，来获取CallAdapter的对象
 public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
 Retrofit retrofit);
 
 protected static Type getParameterUpperBound(int index, ParameterizedType type) {
 return Utils.getParameterUpperBound(index, type);
 }
 
 protected static Class<?> getRawType(Type type) {
 return Utils.getRawType(type);
 }
 }
 }

在创建Retrofit的时候，在CallAdapter.Factory的添加时，使用了RxJava的工厂，用于将Call请求转换为RxJava对应的请求；

.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

###### RxJava2CallAdapterFactory ######

public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {
 
 public static RxJava2CallAdapterFactory create() {
     //对Scheduler进行赋值，创建时，传的是null
 return new RxJava2CallAdapterFactory(null, false);
 }
 
 @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
 public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) {
 if (scheduler == null) throw new NullPointerException("scheduler == null");
 return new RxJava2CallAdapterFactory(scheduler, false);
 }
 
 private final @Nullable Scheduler scheduler;
 private final boolean isAsync;
 
 private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
 this.scheduler = scheduler;
 this.isAsync = isAsync;
 }
 
 //通过get方法创建一个RxJava的CallAdapter,也就是RxJava2CallAdapter；
 public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
 Class<?> rawType = getRawType(returnType);
 
 if (rawType == Completable.class) {
 // 创建RxJava2CallAdapter
 return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
 false, true);
 }
 ...
 // 创建RxJava2CallAdapter
 return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
 isSingle, isMaybe, false);
 }

###### RxJava2CallAdapter ######

public Object adapt(Call<R> call) {
 // 第一步：根据是否是异步的参数创建对应的Observable
 Observable<Response<R>> responseObservable = isAsync
 ? new CallEnqueueObservable<>(call)
 : new CallExecuteObservable<>(call);
 
 Observable<?> observable;
 // 第二步：根据各种判断，再封装一层Observable返回
 if (isResult) {
 observable = new ResultObservable<>(responseObservable);
 } else if (isBody) {
     //对订阅的观察者进行封装，在onNext方法中将body返回
 observable = new BodyObservable<>(responseObservable);
 } else {
 observable = responseObservable;
 }
     //最终返回一个RxJava的被观察者：Observable
 ... 
 return observable;
 }

##### **Retrofit.Builder\#build** #####

主要是做各种参数的赋值，最终通过参数来创建Retrofit的实例

public Retrofit build() {
   if (baseUrl == null) {
 throw new IllegalStateException("Base URL required.");
 }
 
 okhttp3.Call.Factory callFactory = this.callFactory;
 if (callFactory == null) {
         //callFactory为空，重新创建一个OkHttpClient进行赋值
 callFactory = new OkHttpClient();
 }
 
 Executor callbackExecutor = this.callbackExecutor;
 if (callbackExecutor == null) {
         // 判断Executor为空时，就用Platform的默认Executor进行赋值，主线程中的Handler
 callbackExecutor = platform.defaultCallbackExecutor();
 }
 
 // 通过添加的CallAdapter.Factory来创建一个新的CallAdapter.Factory集合；
 List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
 
 // 添加Platform的默认CallAdapter.Factory，如果没有添加CallAdapter.Factory，那么就会使用这个Platform的默认CallAdapter.Factory； 
     callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
 
 // 创建Converter.Factory的集合
 List<Converter.Factory> converterFactories = new ArrayList<>(
 1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
 
 // 添加默认的Converter.Factory
 converterFactories.add(new BuiltInConverters());
 // 添加自定的Converter.Factory
 converterFactories.addAll(this.converterFactories);
 // 添加Platform的默认Converter.Factory
 converterFactories.addAll(platform.defaultConverterFactories());
 // 最终创建Retrofit实例；
 return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
 unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
 }

1.  #### **Retrofit\#create** ####

**Retrofit**使用动态代理在调用接口的方法之前，统一去解析处理Header和URL等操作；这样就不用每次在新增一个请求的方法，就去写一遍这个解析的逻辑

public <T> T create(final Class<T> service) {
 Utils.validateServiceInterface(service);
     // 验证接口的参数以及配置是否正确
 if (validateEagerly) {
         //用于加载接口的配置，用于判断接口对应的header，body以及方法的参数等配置是否正确，如果不正确那么就会抛出异常；
 eagerlyValidateMethods(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 Object invoke(Object proxy, Method method, @Nullable Object[] args)
 throws Throwable {
 
             // 判断是否是Object，如果是的话，就直接调用方法返回
 if (method.getDeclaringClass() == Object.class) {
 return method.invoke(this, args);
 }
 
         // 判断是否是Java8平台的默认方法类型，如果是的话，就调用Java8平台的invokeDefaultMethod方法
 if (platform.isDefaultMethod(method)) {
 return platform.invokeDefaultMethod(method, service, proxy, args);
 }
 // 解析方法；解析在接口配置的注解以及参数，比如header，body，url等等
 return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
 }
 });
 }

##### loadServiceMethod() #####

ServiceMethod<?> loadServiceMethod(Method method) {
     //先从缓存map集合里面获取ServiceMethod；
 ServiceMethod<?> result = serviceMethodCache.get(method);
 if (result != null) return result;
 
 synchronized (serviceMethodCache) {
 result = serviceMethodCache.get(method);
         //如果缓存中获取不到，通过解析注解，获取到ServiceMethod对象；
 if (result == null) {
 result = ServiceMethod.parseAnnotations(this, method);
         //将解析后的ServiceMethod对象存入到map集合中；loadServiceMethod
 serviceMethodCache.put(method, result);
 }
 }
 return result;
 }

##### ServiceMethod #####

abstract class ServiceMethod<T> {
 static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
     // 通过解析接口方法的注解，获取RequestFactory
 RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
 
 Type returnType = method.getGenericReturnType();
 if (Utils.hasUnresolvableType(returnType)) {
 throw methodError(method,
 "Method return type must not include a type variable or wildcard: %s", returnType);
 }
 if (returnType == void.class) {
 throw methodError(method, "Service methods cannot return void.");
 }
     // 解析注解并获取ServiceMethod对象
 return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
 }
 
 abstract T invoke(Object[] args);
 }

###### parseAnnotations ######

static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
        return new Builder(retrofit, method).build();
      }

###### Builder() ######

通过Builder来创建RequestFactory

Builder(Retrofit retrofit, Method method) {
         this.retrofit = retrofit;
         this.method = method;
         // 获取方法所有的注解，包括自己声明的以及继承的
         this.methodAnnotations = method.getAnnotations();
         // 获取方法参数的所有类型，包含泛型；
         this.parameterTypes = method.getGenericParameterTypes();
         // 获取方法参数上的所有注解
         this.parameterAnnotationsArray = method.getParameterAnnotations();
       }

###### build() ######

在接口的方法里面定义的相关url，header等注解，最终在这里解析并转化为okhttp请求的Call

equestFactory build() {
 for (Annotation annotation : methodAnnotations) {
 // 遍历方法的注解，解析方法的参数配置，获取到请求的url，header等参数
 parseMethodAnnotation(annotation);
 }
 
 ...
 int parameterCount = parameterAnnotationsArray.length;
 parameterHandlers = new ParameterHandler<?>[parameterCount];
 for (int p = 0; p < parameterCount; p++) {
 // 遍历方法的参数，以及参数的类型，解析方法的参数逻辑
 parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p]);
 }
 
 ...
 // 根据上面解析的参数配置，创建RequestFactory
 return new RequestFactory(this);
 }

###### parseMethodAnnotation ######

用来解析方法注解的配置信息；通过注解Annotation，获取到url，header，isMultipart等参数，并将其赋值给建造者Builder的成员变量；

![c5c231806fc230f8f198a51d2f2e6e9a.png][]

private void parseMethodAnnotation(Annotation annotation) {
          if (annotation instanceof DELETE) {
            parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
          } else if (annotation instanceof GET) {
            parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
          } else if (annotation instanceof HEAD) {
            parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
          } else if (annotation instanceof PATCH) {
            parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
          } else if (annotation instanceof POST) {
            parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
          } else if (annotation instanceof PUT) {
            parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
          } else if (annotation instanceof OPTIONS) {
            parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
          } else if (annotation instanceof HTTP) {
            HTTP http = (HTTP) annotation;
            parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
          } else if (annotation instanceof retrofit2.http.Headers) {
            String[] headersToParse = ((retrofit2.http.Headers) annotation).value();
            if (headersToParse.length == 0) {
              throw methodError(method, "@Headers annotation is empty.");
            }
            headers = parseHeaders(headersToParse);
          } else if (annotation instanceof Multipart) {
            if (isFormEncoded) {
              throw methodError(method, "Only one encoding annotation is allowed.");
            }
            isMultipart = true;
          } else if (annotation instanceof FormUrlEncoded) {
            if (isMultipart) {
              throw methodError(method, "Only one encoding annotation is allowed.");
            }
            isFormEncoded = true;
          }
        }

###### parseParameter ######

遍历获取到的方法的参数类型parameterTypes以及方法参数的注解parameterAnnotationsArray，来解析并获取相关配置，最终调用parseParameterAnnotation()

![f21129c285c52a5676a9c4c2cf804970.png][]

private ParameterHandler<?> parseParameter(
 int p, Type parameterType, @Nullable Annotation[] annotations) {
 ParameterHandler<?> result = null;
 if (annotations != null) {
 for (Annotation annotation : annotations) {
 ParameterHandler<?> annotationAction =
 parseParameterAnnotation(p, parameterType, annotations, annotation);
 
 if (annotationAction == null) {
 continue;
 }
 
 if (result != null) {
 throw parameterError(method, p,
 "Multiple Retrofit annotations found, only one allowed.");
 }
 
 result = annotationAction;
 }
 }
 
 if (result == null) {
 throw parameterError(method, p, "No Retrofit annotation found.");
 }
 
 return result;
 }

## 三、Retrofit中涉及到设计模式 ##

动态代理：**Retrofit\#create**

抽象工厂：**CallAdapter.Factory | Converter.Factory**

builder：**Retrofit.Builder**

外观/门面：所有功能通过Retrofit类去调用

## 四、Retrofit总结 ##

1.  用Retrofit创建动态代理类 retrofit.create()

1.  用动态代理类获取请求对象 Call request.getcall()

1.  触发动态代理接口InvocationHandler的回调invoke方法

1.  调用Retrofit的loadServiceMethod()方法，判断是否有缓存

1.  调用HttpServiceMethod的invoke()方法

1.  调用CallAdapter的adapt()方法，判断是否使用饿RxJava

1.  是：

1.  调用RxJava2CallAdapter的adapt()方法

1.  调用CallEnqueueObservable的subscribeActual方法(异步) / CallExecuteObservable的ubscribeActual方法(同步)

1.  最终调用OkhttpCall的enqueue方法 / execute方法

1.  否：

1.  返回了ExecuteCallAdapterFactory.ExecutorCallbackCall的call对象

1.  调用delegate.enqueue方法请求数据

1.  最终调用OkhttpCall的enqueue方法请求数据

1.  调用OkhttpCall的arseResponse方法，然后调用Converter的convert方法，最终将返回的数据转化成对应的类型

## 五、注解 ##

#### **请求方法注解** ####

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:132px;vertical-align:top;height:52px;">注解名称</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">说明</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@GET</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">get请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@POST</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">post请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@PUT</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">put请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@DELETE</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">delete请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@PATCH</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">patch请求，该请求是对put请求的补充，用于更新局部资源</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@HEAD</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">head请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@OPTIONS</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">option请求</td> 
 </tr> 
 <tr> 
 <td style="width:132px;vertical-align:middle;height:52px;">@HTTP</td> 
 <td style="width:613px;vertical-align:middle;height:52px;">通用注解,可以替换以上所有的注解，其拥有三个属性：method，path，hasBody</td> 
 </tr> 
 </tbody> 
</table>

#### **请求标记注解** ####

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:204px;vertical-align:middle;height:52px;">注解名称</td> 
 <td style="width:440px;vertical-align:middle;height:52px;">说明</td> 
 </tr> 
 <tr> 
 <td style="width:204px;vertical-align:middle;height:52px;">@FormUrlEncoded</td> 
 <td style="width:440px;vertical-align:middle;height:52px;">表示请求发送编码表单数据，每个键值对需要使用@Field注解</td> 
 </tr> 
 <tr> 
 <td style="width:204px;vertical-align:middle;height:52px;">@Multipart</td> 
 <td style="width:440px;vertical-align:middle;height:52px;">表示请求发送multipart数据，需要配合使用@Part</td> 
 </tr> 
 <tr> 
 <td style="width:204px;vertical-align:middle;height:52px;">@Streaming</td> 
 <td style="width:440px;vertical-align:middle;height:52px;">表示响应用字节流的形式返回.如果没使用该注解,默认会把数据全部载入到内存中.该注解在在下载大文件的特别有用</td> 
 </tr> 
 </tbody> 
</table>

#### 请求参数注解 ####

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:100px;vertical-align:top;height:52px;"></td> 
 <td style="width:117px;vertical-align:top;height:52px;">注解名称</td> 
 <td style="width:426px;vertical-align:top;height:52px;">说明</td> 
 </tr> 
 <tr> 
 <td style="width:100px;vertical-align:top;height:104px;">请求头</td> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Headers</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">用于添加固定请求头，可以同时添加多个。通过该注解添加的请求头不会相互覆盖，而是共同存在</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Header</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">作为方法的参数传入，用于添加不固定值的Header，该注解会更新已有的请求头</td> 
 </tr> 
 <tr> 
 <td style="width:100px;vertical-align:top;height:468px;">请求参数</td> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Body</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">多用于post请求发送非表单数据,比如想要以post方式传递json格式数据</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Filed</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">多用于post请求中表单字段,Filed和FieldMap需要FormUrlEncoded结合使用</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@FiledMap</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">和@Filed作用一致，用于不确定表单参数</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Part</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">用于表单字段,Part和PartMap与Multipart注解结合使用,适合文件上传的情况</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@PartMap</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">用于表单字段,默认接受的类型是Map&lt;String,REquestBody&gt;，可用于实现多文件上传</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Path</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">用于url中的占位符</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Query</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">用于Get中指定参数</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@QueryMap</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">和Query使用类似</td> 
 </tr> 
 <tr> 
 <td style="width:117px;vertical-align:middle;height:52px;">@Url</td> 
 <td style="width:426px;vertical-align:middle;height:52px;">指定请求路径</td> 
 </tr> 
 </tbody> 
</table>

![59eca4a68bb715961bc1c5be5fac3214.png][]

[c5c231806fc230f8f198a51d2f2e6e9a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d19eeaec6e0c4152846c1b6ba43b6f9a.png
[f21129c285c52a5676a9c4c2cf804970.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0031c455c03f4f908711c9c30ab8fce2.png
[59eca4a68bb715961bc1c5be5fac3214.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d43507cea7b94d209ccf4cd041cf7fa5.png