devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android library依赖 aar_Android-模块化、组件化、插件化、热修复-组件化工程构建+页面路由多种方式实践...

作者：从前慢现在也慢 | 2024-03-28 21:52:18

赞

踩

android多个模块间 依赖 arr api

上一篇MonkeyLei：Android-模块化、组件化、插件化、热修复-组件化一下试试 我们大概尝试了下一个Module的library与application切换。这也是为为后续的继续做准备...今天我们就尝试自己搭建一个组件化工程，并初步做一个页面的跳转（组件间的通信其中一个点），后续还会完善组件间相互通信的方式。

工程实践完后，我会设置下Module的状态（Library和Module直接做切换），然后单独运行App或者Module，如果都没问题，这才能保证组件之间无耦合！！！

工程走起!

cbf929ddd3e5aefdfd11aea8e6babf2b.png

1. 公共库Module一般作为Library使用。而组件Module我们可以来回切换，但是我们新建Module的时候还是如下方式（保证有启动的manifest配置）：

57d7892b0367db709e7252b9327c38e9.png

f4b012711bd05efab7ea4e348a022284.png

2. 然后按照上一篇学到的知识，代码配置下Module的Library和Application切换；然而为了方便统一管理App基础信息，各个Module的版本信息，以及第三方依赖库的版本信息等，我们项目根目录下新建一个config.gradle，专门用来配置：

config.gradle

  1.   /**
  2.  * 全局统一配置
  3.  */
  4. ext {
  5.     /**
  6.      * module开关统一声明在此处
  7.      * true：module作为application，可单独打包为apk
  8.      * false：module作为library，可作为宿主application的组件
  9.      */
  10.     isLoginModule = false
  11.     isPersonalModule = false
  12.  
  13.     /**
  14.      * 版本统一管理
  15.      */
  16.     versions = [
  17.             applicationId          : "com.skl.zujianhua",        // 应用ID
  18.             versionCode            : 1,                         // 版本号
  19.             versionName            : "1.0.0",                    // 版本名称
  20.  
  21.             compileSdkVersion      : 28,
  22.             minSdkVersion          : 15,
  23.             targetSdkVersion       : 28,
  24.             buildToolsVersion      : "29.0.0",
  25.  
  26.             constraintlayoutVersion: "1.1.3",
  27.             runnerVersion          : "1.0.2",
  28.             espressoVersion        : "3.0.2",
  29.             junitVersion           : "4.12",
  30.             appcompatVersion       : "28.0.0",
  31.  
  32.             arouterApiVersion      : "1.5.0",
  33.             arouterCompilerVersion : "1.2.2",
  34.     ]
  35.  
  36.     dependencies = [
  37.             "appcompat"       : "com.android.support:appcompat-v7:${versions["appcompatVersion"]}",
  38.             "constraintlayout": "com.android.support.constraint:constraint-layout:${versions["constraintlayoutVersion"]}",
  39.             "runner"          : "com.android.support.test:runner:${versions["runnerVersion"]}",
  40.             "espresso_core"   : "com.android.support.test.espresso:espresso-core:${versions["espressoVersion"]}",
  41.             "junit"           : "junit:junit:${versions["junitVersion"]}",
  42.             // TODO MD等新增支持库
  43.             //            //注释处理器
  44.             //            "support_annotations" : "com.android.support:support-annotations:${versions["annotationsVersion"]}",
  45.             //            "design"              : "com.google.android.material:material:${versions["designVersion"]}",
  46.  
  47.             // TODO 其他公共的依赖都可以配置到这里
  48.             //               //方法数超过65535解决方法64K MultiDex分包方法
  49.             //            "multidex"            : "androidx.multidex:multidex:2.0.0",
  50.  
  51.             //阿里路由
  52.             "arouter_api"     : "com.alibaba:arouter-api:${versions["arouterApiVersion"]}",
  53.             "arouter_compiler": "com.alibaba:arouter-compiler:${versions["arouterCompilerVersion"]}",
  54.             //            "arouter_annotation"  : "com.alibaba:arouter-annotation:${versions["arouterAnnotationVersion"]}",
  55.             //
  56.             //            //黄油刀
  57.             //            "butterknife"         : "com.jakewharton:butterknife:${versions["butterknifeVersion"]}",
  58.             //            "butterknife_compiler": "com.jakewharton:butterknife-compiler:${versions["butterknifeVersion"]}"
  59.     ]
  60. }

