Arouter 源码学习 1

今天药忘吃喽~ 2022-10-21 03:41 235阅读 0赞

# 前言 #

[ARouter开源地址][ARouter]

本系列是笔者学习`ARouter`开篇系列.本文不是教程系列,而是大致分析`Arouter`路由分发逻辑.

以下是一些预备知识:  
`Arouter`是一个基于`apt`框架,  
对于`@Route`,`@Interceptor`,`@Autowired`等注解的类会在`Example/app/build/generated/source/kapt`生成对应的类,如下图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]  
注意除了`Autowired`注解生成在我们自己的包下,其他类全部都在`com.alibaba.android.arouter.routes`.(这么做是为了方便构建路由表时方便查找对应的映射信息)

# 源码分析 #

## 初始化 ##

本小节是解析`Arouter`初始化代码,可能你需要`MultiDex`基础知识.  
上面我们说过`Arouter`会生成对应类的进而完成路由的分发,和注入.

举个例子:  
我们有一个路由信息如下:

@Route(path = "/test/activity")
    class LibOneActivity : Activity() {
        
    }

我们在另一个Activity进行跳转

ARouter
                .getInstance()
                .build("/test/activity")
                .navigation();

现在的问题是,`Arouter`怎么知道`/test/activity`对应`LibOneActivity`?  
首先我们需要知道`@Route(path = "/test/activity")`会生成如下一个类:

package com.alibaba.android.arouter.routes;
    
    public class ARouter$$Group$$test implements IRouteGroup {
        
      @Override
      public void loadInto(Map<String, RouteMeta> atlas) {
        
        atlas.put("/test/activity", RouteMeta.build(RouteType.ACTIVITY, LibOneActivity.class, "/test/activity", "test", new java.util.HashMap<String, Integer>(){
        {
        put("person", 11); put("name", 8); put("age", 3); }}, -1, -2147483648));
      }
    }

`Arouter`会利用生成的类构造一个路由表,从而完成键值对映射,对于怎么具体利用上面的类且看下文.

`Arouter`初始化代码

//这里我们顺带分析`MultiDex`下Arouter的处理逻辑
    public class App extends MultiDexApplication {
        
    
        @Override
        public void onCreate() {
        
            super.onCreate();
           
            ARouter.init(this); // 尽可能早，推荐在Application中初始化
        }
    }

//ARouter.java
    class ARouter{
        
    
     public static void init(Application application) {
        
           		//略...
                hasInit = _ARouter.init(application);
    			//略...
        }
    }

//_ARouter.java
    class _ARouter{
        
    	 protected static synchronized boolean init(Application application) {
        
            mContext = application;
            //我们重点看这个,executor是一个线程池类ThreadPoolExecutor
            //LogisticsCenter内部会完成一个路由表的构建
            LogisticsCenter.init(mContext, executor);
            logger.info(Consts.TAG, "ARouter init success!");
            hasInit = true;
            mHandler = new Handler(Looper.getMainLooper());
    
            return true;
        }
    
    }

//LogisticsCenter.java
    class LogisticsCenter{
        
    		 public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
        
            mContext = context;
            executor = tpe;
    
            try {
        
                //billy.qi modified at 2017-12-06
                //load by plugin first
                //通过Arouter提供gradle插件完成对路由表的构建.这里会采用字节插装的实现
                //这个插件不是必选的,我们姑且把这个函数视为不存在即可.
                //如果不通过插件初始化路由会在初始化时及其耗时
                loadRouterMap();
                //registerByPlugin判断是否启用插件帮助我们构建路由表
                if (registerByPlugin) {
        
                } else {
        
                
                    Set<String> routerMap;
    
                    //对于debug版本每次都重新构建路由表
                    //对于apk升级版本同样进行路由升级
                    if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
        
                        
                        //ROUTE_ROOT_PAKCAGE为字符串,内容为com.alibaba.android.arouter.routes
                        //getFileNameByPackageName查找当前apk下所有ROUTE_ROOT_PAKCAGE包下的类
                        //现在你知道为什么Arouter为什么要将所有生成的类放入包下了吧
                        routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
                        //如果路由表不为空
                        //将其序列化进行持久化
                        if (!routerMap.isEmpty()) {
        
                            context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
                        }
    					//Arouter每次更新路由表内部提升一个版本
                        PackageUtils.updateVersion(context);    // Save new version name when router map update finishes.
                    } else {
        
                    //直接从持久化数据拿取缓存数据
                        routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
                    }
    
    				//拿取routerMap取得的对象,按照类名进行分组放入Warehouse对应的map结构中
                    for (String className : routerMap) {
        
                        if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
        
                        	//反射构造放入Warehouse中
                            ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
                        } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
        
                        	//反射构造放入Warehouse中
                            ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                        } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
        
                        //反射构造放入Warehouse中
                            ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
                        }
                    }
                }
    
              
    
             
            } catch (Exception e) {
        
                throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]");
            }
    }

