retrofit系列-ServiceMethod创建流程

讨厌所有昵称是海洋精灵的

于 2024-01-04 18:29:48 发布

阅读量879

点赞数 20

分类专栏： retrofit 文章标签： retrofit

本文链接：https://blog.csdn.net/lostfish123/article/details/135299187

版权

retrofit 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.使用retrofit的例子

创建一个interface RetrofitServiceApi

public interface RetrofitServiceApi {
    @POST("/user/get/userinfo")
    Call<BaseResponse<UserInfoResponse>> requestUserInfo(@Query("token") String token);
}

调用Retrofit的create方法来创建 RetrofitServiceApi对象后，调用requestUserInfo方法

//调用RetrofitServiceApi的requestUserInfo方法

public Call<BaseResponse<UserInfoResponse>> requestUserInfo(String token) {
    return mRetrofit.create(RetrofitServiceApi.class).requestUserInfo(token);
}

2.Retrofit.create

调用Proxy.nexProxyInstance创建动态代理对象
调用参数的service的方法的时候，会触发invoke方法的执行

//retrofit\src\main\java\retrofit2\Retrofit.java

public final class Retrofit {

    public <T> T create(final Class<T> service) {
        validateServiceInterface(service); //判断是不是接口，不是的话就抛出异常

        return (T)
            Proxy.newProxyInstance(
                service.getClassLoader(),
                new Class<?>[] {service},
                new InvocationHandler() {
                    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.
                        //获取声明该方法的类的 Class 对象
                        if (method.getDeclaringClass() == Object.class) {
                            return method.invoke(this, args);
                        }
                        args = args != null ? args : emptyArgs;
                        Platform platform = Platform.get();
                        return platform.isDefaultMethod(method)
                             ? platform.invokeDefaultMethod(method, service, proxy, args)
                             : loadServiceMethod(method).invoke(args);
                    }
            });
    }
}

3.Retrofit.loadServiceMethod

先从缓存里获取ServiceMethod

找到，返回结果；

没找到，调用ServiceMethod.parseAnnotations创建ServiceMethod后，放入缓存，返回结果；

public final class Retrofit {
    private final Map<Method, ServiceMethod<?>> serviceMethodCache = new 
                ConcurrentHashMap<>();    

    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); //生成ServiceMethod
                serviceMethodCache.put(method, result);//放入方法缓存
            }
        }
        return result;
    }
}

4.ServiceMethod.parseAnnotations 创建ServiceMethod

//retrofit\src\main\java\retrofit2\ServiceMethod.java

abstract class ServiceMethod<T> {
    static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
        //4.1
        RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

        //省略部分代码

        //4.2
        return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
    }
}

4.1.RequestFactory.parseAnnotations

//retrofit\src\main\java\retrofit2\RequestFactory.java

final class RequestFactory {
    //所以一个Method对应一个RequestFactory
    static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
        return new Builder(retrofit, method).build();
    }
}

4.1.1.new Builder

//retrofit\src\main\java\retrofit2\RequestFactory.java

final class RequestFactory {
    
    static final class Builder {
        final Annotation[] methodAnnotations;
        final Annotation[][] parameterAnnotationsArray;

        Builder(Retrofit retrofit, Method method) {
            this.retrofit = retrofit;
            this.method = method;
            this.methodAnnotations = method.getAnnotations();
            this.parameterTypes = method.getGenericParameterTypes();
            this.parameterAnnotationsArray = method.getParameterAnnotations();
        }
    }
}

4.1.2.build

//retrofit\src\main\java\retrofit2\RequestFactory.java

final class RequestFactory {
    
    static final class Builder {

        RequestFactory build() {
            for (Annotation annotation : methodAnnotations) {
                parseMethodAnnotation(annotation); //4.1.2.1
            }

            //省略部分代码

            return new RequestFactory(this);
        }
    }
}

4.1.2.1.parseMethodAnnotation

根据annotation来确定调用parseHttpMethodAndPath方法时各个参数的值

//retrofit\src\main\java\retrofit2\RequestFactory.java
final class RequestFactory {
    static final class Builder {
        private void parseMethodAnnotation(Annotation annotation) {
            //省略部分代码
            if (annotation instanceof POST) {
                parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
            }
        }
    }
}

//retrofit\src\main\java\retrofit2\RequestFactory.java
final class RequestFactory {

    static final class Builder {
        @Nullable String httpMethod;
        boolean hasBody;
        @Nullable String relativeUrl;
        @Nullable Set<String> relativeUrlParamNames;

        private void parseHttpMethodAndPath(String httpMethod, String value, boolean 
            hasBody){
            this.httpMethod = httpMethod;
            this.hasBody = hasBody;

            if (value.isEmpty()) { //上面例子的value是""
                return;
            }

            //如果不是""，会继续解析URL参数
            this.relativeUrl = value;
            this.relativeUrlParamNames = parsePathParameters(value);
        }

        static Set<String> parsePathParameters(String path) {
            Matcher m = PARAM_URL_REGEX.matcher(path);
            Set<String> patterns = new LinkedHashSet<>();
            while (m.find()) {
                patterns.add(m.group(1));
            }
            return patterns;
        }
    }
}

4.2.HttpServiceMethod.parseAnnotations

abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
    static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
        //1.创建CallAdapter
        CallAdapter<ResponseT, ReturnT> callAdapter =
            createCallAdapter(retrofit, method, adapterType, annotations);
        //2.创建Converter
        Converter<ResponseBody, ResponseT> responseConverter =
            createResponseConverter(retrofit, method, responseType);

        okhttp3.Call.Factory callFactory = retrofit.callFactory;

        //创建HttpServiceMethod
        if (!isKotlinSuspendFunction) {
            return new CallAdapted<>(requestFactory, callFactory, responseConverter, 
                 callAdapter);
        } else if (continuationWantsResponse) {
            //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
            return (HttpServiceMethod<ResponseT, ReturnT>)
                new SuspendForResponse<>(
                    requestFactory,
                    callFactory,
                    responseConverter,
                    (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
        } else {
            //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
            return (HttpServiceMethod<ResponseT, ReturnT>)
                new SuspendForBody<>(
                    requestFactory,
                    callFactory,
                    responseConverter,
                    (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
                    continuationBodyNullable,
                    continuationIsUnit);
        }
    }
}