2.1 根目录下的build.gradle下添加config配置：

  apply from: "config.gradle"

3. 此时我们不想每个Library/Application用到第三方库（比如Butterknife、Arouter、MultiDex等）都去依赖，因此我们新建一个基础模块basemodule: - (Arouter实践过了，所以就一并贴出来算了。不过我们的学习过程一般都是渐进式的，先实现基础工程，模块的构建，完事三方依赖都配置好，切换都测试成功了，然后再开始搞路由！)

重点看下build.gradle配置：

  1. apply plugin: 'com.android.library'
  2.  
  3. android {
  4.     compileSdkVersion 28
  5.     buildToolsVersion "29.0.0"
  6.  
  7.  
  8.     defaultConfig {
  9.         minSdkVersion 15
  10.         targetSdkVersion 28
  11.         versionCode 1
  12.         versionName "1.0"
  13.  
  14.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  15.         javaCompileOptions {
  16.             annotationProcessorOptions {
  17.                 arguments = [AROUTER_MODULE_NAME: project.getName()]
  18.             }
  19.         }
  20.     }
  21.  
  22.     buildTypes {
  23.         release {
  24.             minifyEnabled false
  25.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  26.         }
  27.     }
  28.  
  29. }
  30.  
  31. dependencies {
  32.     implementation fileTree(dir: 'libs', include: ['*.jar'])
  33.  
  34.     // 把implementation 用api代替,它是对外部公开的, 所有其他的module就不需要添加该依赖
  35.     api rootProject.ext.dependencies["appcompat"]
  36.     api rootProject.ext.dependencies["constraintlayout"]
  37.     api rootProject.ext.dependencies["junit"]
  38.     api rootProject.ext.dependencies["runner"]
  39.     api rootProject.ext.dependencies["espresso_core"]
  40.  
  41.     //    //注释处理器，butterknife所必需
  42.     //    api rootProject.ext.dependencies["support_annotations"]
  43.     //
  44.     //    //MultiDex分包方法
  45.     //    api rootProject.ext.dependencies["multidex"]
  46.     //
  47.     //    //Material design
  48.     //    api rootProject.ext.dependencies["design"]
  49.     //
  50.     //    //黄油刀
  51.     //    api rootProject.ext.dependencies["butterknife"]
  52.     //    annotationProcessor rootProject.ext.dependencies["butterknife_compiler"]
  53.  
  54.     //Arouter路由
  55.     annotationProcessor rootProject.ext.dependencies["arouter_compiler"]
  56.     api rootProject.ext.dependencies["arouter_api"]
  57.     //    api rootProject.ext.dependencies["arouter_annotation"]
  58. }

4. 然后接着我们创建Appliaction模块Login和Personal，这样创建出来就直接配置上了，然后单独可以运行啦，记得都依赖上basemodule - 后续的公共模块都可以放到basemodule中去！

50617d8d1ae651cce96da3010af68077.png

4.1 然后根据之前的知识配置下和Library的切换: - 参数都是根目录/congig.gradle配置的，别忘记了