我们看下`Warehouse`类:

//Warehouse.java
    class Warehouse {
        
        // Cache route and metas
        static Map<String, Class<? extends IRouteGroup>> groupsIndex = new HashMap<>();
        static Map<String, RouteMeta> routes = new HashMap<>();
    
        // Cache provider
        static Map<Class, IProvider> providers = new HashMap<>();
        static Map<String, RouteMeta> providersIndex = new HashMap<>();
    
        // Cache interceptor
        static Map<Integer, Class<? extends IInterceptor>> interceptorsIndex = new UniqueKeyTreeMap<>("More than one interceptors use same priority [%s]");
        static List<IInterceptor> interceptors = new ArrayList<>();
    }

可见 `ARouter.init(this);`作用如下:  
取出`com.alibaba.android.arouter.routes`包下面的所有类,根据分类放入`Warehouse`中.

我们再细看一下`getFileNameByPackageName`函数如何驱动对应包下所有的类.

ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);

public class ClassUtils {
        
    	//获得packageName下面所有的类
        public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
        
        	//结果容器    
            final Set<String> classNames = new HashSet<>();
    		//getSourcePaths获得所有dex文件夹路径,如果android版本已经天然支持multiDex,那么仅返回apk路径
            List<String> paths = getSourcePaths(context);
            //用于让主线程等候所有dex查找完成
            final CountDownLatch parserCtl = new CountDownLatch(paths.size());
    
            for (final String path : paths) {
        
            	//在子线程中进行io操作读取所有dex下的类
                DefaultPoolExecutor.getInstance().execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        DexFile dexfile = null;
    
                        try {
        
                        	//构造一个DexFile
                            if (path.endsWith(EXTRACTED_SUFFIX)) {
        
                                dexfile = DexFile.loadDex(path, path + ".tmp", 0);
                            } else {
        
                                dexfile = new DexFile(path);
                            }
    						//DexFile的entries方法可以获得一个迭代器,获取当前dex中所有的类
                            Enumeration<String> dexEntries = dexfile.entries();
                            while (dexEntries.hasMoreElements()) {
        
                                String className = dexEntries.nextElement();
                                //符合当前包名就放入结果集合
                                if (className.startsWith(packageName)) {
        
                                    classNames.add(className);
                                }
                            }
                        } catch (Throwable ignore) {
        
                        } finally {
        
                            if (null != dexfile) {
        
                                try {
        
                                    dexfile.close();
                                } catch (Throwable ignore) {
        
                                }
                            }
    
                            parserCtl.countDown();
                        }
                    }
                });
            }
    		//加载完成后返回结果
    		//注意这里其实有可能会ANR的,所以推荐能使用Arouter的Plugin就使用,不过存在局限性.
            parserCtl.await();
    
            return classNames;
        }
    
    }

这里你会发现`Arouter`虽然使用起来傻瓜式,其实隐含了ANR风险.`Arouter`的`Gradle`插件可以帮助我们避免这一情况,但是也存在局限性(这个问题后续文章在讨论).

我们最后看下  
`public static List<String> getSourcePaths(Context context)`函数

