概述

從 2016 年開始，模組化在 Android 社群越來越多的被提及。隨著移動平臺的不斷髮展，移動平臺上的軟體慢慢走向複雜化，體積也變得臃腫龐大，為了降低大型軟體複雜性和耦合度，同時也為了適應模組重用、多團隊並行開發測試等等需求，模組化在 Android 平臺上變得勢在必行。阿里 Android 團隊在年初開源了他們的容器化框架 Atlas 就很大程度說明了當前 Android 平臺開發大型商業專案所面臨的問題。

那麼什麼是模組化呢，和我們常說的元件化又有什麼聯絡和區別呢？根據《 Java 應用架構設計：模組化模式與 OSGi 》一書中對模組化的定義：模組化是一種處理複雜系統分解為更好的可管理模組的方式。對於這種概念性的解釋，太過生澀難懂，不夠直觀。

那麼究竟何為模組化呢？舉個例子，相信隨著業務的不斷迭代，APK專案已經無限大了，以我們公司的電商專案為例，在迭代了5年後，apk的體積已經40M+，如果使用傳統的ant打包大概差不多要近10分鐘，如果用增量打包時間也要3-5分鐘。但是可以發現，很多老的程式碼其實我們在最新的版本是不需要的，當然我們可以手動的將這些程式碼刪除，但是又還怕啥時候用到。此時，最好的方法就是將這些模組獨立成一個獨立的工程，當需要的時候再引入進來，這就是模組化的一個背景。

所以，此處，我們對模組化和元件化做一個簡單的定義：
模組化：指解決一個複雜問題時自頂向下逐層把系統劃分成若干模組的過程，如訂單模組（OrderModule）、特賣模組（SPecialModule）、即時通訊模組（InstantMessagingModule）等等。

元件化：元件是指通用的功能或者UI庫可以做成一個功能元件，如地圖元件（MapSDK）、支付元件（AnjukePay）、路由元件（Router）等等；

外掛化：和模組化差不多，只是它是可以把模組打包成獨立的apk，可以動態的載入，刪除，獨立的外掛apk可以線上下載安裝，有利於減少apk的體積和實現模組的熱修復。目前熱門的外掛化方案有：阿里的atlas，360公司的RePlugin，滴滴的VirtualAPK等等；

例如，下面是模組化之前和模組化之後的專案的目錄結構：

模組化的示意圖可以用下面的模型表示：

模組化要解決的問題

要使用模組化開發Android專案，有以下幾點需要注意：

1. 模組間頁面跳轉（路由）；
2. 模組間事件通訊；
3. 模組間服務呼叫；
4. 模組的獨立執行；
5. 其他注意事項；
   為了方便講解，我們以下面的專案為例：
   
   這是一個常見的首頁畫面，該頁面主要有首頁、微聊、推薦和我的組成。我們將該4個Tab單獨成4個獨立的模組。
   

其中：

• app模組：主模組，主要進行搭載各個模組的功能；
• lib_base：對ARouter進行初始化，和放置一些各個模組公用的封裝類；
• module_home，module_caht,module_recom,module_me：分別對應“首頁”、“微聊”、“推薦”、“我的”模組。

ARouter模組化開發

ARouter各個模組的gradle配置

app模組是程式的容器，起到程式入口的作用，lib_base作為基礎模組，用來將一些公共的庫和對ARouter的初始化操作放在這一模組中。因此每個子模組都會用到它裡面的內容，所以我們在 lib_base中新增如下內容。

 compile 'com.alibaba:arouter-api:1.2.4'
    annotationProcessor "com.alibaba:arouter-compiler:1.1.4"
    compile 'com.android.support:design:27.1.1'
    compile 'org.simple:androideventbus:1.0.5.1'
    compile 'com.alibaba:fastjson:1.2.31'

因為我們把攔截器等公用類放在base註冊，在編譯期間生成路徑對映。所以還需要在build中加入如下配置：

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

由於每個子模組都會用到lib_base裡面的東西，所以需要在各子模組的build檔案中匯入（即module_home,module_caht,module_recom,module_me等模組中）如下配置：

//注意，此處也需要引入了com.alibaba:arouter-compiler:1.1.4
annotationProcessor 'com.alibaba:arouter-compiler:1.1.4'
compile project(':lib_base')

同樣，也需要在各子模組的build中加入如下配置。

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

然後在app模組（也即是主模組）對各個子模組進行依賴。