login/build.gradle

  1.  if (Boolean.valueOf(rootProject.ext.isLoginModule)) {
  2.     apply plugin: 'com.android.application'
  3. } else {
  4.     apply plugin: 'com.android.library'
  5. }
  6.  
  7. // TODO 虽然依赖了公共库，但是有些配置还是要模块内部自己配置
  8. // apply plugin: 'com.jakewharton.butterknife'
  9.  
  10. android {
  11.     compileSdkVersion 28
  12.     buildToolsVersion "29.0.0"
  13.  
  14.  
  15.     defaultConfig {
  16.         // Application模式下设置applicationId
  17.         if (Boolean.valueOf(rootProject.ext.isLoginModule)) {
  18.             applicationId "com.skl.login"
  19.         }
  20.         minSdkVersion 15
  21.         targetSdkVersion 28
  22.         versionCode 1
  23.         versionName "1.0"
  24.  
  25.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  26.         javaCompileOptions {
  27.             annotationProcessorOptions {
  28.                 arguments = [AROUTER_MODULE_NAME: project.getName()]
  29.             }
  30.         }
  31.     }
  32.  
  33.     buildTypes {
  34.         release {
  35.             minifyEnabled false
  36.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  37.         }
  38.     }
  39.  
  40.     sourceSets {
  41.         main {
  42.             if (Boolean.valueOf(rootProject.ext.isLoginModule)) {
  43.                 manifest.srcFile 'src/main/AndroidManifest.xml'
  44.             } else {
  45.                 // Library模式可以不用配置manifest文件
  46.             }
  47.         }
  48.     }
  49. }
  50.  
  51. dependencies {
  52.     implementation fileTree(dir: 'libs', include: ['*.jar'])
  53.  
  54.     // 公共依赖库
  55.     implementation project(path: ':basemodule')
  56.  
  57.     // TODO 虽然依赖了公共库，但是有些配置还是要模块内部自己配置
  58.     //    //黄油刀
  59.     //    annotationProcessor rootProject.ext.dependencies["butterknife_compiler"]
  60.     //Arouter路由
  61.     annotationProcessor rootProject.ext.dependencies["arouter_compiler"]
  62. }

personal/build.gradle

  1. if (Boolean.valueOf(rootProject.ext.isPersonalModule)) {
  2.     apply plugin: 'com.android.application'
  3. } else {
  4.     apply plugin: 'com.android.library'
  5. }
  6.  
  7. // TODO 虽然依赖了公共库，但是有些配置还是要模块内部自己配置
  8. // apply plugin: 'com.jakewharton.butterknife'
  9.  
  10. android {
  11.     compileSdkVersion 28
  12.     buildToolsVersion "29.0.0"
  13.  
  14.  
  15.     defaultConfig {
  16.         // Application模式下设置applicationId
  17.         if (Boolean.valueOf(rootProject.ext.isLoginModule)) {
  18.             applicationId "com.skl.personal"
  19.         }
  20.         minSdkVersion 15
  21.         targetSdkVersion 28
  22.         versionCode 1
  23.         versionName "1.0"
  24.  
  25.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  26.         javaCompileOptions {
  27.             annotationProcessorOptions {
  28.                 arguments = [AROUTER_MODULE_NAME: project.getName()]
  29.             }
  30.         }
  31.     }
  32.  
  33.     buildTypes {
  34.         release {
  35.             minifyEnabled false
  36.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  37.         }
  38.     }
  39.  
  40.     sourceSets {
  41.         main {
  42.             if (Boolean.valueOf(rootProject.ext.isPersonalModule)) { // apk
  43.                 manifest.srcFile 'src/main/AndroidManifest.xml'
  44.             } else {
  45.                 // Library模式可以不用配置manifest文件
  46.             }
  47.         }
  48.     }
  49. }
  50.  
  51. dependencies {
  52.     implementation fileTree(dir: 'libs', include: ['*.jar'])
  53.  
  54.     // 公共依赖库
  55.     implementation project(path: ':basemodule')
  56.  
  57.     // TODO 虽然依赖了公共库，但是有些配置还是要模块内部自己配置
  58.     //    //黄油刀
  59.     //    annotationProcessor rootProject.ext.dependencies["butterknife_compiler"]
  60.     //Arouter路由
  61.     annotationProcessor rootProject.ext.dependencies["arouter_compiler"]
  62. }

5. 修改下app主模块下的布局，做一个点击按钮事件，分别用来跳转到login和personal页面:

