Android 組件化最佳實踐 ARetrofit 原理

時間 2019-11-06

標籤 android 組件最佳實踐 aretrofit 原理欄目 Android 简体版

原文原文鏈接

本文首發於 vivo互聯網技術微信公衆號 mp.weixin.qq.com/s/TXFt7ymgQ…
做者：朱壹飛java

ARetrofit 是一款針對Android組件之間通訊的路由框架，實現快速組件化開發的利器。本文主要講述 ARetrofit 實現的原理。android

簡介

ARetrofit 是一款針對Android組件之間通訊的路由框架，實現快速組件化開發的利器。git

源碼連接：github

github.com/yifei8/ARet…

組件化架構 APP Demo, ARetrofit 使用實例：編程

github.com/yifei8/Happ…

組件化

Android組件化已經不是一個新鮮的概念了，出來了已經有很長一段時間了，你們能夠自行Google，能夠看到一堆相關的文章。設計模式

簡單的來講，所謂的組件就是Android Studio中的Module，每個Module都遵循高內聚的原則，經過ARetrofit 來實現無耦合的代碼結構，以下圖：api

每個 Module 可單獨做爲一個 project 運行，而打包到總體時 Module 之間的通訊經過 ARetrofit 完成。bash

ARetrofit 原理

講原理以前，我想先說說爲何要ARetrofit。開發ARetrofit 這個項目的思路來源實際上是 Retrofit，Retrofit 是Square公司開發的一款針對 Android 網絡請求的框架，這裏不對Retrofit展開來說。主要是 Retrofit 框架使用很是多的設計模式，能夠說 Retrofit 這個開源項目將Java的設計模式運用到了極致，固然最終提供的API也是很是簡潔的。如此簡潔的API，使得咱們APP中的網絡模塊實現變得很是輕鬆，而且維護起來也很舒服。所以我以爲有必要將Android組件之間的通訊也變得輕鬆，使用者能夠優雅的經過簡潔的API就能夠實現通訊，更重要的是維護起來也很是的舒服。微信

ARetrofit 基本原理能夠簡化爲下圖所示：網絡

1.經過註解聲明須要通訊的Activity／Fragment或者Class

2.每個module經過annotationProcessor在編譯時生成待注入的RouteInject的實現類和AInterceptorInject的實現類。

這一步在執行app[build]時會輸出日誌，能夠直觀的看到，以下圖所示：

注: AInjecton::Compiler >>> Apt interceptor Processor start... <<<
注: AInjecton::Compiler enclosindClass = null
注: AInjecton::Compiler value = 3
注: AInjecton::Compiler auto generate class = com$$sjtu$$yifei$$eCGVmTMvXG$$AInterceptorInject
注: AInjecton::Compiler add path= 3 and class= LoginInterceptor
....
注: AInjecton::Compiler >>> Apt route Processor start... <<<
注: AInjecton::Compiler enclosindClass = null
注: AInjecton::Compiler value = /login-module/ILoginProviderImpl
注: AInjecton::Compiler enclosindClass = null
注: AInjecton::Compiler value = /login-module/LoginActivity
注: AInjecton::Compiler enclosindClass = null
注: AInjecton::Compiler value = /login-module/Test2Activity
注: AInjecton::Compiler enclosindClass = null
注: AInjecton::Compiler value = /login-module/TestFragment
注: AInjecton::Compiler auto generate class = com$$sjtu$$yifei$$VWpdxWEuUx$$RouteInject
注: AInjecton::Compiler add path= /login-module/TestFragment and class= null
注: AInjecton::Compiler add path= /login-module/LoginActivity and class= null
注: AInjecton::Compiler add path= /login-module/Test2Activity and class= null
注: AInjecton::Compiler add path= /login-module/ILoginProviderImpl and class= null
注: AInjecton::Compiler >>> Apt route Processor succeed <<<

複製代碼

3.將編譯時生成的類注入到RouterRegister中，這個類主要用於維護路由表和攔截器，對應的[build]日誌以下：