compile project(':module_home')
compile project(':module_chat')
compile project(':module_recom')
compile project(':module_me')

子模組依賴規則配置

對於模組化專案，每個單獨的Module 都可以單獨編譯成 APK。在開發階段需要單獨打包編譯，專案釋出的時候又需要它作為專案的一個 Module 來整體編譯打包。簡單的說就是開發時是 Application，釋出時是 Library。所以，需要在子模組中做如下的配置：

if(isBuildModule.toBoolean()){
    apply plugin: 'com.android.application'
}else{
    apply plugin: 'com.android.library'
}

同理，Manifest.xml 也需要有兩套：

if (isBuildModule.toBoolean()) {
           manifest.srcFile 'src/main/debug/AndroidManifest.xml'
       } else {
           manifest.srcFile 'src/main/release/AndroidManifest.xml'
       }

同時，每個子模組的defaultConfig還需要增加如下配置：

defaultConfig {
        if (!isNeedMeModule.toBoolean()) {
            applicationId "com.xzh.module_me"
        }
 }

而上面的isBuildModule.toBoolean()判斷條件，讀取的是專案根目錄下的gradle.properties配置檔案。

# 是否需要單獨編譯 true表示需要，false表示不需要
isNeedHomeModule=false
#isNeedHomeModule=true
isNeedChatModule=false
#isNeedChatModule=false
isNeedRecomModule=false
#isNeedRecomModule=false
isNeedMeModule=false
#isNeedMeModule=false

然後根據上面的編譯配置在app模組中新增如下依賴：

if (!isNeedHomeModule.toBoolean()) {
        compile project(':module_home')
    }
    if (!isNeedChatModule.toBoolean()) {
        compile project(':module_chat')
    }
    if (!isNeedRecomModule.toBoolean()) {
        compile project(':module_recom')
    }
    if (!isNeedMeModule.toBoolean()) {
        compile project(':module_me')
    }

如果需要單獨執行某個模組時，只需要修改gradle.properties對應的配置即可。例如，需要單獨執行module_home模組時，只需要開啟對於的配置即可isNeedHomeModule=true。

配置注意

由於配置後項目只有一個入口和啟動檔案（即app模組的MainActvity），所以其他子模組的MainActivity的intent-filter攔截要去掉，不然會有多個桌面入口。

<activity android:name=".MainActivity">
            <!--<intent-filter>-->
                <!--<action android:name="android.intent.action.MAIN" />-->

                <!--<category android:name="android.intent.category.LAUNCHER" />-->
            <!--</intent-filter>-->
        </activity>

ARouter使用

以上面的效果實現為例，在MainActivity中使用TabLayout+Adapter的形式搭建4個Tab頁面。程式碼如下：

public class MainActivity extends AppCompatActivity {

    private ViewPager mMViewPager;
    private TabLayout mToolbarTab;
    private int[] tabIcons = {
            R.drawable.tab_home,
            R.drawable.tab_weichat,
            R.drawable.tab_recommend,
            R.drawable.tab_user
    };
    private String[] tab_array;
    private DemandAdapter mDemandAdapter;
    private List<Fragment> fragments = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private void init() {
        initData();
        initView();
        setViewPagerAdapter();
        setTabBindViewPager();
        setItem();
    }

    private void initData() {
        tab_array = getResources().getStringArray(R.array.tab_main);
        fragments.clear();
        fragments.add(FragmentUtils.getHomeFragment());
        fragments.add(FragmentUtils.getChatFragment());
        fragments.add(FragmentUtils.getRecomFragment());
        fragments.add(FragmentUtils.getMeFragment());
    }

    private void initView() {
        mMViewPager = (ViewPager) findViewById(R.id.mViewPager);
        mToolbarTab = (TabLayout) findViewById(R.id.toolbar_tab);

    }

    private void setViewPagerAdapter() {
        mDemandAdapter = new DemandAdapter(getSupportFragmentManager(),fragments);
        mMViewPager.setAdapter(mDemandAdapter);
    }

    private void setTabBindViewPager() {
        mToolbarTab.setupWithViewPager(mMViewPager);
    }

    private void setItem() {

        for (int i = 0; i < mToolbarTab.getTabCount(); i++) {
            mToolbarTab.getTabAt(i).setCustomView(getTabView(i));
        }
    }