app/activity_main.xml 

  1.     <?xml version="1.0" encoding="utf-8"?>
  2. <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity">
  8.  
  9.     <Button
  10.         android:layout_width="wrap_content"
  11.         android:layout_height="wrap_content"
  12.         android:onClick="GoLogin"
  13.         android:text="跳转到Login界面"
  14.         app:layout_constraintLeft_toLeftOf="parent"
  15.         app:layout_constraintTop_toTopOf="parent" />
  16.  
  17.     <Button
  18.         android:layout_width="wrap_content"
  19.         android:layout_height="wrap_content"
  20.         android:onClick="GoPersonal"
  21.         android:text="跳转到个人信息页面"
  22.         app:layout_constraintEnd_toEndOf="parent"
  23.         app:layout_constraintTop_toTopOf="parent" />
  24.  
  25. </android.support.constraint.ConstraintLayout>

MainActivity.java 

  1. package com.skl.zujianhua;
  2.  
  3. import android.support.v7.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6.  
  7. import com.alibaba.android.arouter.launcher.ARouter;
  8.  
  9. public class MainActivity extends AppCompatActivity {
  10.  
  11.     @Override
  12.     protected void onCreate(Bundle savedInstanceState) {
  13.         super.onCreate(savedInstanceState);
  14.         setContentView(R.layout.activity_main);
  15.     }
  16.  
  17.     /**
  18.      * 跳转到登录页面
  19.      *
  20.      * @param view
  21.      */
  22.     public void GoLogin(View view) {
  23.         // 跳转方式1： 通过反射
  24. //        try {
  25. //            Class clazz = Class.forName("com.skl.login.LoginActivity");
  26. //            Intent intent = new Intent(this, clazz);
  27. //            startActivity(intent);
  28. //            // startActivityForResult(intent, 110);
  29. //        } catch (ClassNotFoundException e) {
  30. //            e.printStackTrace();
  31. //        }
  32.  
  33.         // 跳转方式2：每个页面都注册到base模块，由base模块提供跳转服务
  34. //        CompomentsService.getiAppComponentHashMap(AppConfig.PAGE_TYPE.LOGIN).launch(this, null);
  35.  
  36.         // 跳转方式3：采用URI方式
  37. //        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("activity://login")));
  38.  
  39.         // 跳转方式4：采用 Arouter
  40.         ARouter.getInstance().build("/hl/login")
  41.                 // .withString("nothing", "Gone with the Wind")
  42.                 // .withObject("author", Object)
  43.                 .navigation(this, 110);
  44.     }
  45.  
  46.     /**
  47.      * 跳转到个人中心
  48.      *
  49.      * @param view
  50.      */
  51.     public void GoPersonal(View view) {
  52.         // 跳转方式4：采用 Arouter
  53.         ARouter.getInstance().build("/ppx/personal")
  54.                 // .withString("nothing", "Gone with the Wind")
  55.                 // .withObject("author", Object)
  56.                 .navigation(this, 110);
  57.     }
  58. }

5.1 上面分别列出了四种跳转方式，首先反射的方式，这个要试试哈。记得页面是需要配置到AndroidManifest.xml的哟。

5.2 先说跳转方式3， URI的方式，这个需要配置待跳转页面的scheme、host、action、category信息，然后跳转时根据scheme和host做路由：

login/src/main/AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.skl.login">
  4.  
  5.     <application
  6.         android:allowBackup="true"
  7.         android:icon="@mipmap/ic_launcher"
  8.         android:label="@string/app_name"
  9.         android:roundIcon="@mipmap/ic_launcher_round"
  10.         android:supportsRtl="true"
  11.         android:theme="@style/AppTheme">
  12.         <activity android:name=".LoginActivity">
  13.             <!--跳转方式3：提供URI方式-->
  14.             <intent-filter>
  15.                 <action android:name="android.intent.action.VIEW" />
  16.                 <category android:name="android.intent.category.DEFAULT" />
  17.                 <category android:name="android.intent.category.BROWSABLE" />
  18.                 <data android:scheme="activity" />
  19.                 <data android:host="login" />
  20.             </intent-filter>
  21.         </activity>
  22.     </application>
  23.  
  24. </manifest>

然后 startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("activity://login")));就可以跳转了啦.....