//得到上下文对应所有dex的集合
      public static List<String> getSourcePaths(Context context) throws PackageManager.NameNotFoundException, IOException {
        
            
            ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), 0);
        	//当前apk路径    
            File sourceApk = new File(applicationInfo.sourceDir);
    	
            List<String> sourcePaths = new ArrayList<>();
            //将当前apk放入结果中
            sourcePaths.add(applicationInfo.sourceDir); //add the default apk path
    
    		//如果当前系统需要可能需要分包,那么Arouter假设你使用Google官方的库,
    		//如果你使用其他的分包方案下面的代码会存在错误
    		
            //文件的前缀
            String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
    
    //        如果VM已经支持了MultiDex，就不要去Secondary Folder加载 Classesx.zip了，那里已经么有了
    //        通过是否存在sp中的multidex.version是不准确的，因为从低版本升级上来的用户，是包含这个sp配置的
            if (!isVMMultidexCapable()) {
        
                //Google的MultiDex会持久化分包结果存储到sharedPreference,比如有多个dex包
                //getMultiDexPreferences读取MultiDex持久化数据,返回dex有多少个包
                int totalDexNumber = getMultiDexPreferences(context).getInt(KEY_DEX_NUMBER, 1);
                //MultiDex库会将所有dex放入code_cache/secondary-dexes中
                File dexDir = new File(applicationInfo.dataDir, SECONDARY_FOLDER_NAME);
    			
                for (int secondaryNumber = 2; secondaryNumber <= totalDexNumber; secondaryNumber++) {
        
                    //for each dex file, ie: test.classes2.zip, test.classes3.zip...
                    //读取dex文件,这里同样是根据MultiDex库的规范进行操作.
                    String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
                    File extractedFile = new File(dexDir, fileName);
                    if (extractedFile.isFile()) {
        
                        sourcePaths.add(extractedFile.getAbsolutePath());
                        //we ignore the verify zip part
                    } else {
        
                        throw new IOException("Missing extracted secondary dex file '" + extractedFile.getPath() + "'");
                    }
                }
            }
    		//这里是Arouter用于支持instant run,不过现在已经没有
            if (ARouter.debuggable()) {
         // Search instant run support only debuggable
                sourcePaths.addAll(tryLoadInstantRunDexFile(applicationInfo));
            }
            return sourcePaths;
        }

## 注入分析 ##

案例如下:

@Route(path = "/yourservicegroupname/hello", name = "测试服务")
    public class HelloServiceImpl implements HelloService {
        
    
        @Override
        public String sayHello(String name) {
        
            return "hello, " + name;
        }
    
        @Override
        public void init(Context context) {
        
    
        }
    }
    
    
    class MainActivity : Activity() {
        
    
        @Autowired(name = "/yourservicegroupname/hello")
        @JvmField
        var helloService2: HelloService? = null
    
        override fun onCreate(savedInstanceState: Bundle?) {
        
          	//注入一个服务
            ARouter.getInstance().inject(this);
    
            val sayHello = helloService2?.sayHello("你好")
    
        }
    }

