阿里ARouter使用及源码解析（一）

其他 2019-03-10 11:38:06 阅读次数: 0

在app的开发中，页面之间的相互跳转是最基本常用的功能。在Android中的跳转一般通过显式intent和隐式intent两种方式实现的，而Android的原生跳转方式会存在一些缺点：

  • 显式intent的实现方式，因为会存在直接的类依赖的问题，导致耦合严重；
  • 隐式intent的实现方式，则会出现规则集中式管理，导致协作变得困难；
  • 可配置性较差，一般而言配置规则都是在Manifest中的，这就导致了扩展性较差；
  • 跳转过程无法控制，一旦使用了StartActivity()就无法插手其中任何环节了，只能交给系统管理；
  • 当多组件化开发，使用原生的路由方式很难实现完全解耦；

而阿里的ARouter路由框架具有解耦、简单易用、支持多模块项目、定制性较强、支持拦截逻辑等诸多优点，很好的解决了上述的问题。关于ARouter具体实现功能，典型应用以及相应技术方案实现的介绍不在这详细介绍，具体可参见开源最佳实践：Android平台页面路由框架ARouter。

阿里ARouter的分析计划

基本功能使用

1.添加依赖和配置

android {
    defaultConfig {
    ...
    javaCompileOptions {
        annotationProcessorOptions {
        arguments = [ moduleName : project.getName() ]
        }
    }
    }
}

dependencies {
    compile 'com.alibaba:arouter-api:1.2.1.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.1.2.1'
    ...
}

2.添加注解

// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级，/xx/xx
@Route(path = "/test/test1")
public class Test1Activity extends AppCompatActivity{ @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_test1); } }

3.初始化SDK

public class MainActivity extends AppCompatActivity implements View.OnClickListener { private Button btn1,btn2; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btn1 = (Button) findViewById(R.id.btn1); btn2 = (Button) findViewById(R.id.btn2); btn1.setOnClickListener(this); btn2.setOnClickListener(this); } @Override public void onClick(View v) { if (v.getId() == R.id.btn1) { // 如果使用了InstantRun，必须在初始化之前开启调试模式，但是上线前需要关闭，InstantRun仅用于开发阶段， // 线上开启调试模式有安全风险，可以使用BuildConfig.DEBUG来区分环境 ARouter.openDebug(); ARouter.init(getApplication()); // 尽可能早，推荐在Application中初始化 } } }

4.发起跳转操作

public class MainActivity extends AppCompatActivity implements View.OnClickListener { private Button btn1,btn2; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btn1 = (Button) findViewById(R.id.btn1); btn2 = (Button) findViewById(R.id.btn2); btn1.setOnClickListener(this); btn2.setOnClickListener(this); } @Override public void onClick(View v) { if (v.getId() == R.id.btn1) { .... } else if (v.getId() == R.id.btn2){ ARouter.getInstance().build("/test/test1").navigation(); } } }

以上相关代码就是ARouter的最基本功能使用的步骤，下面来分析跳转功能是如何实现的。

原理分析
1.ARouter编译的过程

ARouter在编译期的时候，利用自定义注解完成了页面的自动注册。相关注解源码参见arouter-annotation，编译处理器源码参见arouter-compiler

下面是注解@Route的源码介绍：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface Route {

    /** *路由的路径，标识一个路由节点 */ String path(); /** * 将路由节点进行分组，可以实现按组动态加载 */ String group() default ""; /** * 路由节点名称，可用于生成javadoc文档 */ String name() default "undefined"; /** * 用32位int类型标示，可用于页面的一些配置 */ int extras() default Integer.MIN_VALUE; /** * 路由的优先级 */ int priority() default -1; }

Route中的extra值是个int值，由32位表示，即转换成二进制后，一个int中可以配置31个1或者0，而每一个0或者1都可以表示一项配置（排除符号位），如果从这31个位置中随便挑选出一个表示是否需要登录就可以了，只要将标志位置为1，就可以在声明的拦截器中获取到这个标志位，通过位运算的方式判断目标页面是否需要登录。所以可以通过extra给页面配置30多个属性，然后在拦截器中去进行处理。
ARouter在拦截器中会把目标页面的信息封装一个类Postcard，这个类就包含了目标页面注解上@Route标识的各种信息。关于拦截器的使用以及源码分析，后续会有介绍。

将代码编译一遍，可以看到ARouter生成下面几个源文件：

上面三个文件均是通过注解处理器RouteProcessor生成的，关于如何自定义注解处理器，可以阅读Android编译时注解APT实战（AbstractProcessor），同时也需要学习JavaPoet的基本使用。下面我们看RouteProcessor是如何生成相关文件的。

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { //判断被注解了的元素集合是否为空 if (CollectionUtils.isNotEmpty(annotations)) { //获取所有被@Route注解的元素集合，Element可以是类、方法、变量等 Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class); try { logger.info(">>> Found routes, start... <<<"); //具体处理注解，生成java文件的方法 this.parseRoutes(routeElements); } catch (Exception e) { logger.error(e); } return true; } return false; }

process()方法相当于处理器的主函数main()，可以在这个方法中扫描、评估和处理注解的代码，以及生成Java文件。RouteProcessor中调用了parseRoutes()，用来处理所有被@Route注解的元素。在分析上述三个java文件如何生成之前，先看看生成文件的具体代码。

  • ARouter$$Root$$app类
public class ARouter$$Root$$app implements IRouteRoot { @Override public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) { routes.put("test", ARouter$$Group$$test.class); } }
  • ARouter$$Group$$test类
public class ARouter$$Group$$test implements IRouteGroup { @Override public void loadInto(Map<String, RouteMeta> atlas) { atlas.put("/test/test1", RouteMeta.build(RouteType.ACTIVITY, Test1Activity.class, "/test/test1", "test", null, -1, -2147483648)); } }
  • ARouter$$Providers$$app类
public class ARouter$$Providers$$app implements IProviderGroup { @Override public void loadInto(Map<String, RouteMeta> providers) { } }

我们接着分析上述三个文件是如何生成的

1.首先获取生成方法的参数的类型和参数名称