5.3 接着说跳转方式4 ，ARouter的方式，github地址，上面配置方式都有啦：alibaba/ARouter

照着配置就行，不过要注意我们有basemodule，多个library，so，注意下面这个说明： - javaCompileOptions比较关键，不然你的路由就会报="http://www.baidu.com/link?url=SFoQYEc0VH3o8IZkDe1H0v2W30NKqGHpsDU24PfR5pLn_c7GdXgkmO8moxxq7YGDO8VFzM4u0FFIwpTv25xIgKeKXK3YTN6DS8bTFKQuthy">ARouter there's no route matched

  1.  虽然我们basemodule采用api的方式引入了arouter：
  2. basemodule/build.gradle
  3.     //Arouter路由
  4.     annotationProcessor rootProject.ext.dependencies["arouter_compiler"]
  5.     api rootProject.ext.dependencies["arouter_api"]
  6.  
  7.  
  8. 但是其他的Module需要使用的地方同样需要添加如下配置：
  9. login/build.gradle
  10. personal/build.gradle
  11.  
  12. android {
  13.     compileSdkVersion 28
  14.     buildToolsVersion "29.0.0"
  15.  
  16.     defaultConfig {
  17.         ......
  18.         javaCompileOptions {
  19.             annotationProcessorOptions {
  20.                 arguments = [AROUTER_MODULE_NAME: project.getName()]
  21.             }
  22.         }
  23.     }
  24.     .....
  25. }
  26.  
  27. dependencies {
  28.     implementation fileTree(dir: 'libs', include: ['*.jar'])
  29.  
  30.     // 公共依赖库
  31.     implementation project(path: ':basemodule')
  32.  
  33.     // TODO 虽然依赖了公共库，但是有些配置还是要模块内部自己配置
  34.     //    //黄油刀
  35.     //    annotationProcessor rootProject.ext.dependencies["butterknife_compiler"]
  36.     // Arouter路由
  37.     annotationProcessor rootProject.ext.dependencies["arouter_compiler"]
  38. }