//生成的其中一个类会放入Warehouse.groupsIndex中
    public class ARouter$$Group$$yourservicegroupname implements IRouteGroup {
        
      @Override
      public void loadInto(Map<String, RouteMeta> atlas) {
        
        atlas.put("/yourservicegroupname/hello", RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/yourservicegroupname/hello", "yourservicegroupname", null, -1, -2147483648));
      }
    }

`@Autowired`类似`Dagger`的`@Inject`,用于依赖注入.本小节我们分析下`Arouter`的代码.  
存在`@Autowired`的代码会在编译时生成对于对应类用于注入.

package com.example.example;
    
    public class MainActivity$$ARouter$$Autowired implements ISyringe {
        
      private SerializationService serializationService;
    
      @Override
      public void inject(Object target) {
        
      	//serializationService对象我们可以先跳过
        serializationService = ARouter.getInstance().navigation(SerializationService.class);
        MainActivity substitute = (MainActivity)target;
        
        //执行注入
        substitute.helloService2 = (HelloService)ARouter.getInstance().build("/yourservicegroupname/hello").navigation();
      }
    }

在分析如何调`MainActivity$$ARouter$$Autowired.inject`之前,我们看下`(HelloService)ARouter.getInstance().build("/yourservicegroupname/hello").navigation();`代码分析

(HelloService)ARouter
    					 .getInstance()//获取单例
    					 .build("/yourservicegroupname/hello")
    					 .navigation();

class ARouter{
        
    	private volatile static ARouter instance = null;
    	//DCL单例模式
    	public static ARouter getInstance() {
        
            if (!hasInit) {
        
                throw new InitException("ARouter::Init::Invoke init(context) first!");
            } else {
        
                if (instance == null) {
        
                    synchronized (ARouter.class) {
        
                        if (instance == null) {
        
                            instance = new ARouter();
                        }
                    }
                }
                return instance;
            }
        }
        //构建
        public Postcard build(String path) {
        
            return _ARouter.getInstance().build(path);
        }
    }

//_ARouter.java
    final class _ARouter {
        
    	protected Postcard build(String path) {
        
           		//获取路由修改器实现类,这里我视为无即可
                PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
      			//如果存在调用路由修改器,这里我们不需要深究
                if (null != pService) {
        
                    path = pService.forString(path);
                }
                //继续下一步构建
                return build(path, extractGroup(path), true);
           
        }
        
         protected Postcard build(String path, String group, Boolean afterReplace) {
        
           		//根据afterReplace判断是否需要调用PathReplaceService实现类.
           		//这里我们跳过
                if (!afterReplace) {
        
                    PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
                    if (null != pService) {
        
                        path = pService.forString(path);
                    }
                }
                //构建了一个Postcard
                return new Postcard(path, group);
            }
      
        
    }

综上我们把代码在简化下:

Arouter router = ARouter.getInstance()//获取单例
    Postcard card = router.build("/yourservicegroupname/hello");
    HelloService service = card.navigation();

从上面看`Postcard.navigation`会得到`"/yourservicegroupname/hello"`对应的实现类,

class Postcard{
        
    	 //navigation会得到预期类
    	 public Object navigation() {
        
            return navigation(null);
        }
         public Object navigation(Context context) {
        
         	//链式向下调用
            return navigation(context, null);
        }
        public Object navigation(Context context, NavigationCallback callback) {
        
           	//又调用到Arouter
            return ARouter
            	.getInstance()
            	.navigation(context, this, -1, callback);
        }
    }

//ARouter.java
    class ARouter{
        
     public Object navigation(Context mContext, Postcard postcard, int requestCode, NavigationCallback callback) {
        
            return _ARouter.getInstance().navigation(mContext, postcard, requestCode, callback);
        }
    }

最终的实现又回到`_ARouter`

//_ARouter.java
    class _ARouter{
        
    	 protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        
    	 	//获取PretreatmentService的实现类,这里我们可以先忽略
    	 	//PretreatmentService是一个允许我们在在进行navigation前进行监听的一个类
    	 	//你可以改变postcard,从而影响最终的结果,
            PretreatmentService pretreatmentService = ARouter.getInstance().navigation(PretreatmentService.class);
         	//如果PretreatmentService的onPretreatment返回false,那么不会从navigation返回任何数据
            if (null != pretreatmentService && !pretreatmentService.onPretreatment(context, postcard)) {
        
                return null;
            }
    
            try {
        
            	//核心实现,内部会将所想要类的实例放入postcard
                LogisticsCenter.completion(postcard);
            } catch (NoRouteFoundException ex) {
        
               	//异常状况回调接口
                if (null != callback) {
        
                    callback.onLost(postcard);
                } else {
        
                    //调用降级服务
                    DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
                    if (null != degradeService) {
        
                        degradeService.onLost(context, postcard);
                    }
                }
    
                return null;
            }
    		//运行到这个证明可以寻找到资源,回调接口
            if (null != callback) {
        
                callback.onFound(postcard);
            }
    		//调用拦截,因为我们是provider类所以isGreenChannel
            if (!postcard.isGreenChannel()) {
           
    			 // It must be run in async thread, maybe interceptor cost too mush time made ANR.
              	//...略
            } else {
        
                return _navigation(context, postcard, requestCode, callback);
            }
    
            return null;
        }
    	//最终调用到这
    	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()) {
        
                case ACTIVITY:
                   //略
                    break;
                case PROVIDER:
                // LogisticsCenter.completion(postcard)内部会将对象放入
                    return postcard.getProvider();
                case BOARDCAST:
                case CONTENT_PROVIDER:
                case FRAGMENT:
                  //略
                case METHOD:
                case SERVICE:
                default:
                    return null;
            }
    
            return null;
        }
    }

最后我们研究下`LogisticsCenter.completion`函数.

class LogisticsCenter{
        
