前言

这一篇我们来具体看一下ARouter的实现原理，如果你之前没有接触过ARouter，可以先阅读上一篇：
Android：从零开始打造自己的深度链接库（一）：ARouter简介
废话不多，我们赶紧分析源码。

正文

首先我们从github下载最新的源码：

被选中的三个Module是我们今天分析的重点：

arouter-annotation

从名称看我们可以猜到这是自定义注解的库，我们就直接截个图：

我们看到了之前使用过的@Router，@Autowired，@Interceptor，这个库就直接略过。

arouter-compiler

我们先思考一个问题：

为什么通过注解，我们就可以跳转到指定的页面呢，ARouter是怎么做到的？

如果你之前看过EventBus，或者LitePal的源码，这一篇对于你来说就是小case。因为核心的原理都是一样的。

@AutoService(Processor.class)@SupportedOptions(KEY_MODULE_NAME)@SupportedSourceVersion(SourceVersion.RELEASE_7)@SupportedAnnotationTypes({ANNOTATION_TYPE_AUTOWIRED})public class AutowiredProcessor extends AbstractProcessor

要想编译时处理注解，需要实现对应的AbstractProcessor，并使用@AutoService(Processor.class)注解，这样在编译时，这个注解解析器就会被执行，我们可以在编译时生成源文件来保存必要的信息，这样做的好处是，把注解解析的成本放在编译期间，从而节省了运行时的时间，对于用户来说，这样的体验是值得推荐的。

我们以AutowiredProcessor为例，分析一下编译期间ARouter到底做了哪些工作：