TransformPluginLaunch >>> ========== Transform scan start ===========
TransformPluginLaunch >>> ========== Transform scan end cost 0.238 secs and start inserting ===========
TransformPluginLaunch >>> Inserting code to jar >> /Users/yifei/as_workspace/ARetrofit/app/build/intermediates/transforms/TransformPluginLaunch/release/8.jar
TransformPluginLaunch >>> to class >> com/sjtu/yifei/route/RouteRegister.class
InjectClassVisitor >>> inject to class:
InjectClassVisitor >>> com/sjtu/yifei/route/RouteRegister{
InjectClassVisitor >>>        public *** init() {
InjectClassVisitor >>>            register("com.sjtu.yifei.FBQWNfbTpY.com$$sjtu$$yifei$$FBQWNfbTpY$$RouteInject")
InjectClassVisitor >>>            register("com.sjtu.yifei.klBxerzbYV.com$$sjtu$$yifei$$klBxerzbYV$$RouteInject")
InjectClassVisitor >>>            register("com.sjtu.yifei.JmhcMMUhkR.com$$sjtu$$yifei$$JmhcMMUhkR$$RouteInject")
InjectClassVisitor >>>            register("com.sjtu.yifei.fpyxYyTCRm.com$$sjtu$$yifei$$fpyxYyTCRm$$AInterceptorInject")
InjectClassVisitor >>>        }
InjectClassVisitor >>> }
TransformPluginLaunch >>> ========== Transform insert cost 0.017 secs end ===========

複製代碼

4.Routerfit.register(Class<T> service) 這一步主要是經過動態代理模式實現接口中聲明的服務。

前面講的是總體的框架設計思想，便於讀者從全局的以爲來理解ARetrofit的框架的架構。接下來，將待你們個個擊破上面提到的annotationProcessor、 transform在項目中如何使用，以及動態代理、攔截器功能的實現等細節。

1、annotationProcessor生成代碼

annotationProcessor(註解處理器)是javac內置的一個用於編譯時掃描和處理註解(Annotation)的工具。簡單的說，在源代碼編譯階段，經過註解處理器，咱們能夠獲取源文件內註解(Annotation)相關內容。Android Gradle 2.2 及以上版本提供annotationProcessor的插件。

在ARetrofit中annotationProcessor對應的module是auto-complier，在使用annotationProcessor以前首先須要聲明好註解。關於註解不太瞭解或者遺忘的同窗可直接參考我以前寫的Java註解這篇文章，本項目中聲明的註解在auto-annotation這個module中，主要有：

@Extra 路由參數
@Flags intent flags
@Go 路由路徑key
@Interceptor 聲明自定義攔截器
@RequestCode 路由參數
@Route路由
@Uri
@IMethod 用於標記註冊代碼將插入到此方法中(transform中使用)
@Inject 用於標記須要被注入類，最近都將插入到標記了#com.sjtu.yifei.annotation.IMethod的方法中(transform中使用)

建立自定義的註解處理器，具體使用方法可參考利用註解動態生成代碼，本項目中的註解處理器以下所示：

//這是用來註冊註解處理器要處理的源代碼版本。
@SupportedSourceVersion(SourceVersion.RELEASE_8)
//這個註解用來註冊註解處理器要處理的註解類型。有效值爲徹底限定名（就是帶所在包名和路徑的類全名
@SupportedAnnotationTypes({ANNOTATION_ROUTE, ANNOTATION_GO})
//來註解這個處理器，能夠自動生成配置信息
@AutoService(Processor.class)
public class IProcessor extends AbstractProcessor {
     
}

複製代碼

生成代碼的關鍵部分在GenerateAInterceptorInjectImpl 和 GenerateRouteInjectImpl中，如下貼出關鍵代碼：

public void generateAInterceptorInjectImpl(String pkName) {
        try {
            String name = pkName.replace(".",DECOLLATOR) + SUFFIX;
            logger.info(String.format("auto generate class = %s", name));
            TypeSpec.Builder builder = TypeSpec.classBuilder(name)
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Inject.class)
                    .addSuperinterface(AInterceptorInject.class);
 
            ClassName hashMap = ClassName.get("java.util", "HashMap");
 
            //Map<String, Class<?>>
            TypeName wildcard = WildcardTypeName.subtypeOf(Object.class);
            TypeName classOfAny = ParameterizedTypeName.get(ClassName.get(Class.class), wildcard);
            TypeName string = ClassName.get(Integer.class);
 
            TypeName map = ParameterizedTypeName.get(ClassName.get(Map.class), string, classOfAny);
 
            MethodSpec.Builder injectBuilder = MethodSpec.methodBuilder("getAInterceptors")
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Override.class)
                    .returns(map)
                    .addStatement("$T interceptorMap = new $T<>()", map, hashMap);
 
            for (Map.Entry<Integer, ClassName> entry : interceptorMap.entrySet()) {
                logger.info("add path= " + entry.getKey() + " and class= " + entry.getValue().simpleName());
                injectBuilder.addStatement("interceptorMap.put($L, $T.class)", entry.getKey(), entry.getValue());
            }
            injectBuilder.addStatement("return interceptorMap");
 
            builder.addMethod(injectBuilder.build());
 
            JavaFile javaFile = JavaFile.builder(pkName, builder.build())
                    .build();
            javaFile.writeTo(filer);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }
 