    	    public synchronized static void completion(Postcard postcard) {
        
           
    		//postcard.getPath()返回/yourservicegroupname/hello
    		//Warehouse.routes在初始化是被没有放入任何对象
    		//Warehouse.routes是用于存放路由缓存,key为路径,value是对应的实例化对象
            RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
            //如果没有缓存过必然为true
            if (null == routeMeta) {
            // Maybe its does't exist, or didn't load.
                //从初始化分组中获取对应的类
                Class<? extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());  // Load route meta.
                //在为空直接抛出异常	
                if (null == groupMeta) {
        
                    throw new NoRouteFoundException(TAG + "There is no route match the path [" + postcard.getPath() + "], in group [" + postcard.getGroup() + "]");
                } else {
        
                  // groupMeta.getConstructor()对应所属类的构造方法
                  // newInstance反射构造对象,这里构造的ARouter$$Group$$yourservicegroupname对象
                  //因为我们的HelloServiceImpl属于这个分组
                  IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();
                  //调用loadInto函数将其放入Warehouse.routes中
                  //结果放一个key:/yourservicegroupname/hello value:RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/yourservicegroupname/hello", "yourservicegroupname", null, -1, -2147483648) 
                  iGroupInstance.loadInto(Warehouse.routes);
                  //因为已经将groupsIndex对应分组的对象实例化,删除一个减轻内存负担
                  Warehouse.groupsIndex.remove(postcard.getGroup());
    			  //加载缓存后重新进入函数
                  completion(postcard);   // Reload
                
            } else {
        
              //略
            }
        }
    
    }

上面构造一个`ARouter$$Group$$yourservicegroupname`实例放入`Warehouse.routes`中接着重新接入`completion`.

public synchronized static void completion(Postcard postcard) {
        
            if (null == postcard) {
        
                throw new NoRouteFoundException(TAG + "No postcard!");
            }
    		//得到: RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/yourservicegroupname/hello", "yourservicegroupname", null, -1, -2147483648)
            RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
            if (null == routeMeta) {
        
               //略
            } else {
        
    			//一些基础属性赋值        
    			//com.example.applibrary.HelloServiceImpl
                postcard.setDestination(routeMeta.getDestination());
                //PROVIDER
                postcard.setType(routeMeta.getType());
                //-1
                postcard.setPriority(routeMeta.getPriority());
                //附加信息 由于这里没有设置,这里无就是无意义的int数值
                postcard.setExtra(routeMeta.getExtra());
    
    
                
    			//我们这里属于provider类型
                switch (routeMeta.getType()) {
        
                    case PROVIDER: 
                    	//拿着类反射构造实例
                        Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
                        //从缓存中拿取实例
                        IProvider instance = Warehouse.providers.get(providerMeta);
                        //如果对象为空利用反射构造
                        if (null == instance) {
         
                            IProvider provider;
                            try {
        
                            	//反射构造
                                provider = providerMeta.getConstructor().newInstance();
                                provider.init(mContext);
                                //放入map中
                                Warehouse.providers.put(providerMeta, provider);
                                instance = provider;
                            } catch (Exception e) {
        
                                throw new HandlerException("Init provider failed! " + e.getMessage());
                            }
                        }
                        //放入postcard中
                        postcard.setProvider(instance);
                        //设置标志位greenChannel为true,用于跳过所有的拦截器
                        postcard.greenChannel();    
                        break;
                    case FRAGMENT:
                        postcard.greenChannel();    // Fragment needn't interceptors
                    default:
                        break;
                }
            }
        }

上面便完成了一小部分的代码分析,我们在看看下面的代码应该就不难理解了

//执行注入
        substitute.helloService2 = (HelloService)ARouter.getInstance().build("/yourservicegroupname/hello").navigation();

上面流程分析中你可以看到经过了很多`拦截`,我们现在来统一做下总结:

1.  `PathReplaceService` 可用于替换路由字符串.用于构造`Postcard调用`
2.  `PretreatmentService`可用于拦截Postcard.在调用`Arouter`的`navigation`获取Postcard对应的实例化对象时触发
3.  (仅当错误寻找不到目标类时)`DegradeService`

我们接着分析下面的代码:

class MainActivity : Activity() {
        
    
        @Autowired(name = "/yourservicegroupname/hello")
        @JvmField
        var helloService2: HelloService? = null
    
        override fun onCreate(savedInstanceState: Bundle?) {
        
        	//分析这
            ARouter.getInstance().inject(this);
    
            val sayHello = helloService2?.sayHello("你好")
    
        }

ARouter.getInstance().inject(this);

//ARouter.java
    class ARouter{
        
     public void inject(Object thiz) {
        
            _ARouter.inject(thiz);
        }
    }

class _ARouter{
        
