優雅地調用接口--手把手帶你從0到1實作retrofit架構

retrofit作為http請求的接口架構而被衆人熟知道，它獨特且優雅的接口使用習慣被無數的程式員所認可。 http://square.github.io/retrofit/

介紹

A type-safe HTTP client for Android and Java

Retrofit是一個基于AOP思想，對RestfulApi注解進行動态代理的網絡架構。

public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();


GitHubService service = retrofit.create(GitHubService.class);

我們的JT架構

JTHttpClient
                .create()
                .setSecLevel(JtRequest.NORMAL)
                .url(Urls.index_V)
                .build()
                .post(HomeModule.class)
                .subscribe(new JtSingObserver<HomeModule>(this) {
                    @Override
                    public void onSuccess(HomeModule homeModule) {
                        if (homeModule.header.app_login_status == 0) {
                            JTApi.get().logout();
                        }
                        sHomeModule = homeModule;
                        mHomeModule.setValue(homeModule);

                    }

                    @Override
                    public void onError(Throwable e) {
                        sHomeModule = null;
                        mHomeModule.setValue(null);
                        UIUtil.INSTANCE.showExceptionMsg(e);
                    }
                });

我在深思熟慮中打造的JT架構雖然簡單易用性和性能上其實已經很優秀，但是經過我再一次的深思熟慮覺得依然存在着一些問題。

模闆類代碼太多
泛型傳遞太頻發（兩次）
鍊式的調用過程某種程度意味效率的低下（選擇遺忘的太多）

Retrofit的實作過程

retrofit的主要技術細節包括：

1.接口的執行個體化

2.擷取泛型的傳回值type（資料的解析和執行個體化觀察者需要）

3.擷取Method之後通過反射擷取方法注解和參數注解

我們忽略了一些AOP程式設計的細節，而是主要去關注一個注解方法對象（Method）的解析過程。

retrofit将Method對象解析成對應http request；将request的參數給下層的網絡擴充卡adapter(可以認為是OkhttpAdapter），擴充卡調用自身execute方法，調用成功後通過線程分發器發送到對應的線程。至此，完成了retrofit對網絡的完整的抽象。

retrofit_stay.png

public <T> T create(final Class<T> service) {//函數的入口，執行個體化接口對象
        Utils.validateServiceInterface(service);//檢查service合法性
        if (validateEagerly) {
            eagerlyValidateMethods(service);
        }
        //動态代理執行個體化對象
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] {service},
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object... args)
                            throws Throwable {
                        // If the method is a method from Object then defer to normal invocation.
                        //解析method注解并交給call對象（網絡執行者，預設okhttpclient）
                        // 觸發http請求的方法。invoke會傳回Call對象，調用該對象的方法即可完成網絡請求
                        return loadMethodHandler(method).invoke(args);

                    }
                });
    }

    MethodHandler loadMethodHandler(Method method) {
        MethodHandler handler;
        synchronized(methodHandlerCache) {//檢視靜态緩存區，是否有對應method可用，加快執行的速度
            handler = methodHandlerCache.get(method);
            if (handler == null) {
                //建立MethodHandler對象，
                //該對象用來管理
                // requestFactory請求構造器，
                // callFactory（http執行棧預設OkHttpClient），
                // callAdapter回調擴充卡（用于線程的分發），
                // responseConverter内容轉換器
                // 可以認為一種接口method與http請求過程的媒介
                // new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,responseConverter);

                handler = MethodHandler.create(this, method);
                methodHandlerCache.put(method, handler);
            }
        }
        return handler;
    }

    static MethodHandler create(Retrofit retrofit, Method method) {
        //建立callAdapter， callAdapter是一個可以用來觸發網絡成功或失敗的回調的對象，該方法主要
        // 1.查找目前隊列中可用的callAdapter
        // 2.不管有沒有查找成功都會擷取method傳回值(method.getGenericReturnType())的泛型type
        // 3.驗證合法性
        CallAdapter<?> callAdapter = createCallAdapter(method, retrofit);
        Type responseType = callAdapter.responseType();
        if (responseType == Response.class || responseType == okhttp3.Response.class) {
            throw Utils.methodError(method, "'"
                    + Types.getRawType(responseType).getName()
                    + "' is not a valid response body type. Did you mean ResponseBody?");
        }
        //建立responseConverter，這個方法不關注
        Converter<ResponseBody, ?> responseConverter =
                createResponseConverter(method, retrofit, responseType);
        //解析獲得請求的參數，建立requestFactory，最為核心且最複雜的方法
        //        RequestFactory:
        //        private final String method;
        //        private final BaseUrl baseUrl;
        //        private final String relativeUrl;
        //        private final Headers headers;
        //        private final MediaType contentType;
        //        private final boolean hasBody;
        //        private final boolean isFormEncoded;
        //        private final boolean isMultipart;
        //        private final RequestAction[] requestActions;
        RequestFactory requestFactory = RequestFactoryParser.parse(method, responseType, retrofit);
        return new MethodHandler(retrofit.callFactory(), requestFactory, callAdapter,
                responseConverter);
    }

  
    static RequestFactory parse(Method method, Type responseType, Retrofit retrofit) {
        RequestFactoryParser parser = new RequestFactoryParser(method);

        Annotation[] methodAnnotations = method.getAnnotations();
        //解析method方法的注解annotations[]
        parser.parseMethodAnnotations(responseType, methodAnnotations);
        //解析method參數的注解annotations[][]，此處是二維數組
        parser.parseParameters(retrofit, methodAnnotations);

        return parser.toRequestFactory(retrofit.baseUrl());
    }