5.3.1 然后我们的login，personal都配置上路由信息，方便路由跳转(其他用法待深入） - 路由配置注意：不同module的路由路径的一级命名不能相同。

4911375943d6846f1057b9e8dac6a59f.png

login/ LoginActivity.java 

  1.   package com.skl.login;
  2.  
  3. import android.support.v7.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6.  
  7. import com.alibaba.android.arouter.facade.annotation.Route;
  8.  
  9. @Route(path = "/hl/login")
  10. public class LoginActivity extends AppCompatActivity {
  11.  
  12.     @Override
  13.     protected void onCreate(Bundle savedInstanceState) {
  14.         super.onCreate(savedInstanceState);
  15.         setContentView(R.layout.activity_login);
  16.     }
  17.  
  18.     /**
  19.      * 登录 + 可以保存数据到本地(采用sharedpreferences的方式存储)
  20.      * TODO 注意：这里为了模拟组件间的接口调用，采用其他方式
  21.      * @param view
  22.      */
  23.     public void logining(View view) {
  24.  
  25.     }
  26. }

personal/PersonalActivity.java 

  1.  package com.skl.personal;
  2.  
  3. import android.support.v7.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6.  
  7. import com.alibaba.android.arouter.facade.annotation.Route;
  8.  
  9. @Route(path = "/ppx/personal")
  10. public class PersonalActivity extends AppCompatActivity {
  11.  
  12.     @Override
  13.     protected void onCreate(Bundle savedInstanceState) {
  14.         super.onCreate(savedInstanceState);
  15.         setContentView(R.layout.activity_personal);
  16.     }
  17.  
  18.     /**
  19.      * 获取登录页面个人信息并展示
  20.      * @param view
  21.      */
  22.     public void getLoginInfo(View view) {
  23.  
  24.     }
  25. }

然后开始路由前，主模块app下的MainApplication需要初始化路由组件 - 直接文档添加过来稍加处理就行

  1.         // ARouter路由初始化
  2.         if (BuildConfig.DEBUG) {           // These two lines must be written before init, otherwise these configurations will be invalid in the init process
  3.             ARouter.openLog();     // Print log
  4.             ARouter.openDebug();   // Turn on debugging mode (If you are running in InstantRun mode, you must turn on debug mode! Online version needs to be closed, otherwise there is a security risk)
  5.         }
  6.         ARouter.init(this); // As early as possible, it is recommended to initialize in the Application

5.3.2 此时就可以进行路由跳转了呀

  1.         // 跳转方式4：采用 Arouter
  2.         ARouter.getInstance().build("/hl/login")
  3.                 // .withString("nothing", "Gone with the Wind")
  4.                 // .withObject("author", Object)
  5.                 .navigation(this, 110);

6. 最后跳转方式2，这里采用下沉到base模块的方式，各个组件注册到base模块的服务页面，然后由各个模块提供lunch方法。其他模块使用的时候只需要调用base模块的注册的组件对应的lunch方法既可！这个就主要涉及到接口的使用了。

处理方式：6.1 定义IAppComponent接口

  1.   package com.skl.basemodule.common_interface;
  2.  
  3. import android.app.Application;
  4. import android.content.Context;
  5.  
  6. /**
  7.  * 组件Application初始化时需要实现的接口
  8.  */
  9. public interface IAppComponent {
  10.     void initialize(Application app);
  11.     void launch(Context context, String extra);
  12. }

6.2 此时就需要各个模块添加Application类（basemodule纯粹是一个library，不参与），然后统一由主Application去调用各个模块的initialize方法（这个时候模块Library要注意，如果不涉及到单独运行，不用去配置application，不然运行报错啦）,如下：

f77c10caa9c2fb7a0c8c1270dd7129c9.png

9de6d2e9b7590737ac73cb71cced2416.png

6.3 主模块此时由于不能直接与其他模块产生耦合，所以采用反射的方式去初始化各个组件的Application：

实现之前先定义一个basemodule/AppConfig.java用来存储组件信息： - 我采用的接口和其他人略有不同，主要是方便到时候根据枚举进行页面注册，同时根据枚举进行页面跳转，后面就知道了

  1. package com.skl.basemodule;
  2.  
  3. import java.util.HashMap;
  4.  
  5. public class AppConfig {
  6.     public enum PAGE_TYPE {
  7.         LOGIN, PERSONAL
  8.     }
  9.  
  10.     /**
  11.      * 组件集合
  12.      */
  13.     public static HashMap<PAGE_TYPE, String> COMPONENTS = new HashMap<PAGE_TYPE, String>() {
  14.         {
  15.             // 登录页面
  16.             put(PAGE_TYPE.LOGIN, "com.skl.login.LoginApplication");
  17.             // 登录页面
  18.             put(PAGE_TYPE.PERSONAL, "com.skl.login.PersonalApplication");
  19.         }
  20.     };
  21. }

app/src/main/xxxxx/MainApplication.java - MainApplication也实现组件通信的接口IAppComponent，其他页面有可能也需要跳转到主页面

  1.   package com.skl.zujianhua;
  2.  
  3. import android.app.Application;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.os.Build;
  7. import android.os.Bundle;
  8.  
  9. import com.alibaba.android.arouter.launcher.ARouter;
  10. import com.skl.basemodule.AppConfig;
  11. import com.skl.basemodule.common_interface.IAppComponent;
  12.  
  13. import java.util.Map;
  14.  
  15. public class MainApplication extends Application implements IAppComponent {
  16.     @Override
  17.     public void onCreate() {
  18.         super.onCreate();
  19.         initialize(this);
  20.     }
  21.  
  22.     @Override
  23.     public void initialize(Application app) {
  24.         // 遍历所有的组件的Application类，依次用反射的方式实现组件初始化和注册
  25.         for(Map.Entry<AppConfig.PAGE_TYPE, String> entry: AppConfig.COMPONENTS.entrySet())
  26.         {
  27.             try {
  28.                 Class classz = Class.forName(entry.getValue());
  29.                 Object object = classz.newInstance();
  30.                 // 实例化后，调用各个组件的initialize方法（init会实现组件的注册）
  31.                 if (object instanceof IAppComponent) {
  32.                     ((IAppComponent) object).initialize(app);
  33.                 }
  34.             } catch (IllegalAccessException e) {
  35.                 e.printStackTrace();
  36.             } catch (InstantiationException e) {
  37.                 e.printStackTrace();
  38.             } catch (ClassNotFoundException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.  
  43.         // ARouter路由初始化
  44.         if (BuildConfig.DEBUG) {           // These two lines must be written before init, otherwise these configurations will be invalid in the init process
  45.             ARouter.openLog();     // Print log
  46.             ARouter.openDebug();   // Turn on debugging mode (If you are running in InstantRun mode, you must turn on debug mode! Online version needs to be closed, otherwise there is a security risk)
  47.         }
  48.         ARouter.init(this); // As early as possible, it is recommended to initialize in the Application
  49.     }
  50.  
  51.     @Override
  52.     public void launch(Context context, String extra) {
  53.         Intent intent = new Intent(context, MainActivity.class);
  54.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
  55.             Bundle bundle = new Bundle();
  56.             if (null != extra && !extra.equals(""))
  57.                 bundle.putString("extra_data", extra);
  58.             context.startActivity(intent, bundle);
  59.         } else {
  60.             if (null != extra && !extra.equals(""))
  61.                 intent.putExtra("extra_data", extra);
  62.             context.startActivity(intent);
  63.         }
  64.     }
  65. }

6.4 为了实现组件Application初始化，并且能全局存储组件的信息，我们定一个组件服务类CompomentsService.java - 注册组件时根据枚举存储组件信息，同时提供了获取组件（类型就是通信接口IAppComponent ）

  1.  package com.skl.basemodule;
  2.  
  3. import com.skl.basemodule.common_interface.IAppComponent;
  4.  
  5. import java.util.HashMap;
  6.  
  7. /**
  8.  * 组件初始化时都注册到这个服务里面
  9.  */
  10. public class CompomentsService {
  11.     private static HashMap<AppConfig.PAGE_TYPE, IAppComponent> iAppComponentHashMap = new HashMap<>();
  12.  
  13.     public static void setiAppComponentHashMap(AppConfig.PAGE_TYPE componentName, IAppComponent iAppComponent){
  14.         iAppComponentHashMap.put(componentName, iAppComponent);
  15.     }
  16.  
  17.     public static IAppComponent getiAppComponentHashMap(AppConfig.PAGE_TYPE componentName){
  18.         if (iAppComponentHashMap.containsKey(componentName)){
  19.             return iAppComponentHashMap.get(componentName);
  20.         }
  21.         return null;
  22.     }
  23. }

6.5 然后此时我们就可以把login、personal模块初始化并注册了：

login/ LoginApplication.java - 里面有注释，相对好理解

  1.   package com.skl.login;
  2.  
  3. /**
  4.  * 单独运行时需要的话可以配置到AndroidManifest，不需要就不要配置，不然运行报错
  5.  */
  7. import android.app.Application;
  8. import android.content.Context;
  9. import android.content.Intent;
  10. import android.os.Build;
  11. import android.os.Bundle;
  12.  
  13. import com.skl.basemodule.AppConfig;
  14. import com.skl.basemodule.CompomentsService;
  15. import com.skl.basemodule.common_interface.IAppComponent;
  16.  
  17. public class LoginApplication extends Application implements IAppComponent {
  18.     /**
  19.      * 单独作为Application时会走该方法
  20.      */
  21.     @Override
  22.     public void onCreate() {
  23.         super.onCreate();
  24.         // TODO 单独运行时没有需要可以不用调用
  25.         initialize(this);
  26.     }
  27.  
  28.     /**
  29.      * App的Application注册组件时会调用initialize方法!
  30.      *
  31.      * @param app
  32.      */
  33.     @Override
  34.     public void initialize(Application app) {
  35.         // 注册自己到组件服务
  36.         CompomentsService.setiAppComponentHashMap(AppConfig.PAGE_TYPE.LOGIN, this);
  37.     }
  38.  
  39.     /**
  40.      * 启动自己
  41.      *
  42.      * @param context
  43.      * @param extra
  44.      */
  45.     @Override
  46.     public void launch(Context context, String extra) {
  47.         Intent intent = new Intent(context, LoginActivity.class);
  48.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
  49.             Bundle bundle = new Bundle();
  50.             if (null != extra && !extra.equals(""))
  51.                 bundle.putString("extra_data", extra);
  52.             context.startActivity(intent, bundle);
  53.         } else {
  54.             if (null != extra && !extra.equals(""))
  55.                 intent.putExtra("extra_data", extra);
  56.             context.startActivity(intent);
  57.         }
  58.     }
  59. }

personal/PersonalApplication.java 

  1. package com.skl.personal;
  2.  
  3. import android.app.Application;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.os.Build;
  7. import android.os.Bundle;
  8.  
  9. import com.skl.basemodule.AppConfig;
  10. import com.skl.basemodule.CompomentsService;
  11. import com.skl.basemodule.common_interface.IAppComponent;
  12.  
  13. /**
  14.  * 单独运行时需要的话可以配置到AndroidManifest，不需要就不要配置，不然运行报错
  15.  */
  16. public class PersonalApplication extends Application implements IAppComponent {
  17.     /**
  18.      * 单独作为Application时会走该方法
  19.      */
  20.     @Override
  21.     public void onCreate() {
  22.         super.onCreate();
  23.         // TODO 单独运行时没有需要可以不用调用
  24.         initialize(this);
  25.     }
  26.  
  27.     /**
  28.      * App的Application注册组件时会调用initialize方法!
  29.      *
  30.      * @param app
  31.      */
  32.     @Override
  33.     public void initialize(Application app) {
  34.         // 注册自己到组件服务
  35.         CompomentsService.setiAppComponentHashMap(AppConfig.PAGE_TYPE.PERSONAL, this);
  36.     }
  37.  
  38.     /**
  39.      * 启动自己
  40.      *
  41.      * @param context
  42.      * @param extra
  43.      */
  44.     @Override
  45.     public void launch(Context context, String extra) {
  46.         Intent intent = new Intent(context, PersonalActivity.class);
  47.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
  48.             Bundle bundle = new Bundle();
  49.             if (null != extra && !extra.equals(""))
  50.                 bundle.putString("extra_data", extra);
  51.             context.startActivity(intent, bundle);
  52.         } else {
  53.             if (null != extra && !extra.equals(""))
  54.                 intent.putExtra("extra_data", extra);
  55.             context.startActivity(intent);
  56.         }
  57.     }
  58. }