    	 static void inject(Object thiz) {
        
    	 	//这一段代码上面有过类似的分析
    	 	///arouter/service/autowired这个类的实现由Arouter提供
            AutowiredService autowiredService = ((AutowiredService) ARouter.getInstance().build("/arouter/service/autowired").navigation());
         
            if (null != autowiredService) {
        
            	//最后调用了实现类的autowire
                autowiredService.autowire(thiz);
            }
        }
    }

我们看下`Arouter`为我们提供的相关类

@Route(path = "/arouter/service/autowired")
    public class AutowiredServiceImpl implements AutowiredService {
        
        private LruCache<String, ISyringe> classCache;
        private List<String> blackList;
    
        @Override
        public void init(Context context) {
        
            classCache = new LruCache<>(50);
            blackList = new ArrayList<>();
        }
    
    	//注入时调用到这
        @Override
        public void autowire(Object instance) {
        
            doInject(instance, null);
        }
    
       //instance是MainActivity 
       //parent是空
        private void doInject(Object instance, Class<?> parent) {
        
    		//返回的是com.example.example.MainActivity
            Class<?> clazz = null == parent ? instance.getClass() : parent;
    		
    		//getSyringe是根据传入的类的全限定名字,获取对应的生成类实例
    		//这里就是返回MainActivity$$ARouter$$Autowired实例
            ISyringe syringe = getSyringe(clazz);
            
            if (null != syringe) {
        
            	//这个函数在上文已经做过分析
                syringe.inject(instance);
            }
            
    		//注入父类的实例,这里我们不在分析比较简单.
            Class<?> superClazz = clazz.getSuperclass();
            if (null != superClazz && !superClazz.getName().startsWith("android")) {
        
                doInject(instance, superClazz);
            }
        }
    
        private ISyringe getSyringe(Class<?> clazz) {
        
        	//得到类名MainActivity
            String className = clazz.getName();
    
            try {
        
            	//是否存在黑名单队列里面,如果存在旧直接返回空
            	//blackList用于存储找不到的类,用于方便下次直接返回
                if (!blackList.contains(className)) {
        
                	//查看是否在缓存中,第一次自然为null
                    ISyringe syringeHelper = classCache.get(className);
                    //为空,那么利用反射构造
                    if (null == syringeHelper) {
          // No cache.
                        syringeHelper = (ISyringe) Class.forName(clazz.getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance();
                    }
                    //放入缓存中
                    classCache.put(className, syringeHelper);
                    return syringeHelper;
                }
            } catch (Exception e) {
        
                blackList.add(className);    // This instance need not autowired.
            }
    
            return null;
        }
    }

貌似比较简单.综上我们完成了Arouter的注入代码分析,我们接下来看下路由跳转代码相关.

## 路由 ##

@Route(path = "/test/activity")
    class LibOneActivity : Activity() {
        
    
        @Autowired
        @JvmField
        var name: String = "";
    
        @Autowired
        @JvmField
        var age: Int = 0
    
        @Autowired
        @JvmField
        var person: LibPerson? = null
    
        private val TAG = "LibOneActivity"
    
        override fun onCreate(savedInstanceState: Bundle?) {
        
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_lib_one)
            ARouter.getInstance().inject(this);
            Log.e(TAG, "onCreate: name ${name} age ${age}")
        }
    }

生成的类

//ARouter$$Group$$test.java
    package com.alibaba.android.arouter.routes;
    
    public class ARouter$$Group$$test implements IRouteGroup {
        
      @Override
      public void loadInto(Map<String, RouteMeta> atlas) {
        
        atlas.put("/test/activity", RouteMeta.build(RouteType.ACTIVITY, LibOneActivity.class, "/test/activity", "test", new java.util.HashMap<String, Integer>(){
        {
        put("person", 11); put("name", 8); put("age", 3); }}, -1, -2147483648));
      }
    }
    
    
    //ARouter$$Root$$applibrary.java
    package com.alibaba.android.arouter.routes;
    public class ARouter$$Root$$applibrary implements IRouteRoot {
        
      @Override
      public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
        
        routes.put("test", ARouter$$Group$$test.class);
      }
    }

我们执行的跳转代码:

class MainActivity : Activity() {
        
    //略
     fun onclick(view: View) {
        
            ARouter
                .getInstance()
                .build("/test/activity")
                .withString("name", "ZhangsanSan")
                .withInt("age", 13)
                .withObject("person", LibPerson())
                .navigation();
    
        }
    }