//該方法用于通過returnType查找對應的callAdapter并擷取執行個體化的callAdapter對象
    private static CallAdapter<?> createCallAdapter(Method method, Retrofit retrofit) {
        Type returnType = method.getGenericReturnType();
        if (Utils.hasUnresolvableType(returnType)) {
            throw Utils.methodError(method,
                    "Method return type must not include a type variable or wildcard: %s", returnType);
        }
        if (returnType == void.class) {
            throw Utils.methodError(method, "Service methods cannot return void.");
        }
        Annotation[] annotations = method.getAnnotations();
        try {
            return retrofit.callAdapter(returnType, annotations);
        } catch (RuntimeException e) { // Wide exception range because factories are user code.
            throw Utils.methodError(e, method, "Unable to create call adapter for %s", returnType);
        }
    }

JT的實作

主要實作的步驟：

動态代理執行個體化接口對象
在invoke函數中擷取被調用的Method對象
解析并拿到Method中的request參數和傳回值泛型的type

//return type
Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }
//緩存Method的request.builder參數，調用perform方法去注入builder
private List<RequestAction> requestActionList = new ArrayList<>();

通過jtclient發送http請求

5.根據3中的傳回值泛型type解析response

6.最後，通知觀察者，處理所訂閱的事件

apiService = Proxy.newProxyInstance(service.getClassLoader(),
                new Class<?>[] {service},
                new InvocationHandler() {

                    //這個invoke方法會在代理對象的方法中調用，第一個參數就是代理對象
                    //第二個參數是代理對象調用的方法
                    //第三個參數方法的參數
                    @Override
                    public Object invoke(Object proxy, Method method, Object... args)
                            throws Throwable {
                        validateServiceInterface(service);

                        // If the method is a method from Object then defer to normal invocation.
                        if (method.getDeclaringClass() == Object.class) {
                            return method.invoke(this, args);
                        }
                        //調用loadMethodHandler
                        return loadMethodHandler(method).invoke(args);
                    }
                });

Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }






        MethodHandler(Method method) {
            if (JTApi.get().isDebug()) {
                Log.e("MethodHandler", "MethodHandler-method " + method.getName());
            }
            Type returnType = method.getGenericReturnType();
            if (method.getReturnType() == Single.class) {
            } else {
                throw new IllegalArgumentException("you must return a type == Single.class");
            }
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType)
                        .getActualTypeArguments();
                if (actualTypeArguments.length == 1) {
                    mReturnType = actualTypeArguments[0];
                } else {
                    throw new IllegalArgumentException();
                }
            }
            Annotation[] methodAnnotation = method.getAnnotations();
            for (Annotation annotation : methodAnnotation) {
                if (annotation instanceof Url) {
                    mUrl = ((Url) annotation).value();
                } else if (annotation instanceof Security) {
                    security = ((Security) annotation).value();
                }
            }

            Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            if (parameterAnnotations == null || parameterAnnotations.length == 0) {
                return;
            }
            for (Annotation[] annotations : parameterAnnotations) {
                if (annotations != null && annotations.length != 0) {
                    for (Annotation aMethodAnnotation : annotations) {
                        if (aMethodAnnotation instanceof Field) {
                            Field field = (Field) aMethodAnnotation;
                            requestActionList.add(new FieldRequestAction(field.value()));
                            break;

                        } else if (aMethodAnnotation instanceof FieldMap) {
                            requestActionList.add(new FieldMapRequestAction());
                        } else if (aMethodAnnotation instanceof Path) {
                            Path path = (Path) aMethodAnnotation;
                            requestActionList.add(new PathRequestAction(path.value()));
                        }
                    }
                }
            }
        }
        public Object invoke(Object... objects) {
            JtRequest.Builder builder = JTHttpClient.create().url(mUrl);
            if (objects != null && objects.length > 0) {
                if (objects.length != requestActionList.size()) {
                    throw new NullPointerException("url: " + mUrl + "\nrequestActionList length is "
                            + "not equals objects length");
                }
                for (int i = 0; i < requestActionList.size(); i++) {
                    requestActionList.get(i).perform(builder, objects[i]);
                }
            }

            return builder.setSecLevel(security).build().post(mReturnType);

        }

//execute
builder.setSecLevel(security).build().post(mReturnType);

優雅地調用接口--手把手帶你從0到1實作retrofit架構

介紹

我們的JT架構

Retrofit的實作過程

JT的實作

繼續閱讀

nginx location中斜線的位置的重要性

Android電視機（機頂盒）初次開發的一些經驗分享

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method