7. 完事了我们就可以采用下沉到公共模块的方式来实现页面跳转 - 枚举方便我们清晰知道要跳转到哪里。相比Arouter，还是不安逸。但是了解一下也好鸭.....

  1.           // 跳转方式2：每个页面都注册到base模块，由base模块提供跳转服务
  2.          CompomentsService.getiAppComponentHashMap(AppConfig.PAGE_TYPE.LOGIN).launch(this, null);

8. 大概一个组件化工程目前一天两天的学习过程和实践就是酱紫。。。还有很多我们可以去联想和实践的，比如页面之间的相互通信，主动回调通知刷新等。以及Eventbus相关集成，如何集成的更好，其他的路由通信方式等等一堆问题！。。。。

组件化如果产生了耦合就尴尬了，这就是设计的魅力！

附上工程地址吧： https://gitee.com/heyclock/doc/tree/master/组件化

一些个参考：可以多像网友学习，但是还是要有自己的想法，哪怕改成自己顺手都是可以的，可能会实践的不好也没关系，至少大的方向应该是对的了。。

https://blog.csdn.net/jiyidehao/article/details/85390370

Android组件化

https://blog.csdn.net/sziitjin/article/details/97761949

Android组件化框架搭建

https://blog.csdn.net/hailong0529/article/details/89392064

https://blog.csdn.net/gaolei1201/article/details/77601027 - 如何跳转页面的方式

alibaba/ARouter

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/331662
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号