 private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
        if (CollectionUtils.isNotEmpty(routeElements)) {
          
            logger.info(">>> Found routes, size is " + routeElements.size() + " <<<"); rootMap.clear(); // TypeElement 表示一个类或接口元素 // public static final String ACTIVITY = "android.app.Activity"; //得到类activity元素 TypeElement type_Activity = elementUtil.getTypeElement(ACTIVITY); // public static final String SERVICE = "android.app.Service"; //得到类service的元素 TypeElement type_Service = elementUtil.getTypeElement(SERVICE); // public static final String SERVICE = "android.app.Fragment"; TypeMirror fragmentTm = elements.getTypeElement(FRAGMENT).asType(); // public static final String SERVICE = "android.support.v4.app.Fragment"; TypeMirror fragmentTmV4 = elements.getTypeElement(Consts.FRAGMENT_V4).asType(); // public static final String IROUTE_GROUP = "com.alibaba.android.arouter.facade.template.IRouteGroup"; //得到接口IRouteGroup元素 TypeElement type_IRouteGroup = elementUtil.getTypeElement(IROUTE_GROUP); // public static final String IROUTE_GROUP = "com.alibaba.android.arouter.facade.template.IProviderGroup"; //得到接口IProviderGroup元素 TypeElement type_IProviderGroup = elementUtil.getTypeElement(IPROVIDER_GROUP); //获取RouteMeta，RouteType类名 ClassName routeMetaCn = ClassName.get(RouteMeta.class); ClassName routeTypeCn = ClassName.get(RouteType.class); //下面代码是获取生成java文件中方法的参数类型名称和参数名称。 /* 获取获取ARouter$$Root$$app 类中方法参数Map<String, Class<? extends IRouteGroup>>类型的名称 */ ParameterizedTypeName inputMapTypeOfRoot = ParameterizedTypeName.get( ClassName.get(Map.class), ClassName.get(String.class), ParameterizedTypeName.get( ClassName.get(Class.class), WildcardTypeName.subtypeOf(ClassName.get(type_IRouteGroup)) ) ); /* 获取ARouter$$Group$$test，ARouter$$Providers$$app类中方法参数 Map<String, RouteMeta>类型的名称 */ ParameterizedTypeName inputMapTypeOfGroup = ParameterizedTypeName.get( ClassName.get(Map.class), ClassName.get(String.class), ClassName.get(RouteMeta.class) ); /* 获取相关的参数 */ //获取ARouter$$Root$$app 类中方法的参数Map<String, Class<? extends IRouteGroup>> routes ParameterSpec rootParamSpec = ParameterSpec.builder(inputMapTypeOfRoot, "routes").build(); //获取ARouter$$Group$$test类中方法的参数Map<String, RouteMeta> atlas ParameterSpec groupParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "atlas").build(); //获取ARouter$$Providers$$app类中方法的参数Map<String, RouteMeta> providers ParameterSpec providerParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "providers").build(); ..... } }

2.获取了方法的参数的类型和参数名称后，下面便是生成相应的方法

 private void parseRoutes(Set<? extends Element> routeElements) throws IOException { if (CollectionUtils.isNotEmpty(routeElements)) { ........ /* 首先创建ARouter$$Root$$xxx 类中的loadInto()方法 @Override public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {} */ MethodSpec.Builder loadIntoMethodOfRootBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO) .addAnnotation(Override.class) .addModifiers(PUBLIC) .addParameter(rootParamSpec); // 遍历所有被@Route注解的元素 for (Element element : routeElements) { TypeMirror tm = element.asType(); Route route = element.getAnnotation(Route.class); RouteMeta routeMete = null; //判断该元素否为 Activity 、IProvider 、 Service 的子类，然后创建相应的RouteMeta 对象 if (typeUtil.isSubtype(tm, type_Activity.asType())) { // Activity logger.info(">>> Found activity route: " + tm.toString() + " <<<"); // 如果是acitiviy类型，获取所有被@Autowired的属性 //关于@Autowired的注解，我们之后再进行分析 Map<String, Integer> paramsType = new HashMap<>(); for (Element field : element.getEnclosedElements()) { if (field.getKind().isField() && field.getAnnotation(Autowired.class) != null && !typeUtil.isSubtype(field.asType(), iProvider)) { // It must be field, then it has annotation, but it not be provider. Autowired paramConfig = field.getAnnotation(Autowired.class); paramsType.put(StringUtils.isEmpty(paramConfig.name()) ? field.getSimpleName().toString() : paramConfig.name(), TypeUtils.typeExchange(field.asType())); } } // ACTIVITY类型节点 routeMete = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType); } else if (typeUtil.isSubtype(tm, iProvider)) { // IProvider logger.info(">>> Found provider route: " + tm.toString() + " <<<"); //从该判断可看出，如果要想成功注册一个 PROVIDER 类型的路由节点， //一定要实现 com.alibaba.android.arouter.facade.template.IProvider 这个接口 routeMete = new RouteMeta(route, element, RouteType.PROVIDER, null); } else if (typeUtil.isSubtype(tm, type_Service.asType())) { // Service logger.info(">>> Found service route: " + tm.toString() + " <<<"); //SERVICE类型节点 routeMete = new RouteMeta(route, element, RouteType.parse(SERVICE), null); } else if (types.isSubtype(tm, fragmentTm) || types.isSubtype(tm, fragmentTmV4)) { logger.info(">>> Found fragment route: " + tm.toString() + " <<<"); //FRAGMENT类型节点 routeMete = new RouteMeta(route, element, RouteType.parse(FRAGMENT), null); } //routeMete包含了每个路由节点的各种信息，下面的方法的主要功能就是根据@Route注解信息对节点进行分组，保存在groupMap集合中。 //关于方法的具体实现，后面会有解析 categories(routeMete); } ......... } }

以上代码主要功能就是遍历所有被@Route注解的元素，然后将每个路由节点的信息按照类型（ACTIVITY类型，实现了IProvider 接口类型以及SERVICE类型）封装到RouteMeta中，最后调用categories(routeMete)方法将节点分组，保存在groupMap集合。

继续往下分析

 private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
        if (CollectionUtils.isNotEmpty(routeElements)) {
            ........

             /*
              然后创建ARouter$$Providers$$xxx 类中的loadInto()方法
             @Override
             public void loadInto(Map<String, RouteMeta> providers) {}
             */
            MethodSpec.Builder loadIntoMethodOfProviderBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
                    .addAnnotation(Override.class)
                    .addModifiers(PUBLIC)
                    .addParameter(providerParamSpec);

            //遍历分组的集合，生成相应的java文件 //因为本文使用的例子没有对页面进行分组，所以只生成了一个组文件ARouter$$Group$$xxx for (Map.Entry<String, Set<RouteMeta>> entry : groupMap.entrySet()) { String groupName = entry.getKey(); /* 创建ARouter$$Group$$xxx 类中的loadInto()方法 @Override public void loadInto(Map<String, RouteMeta> atlas) {} */ MethodSpec.Builder loadIntoMethodOfGroupBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO) .addAnnotation(Override.class) .addModifiers(PUBLIC) .addParameter(groupParamSpec); // 生成loadInto()方法体 Set<RouteMeta> groupData = entry.getValue(); //遍历每个组里面的路由节点 for (RouteMeta routeMeta : groupData) { switch (routeMeta.getType()) { //如果节点类型是PROVIDER， case PROVIDER: //获取路由节点元素的接口集合 List<? extends TypeMirror> interfaces = ((TypeElement) routeMeta.getRawType()).getInterfaces(); for (TypeMirror tm : interfaces) { if (types.isSameType(tm, iProvider)) { // Its implements iProvider interface himself. //路由节点元素其中一个接口是 com.alibaba.android.arouter.facade.template.IProvider //给ARouter$$Providers$$xxx 类中的loadInto()添加方法体 loadIntoMethodOfProviderBuilder.addStatement( "providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))", (routeMeta.getRawType()).toString(),//路由节点元素的全名 routeMetaCn, routeTypeCn, ClassName.get((TypeElement) routeMeta.getRawType()), routeMeta.getPath(), routeMeta.getGroup()); } else if (types.isSubtype(tm, iProvider)) { //路由节点元素其中一个接口是com.alibaba.android.arouter.facade.template.IProvider 接口的子类型 loadIntoMethodOfProviderBuilder.addStatement( "providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))", tm.toString(), //IProvider子类型的全名 routeMetaCn, routeTypeCn, ClassName.get((TypeElement) routeMeta.getRawType()), routeMeta.getPath(), routeMeta.getGroup()); } //上面方法体的代码为： //providers.put("实现接口的名称", RouteMeta.build(RouteType.PROVIDER, 类名.class, "@Route.path", "@Route.group", null, @Route.priority, @Route.extras)); } break; default: break; } // 将路由节点中被@Autowired注解的属性集合转换成字符串 StringBuilder mapBodyBuilder = new StringBuilder(); //获取路由节点中被@Autowired注解的属性集合 Map<String, Integer> paramsType = routeMeta.getParamsType(); if (MapUtils.isNotEmpty(paramsType)) { for (Map.Entry<String, Integer> types : paramsType.entrySet()) { mapBodyBuilder.append("put(\"").append(types.getKey()).append("\", ").append(types.getValue()).append("); "); } } String mapBody = mapBodyBuilder.toString(); //给ARouter$$Group$$xxx 类中的loadInto()添加方法体 //注意：有多个分组就会创建多个组文件 loadIntoMethodOfGroupBuilder.addStatement( "atlas.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, " + (StringUtils.isEmpty(mapBody) ? null : ("new java.util.HashMap<String, Integer>(){{" + mapBodyBuilder.toString() + "}}")) + ", " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))", routeMeta.getPath(), routeMetaCn, routeTypeCn, ClassName.get((TypeElement) routeMeta.getRawType()), routeMeta.getPath().toLowerCase(), routeMeta.getGroup().toLowerCase()); } // 真正生成ARouter$$Group$$test JAVA文件 //NAME_OF_GROUP = ARouter$$Group$$ // groupName = test; 关于groupname的值在方法categories(routeMete)中会有讲解 String groupFileName = NAME_OF_GROUP + groupName; JavaFile.builder(PACKAGE_OF_GENERATE_FILE, TypeSpec.classBuilder(groupFileName) .addJavadoc(WARNING_TIPS) .addSuperinterface(ClassName.get(type_IRouteGroup)) .addModifiers(PUBLIC) .addMethod(loadIntoMethodOfGroupBuilder.build()) .build() ).build().writeTo(mFiler); logger.info(">>> Generated group: " + groupName + "<<<"); //将生成的组文件放在rootmap集合中去，为下面生成ARouter$$Root$$xxx文件做准备 rootMap.put(groupName, groupFileName); } ....... } }

以上代码主要功能由几点：

  • 遍历groupmap集合给ARouter$$Group$$xxx类中的loadInto()添加方法体，并且生成ARouter$$Group$$xxx JAVA文件，而文件命名为ARouter$$Group$$+groupname，其中有多个分组就会创建多个组文件。比如AROUTER源码中的样例就生成了多个分组文件
两个分组文件

关于生成的loadInto()中的方法体的例子，来自 AROUTER源码中的样例：

public class ARouter$$Group$$test implements IRouteGroup { @Override public void loadInto(Map<String, RouteMeta> atlas) { //存在被@Autowired注解参数生成的代码 atlas.put("/test/activity1", RouteMeta.build(RouteType.ACTIVITY, Test1Activity.class, "/test/activity1", "test", new java.util.HashMap<String, Integer>(){{put("name", 18); put("boy", 0); put("age", 3); put("url", 18); }}, -1, -2147483648)); ..... //没有被@Autowired注解参数生成的代码 atlas.put("/test/activity4", RouteMeta.build(RouteType.ACTIVITY, Test4Activity.class, "/test/activity4", "test", null, -1, -2147483648)); .... } }
  • 遍历每个组里面的路由节点，查找节点类型是否为PROVIDER类型，如果是就向给ARouter$$Providers$$xxx类中的loadInto()添加方法，其文件命名ARouter$$Providers$$+modulename。关于生成的loadInto()中的方法体的例子，来自 AROUTER源码中的样例：
public class ARouter$$Providers$$app implements IProviderGroup { @Override public void loadInto(Map<String, RouteMeta> providers) { providers.put("com.alibaba.android.arouter.demo.testservice.HelloService", RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/service/hello", "service", null, -1, -2147483648)); //路由节点元素其中一个接口是IProvider的子类型 providers.put("com.alibaba.android.arouter.facade.service.SerializationService", RouteMeta.build(RouteType.PROVIDER, JsonServiceImpl.class, "/service/json", "service", null, -1, -2147483648)); //路由节点元素其中一个接口是IProvider接口 providers.put("com.alibaba.android.arouter.demo.testservice.SingleService", RouteMeta.build(RouteType.PROVIDER, SingleService.class, "/service/single", "service", null, -1, -2147483648)); } }
  • 将生成的组文件放在rootmap集合中去，为下面生成ARouter$$Root$$xxx文件做准备，其文件命名ARouter$$Root$$+modulename。

我们接着分析parseRoutes()方法最后一段代码，这段代码其实很简单，主要目的就是给ARouter$$Root$$xxx的loadInto()添加方法体，最后生成Router$$Providers$$xxx，ARouter$$Root$$xxx文件

 private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
        if (CollectionUtils.isNotEmpty(routeElements)) {
            ........
            //遍历rootMap集合，给ARouter$$Root$$xxx的`loadInto()`添加方法体
            if (MapUtils.isNotEmpty(rootMap)) { // Generate root meta by group name, it must be generated before root, then I can findout the class of group. for (Map.Entry<String, String> entry : rootMap.entrySet()) { loadIntoMethodOfRootBuilder.addStatement("routes.put($S, $T.class)", entry.getKey(), ClassName.get(PACKAGE_OF_GENERATE_FILE, entry.getValue())); } } // 生成Router$$Providers$$xxx文件 String providerMapFileName = NAME_OF_PROVIDER + SEPARATOR + moduleName; JavaFile.builder(PACKAGE_OF_GENERATE_FILE, TypeSpec.classBuilder(providerMapFileName) .addJavadoc(WARNING_TIPS) .addSuperinterface(ClassName.get(type_IProviderGroup)) .addModifiers(PUBLIC) .addMethod(loadIntoMethodOfProviderBuilder.build()) .build() ).build().writeTo(mFiler); logger.info(">>> Generated provider map, name is " + providerMapFileName + " <<<"); // 生成ARouter$$Root$$xxx文件 String rootFileName = NAME_OF_ROOT + SEPARATOR + moduleName; JavaFile.builder(PACKAGE_OF_GENERATE_FILE, TypeSpec.classBuilder(rootFileName) .addJavadoc(WARNING_TIPS) .addSuperinterface(ClassName.get(elementUtil.getTypeElement(ITROUTE_ROOT))) .addModifiers(PUBLIC) .addMethod(loadIntoMethodOfRootBuilder.build()) .build() ).build().writeTo(mFiler); logger.info(">>> Generated root, name is " + rootFileName + " <<<"); } }

关于生成的loadInto()中的方法体的例子，来自 AROUTER源码中的样例：

public class ARouter$$Root$$app implements IRouteRoot { @Override public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) { routes.put("service", ARouter$$Group$$service.class); routes.put("test", ARouter$$Group$$test.class); } }

上面分析的便是parseRoutes()方法所有代码的解析

3.最后我们看下categories()方法是如何分组的

   private void categories(RouteMeta routeMete) { //如果路由路径合法，且有groupname进行执行 if (routeVerify(routeMete)) { logger.info(">>> Start categories, group = " + routeMete.getGroup() + ", path = " + routeMete.getPath() + " <<<"); //根据groupname获取该组的路由节点集合，如果集合为空，则创建一个新的组，将该节点添加进去，并将组集合保存在groupmap中； //不为空，则添加到所属的组集合中去 Set<RouteMeta> routeMetas = groupMap.get(routeMete.getGroup()); if (CollectionUtils.isEmpty(routeMetas)) { Set<RouteMeta> routeMetaSet = new TreeSet<>(new Comparator<RouteMeta>() { @Override public int compare(RouteMeta r1, RouteMeta r2) { try { return r1.getPath().compareTo(r2.getPath()); } catch (NullPointerException npe) { logger.error(npe.getMessage()); return 0; } } }); routeMetaSet.add(routeMete); groupMap.put(routeMete.getGroup(), routeMetaSet); } else { routeMetas.add(routeMete); } } else { logger.warning(">>> Route meta verify error, group is " + routeMete.getGroup() + " <<<"); } } //判断路由路径是否合法，并且设置groupname private boolean routeVerify(RouteMeta meta) { String path = meta.getPath(); //如果路径为空，或者不是由'/'开头，返回false if (StringUtils.isEmpty(path) || !path.startsWith("/")) { // The path must be start with '/' and not empty! return false; } //如果在@Route注解中没有设置group标识，那么就默认取path路径第一段路径名作为groupname if (StringUtils.isEmpty(meta.getGroup())) { // Use default group(the first word in path) try { String defaultGroup = path.substring(1, path.indexOf("/", 1)); if (StringUtils.isEmpty(defaultGroup)) { return false; } meta.setGroup(defaultGroup); return true; } catch (Exception e) { logger.error("Failed to extract default group! " + e.getMessage()); return false; } } return true; }

通过分析，如果@Route注解中有设置group标识，作为groupname，如果没有就取/xxx1/xxx2，xxx1作为groupname，并将同一组的路由节点放到同一个集合中去。

至此关于@Route注解在编译期时生成ARouter$$Root$$xxx，Router$$Providers$$xxx，ARouter$$Group$$xxx三种映射文件的源码分析完毕。

2.ARouter初始化过程

ARouter经过代码编译后，生成了相应的映射文件，我们可以断定，ARouter 的初始化会将这些文件加载到内存中去，形成一个路由表，以供后面路由查找跳转之用。其相关源码可参见 arouter-api

  • ARouter的init()方法
public static void init(Application application) { if (!hasInit) { logger = _ARouter.logger; _ARouter.logger.info(Consts.TAG, "ARouter init start."); hasInit = _ARouter.init(application); if (hasInit) { _ARouter.afterInit(); } _ARouter.logger.info(Consts.TAG, "ARouter init over."); } }

由上面代码可以看出，其初始化实际上是调用了_ARouter 的 init ()方法，而且其他的跳转方法最终调用的也是_ARouter 种的方法。

  • _ARouter的init()方法
  protected static synchronized boolean init(Application application) { mContext = application; LogisticsCenter.init(mContext, executor); logger.info(Consts.TAG, "ARouter init success!"); hasInit = true; return true; }

_ARouter中又调用了LogisticsCenter.init()，继续追踪下去，其中传入了一个线程池executor，这个线程池在拦截器的时候会使用到。

    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException { mContext = context; executor = tpe; try { //ROUTE_ROOT_PAKCAGE = "com.alibaba.android.arouter.routes" // 获取ROUTE_ROOT_PAKCAGE 包里面的所有文件 List<String> classFileNames = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE); //遍历所有ROUTE_ROOT_PAKCAGE 包里的文件 for (String className : classFileNames) { //文件名以“com.alibaba.android.arouter.routes.ARouter$$Root”开头执行下面代码 if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) { // 通过反射实例化，并且调用loadInto()，目的即是将编译生成的ARouter$$Group$$xxx文件加载到内存中，保存在Warehouse.groupsIndex； ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex); } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) { //文件名以“com.alibaba.android.arouter.routes.ARouter$$Interceptors”开头执行下面代码 // 执行编译生成的ARouter$$Interceptors$$xxx的loadInto()，将自定义拦截器类存放在Warehouse.interceptorsIndex中 ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex); } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) { //文件名以“com.alibaba.android.arouter.routes.ARouter$$Providers”开头执行下面代码 // 执行编译生成的ARouter$$Interceptors$$xxx的loadInto() ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex); } } if (Warehouse.groupsIndex.size() == 0) { logger.error(TAG, "No mapping files were found, check your configuration please!"); } if (ARouter.debuggable()) { logger.debug(TAG, String.format(Locale.getDefault(), "LogisticsCenter has already been loaded, GroupIndex[%d], InterceptorIndex[%d], ProviderIndex[%d]", Warehouse.groupsIndex.size(), Warehouse.interceptorsIndex.size(), Warehouse.providersIndex.size())); } } catch (Exception e) { throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]"); } }
  • _ARouter的afterInit()方法
static void afterInit() { // 通过路由机制，初始化路由拦截机制。关于路由拦截机制的使用和原理，后续文章会有分析 interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation(); }

以上就是ARouter初始化的所有代码，关于如何查找到com.alibaba.android.arouter.routes包内所有文件这里便不做过多分析，大家可以去阅读 arouter-api中ClassUtils这个类的源码。
总结下来，其实ARouter 的初始化只做了一件事，找到自己编译期产生的清单文件，把 Group 、Interceptor 、Provider 三种清单加载到 Warehouse 内存仓库中。即下面这些文件，来源自AROUTER源码中的样例

值得注意的是，在初始化阶段，ARouter 仅载入了 Group 清单，并没有具体载入每个 Group 中包含的具体的路由节点清单，只有当使用到具体的 Group 时，才会加载对应的 Group 列表。这种分组管理，按需加载，大大的降低了初始化时的内存压力。并且Warehouse类中保存了路由清单，并且将使用过的路由对象缓存起来，之后查找都是直接使用缓存的对象 。

3.ARouter调用过程分析

页面跳转最基本方法

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

获取Provider服务（实现了IProvider接口以及IProvider子类接口的服务类）的方法有两种：

1.byName方式
ARouter.getInstance().build("/service/hello").navigation()

2.byType方式
ARouter.getInstance().navigation(HelloService.class)

ARouter路由跳转采用链式调用，ARouter.getInstance()其中采用的单例模式，获取ARouter的实例，这个就不作过多分析，主要分析build()和navigation()。

build()方法
ARouter的build(String path)和init()方法一样，调用的是_ARouter的build(String path)方法。

  protected Postcard build(String path) {
        if (TextUtils.isEmpty(path)) { throw new HandlerException(Consts.TAG + "Parameter is invalid!"); } else { PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class); if (null != pService) { path = pService.forString(path); } return build(path, extractGroup(path)); } }

其中extractGroup(String path)就是根据path获取分组名，即path第一段“/”符号之间的值

  private String extractGroup(String path) {
        if (TextUtils.isEmpty(path) || !path.startsWith("/")) {
            throw new HandlerException(Consts.TAG + "Extract the default group failed, the path must be start with '/' and contain more than 2 '/'!"); } try { // /xxx1/xxx2 ===> defaulGroup = xxx1 String defaultGroup = path.substring(1, path.indexOf("/", 1)); if (TextUtils.isEmpty(defaultGroup)) { throw new HandlerException(Consts.TAG + "Extract the default group failed! There's nothing between 2 '/'!"); } else { return defaultGroup; } } catch (Exception e) { logger.warning(Consts.TAG, "Failed to extract default group! " + e.getMessage()); return null; } }

build(String path)方法最终调用的是build(String path, String group)

    protected Postcard build(String path, String group) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) { throw new HandlerException(Consts.TAG + "Parameter is invalid!"); } else { PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class); if (null != pService) { path = pService.forString(path); } return new Postcard(path, group); } }

值得注意的是其中ARouter.getInstance().navigation(PathReplaceService.class)就是得到实现PathReplaceService接口的一个服务对象，对原始path进行处理后，生成新的path路径。而这个类需要我们自己自定义去实现，如果没有实现，pService=null，原始path不做任何处理。
下面是PathReplaceService接口，我们可以通过实现forString()和forUri()方法，对某些url进行替换处理，跳转到其他的目标页面。

public interface PathReplaceService extends IProvider { /** * For normal path. * * @param path raw path */ String forString(String path); /** * For uri type. * * @param uri raw uri */ Uri forUri(Uri uri); }

最后返回一个Postcard实例对象，里面封装了路由节点的路径，分组等节点信息。其实build()方法的目的只有一个就是根据路由，封装成Postcard对象，其对象贯穿之后整个路由过程。Postcard 包含了众多的属性值，提供了路由过程中所有的控制变量。

public final class Postcard extends RouteMeta { private Uri uri; private Object tag; // A tag prepare for some thing wrong. private Bundle mBundle; // 传递的参数 private int flags = -1; // intent 的flag标志 private int timeout = 300; // Navigation timeout, TimeUnit.Second ! private IProvider provider; // IProvider服务对象 private boolean greenChannal; private SerializationService serializationService;//序列化服务对象 // 跳转动画 private Bundle optionsCompat; // The transition animation of activity private int enterAnim; private int exitAnim; // copy from RouteMeta private RouteType type; // 路由节点类型 private Element rawType; private Class<?> destination; //需要跳转到的页面 private String path; // 路径 private String group; // 分组 private int priority = -1; // 优先级 private int extra; // 配置标识 private Map<String, Integer> paramsType; // 路由页面被@Autowired注解属性 // ...... }

navigation()方法
关于页面跳转的navigation()方法有多个重载的方法，但最终都会调用_ARouter下面这个方法

    protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) { try { //首先对postcard进行一些处理，设置postcard的destination，type，priority 等一些属性值，completion()后面会有分析 LogisticsCenter.completion(postcard); } catch (NoRouteFoundException ex) { logger.warning(Consts.TAG, ex.getMessage()); if (debuggable()) { // Show friendly tips for user. Toast.makeText(mContext, "There's no route matched!\n" + " Path = [" + postcard.getPath() + "]\n" + " Group = [" + postcard.getGroup() + "]", Toast.LENGTH_LONG).show(); } // 如果处理postcard失败，通过 callback 回调失败结果 // callback为空的情况下，如果有定义全局的降级处理（DegradeService），则使用全局处理 //降级处理也需要我们自己实现DegradeService接口 if (null != callback) { callback.onLost(postcard); } else { // No callback for this invoke, then we use the global degrade service. DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class); if (null != degradeService) { degradeService.onLost(context, postcard); } } return null; } //路由处理成功，回调callback.onFound() if (null != callback) { callback.onFound(postcard); } //目前来说，PROVIDER服务类型，以及FRAGMENT类型不需要通过拦截器外，其他类型均需要通过拦截器 //关于拦截器相关用法及原理分析在后续的文章中会讲解到，大家去可以关注下 if (!postcard.isGreenChannel()) { interceptorService.doInterceptions(postcard, new InterceptorCallback() { /** * Continue process * * @param postcard route meta */ @Override public void onContinue(Postcard postcard) { _navigation(context, postcard, requestCode, callback); } /** * Interrupt process, pipeline will be destory when this method called. * * @param exception Reson of interrupt. */ @Override public void onInterrupt(Throwable exception) { if (null != callback) { callback.onInterrupt(postcard); } logger.info(Consts.TAG, "Navigation failed, termination by interceptor : " + exception.getMessage()); } }); } else { return _navigation(context, postcard, requestCode, callback); } return null; }

值得注意的是，当跳转路由处理失败的时候，会获取一个降级服务，我们可以实现DegradeService接口，实现onLost()方法，对路由处理失败的情况进行处理，比如跳转到一个信息提示页面，让用户去更新版本等操作等。 下面是DegradeService接口：

public interface DegradeService extends IProvider { /** * Router has lost. * * @param postcard meta */ void onLost(Context context, Postcard postcard); }

通过上面代码的分析，不管是否通过拦截器进行处理，最后都会调用_navigation()达到路由的目的：

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: //下面就是最基本的使用intent进行activity进行跳转 // 创建intent final Intent intent = new Intent(currentContext, postcard.getDestination()); //设置传参 intent.putExtras(postcard.getExtras()); //activity启动标志 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); } // 在主线程中进行跳转 new Handler(Looper.getMainLooper()).post(new Runnable() { @Override public void run() { //新版本带转场动画的启动方式 if (requestCode > 0) { // Need start for result ActivityCompat.startActivityForResult((Activity) currentContext, intent, requestCode, postcard.getOptionsBundle()); } else { ActivityCompat.startActivity(currentContext, intent, postcard.getOptionsBundle()); } if ((0 != postcard.getEnterAnim() || 0 != postcard.getExitAnim()) && currentContext instanceof Activity) { // Old version. //老版本的跳转动画 ((Activity) currentContext).overridePendingTransition(postcard.getEnterAnim(), postcard.getExitAnim()); } //跳转成功，回调callback.onArrival() if (null != callback) { // Navigation over. callback.onArrival(postcard); } } }); break; case PROVIDER: return postcard.getProvider(); case BOARDCAST: case CONTENT_PROVIDER: case FRAGMENT: Class fragmentMeta = postcard.getDestination(); try { //实例化fragment，并传递参数 Object instance = fragmentMeta.getConstructor().newInstance(); 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实现了 ACTIVITY ， PROVIDER ，FRAGMENT三种种类型。上面关于postcard的provider，destination的值都是在completion()中设置的。我们接着看LogisticsCenter的completion(Postcard postcard)。

    public synchronized static void completion(Postcard postcard) {
        if (null == postcard) {
            throw new NoRouteFoundException(TAG + "No postcard!"); } // 查找Warehouse仓库的路由节点缓存，看是否已在缓存中 RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath()); if (null == routeMeta) { // 如果没有，查找仓库的组别清单中是否存在该组别，组别清单已经在初始化的时候加载到仓库中去了 Class<? extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup()); //如果没有抛出异常 if (null == groupMeta) { throw new NoRouteFoundException(TAG + "There is no route match the path [" + postcard.getPath() + "], in group [" + postcard.getGroup() + "]"); } else { // Load route and cache it into memory, then delete from metas. try { if (ARouter.debuggable()) { logger.debug(TAG, String.format(Locale.getDefault(), "The group [%s] starts loading, trigger by [%s]", postcard.getGroup(), postcard.getPath())); } // 实例化个组别的类，调用loadInto()，将组别中所有的路由节点加载进仓库Warehouse.routes，缓存 IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance(); iGroupInstance.loadInto(Warehouse.routes); // 从组别清单中删除已加载的组别，防止重复加载 Warehouse.groupsIndex.remove(postcard.getGroup()); if (ARouter.debuggable()) { logger.debug(TAG, String.format(Locale.getDefault(), "The group [%s] has already been loaded, trigger by [%s]", postcard.getGroup(), postcard.getPath())); } } catch (Exception e) { throw new HandlerException(TAG + "Fatal exception when loading group meta. [" + e.getMessage() + "]"); } //当路由节点加载到缓存中去后，重新查找执行else代码，对postcard进行处理 completion(postcard); // Reload } } else { //给postcard设置destination,type,priority等值，供上面讲解到的_navigation()进行使用 // 其中routeMeta是在ARouter$$Group$$xxx的loadInto中创建的 postcard.setDestination(routeMeta.getDestination()); postcard.setType(routeMeta.getType()); postcard.setPriority(routeMeta.getPriority()); postcard.setExtra(routeMeta.getExtra()); //如果通过build(Uri url) 进行跳转的话 通过解析url ，将传参保存进bundle中 Uri rawUri = postcard.getUri(); if (null != rawUri) { //splitQueryParameters()就是在uri中携带的参数进行解析 Map<String, String> resultMap = TextUtils.splitQueryParameters(rawUri); Map<String, Integer> paramsType = routeMeta.getParamsType(); if (MapUtils.isNotEmpty(paramsType)) { // Set value by its type, just for params which annotation by @Param for (Map.Entry<String, Integer> params : paramsType.entrySet()) { setValue(postcard, params.getValue(), params.getKey(), resultMap.get(params.getKey())); } // Save params name which need autoinject. postcard.getExtras().putStringArray(ARouter.AUTO_INJECT, paramsType.keySet().toArray(new String[]{})); } // Save raw uri postcard.withString(ARouter.RAW_URI, rawUri.toString()); } //从这里也可以看出PROVIDER，FRAGMENT不需要通过拦截器 switch (routeMeta.getType()) { case PROVIDER: // 如果是PROVIDER节点类型，从服务节点列表中获取，如果没有，则实例化，并保存在服务节点列表Warehouse.providers中 //并将实例化的对象设置给postcard的provider属性 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); postcard.greenChannel(); // Provider should skip all of interceptors break; case FRAGMENT: postcard.greenChannel(); // Fragment needn't interceptors default: break; } } }

分析到这里，关于页面基本跳转的原理分析就已经结束了。最后就是关于获取Provider服务两种方法的源码分析。其中byName方式，和页面跳转是一模一样的。我们只需要看看byType方式即可。byType方式最后调用的是_ARouter的navigation(Class<? extends T> service)

  protected <T> T navigation(Class<? extends T> service) { try { // 通过 className 获取 Postcard 对象 Postcard postcard = LogisticsCenter.buildProvider(service.getName()); // 兼容1.0.5 compiler sdk版本. if (null == postcard) { // No service, or this service in old version. postcard = LogisticsCenter.buildProvider(service.getSimpleName()); } // 对 Postcard 对象进行处理 LogisticsCenter.completion(postcard); //返回 Postcard 中的 provider 属性值 return (T) postcard.getProvider(); } catch (NoRouteFoundException ex) { logger.warning(Consts.TAG, ex.getMessage()); return null; } }

上面代码中的completion()方法之前已经分析过了，只需要看下LogisticsCenter.buildProvider(service.getName())即可。

  public static Postcard buildProvider(String serviceName) { RouteMeta meta = Warehouse.providersIndex.get(serviceName); if (null == meta) { return null; } else { return new Postcard(meta.getPath(), meta.getGroup()); } }

这个方法非常的简单，就是根据服务类名去仓库Warehouse.providersIndex中获去路由节点元素，然后封装在Postcard对象中。服务类清单列表Warehouse.providersIndex中的值是在初始化时缓存的。值得注意的是，PROVIDER 类型的路由节点既存在于对应的分组中，也存在于服务类清单列表中。所以，ARouter 可通过byType，byName两种方式来获取。

补充

关于ARouter的基本用法上面只有最基本跳转的介绍，下面对其他一些基本使用进行下补充

  • 带参数跳转
//1.传递参数
 ARouter.getInstance().build("/test/activity1")
                        .withString("name", "老王")
                        .withInt("age", 18) .withBoolean("boy", true) .withLong("high", 180) .withString("url", "https://a.b.c") .withParcelable("pac", testParcelable) .withObject("obj", testObj) .navigation(); //2.直接传递Bundle Bundle params = new Bundle(); ARouter.getInstance() .build("/test/activity1") .with(params) .navigation();

这些传参都是保存在生成的postcard对象中的mBundle属性里，然后在跳转的时候通过intent.putExtras(postcard.getExtras())达到传送参数的目的。
值得注意的是，关于对象的传递有两种，一种是withParcelable()方法，不过此方法需要传递的对象实现Parcelable接口，达到序列化的目的；另外一种是withObject()方法，此方法的原理是将实体类转换成json字符串，通过String的方式进行传递，而且使用这种方式需要实现 SerializationService，并使用@Route注解标注，下面是ARouter样例：

@Route(path = "/service/json")
public class JsonServiceImpl implements SerializationService { @Override public void init(Context context) { } @Override public <T> T json2Object(String text, Class<T> clazz) { return JSON.parseObject(text, clazz); } @Override public String object2Json(Object instance) { return JSON.toJSONString(instance); } }

而且，需要在跳转到的页面获取JsonServiceImpl服务，将json字符串转换成对象。

SerializationService serializationService = ARouter.getInstance().navigation(SerializationService.class);
TestObj obj = serializationService.json2Object(getIntent().getString("obj"), TestObj.class);
  • 带返回结果跳转
ARouter.getInstance().build("/test/activity2").navigation(this, 666);

值得注意的是，这时候的 navigation需要传递activit和requestCode。

  • 获取Fragment的实例

定义一个fragment

@Route(path = "/test/fragment")
public class BlankFragment extends Fragment { public BlankFragment() { //必须要一个空的构造器 } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { TextView textView = new TextView(getActivity()); return textView; } }

获取frament

Fragment fragment = (Fragment) ARouter.getInstance().build("/test/fragment").navigation();
  • 带转场动画跳转
// 转场动画(常规方式)
 ARouter.getInstance() .build("/test/activity2")
                      .withTransition(R.anim.slide_in_bottom, R.anim.slide_out_bottom)
                      .navigation(this);

// 转场动画(API16+)
 ActivityOptionsCompat compat = ActivityOptionsCompat.makeScaleUpAnimation(v, v.getWidth() / 2, v.getHeight() / 2, 0, 0); ARouter.getInstance().build("/test/activity2").withOptionsCompat(compat) .navigation();
  • 获取服务

服务是全局单例的，只有在第一次使用到的时候才会被初始化。
暴露服务，必须实现IProvider 接口 或者其子类型

// 声明接口,其他组件通过接口来调用服务
public interface HelloService extends IProvider { String sayHello(String name); } // 实现接口 @Route(path = "/service/hello", name = "测试服务") public class HelloServiceImpl implements HelloService { @Override public String sayHello(String name) { return "hello, " + name; } @Override public void init(Context context) { } }

获取服务

//bytype
HelloService helloService1 = ARouter.getInstance().navigation(HelloService.class);
//byname
HelloService helloService2 = (HelloService) ARouter.getInstance().build("/service/hello").navigation();
  • 多模块结构

app中可能存在多个模块，每个模块下面都有一个root结点，每个root结点都会管理整个模块中的group节点，每个group结点则包含了该分组下的所有页面，而每个模块允许存在多个分组，每个模块中都会有一个拦截器节点就是Interceptor结点，除此之外每个模块还会有控制拦截反转的provider结点

最后

到此，关于ARouter的基本用法以及原理分析的就全部结束了，如果有不清楚或者错误的地方，希望各位同学指出。关于ARouter拦截器，各种服务，依赖注入等更多进阶用法及源码分析会更新在后续的文章。

如果各位同学认为本文对你有一些帮助，希望能点个喜欢，谢谢！

猜你喜欢

转载自www.cnblogs.com/ldq2016/p/10504657.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022