public void generateRouteInjectImpl(String pkName) {
        try {
            String name = pkName.replace(".",DECOLLATOR) + SUFFIX;
            logger.info(String.format("auto generate class = %s", name));
            TypeSpec.Builder builder = TypeSpec.classBuilder(name)
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Inject.class)
                    .addSuperinterface(RouteInject.class);
 
            ClassName hashMap = ClassName.get("java.util", "HashMap");
 
            //Map<String, String>
            TypeName wildcard = WildcardTypeName.subtypeOf(Object.class);
            TypeName classOfAny = ParameterizedTypeName.get(ClassName.get(Class.class), wildcard);
            TypeName string = ClassName.get(String.class);
 
            TypeName map = ParameterizedTypeName.get(ClassName.get(Map.class), string, classOfAny);
 
            MethodSpec.Builder injectBuilder = MethodSpec.methodBuilder("getRouteMap")
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Override.class)
                    .returns(map)
                    .addStatement("$T routMap = new $T<>()", map, hashMap);
 
            for (Map.Entry<String, ClassName> entry : routMap.entrySet()) {
                logger.info("add path= " + entry.getKey() + " and class= " + entry.getValue().enclosingClassName());
                injectBuilder.addStatement("routMap.put($S, $T.class)", entry.getKey(), entry.getValue());
            }
            injectBuilder.addStatement("return routMap");
 
            builder.addMethod(injectBuilder.build());
 
            JavaFile javaFile = JavaFile.builder(pkName, builder.build())
                    .build();
            javaFile.writeTo(filer);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }

複製代碼

2、Transform

Android Gradle 工具在 1.5.0 版本後提供了 Transfrom API, 容許第三方 Plugin在打包dex文件以前的編譯過程當中操做 .class 文件。這一部分面向高級Android工程師的，面向字節碼編程，普通工程師可不作了解。

寫到這裏也許有人會有這樣一個疑問，既然annotationProcessor這麼好用爲何還有Transform面向字節碼注入呢？這裏須要解釋如下，annotationProcessor具備侷限性，annotationProcessor只能掃描當前module下的代碼，且對於第三方的jar、aar文件都掃描不到。而Transform就沒有這樣的侷限性，在打包dex文件以前的編譯過程當中操做.class 文件。

關於Transfrom API在Android Studio中如何使用能夠參考Transform API — a real world example，順便提供一下字節碼指令方便咱們讀懂ASM。

本項目中的Transform插件在AInject中，實現源碼TransformPluginLaunch以下，貼出關鍵部分：

/**
 *
 * 標準transform的格式，通常實現transform能夠直接拷貝一份重命名便可
 *
 * 兩處todo實現本身的字節碼加強／優化操做
 */
class TransformPluginLaunch extends Transform implements Plugin<Project> {
 
    @Override
    void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation)
  
        //todo step1: 先掃描
        transformInvocation.inputs.each {
            TransformInput input ->
                input.jarInputs.each { JarInput jarInput ->
                   ...
                }
 
                input.directoryInputs.each { DirectoryInput directoryInput ->
                    //處理完輸入文件以後，要把輸出給下一個任務
                  ...
                }
        }
        
        //todo step2: ...完成代碼注入
        if (InjectInfo.get().injectToClass != null) {
          ...
        }
   
    }
 
    /**
     * 掃描jar包
     * @param jarFile
     */
    static void scanJar(File jarFile, File destFile) {
         
    }
 
    /**
     * 掃描文件
     * @param file
     */
    static void scanFile(File file, File dest) {
       ...
    }
}

複製代碼

注入代碼通常分爲兩個步驟：

第一步：掃描
這一部分主要是掃描的內容有：
注入類和方法的信息，是AutoRegisterContract的實現類和其中@IMethod，@Inject的方法。
待注入類的和方法信息，是RouteInject 和 AInterceptorInject實現類且被@Inject註解的。
第二步：注入
以上掃描的結果，將待注入類注入到注入類的過程。這一過程面向ASM操做，可參考字節碼指令來讀懂如下的關鍵注入代碼：

class InjectClassVisitor extends ClassVisitor {
...
    class InjectMethodAdapter extends MethodVisitor {
 
        InjectMethodAdapter(MethodVisitor mv) {
            super(Opcodes.ASM5, mv)
        }
 
        @Override
        void visitInsn(int opcode) {
            Log.e(TAG, "inject to class:")
            Log.e(TAG, own + "{")
            Log.e(TAG, " public *** " + InjectInfo.get().injectToMethodName + "() {")
            if (opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) {
                InjectInfo.get().injectClasses.each { injectClass ->
                    injectClass = injectClass.replace('/', '.')
                    Log.e(TAG, " " + method + "(\"" + injectClass + "\")")
                    mv.visitVarInsn(Opcodes.ALOAD, 0)
                    mv.visitLdcInsn(injectClass)
                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, own, method, "(Ljava/lang/String;)V", false)
                }
            }
            Log.e(TAG, " }")
            Log.e(TAG, "}")
            super.visitInsn(opcode)
        }
...
    }