我们开始逐行分析,我们将上面的代码改成以下的写法

//上文已经讲解过,只不过上文获取的是Provider类型的,这里是Activity类型的	
     Postcard card =  ARouter
                .getInstance()
                .build("/test/activity")

//分析1
    card.withString("name", "ZhangsanSan")
         .withInt("age", 13)
    //分析2     
    card.withObject("person", LibPerson())
    
    //分析3 重点
    card.navigation();

**分析1**:

public final class Postcard extends RouteMeta {
        
    
        private Bundle mBundle;   
        //简单的将数据放入Bundle中
     public Postcard withString(@Nullable String key, @Nullable String value) {
        
            mBundle.putString(key, value);
            return this;
        }
        //简单的将数据放入Bundle中
      public Postcard withInt(@Nullable String key, int value) {
        
            mBundle.putInt(key, value);
            return this;
        }
    
    }

**分析2**:

`card.withObject("person", LibPerson())`

public final class Postcard extends RouteMeta {
        
    
    
     public Postcard withObject(@Nullable String key, @Nullable Object value) {
        
     		//获取序列化实现类
            serializationService = ARouter.getInstance().navigation(SerializationService.class);
            //调用序列化实现类将其转化为字符串后放入mBundle中
            mBundle.putString(key, serializationService.object2Json(value));
            
            return this;
        }
    }

**分析3**

`card.navigation();`  
这个也是比较稍微比较重点的地方,上位介绍过类似的代码,所以看起来不会太复杂.

由于上文讲过`navigation`我们直接看一些核心的调用函数把

class _ARouter{
        
     protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        
    		
    		//...略
    
            try {
        
            	//我们看下LogisticsCenter是如何构造一个actvity类型的放入postcard的
                LogisticsCenter.completion(postcard);
            } catch (NoRouteFoundException ex) {
        
               	//略
                return null;
            }
    
          //略
    
            return null;
        }
    }

public synchronized static void completion(Postcard postcard) {
        
          	//第一次必然为空
            RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
            if (null == routeMeta) {
            // Maybe its does't exist, or didn't load.
                //获取对应的组的对象,返回ARouter$$Group$$test
                Class<? extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());  // Load route meta.
                
                if (null == groupMeta) {
        
                    //略
                } else {
        
                   
                    //构造
                    //RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/yourservicegroupname/hello", "yourservicegroupname", null, -1, -2147483648)
                    //实例放入缓存中,然后再次进入放入
                    IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();
                    iGroupInstance.loadInto(Warehouse.routes);
                    Warehouse.groupsIndex.remove(postcard.getGroup());
    
                    completion(postcard);   // Reload
                }
            } else {
        
               
               //略
            }
        }

二次进入`completion`时:

public synchronized static void completion(Postcard postcard) {
        
            //返回ARouter$$Group$$test
            RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
            if (null == routeMeta) {
           
               //略
            } else {
        
                //com.example.applibrary.LibOneActivity
                postcard.setDestination(routeMeta.getDestination());
                //Activity
                postcard.setType(routeMeta.getType());
                //无
                postcard.setPriority(routeMeta.getPriority());
                //无
                postcard.setExtra(routeMeta.getExtra());
    
    			//这里没有一个匹配的直接返回
                switch (routeMeta.getType()) {
        
                    case PROVIDER:  
                       //略
                        break;
                    case FRAGMENT:
                    default:
                        break;
                }
            }
        }

class _ARouter{
        
    
        protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        
    		//略
    
            try {
        
                LogisticsCenter.completion(postcard);
            } catch (NoRouteFoundException ex) {
        
               //略
            }
    
            
    		//这里由于在completion函数中并没设置,所以会进入if中
            if (!postcard.isGreenChannel()) {
          
            	//这里会构造一个新的线程回调我们所有的@Interceptor注解的类相关函数
            	//doInterceptions实在比较简单,可以简答理解就是开了个线程然后调用@Interceptor相关函数
                interceptorService.doInterceptions(postcard, new InterceptorCallback() {
        
                    //拦截处理器完成后回调用到这
                    @Override
                    public void onContinue(Postcard postcard) {
        
                        _navigation(context, postcard, requestCode, callback);
                    }
    
                   
                });
            } else {
        
                return _navigation(context, postcard, requestCode, callback);
            }
    
            return null;
        }
    }