@Overridepublic boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {        if (CollectionUtils.isNotEmpty(set)) {            try {                logger.info(">>> Found autowired field, start... <<<");                // 取出Autowired.class                categories(roundEnvironment.getElementsAnnotatedWith(Autowired.class));                // 生成帮助文件                generateHelper();            } catch (Exception e) {                logger.error(e);            }            // 注解处理完毕返回true            return true;        }        return false;    }

直接的解析工作需要重写process方法，从所有的注解中取出需要解析的注解集合，先看看这个categories（）方法做了哪些处理：

private void categories(Set<? extends Element> elements) throws IllegalAccessException {// 判断使用了Autowired注解是否为空        if (CollectionUtils.isNotEmpty(elements)) {            for (Element element : elements) {            // 得到被注解的元素的父级元素            // 例如被注解的是一个属性，那么得到的就是这个类                TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();// 被注解的元素不可以被private修饰                if (element.getModifiers().contains(Modifier.PRIVATE)) {                    throw new IllegalAccessException("The inject fields CAN NOT BE 'private'!!! please check field ["                            + element.getSimpleName() + "] in class [" + enclosingElement.getQualifiedName() + "]");                }// 因为编译解析器，可能被调用多次，所以这里使用一个键值对组合保存了之前解析过的信息，提高执行效率// 如果已经解析过了，找到之前的key，直接添加到集合中                if (parentAndChild.containsKey(enclosingElement)) { // Has categries                    parentAndChild.get(enclosingElement).add(element);                }                // 没有解析过，保存到集合中 else {                    List childs = new ArrayList<>();                    childs.add(element);                    parentAndChild.put(enclosingElement, childs);                }            }            logger.info("categories finished.");        }    }

上面的代码注释已经写的很详细了，这里我们了解到了新的信息：

@Autowired不能修饰private属性！！！

接下来我们分析一下generateHelper（）方法，因为代码比较多，所以我把几个核心的地方单独分析，刚才我们已经把每一个元素和对应的@AutoWired注解都保存了起来，那肯定是要遍历就这个集合了：

for (Map.Entry> entry : parentAndChild.entrySet()) {                // 创建inject方法                MethodSpec.Builder injectMethodBuilder = MethodSpec.methodBuilder(METHOD_INJECT)                        .addAnnotation(Override.class)                        .addModifiers(PUBLIC)                        .addParameter(objectParamSpec);                // 使用了注解的类                TypeElement parent = entry.getKey();                // 被注解修饰的元素                List childs = entry.getValue();                // 类名                String qualifiedName = parent.getQualifiedName().toString();                // 包名                String packageName = qualifiedName.substring(0, qualifiedName.lastIndexOf("."));                // 要生成的源文件的名称                String fileName = parent.getSimpleName() + NAME_OF_AUTOWIRED;                // 对源文件添加public修饰符，添加要实现的接口，和注释                TypeSpec.Builder helper = TypeSpec.classBuilder(fileName)                        .addJavadoc(WARNING_TIPS)                        .addSuperinterface(ClassName.get(type_ISyringe))                        .addModifiers(PUBLIC);                // 添加一个私有的serializationService属性                FieldSpec jsonServiceField = FieldSpec.builder(TypeName.get(type_JsonService.asType()), "serializationService", Modifier.PRIVATE).build();                helper.addField(jsonServiceField);                // 为刚才创建的inject方法添加代码                // serializationService = ARouter.getInstance().navigation(SerializationService.class)                injectMethodBuilder.addStatement("serializationService = $T.getInstance().navigation($T.class)", ARouterClass, ClassName.get(type_JsonService));                // ClassName.get(parent)类名                injectMethodBuilder.addStatement("$T substitute = ($T)target", ClassName.get(parent), ClassName.get(parent));// 遍历被注解修饰的元素列表// 此处先省略                 for (Element element : childs) {                 ...                }                // 源文件添加方法                helper.addMethod(injectMethodBuilder.build());                // 生成源文件                JavaFile.builder(packageName, helper.build()).build().writeTo(mFiler);            }

果然这里要开始生成源文件了，首先定义了要生成的文件的名称和位置（包名），然后创建一个public的inject方法，此处添加了一个SerializationService服务，这个服务是序列化的服务，我们可以先忽略。

然后就压开始遍历被@Autowired注解的元素集合了：

Autowired fieldConfig = element.getAnnotation(Autowired.class);// 被注解的属性的名称String fieldName = element.getSimpleName().toString();// 如果这是一个IProvide的子类if (types.isSubtype(element.asType(), iProvider)) { // 如果在注解中特别指定了名称if ("".equals(fieldConfig.name())) {    // User has not set service path, then use byType.// 在inject方法中使用属性名，获取属性对应的实例   injectMethodBuilder.addStatement(              "substitute." + fieldName + " = $T.getInstance().navigation($T.class)",              ARouterClass,              ClassName.get(element.asType())         );      } else {              // 使用注解中的名称找到对应的实例          injectMethodBuilder.addStatement(                "substitute." + fieldName + " = ($T)$T.getInstance().build($S).navigation()",                          ClassName.get(element.asType()),                           ARouterClass,                           fieldConfig.name()           );       }       // 判断该属性是否是必须，如果没有找到可以实例化的对象，注解抛出错误       if (fieldConfig.required()) {             injectMethodBuilder.beginControlFlow("if (substitute." + fieldName + " == null)");             injectMethodBuilder.addStatement(                                    "throw new RuntimeException(\"The field '" + fieldName + "' is null, in class '\" + $T.class.getName() + \"!\")", ClassName.get(parent));              injectMethodBuilder.endControlFlow();        }} else{...}

首先判断被@Autowired注解的属性是否是一个IProvider接口，IProvider接口表示一个对外开放的服务，不同Module可以通过IProvider得到对应的服务，这样不同Module之间就可以进行通信。

String originalValue = "substitute." + fieldName;String statement = "substitute." + fieldName + " = " + buildCastCode(element) + "substitute.";boolean isActivity = false;// 是否是Activity的子类if (types.isSubtype(parent.asType(), activityTm)) {  // Activity, then use getIntent()       isActivity = true;       // 可以看Activity要通过intent进行属性的初始化       statement += "getIntent().";} // 是否是Frament的子类else if (types.isSubtype(parent.asType(), fragmentTm) || types.isSubtype(parent.asType(), fragmentTmV4)) {   // Fragment, then use getArguments()        // 可以看Activity要通过getArguments进行属性的初始化        statement += "getArguments().";} // 从此判断可以看出，@Autowired注解的类型只有IProvder，Activity和Fragmentelse {          throw new IllegalAccessException("The field [" + fieldName + "] need autowired from intent, its parent must be activity or fragment!");}                        // 根据对应的类型，找到需要的类型// 例如getInt（），getBoolean()statement = buildStatement(originalValue, statement, typeUtils.typeExchange(element), isActivity);// 如果是一个对象，我们要对应serializationService来实现初始化if (statement.startsWith("serializationService.")) {   // Not mortals      injectMethodBuilder.beginControlFlow("if (null != serializationService)");      injectMethodBuilder.addStatement(                 "substitute." + fieldName + " = " + statement,                  (StringUtils.isEmpty(fieldConfig.name()) ? fieldName : fieldConfig.name()),                                    ClassName.get(element.asType())       );      injectMethodBuilder.nextControlFlow("else");      injectMethodBuilder.addStatement(               "$T.e(\"" + Consts.TAG + "\", \"You want automatic inject the field '" + fieldName + "' in class '$T' , then you should implement 'SerializationService' to support object auto inject!\")", AndroidLog, ClassName.get(parent));       injectMethodBuilder.endControlFlow();} else {       njectMethodBuilder.addStatement(statement, StringUtils.isEmpty(fieldConfig.name()) ? fieldName : fieldConfig.name());}// 非空检查if (fieldConfig.required() && !element.asType().getKind().isPrimitive()) {  // Primitive wont be check.       injectMethodBuilder.beginControlFlow("if (null == substitute." + fieldName + ")");       injectMethodBuilder.addStatement(               "$T.e(\"" + Consts.TAG + "\", \"The field '" + fieldName + "' is null, in class '\" + $T.class.getName() + \"!\")", AndroidLog, ClassName.get(parent));       injectMethodBuilder.endControlFlow();}

上面的代码解析是IProvider以外的情况，通过分析我们又学到了新的知识：

@Autowired只能直接IProvider对象，或者是Activity和Fragment中使用！！！

并且知道Activity和Fragment的中的属性是通过intent和arguments来初始化的，我们已经完整的分析了整个@Autowired直接的解析过程，但是仍然有些懵逼，因为是源文件是通过代码写入的，所以最直观的方法就是看看源文件到底生成了什么。

首先看IProvider：

// 测试服务，其中HelloService实现了IProvider接口public class TestService {    @Autowired    public HelloService helloService;    public TestService(){        ARouter.getInstance().inject(this);    }}// 以下是生成的源文件/** * DO NOT EDIT THIS FILE!!! IT WAS GENERATED BY AROUTER. */public class TestService$$ARouter$$Autowired implements ISyringe {  private SerializationService serializationService;  @Override  public void inject(Object target) {    serializationService = ARouter.getInstance().navigation(SerializationService.class);    TestService substitute = (TestService)target;    substitute.helloService = ARouter.getInstance().navigation(HelloService.class);  }}

Activity：

@Route(path = "/main/TestActivity", extras = 1)public class TestActivity extends AppCompatActivity {    @Autowired    String name;    @Autowired    int age;    @Autowired    TestBean testBean;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_test);        ARouter.getInstance().inject(this);    }}// 生成文件代码public class TestActivity$$ARouter$$Autowired implements ISyringe {  private SerializationService serializationService;  @Override  public void inject(Object target) {    serializationService = ARouter.getInstance().navigation(SerializationService.class);    TestActivity substitute = (TestActivity)target;    substitute.name = substitute.getIntent().getStringExtra("name");    substitute.age = substitute.getIntent().getIntExtra("age", substitute.age);    substitute.testBean = (com.lzp.arouter.activity.bean.TestBean) substitute.getIntent().getSerializableExtra("testBean");  }}

@Autowired注解已经分析完毕，通过同样的道理，我们还可以自行查看RouteProcessor，InterceptorProcessor的内容，最终都是生成了各种源文件保存注解中的信息，这里就不具体分析了。

arouter-api

这个就是ARouter的核心库了，通过刚才分析编译库的内容，我们可以很轻松的知道@Autowired的执行过程，例如：

@Route(path = "/main/TestActivity", extras = 1)public class TestActivity extends AppCompatActivity {    @Autowired    String name;    @Autowired    int age;    @Autowired    TestBean testBean;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_test);        // 必须调用该方法，才有有效        ARouter.getInstance().inject(this);    }}

我们找到inject的最终调用层级在：

static void inject(Object thiz) {        AutowiredService autowiredService = ((AutowiredService) ARouter.getInstance().build("/arouter/service/autowired").navigation());        if (null != autowiredService) {            autowiredService.autowire(thiz);        }    }

根据路由地址“/arouter/service/autowired”，我们在库中找到了AutowiredServiceImpl：

@Route(path = "/arouter/service/autowired")public class AutowiredServiceImpl implements AutowiredService {   ...    @Override    public void autowire(Object instance) {        String className = instance.getClass().getName();        try {            if (!blackList.contains(className)) {                ISyringe autowiredHelper = classCache.get(className);                if (null == autowiredHelper) {  // No cache.                // 通过源文件名称的生成规则，找到生成的源文件                    autowiredHelper = (ISyringe) Class.forName(instance.getClass().getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance();                }                // 调用源文件的inject方法，完成自动装配的工作                autowiredHelper.inject(instance);                classCache.put(className, autowiredHelper);            }        } catch (Exception ex) {            blackList.add(className);    // This instance need not autowired.        }    }}

@Autowired的运行流程就是这样，其中最重要的就是

ARouter.getInstance().build("/arouter/service/autowired").navigation());

我们发现无论是Activity，Fragment还是Service，都是通过这个方法进行匹配的，搞定了他，ARouter的api库就算是大功告成了。

ARouter类的功能都是委托_ARouter类实现的，navigation方法被重载了很多种，但是核心的步骤只有三个：

1、找到路由地址，组装成Postcard对象
2、调用LogisticsCenter.completion(postcard)，完善Postcard的信息
3、返回指定的对象或跳转。

1、找到路由地址，组装成Postcard对象

如果我们直接指定了路由地址，例如：

ARouter.getInstance().build("/arouter/service/autowired").navigation());// 创建对应的Postcard    protected Postcard build(String path, String group) {        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {            throw new HandlerException(Consts.TAG + "Parameter is invalid!");        } else {            // 找到是否有自定义PathReplaceService            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);            if (null != pService) {                path = pService.forString(path);            }            // 默认是没有的，所以会进入到这里            // 如果没有指定group，默认的分组是第一个斜线的单词            return new Postcard(path, group);        }    }

如果我们没有指定url地址，而是使用Class：

protected  T navigation(Class<? extends T> service) {        try {            // 通过编译生成的文件得到Postcard            Postcard postcard = LogisticsCenter.buildProvider(service.getName());            // 注释已经写了，是为了适配1.0.5的版本            // Compatible 1.0.5 compiler sdk.            // Earlier versions did not use the fully qualified name to get the service            if (null == postcard) {                // No service, or this service in old version.                postcard = LogisticsCenter.buildProvider(service.getSimpleName());            }            if (null == postcard) {                return null;            }            // 这是第二步了            LogisticsCenter.completion(postcard);            return (T) postcard.getProvider();        } catch (NoRouteFoundException ex) {            logger.warning(Consts.TAG, ex.getMessage());            return null;        }    }

我们编译出的文件已经记录了Class和路由的对应信息，直接就可以使用。

调用LogisticsCenter.completion(postcard)

这个方法会通过Postcard中的路径信息，完成页面的查找操作：

public synchronized static void completion(Postcard postcard) {        if (null == postcard) {            throw new NoRouteFoundException(TAG + "No postcard!");        }// 得到RouteMeta信息，这个在编译器中已经生成了        RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());        // 一个空的检查，这里就先忽略了        if (null == routeMeta) {    // Maybe its does't exist, or didn't load.           ...        } else {        // 通过RouteMeta，完善Postcard的信息        // 要找到的类名            postcard.setDestination(routeMeta.getDestination());            // 路由的类型            postcard.setType(routeMeta.getType());            // 优先级            postcard.setPriority(routeMeta.getPriority());            // extra，注解中的extra            postcard.setExtra(routeMeta.getExtra());// 通过uri，解析路由的参数            Uri rawUri = postcard.getUri();            if (null != rawUri) {   // Try to set params into bundle.                Map resultMap = TextUtils.splitQueryParameters(rawUri);                Map paramsType = routeMeta.getParamsType();                if (MapUtils.isNotEmpty(paramsType)) {                    // 添加参数                    for (Map.Entry params : paramsType.entrySet()) {                        setValue(postcard,                                params.getValue(),                                params.getKey(),                                resultMap.get(params.getKey()));                    }                    postcard.getExtras().putStringArray(ARouter.AUTO_INJECT, paramsType.keySet().toArray(new String[]{}));                }                postcard.withString(ARouter.RAW_URI, rawUri.toString());            }// 根据不同的类型，做一些补充操作            switch (routeMeta.getType()) {           // 如果是IProvider，这里已经直接通过反射创建对象了                case PROVIDER:  // if the route is provider, should find its instance                    // Its provider, so it must implement IProvider                    Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();                    IProvider instance = Warehouse.providers.get(providerMeta);                    if (null == instance) { // There's no instance of this provider                        IProvider provider;                        try {                            provider = providerMeta.getConstructor().newInstance();                            provider.init(mContext);                            Warehouse.providers.put(providerMeta, provider);                            instance = provider;                        } catch (Exception e) {                            throw new HandlerException("Init provider failed! " + e.getMessage());                        }                    }                    // 设置属性，之后通过这个属性，得到创建的对象                    postcard.setProvider(instance);                    // greenChannel之前已经说过了，表示跳过interceptor                    postcard.greenChannel();    // Provider should skip all of interceptors                    break;                case FRAGMENT:                // fragment也是跳过interceptor的                    postcard.greenChannel();    // Fragment needn't interceptors                default:                    break;            }        }    }

返回指定的对象或跳转

在第二步我们已经完善了Postcard的信息，接下来是第三步，这里有两种情况，如果我们直接使用的是：

protected  T navigation(Class<? extends T> service) {        try {            // 通过编译生成的文件得到Postcard            Postcard postcard = LogisticsCenter.buildProvider(service.getName());            // 注释已经写了，是为了适配1.0.5的版本            // Compatible 1.0.5 compiler sdk.            // Earlier versions did not use the fully qualified name to get the service            if (null == postcard) {                // No service, or this service in old version.                postcard = LogisticsCenter.buildProvider(service.getSimpleName());            }            if (null == postcard) {                return null;            }            // 完善Postcard信息            LogisticsCenter.completion(postcard);            // 返回指定对象            return (T) postcard.getProvider();        } catch (NoRouteFoundException ex) {            logger.warning(Consts.TAG, ex.getMessage());            return null;        }    }

通过刚才第二步的分析，我们可以推断出： navigation(Class<? extends T> service)仅仅适用于IProvider。

其他情况会调用：

protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {        try {        // 第二步，完善Postcard信息            LogisticsCenter.completion(postcard);        } catch (NoRouteFoundException ex) {        // 此处省略，会打印信息，回调callback的onlost方法           ...            return null;        }// 回调onFound        if (null != callback) {            callback.onFound(postcard);        }// 是否要被拦截        if (!postcard.isGreenChannel()) {              interceptorService.doInterceptions(postcard, new InterceptorCallback() {                              @Override                public void onContinue(Postcard postcard) {                // 继续                    _navigation(context, postcard, requestCode, callback);                }                @Override                public void onInterrupt(Throwable exception) {                    if (null != callback) {                        callback.onInterrupt(postcard);                    }                }            });        } else {        // 继续            return _navigation(context, postcard, requestCode, callback);        }        return null;    }

如果跳过或通过了拦截器就会调用_navigation(context, postcard, requestCode, callback)方法，这也是最后一个分析的方法了：

private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {        final Context currentContext = null == context ? mContext : context;        switch (postcard.getType()) {        // 找到Activity，intent添加参数，startActivity            case ACTIVITY:                // Build intent                final Intent intent = new Intent(currentContext, postcard.getDestination());                intent.putExtras(postcard.getExtras());                // Set flags.                int flags = postcard.getFlags();                if (-1 != flags) {                    intent.setFlags(flags);                } else if (!(currentContext instanceof Activity)) {    // Non activity, need less one flag.                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);                }                // Set Actions                String action = postcard.getAction();                if (!TextUtils.isEmpty(action)) {                    intent.setAction(action);                }                // 切换到主线程                runInMainThread(new Runnable() {                    @Override                    public void run() {                        startActivity(requestCode, currentContext, intent, postcard, callback);                    }                });                break;                // 在第二步已经创建IProvider了，直接返回就可以了            case PROVIDER:                return postcard.getProvider();                // 广播，Provider，Fragment            case BOARDCAST:            case CONTENT_PROVIDER:            case FRAGMENT:                Class fragmentMeta = postcard.getDestination();                try {                // 通过返回创建指定对象，请注意这是无参构造方法                    Object instance = fragmentMeta.getConstructor().newInstance();                    // Fragment要添加参数                    if (instance instanceof Fragment) {                        ((Fragment) instance).setArguments(postcard.getExtras());                    } else if (instance instanceof android.support.v4.app.Fragment) {                        ((android.support.v4.app.Fragment) instance).setArguments(postcard.getExtras());                    }                    return instance;                } catch (Exception ex) {                    logger.error(Consts.TAG, "Fetch fragment instance error, " + TextUtils.formatStackTrace(ex.getStackTrace()));                }            case METHOD:            case SERVICE:            default:                return null;        }        return null;    }

到这里ARouter的源码分析就到此结束了。

总结

经过漫长的分析，我们了解了ARouter的实现原理，还学到了文档可能不会提及的用法，最后我们做一个总结：

@Autowired只能注解非private属性
@Autowired只能注解IProvider，或者在Activity和Fragment中使用。
@Autowired注解IProvider会反射创建对象，Activity和Fragment中则通过intent和argument中的携带参数进行填充。
navigation(Class clazz)方法仅适用于IProvider
IProvider和Fragment默认跳过拦截器
如果interceptor要进行耗时操作，请开启异步线程，在主线程中可能会引起ANR

下一篇：Android：从零开始打造自己的深度链接库（三）：自定义XML协议

Android：从零开始打造自己的深度链接库（二）：ARouter源码解析

前言

正文