    public View getTabView(int position) {
        View view = LayoutInflater.from(this).inflate(R.layout.item_tab, null);
        ImageView tab_image = view.findViewById(R.id.tab_image);
        TextView tab_text = view.findViewById(R.id.tab_text);
        tab_image.setImageResource(tabIcons[position]);
        tab_text.setText(tab_array[position]);
        return view;
    }
}

然後，使用ARouter來獲取到各個模組的Fragment。

public class FragmentUtils {

    public static Fragment getHomeFragment() {
        Fragment fragment = (Fragment) ARouter.getInstance().build(RouteUtils.Home_Fragment_Main).navigation();
        return fragment;
    }

    public static Fragment getChatFragment() {
        Fragment fragment = (Fragment) ARouter.getInstance().build(RouteUtils.Chat_Fragment_Main).navigation();
        return fragment;
    }

    public static Fragment getRecomFragment() {
        Fragment fragment = (Fragment) ARouter.getInstance().build(RouteUtils.Recom_Fragment_Main).navigation();
        return fragment;
    }

    public static Fragment getMeFragment() {
        Fragment fragment = (Fragment) ARouter.getInstance().build(RouteUtils.Me_Fragment_Main).navigation();
        return fragment;
    }
}

而FragmentUtils使用了RouteUtils來定義具體的跳轉協議。

public class RouteUtils {

    public static final String Home_Fragment_Main = "/home/main";
    public static final String Chat_Fragment_Main = "/chat/main";
    public static final String Recom_Fragment_Main = "/recom/main";
    public static final String Me_Fragment_Main = "/me/main";

}

上面的子模組使用的是Fragment，所以，在子模組中要使用Route說明。例如：

@Route(path = RouteUtils.Chat_Fragment_Main)
public class MainFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle
            savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_weichat, null);
        return view;
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
    }
}

跨模組跳轉

假如要實現跨模組跳轉，首先在RouteUtils定義

public static final String Me_Login = "/me/main/login";

ARouter要跳轉Activity，就在這個Activity上加入註解。

@Route(path = RouteUtils.Me_Login)
public class LoginActivity extends AppCompatActivity{
}

然後在需要跳轉的地方新增如下程式碼：

ARouter.getInstance().build(RouteUtils.Me_Login).navigation();

實現ForResult返回資料

如果跨模組跳轉需要返回資料，即Activity的StartActivityForResult，則可以使用下面的方式。

ARouter.getInstance().build(RouteUtils.Chat_ForResult).navigation(this, 666); //666即為Code

接收資料資料：

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case 666:
                String name = data.getStringExtra("name");
                UIUtils.showToast(name + ",resultCode===>" + resultCode);
                break;
            default:
                break;
        }
    }

然後，接受返回資料：

Intent intent = new Intent();
            intent.putExtra("name", "ForResult返回的資料");
            setResult(999, intent);
            finish();

使用Eventbus跨模組通訊

使用Eventbus進行跨模組通訊，首先在需要接受的地方定義一個訂閱者。

@Subscriber(tag = EvenBusTag.GOTO_EVENTBUS)
    public void onEvent(String s) {
        UIUtils.showToast(s);
    }

然後在傳送方使用EventBus傳送訊息。例如：

@Route(path = RouteUtils.Me_EventBus)
public class EventBusActivity extends AppCompatActivity implements View.OnClickListener {

    /**
     * eventBus資料接收頁面
     */
    private TextView mTextView;
    /**
     * eventBus返回資料
     */
    private Button mBtnBackData;

    private String name;

    private long age;
    private EventBusBean eventbus;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_event_bus);
        ARouter.getInstance().inject(this);
        initData();
        initView();
    }

    private void initData() {
        name = getIntent().getStringExtra("name");
        age = getIntent().getLongExtra("age", 0);
        eventbus = getIntent().getParcelableExtra("eventbus");
    }

    private void initView() {
        mTextView = (TextView) findViewById(R.id.textView);
        mBtnBackData = (Button) findViewById(R.id.btn_back_data);
        mBtnBackData.setOnClickListener(this);
        mTextView.setText("name=" + name + ",\tage=" + age + ",\tproject=" + eventbus.getProject() +
                ",\tnum=" + eventbus.getNum());
    }

    @Override
    public void onClick(View v) {
        int i = v.getId();
        if (i == R.id.btn_back_data) {
            EventBus.getDefault().post(name, EvenBusTag.GOTO_EVENTBUS);
            finish();
        } else {
        }
    }
}

其實，ARouter的功能遠不止於此，後面將為大家一一講解，並最終自己實現一個模組間的路由。