class _ARouter{
        
        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()) {
        
                case ACTIVITY:
                    //构造一个意图然后跳转到指定的类
                    //postcard.getDestination()为com.example.applibrary.LibOneActivity
                    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;
                case PROVIDER:
                    return postcard.getProvider();
                case BOARDCAST:
                case CONTENT_PROVIDER:
                case FRAGMENT:
                    //略
                case METHOD:
                case SERVICE:
                default:
                    return null;
            }
    
            return null;
        }
    }

上面Arouter主要核心就已经分析完毕了…

## gradle plugin ##

`Arouter`提供了一个`Gradle`,用于避免在运行时去查找类.声明如下  
![w][]  
相关前置知识:  
[AGP tramsform][]

public class PluginLaunch implements Plugin<Project> {
        
    
        @Override
        public void apply(Project project) {
        
            def isApp = project.plugins.hasPlugin(AppPlugin)
            if (isApp) {
        
             
    
                def android = project.extensions.getByType(AppExtension)
                def transformImpl = new RegisterTransform(project)
                ArrayList<ScanSetting> list = new ArrayList<>(3)
                //声明要扫描的类
                list.add(new ScanSetting('IRouteRoot'))
                list.add(new ScanSetting('IInterceptorGroup'))
                list.add(new ScanSetting('IProviderGroup'))
                RegisterTransform.registerList = list
                //使用了Transform在编译时去查找类
                android.registerTransform(transformImpl)
            }
        }
    
    }

Arouter很明显使用使用了`Transform`相关知识在编译期去查找相关类,然后通过子界面插装实现.

class RegisterTransform extends Transform {
        
    	//扫描到的类
    	    static ArrayList<ScanSetting> registerList
    
    	//可以在transform函数中进行遍历所有类或者修改类
    	 @Override
        void transform(Context context, Collection<TransformInput> inputs
                       , Collection<TransformInput> referencedInputs
                       , TransformOutputProvider outputProvider
                       , boolean isIncremental) throws IOException, TransformException, InterruptedException {
        
    
    
            long startTime = System.currentTimeMillis()
            boolean leftSlash = File.separator == '/'
    
            inputs.each {
         TransformInput input ->
               
                input.jarInputs.each {
         JarInput jarInput ->
                   //略 我们这里只看目录类别的输入,jar都差不多
                }
                // scan class files
                input.directoryInputs.each {
         DirectoryInput directoryInput ->
                    //这里是Transform的规范,要求你讲所有的文件输出到这个文件夹,不管你有没有改过
                    File dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
                    //要处理的类的所在文件夹,里面包含了很多个类
                    String root = directoryInput.file.absolutePath
                    
                    if (!root.endsWith(File.separator))
                        root += File.separator
                     //编译所有的文件下的类   
                    directoryInput.file.eachFileRecurse {
         File file ->
                        def path = file.absolutePath.replace(root, '')
                        if (!leftSlash) {
        
                            path = path.replaceAll("\\\\", "/")
                        }
                        //ROUTER_CLASS_PACKAGE_NAME是com/alibaba/android/arouter/routes/
                        //很明显这里表示只处理com/alibaba/android/arouter/routes/下的类
    
                        if(file.isFile() && ScanUtil.shouldProcessClass(path)){
        
                        	//ScanUtil.scanClass函数的作用是利用ASM获取类的名字然后registerList属性中      
                            ScanUtil.scanClass(file)
                        }
                    }
    
                    // 将输入的所有文件拷贝到规范目录 dest中
                    FileUtils.copyDirectory(directoryInput.file, dest)
                }
            }
    
    
            if (fileContainsInitClass) {
        
                registerList.each {
         ext ->
                    if (ext.classList.isEmpty()) {
        
                    } else {
        
                       //得到扫描后的文件写入到LogisticsCenter的loadRouterMap中
                        RegisterCodeGenerator.insertInitCodeTo(ext)
                    }
                }
            }
    
          
        }
    }

看完是不是觉得整个插件很巧妙?这里我们并没有贴出ASM相关操作代码,因为这里其他不可能在无限详细讲解另一个库.

[ARouter]: https://github.com/alibaba/ARouter/blob/master/README_CN.md
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221021/e38d78c44d0f468ba488cbc22e0190a3.png
[w]: /images/20221021/72680bad4a0c449f93e8fe596149beec.png
[AGP tramsform]: https://fanmingyi.blog.csdn.net/article/details/114767720