...
}


複製代碼

3、動態代理

定義：爲其它對象提供一種代理以控制對這個對象的訪問控制；在某些狀況下，客戶不想或者不能直接引用另外一個對象，這時候代理對象能夠在客戶端和目標對象之間起到中介的做用。

Routerfit.register(Class<T> service) 這裏就是採用動態代理的模式，使得ARetrofit的API很是簡潔，使用者能夠優雅定義出路由接口。關於動態代理的學習難度相對來講還比較小，想了解的同窗能夠參考這篇文章java動態代理。

本項目相關源碼：

public final class Routerfit {
...
      private <T> T create(final Class<T> service) {
        RouterUtil.validateServiceInterface(service);
        return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service}, new InvocationHandler() {
            @Override
            public 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);
                }
                ServiceMethod<Object> serviceMethod = (ServiceMethod<Object>) loadServiceMethod(method, args);
                if (!TextUtils.isEmpty(serviceMethod.uristring)) {
                    Call<T> call = (Call<T>) new ActivityCall(serviceMethod);
                    return call.execute();
                }
                try {
                    if (serviceMethod.clazz == null) {
                        throw new RouteNotFoundException("There is no route match the path \"" + serviceMethod.routerPath + "\"");
                    }
                } catch (RouteNotFoundException e) {
                    Toast.makeText(ActivityLifecycleMonitor.getApp(), e.getMessage(), Toast.LENGTH_SHORT).show();
                    e.printStackTrace();
                }
                if (RouterUtil.isSpecificClass(serviceMethod.clazz, Activity.class)) {
                    Call<T> call = (Call<T>) new ActivityCall(serviceMethod);
                    return call.execute();
                } else if (RouterUtil.isSpecificClass(serviceMethod.clazz, Fragment.class)
                        || RouterUtil.isSpecificClass(serviceMethod.clazz, android.app.Fragment.class)) {
                    Call<T> call = new FragmentCall(serviceMethod);
                    return call.execute();
                } else if (serviceMethod.clazz != null) {
                    Call<T> call = new IProviderCall<>(serviceMethod);
                    return call.execute();
                }
 
                if (serviceMethod.returnType != null) {
                    if (serviceMethod.returnType == Integer.TYPE) {
                        return -1;
                    } else if (serviceMethod.returnType == Boolean.TYPE) {
                        return false;
                    } else if (serviceMethod.returnType == Long.TYPE) {
                        return 0L;
                    } else if (serviceMethod.returnType == Double.TYPE) {
                        return 0.0d;
                    } else if (serviceMethod.returnType == Float.TYPE) {
                        return 0.0f;
                    } else if (serviceMethod.returnType == Void.TYPE) {
                        return null;
                    } else if (serviceMethod.returnType == Byte.TYPE) {
                        return (byte)0;
                    } else if (serviceMethod.returnType == Short.TYPE) {
                        return (short)0;
                    } else if (serviceMethod.returnType == Character.TYPE) {
                        return null;
                    }
                }
                return null;
            }
        });
    }
...
}

複製代碼

這裏ServiceMethod是一個很是重要的類，使用了外觀模式，主要用於解析方法中的被註解全部信息並保存起來。

4、攔截器鏈實現

本項目中的攔截器鏈設計，使得使用者能夠很是優雅的處理業務邏輯。以下：

@Interceptor(priority = 3)
public class LoginInterceptor implements AInterceptor {
 
    private static final String TAG = "LoginInterceptor";
    @Override
    public void intercept(final Chain chain) {
        //Test2Activity 須要登陸
        if ("/login-module/Test2Activity".equalsIgnoreCase(chain.path())) {
            Routerfit.register(RouteService.class).launchLoginActivity(new ActivityCallback() {
                @Override
                public void onActivityResult(int i, Object data) {
                    if (i == Routerfit.RESULT_OK) {//登陸成功後繼續執行
                        Toast.makeText(ActivityLifecycleMonitor.getTopActivityOrApp(), "登陸成功", Toast.LENGTH_LONG).show();
                        chain.proceed();
                    } else {
                        Toast.makeText(ActivityLifecycleMonitor.getTopActivityOrApp(), "登陸取消/失敗", Toast.LENGTH_LONG).show();
                    }
                }
            });
        } else {
            chain.proceed();
        }
    }
 
}


複製代碼