1、获取retrofit
new Retrofit.Builder() .baseUrl(url) .build()
2、获取api接口代理类
retrofit.create(Class<T> service);
//-----源码解析---------------------
1、使用步骤
- 实例化Retrofit
new Retrofit.Builder()
.baseUrl() //---基地址
.client() //添加自定义 OkHttpClient
.addConverterFactory() //---添加转换器工厂
.addCallAdapterFactory() //---添加回调适配器 (以上是常用功能 )
.callbackExecutor() //--添加网络请求执行Executor
.callFactory() // 添加okhttp 中Call.Factory
.validateEagerly() //是否一开始就直接缓存网络请求接口里面所有的对应的HttpServiceMethod实例。
.build();
2、获取api接口 动态代理类,通过动态代理操作 接口类。
retrofit.create(final Class<T> service) // --例如 AppHttpApiService apiService=retrofit.create(AppHttpApiService.class);
3、操作接口访问 数据 ,默认返回类型是 call
例如:登录 Call call= apiService.login(acc,pwd);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {}
@Override
public void onResponse(Call call, Response response) throws IOException {
System.out.println("网络响应数据:"+response);
}
});
2、原理解析
- retrofit 实现了接口与数据的分离,通过动态代理的方式来操作接口。
动态代理涉及到两个类 Proxy和InvocationHandler ,
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h) 创建代理类,动态代理方法在执行时,会调用h里面的invoke方法去执行
Retrofit中的创建动态代理类。
@SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety. public <T> T create(final Class<T> service) { validateServiceInterface(service); return (T) Proxy.newProxyInstance( service.getClassLoader(), //对应接口的 ClassLoader 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); } }); }
- 在执行动态代理方法时会调用invoke 方法,在invoke方法里会执行loadServiceMethod().invoke();
在 执行loadServiceMethod() 会得到HttpServiceMethod 实体
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; }
- 在HttpServiceMethod 类里面获取到api接口 注解相关东西 (包括接口里面的方法的返回类型,方法的参数等)
//---这个方法的返回类型是HttpServiceMethod,所以该方法也是得到HttpServiceMethod 的实体的方法 static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations( Retrofit retrofit, Method method, RequestFactory requestFactory) { boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction; boolean continuationWantsResponse = false; boolean continuationBodyNullable = false; Annotation[] annotations = method.getAnnotations(); //--获取该方法的注解 Type adapterType; if (isKotlinSuspendFunction) { //--这部分时kotlin相关的 Type[] parameterTypes = method.getGenericParameterTypes(); Type responseType = Utils.getParameterLowerBound( 0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]); if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) { // Unwrap the actual body type from Response<T>. responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType); continuationWantsResponse = true; } else { // TODO figure out if type is nullable or not // Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class) // Find the entry for method // Determine if return type is nullable or not } adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType); annotations = SkipCallbackExecutorImpl.ensurePresent(annotations); } else { adapterType = method.getGenericReturnType(); //获取方法的返回类型 } CallAdapter<ResponseT, ReturnT> callAdapter = createCallAdapter(retrofit, method, adapterType, annotations); //这里时选择回调适配器 ,如果添加了rxjava适配器,并且方法返回类型是Observable,那么这里选择的适配器就为rxjava 适配器 Type responseType = callAdapter.responseType(); if (responseType == okhttp3.Response.class) { throw methodError( method, "'" + getRawType(responseType).getName() + "' is not a valid response body type. Did you mean ResponseBody?"); } if (responseType == Response.class) { throw methodError(method, "Response must include generic type (e.g., Response<String>)"); } // TODO support Unit for Kotlin? if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) { throw methodError(method, "HEAD method must use Void as response type."); } Converter<ResponseBody, ResponseT> responseConverter = createResponseConverter(retrofit, method, responseType); //--这里获取响应数据转换器 --如果添加了 json转换器, responseType 为json类型,那么转换器就为json,响应的结果就为自动转换为json格式 okhttp3.Call.Factory callFactory = retrofit.callFactory; if (!isKotlinSuspendFunction) { return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter); //--返回HttpServiceMethod 实体 } else if (continuationWantsResponse) { //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object. return (HttpServiceMethod<ResponseT, ReturnT>) //--返回HttpServiceMethod 实体 new SuspendForResponse<>( requestFactory, callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter); } else { //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object. return (HttpServiceMethod<ResponseT, ReturnT>) //--返回HttpServiceMethod 实体 new SuspendForBody<>( requestFactory, callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter, continuationBodyNullable); } }
- 在动态代理的invoke 方法里面还执行了HttpServiceMethod 中invoke方法
@Override final @Nullable ReturnT invoke(Object[] args) { Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter); //-- 网络请求 return adapt(call, args); //-- 根据回调适配器,执行回调功能(例如rxJava, 这里就会将返回的call 转换为Obsrvable) }
- OkHttpCall 就是okhttp 的网络请求相关的代码
@Override public void enqueue(final Callback<T> callback) { Objects.requireNonNull(callback, "callback == null"); okhttp3.Call call; Throwable failure; synchronized (this) { if (executed) throw new IllegalStateException("Already executed."); executed = true; call = rawCall; failure = creationFailure; if (call == null && failure == null) { try { call = rawCall = createRawCall(); } catch (Throwable t) { throwIfFatal(t); failure = creationFailure = t; } } } if (failure != null) { callback.onFailure(this, failure); return; } if (canceled) { call.cancel(); } call.enqueue( new okhttp3.Callback() { @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) { Response<T> response; try { response = parseResponse(rawResponse); } catch (Throwable e) { throwIfFatal(e); callFailure(e); return; } try { 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 } } }); }
- adapt(call, args)是回调适配器 callAdapter的方法,例如如果回调适配器是RxJava3CallAdapter
@Override public Object adapt(Call<R> call) { Observable<Response<R>> responseObservable = isAsync ? new CallEnqueueObservable<>(call) : new CallExecuteObservable<>(call); //根据是异步 和同步来判断执行哪个方法 Observable<?> observable; if (isResult) { observable = new ResultObservable<>(responseObservable); } else if (isBody) { observable = new BodyObservable<>(responseObservable); } else { observable = responseObservable; } if (scheduler != null) { observable = observable.subscribeOn(scheduler); } if (isFlowable) { return observable.toFlowable(BackpressureStrategy.LATEST); } if (isSingle) { return observable.singleOrError(); } if (isMaybe) { return observable.singleElement(); } if (isCompletable) { return observable.ignoreElements(); } return RxJavaPlugins.onAssembly(observable); }
final class CallEnqueueObservable<T> extends Observable<Response<T>> { private final Call<T> originalCall; CallEnqueueObservable(Call<T> originalCall) { this.originalCall = originalCall; } @Override protected void subscribeActual(Observer<? super Response<T>> observer) { // Since Call is a one-shot type, clone it for each new observer. Call<T> call = originalCall.clone(); CallCallback<T> callback = new CallCallback<>(call, observer); observer.onSubscribe(callback); if (!callback.isDisposed()) { call.enqueue(callback); //执行网络访问 } }
3、关键类说明
1、HttpServiceMethod 类 : 每一个接口方法都一个HttpServiceMethod ,它是接口方法的具体实现。
作用;
1、获取接口的返回类型,参数,回调适配器,转换适配器等等
2、网络数据请求
invoke(Object[] args) 方法执行Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter); 得到call
2、OkHttpCall 类:数据请求 关键方法enqueue()和execute();
3、retrofit 类:网络数据访问调度类,整个框架的起点。
方法 ServiceMethod<?> loadServiceMethod(Method method) —>parseAnnotations()——>解析注解(HttpServiceMethod)
4、其他说明
1、注解 :定义了方法,和网络请求参数 ,
2、动态代理 :得到注解类的代理 ,在代理类里面加载 loadServiceMethod(method)——>得到HttpServiceMethod 并且执行HttpServiceMethod.invoke()方法
3、反射