服務模塊化踐行

2017年9月jdk 9正式發布，帶來了很多新特性，其中之一便是模塊化，JDK模塊化的前身是項目 Jigsaw，于2008開始孵化，最早計劃用于jdk7，一部分內容推遲到了jdk8，實際上在jdk9才完成了該項目全部目標，即實現一個模塊系統，并以此實現jdk自身模塊化。本文主要闡述模塊化的概念，為什么關注模塊化，基于jdk9的模塊化實現原理和項目實踐。

1.什么是模塊化

模塊化是個廣泛的概念，用于軟件編程就是將系統分解成獨立且互相連接的模塊的行為，拆分的模塊通常需要提前定義好標準化的接口，以便讓各模塊獨立開發情況下，還能互相調用不受影響。實際上在面向對象語言中對象之間的關注點分離與模塊化的概念基本一致，在實際應用開發中，將復雜業務系統按照業務邏輯等分割成多個獨立的模塊，各模塊提前定義好對外的服務接口，各模塊獨立開發，根據依賴的模塊可獨立完成業務模塊測試、交付。Java語言并不是按照模塊化思想設計的（除了package，在Java語言和虛擬機規范各版本第7章package，程序被組織為一組包。包的成員是類、接口以及子包，它們以包為編譯單元聲明）但是java社區早就有很多模塊。一個jar，一個包，任何一個java類庫，實際上都是一個模塊，通常模塊都附帶一個版本號，以便模塊升級提供新功能并不對低版本的模塊產生影響。

2.為什么模塊化

模塊化有助于將應用分解為不同的模塊，各個模塊可以單獨測試、開發、交付。類庫基本上都是模塊，如果你想將部分類庫提供給別人使用或者使用了別人提供的類庫，那么實際上你已經參與過模塊化應用了。在實際項目中，一般使用構建工具（maven、gradle等）組建，明確指明了依賴的類庫，以及變成類庫，供他人使用。

模塊化的好處之一是便于模塊獨立測試、開發、交付。模塊可按照業務核心情況或依賴順序部分交付，以便項目逐步完成交付，節省資源，增加迭代優化空間，這個概念提別像敏捷開發，采用迭代、循序漸進的方法進行軟件開發，把一個大項目分為多個相互聯系，但也可獨立運行的小項目，并分別完成，在此過程中軟件一直處于可使用狀態。

模塊化的另一個好處是便于升級，修復bug并提供新的服務，而版本號的存在就是為了區分模塊的歷史版本以及避免依賴發生錯誤。像guava、fastjson和fastjson2等類庫證實了這點。

模塊化也可給項目管理帶來方便，復雜業務分割成一個個獨立可復用的模塊，項目結構性更好，出現問題或者需要部分優化，只需要關注部分模塊，對于依賴的模塊由其他人提供維護即可，減少了維護和關注的成本。

3.模塊化的原理

首先需要安裝jdk9，下載地址放在文末附錄。

如下圖1所示為安裝好的jdk9，圖2所示為jdk8的目錄，是多個jar。

圖1

圖2

以上圖1和圖2對比可以看到jdk9拆分成了具體模塊，不再是一個個的jar，每個模塊都有一個module-info.class，文件定義模塊的名字、依賴的模塊、對外開放的類、接口實現類等，實際上module-info就是是模塊化的聲明文件。

除了組織形式發生變化外，真正的區別在哪里呢？圖3是jdk.internal.loader.BuiltinClassLoader的loadClassOrNull方法中的代碼片段，是進行類加載的方法，代碼展示先查找LoadedModule （模塊信息）如果有的話就進行類加載，否則的話，按照雙親委派模式向上委托進行類加載，后一步是為了向前兼容，前一步就是模塊化實現的核心原理，類加載機制不再向上委托，而是根據LoadedModule限制類加載。

其初始化在java.lang.System# initPhase2如圖3.1，主要是虛擬機進行系統模塊化的初始化，并返回ModuleLayer，稱為layer（層，表示一組類加載器），有兩種層，虛擬機提供的boot layer和用戶自定義的layer，用于將基礎模塊和用戶定義模塊與類加載器（層）關聯。

圖3

圖3.1

模塊的定義在Module#defineModules，詳細的解釋可在java9se虛擬機規范5.3.6找到，Java 虛擬機支持將類和接口組織成模塊，調用defineModules，將模塊與layer（類加載器）關聯，設置模塊可訪問、開放的資源以及依賴的資源（由此限制模塊的訪問）， 訪問控制由類的運行時模塊管理，不是由創建類的類加載器或類加載器服務的層管理，至此模塊化的初始化和限制訪問核心功能實現。也可按照以下代碼理解模塊化的組織和實現。BuiltinClassLoader的實現類有三個AppClassLoader，BootClassLoader，PlatformClassLoader，jdk9的類加載器。

//初始化 layer
ModuleLayer boot = ModuleLayer.boot();
Configuration configuration = boot.configuration();
//獲取解析的模塊
Set<ResolvedModule> modules = configuration.modules();
modules.forEach(resolvedModule -> {
    //獲取模塊句柄
    ModuleReference reference = resolvedModule.reference();
    //模塊化的名稱
    System.out.println(reference.descriptor().name());
    try (ModuleReader reader = reference.open()) {
        //模塊化下的全部資源
        reader.list().forEach(System.out::println);
    } catch (IOException ioe) {
        throw new UncheckedIOException(ioe);
    }
});

jdk9以前的類加載機制是大家熟識的雙親委派三層模型，bootstrap classloader <-- extension classloader <-- application classloader，這里不在贅述。下面展示jdk9帶來的改變，維持了三層模型，為了向前兼容，自JEP 220.extension classloader 變改為platform classloader，與application classloader 不在是URLClassLoader 的實現，而是其內部存有LoadedModule，并優先根據模塊化信息自我進行類加載，否則委托給父類，而platform classloader還可以委托給application classloader ，實際的加載機制如下圖4所示，模塊化的類加載機制打破了雙親委派，效率更加高效。以上便是模塊化實現的核心原理，Module控制模塊下類和接口的訪問性，模塊化的類加載不再是雙親委派，運行時模塊根據模塊之間的關系，與layer（一組類加載器）關聯，按照下圖方式進行類加載。

圖4

4.模塊化踐行

下面實踐基于jdk9模塊化項目編譯到運行全過程目錄4.1以及完整多模塊化的項目的使用4.2。

4.1模塊化項目

由hello項目入手品略模塊化項目的編譯、打包、運行、生成運行時環境的過程，深入理解模塊化的按需打包的優點。著重展示模塊化項目從建立到可運行環境輸出過程，項目名為hello，項目目錄如下圖5：

圖5

src目錄下新建一個module-info.java，模塊名是hello。在hello目錄下，新建Main.java，添加代碼代碼，其實就是打印一個hello world。下面進行編譯，運行，鏡像輸出。

public static void main(String[] args){
        System.out.println("hello world");
}

 4.1.1編譯

編譯java文件，out是個目錄，編譯生成文件到out這個目錄下：

javac -d out .\src\hello\Main.java  .\src\module-info.java

4.1.2打包

將out目錄下全部文件也就是（*）打包成 hello.jar 文件，存放在jar目錄下，并指定應用程序入口點為 hello.Main，-c創建新檔案，-f指定檔案文件名，-e指定應用程序入口點。

cd .\out\
mkdir jar
jar -cfe hello.jar hello.Main *

4.1.3運行

運行生成的jar ,--module-path指定模塊路徑， jar是存放hello.jar文件的目錄，控制臺輸出 hello world

java --module-path .\jar\ --module hello/hello.Main    
或者
java --module-path .\jar\ --module hello

4.1.4生成模塊

指定生成模塊的jar是hello.jar，生成模塊 hello.jmod

jmod create --class-path hello.jar hello.jmod

4.1.5生成運行環境

將hello.jmod 放到jdk安裝目錄下的jmods目錄下（windows下module-path指定多個路徑分隔符是半角分號【;】，Linux分隔符是半角冒號【:】我的環境是windows，嘗試多次均為未成功，所以粘貼這個模塊到JDK的基礎模塊中，指定module-path 為當前目錄即可）并在此目錄執行以下命令，指定模塊路徑為當前目錄，--add-modules添加java.base和hello模塊 ，--launcher定義一個入口點直接運行模塊 --output 指定生成的運行時環境的目錄名稱。

jlink --module-path . --add-modules java.base,hello --launcher hello=hello --output jre/

4.1.6運行

打開jre目錄，可以看到如圖6所示，bin目錄下生成可運行hello和 hello.bat，windows下命令行運行  .\hello.bat，控制臺打印，hello world

圖6

4.1.7小結

以上項目生成的文件是一個完整的可運行的Java運行環境即Java Runtime Environment 即jre，而這個可運行的環境大小只有35.9 MB，完整的jre是215M（我的環境中），這也就是模塊化的一大優點，可按需打包依賴，從jdk層支持，應用依賴也可以按照如此按需打包，減少浪費資源，以上是模塊化從編譯到生成jre的過程，下面我們進行模塊化的完整項目開發。

4.2多模塊項目實踐

一個完整項目如何模塊化？模塊之間如何依賴使用？怎么對外開放服務？如何對外允許反射的服務和以及隱式的依賴傳遞，下面項目深入展示模塊化的項目使用基本要點。著重展示了模塊化的使用以各關鍵字的詳細解釋。

假設場景是每天的生活，新建一個項目，建四個模塊，eat、transportation、work、console 項目如下，eat模塊模擬吃喝，transportation模塊模擬交通，work模塊模擬工作，console 模塊模擬生活，項目目錄如圖7所示。

圖7

4.2.1eat模塊

eatapi目錄下，對外提供服務接口，吃飯喝水兩個方法，

public interface EatApi {
    void eat();
    void drink();
}

eatservice目錄下，實現EatApi接口，

public class EatApiImpl implements EatApi {
    @Override
    public void eat(){
        System.out.println("吃飯了");
    }
    @Override
    public void drink(){
        System.out.println("喝水了");
    }
}

模塊化 module-info 類，定義名稱為eat，exports對外暴露eatapi接口，接口的實現為EatApiImpl類，provides  with 可被ServiceLoader根據SPI的方式加載到，但是反射并不能獲取實現類。

module eat {
    exports eatapi;
    provides eatapi.EatApi with eatservice.EatApiImpl;
}

4.2.2.transportation模塊

transportapi目錄下，對外提供服務，模擬交通，

public interface Transportation {
    void transport();
}

transportservice目錄下，實現transportapi接口

public class TransportationImpl implements Transportation {
    @Override
    public void transport(){
        System.out.println("開車出去");
    }
}

模塊化 module-info 類，定義名稱為transportation，exports對外暴露transportapi接口，接口的實現為TransportationImpl類，opens關鍵字，可以加在module關鍵字之前，表明整個模塊都可以被深度反射，opens transportservice 只表明該包下的類可以被深度反射。

module transportation {
    exports transportapi;
    provides transportapi.Transportation with transportservice.TransportationImpl;
    opens transportservice;
}

4.2.3.work模塊

workapi目錄下，對外提供服務，模擬工作，

public interface Work {
    void work() throws Exception;
}

workservice目錄下，實現接口，通過ServiceLoader獲取eat模塊EatApi，通過反射獲取 Transportation實現了類。

public class WorkImpl implements Work {
    @Override
    public void work() throws Exception {
        System.out.println("開始工作了");
        //獲取服務
        EatApi eatApi = ServiceLoader.load(EatApi.class).findFirst().get();
        //喝口水
        eatApi.drink();
        //反射獲取 Transportation實現了類  
        Transportation transportation = getTransportation();
        //出去一趟
        transportation.transport();
        //吃點東西
        eatApi.eat();
        //喝口水
        eatApi.drink();
    }

    private Transportation getTransportation() throws Exception{
        Class<Transportation> transportationClass = (Class<Transportation>)                        Class.forName("transportservice.TransportationImpl");
        Transportation transportation = transportationClass.getDeclaredConstructor().newInstance();
        return transportation;
    }
}

模塊化module，workapi可對外暴露，實現類是WorkImpl，requires 表示依賴模塊， 依賴模塊eat、transportation，調用了這兩個模塊的服務，transitive 關鍵字表示該依賴會被傳遞，引用本服務的服務也會引用transitive修飾的模塊，不用在主服務中在引一次，uses表示使用模塊中的具體服務。

module work {
    exports workapi;
    provides workapi.Work with workservice.WorkImpl;
    requires transitive eat;
    requires transitive transportation;
    uses eatapi.EatApi;
}

4.2.4.console模塊

該模塊調用work模塊以及work transitive 的模塊，

模塊化配置如下，依賴模塊work，使用workapi.Work和eatapi.EatApi

module console {
    requires work;
    uses workapi.Work;
    uses eatapi.EatApi;
}

day1目錄下新建Main，模塊Work的依賴隱式傳遞，最終打印出結果如圖8所示。

public class Main {
    public static void main(String[] args) throws Exception {
        //獲取work 服務
        ServiceLoader<Work> load = ServiceLoader.load(Work.class);
        Work work = load.findFirst().get();
        //調用
        work.work();
        //其他服務
        ServiceLoader<EatApi> eatLoader = ServiceLoader.load(EatApi.class);
        EatApi eatApi = eatLoader.findFirst().get();
        eatApi.eat();
        eatApi.drink();
        //反射獲取
        Transportation transportation = getTransportation();
        transportation.transport();

    }
    private static Transportation getTransportation() throws Exception {
        Class<Transportation> transportationClass = (Class<Transportation>) Class.forName("transportservice.TransportationImpl");
        Transportation transportation = transportationClass.getDeclaredConstructor().newInstance();
        return transportation;
    }
}

圖8

5.總結

以上便是使用模塊化生成需要jre環境和在項目中使用多模塊服務的踐行。

模塊化核心原則模塊必須強封裝性，隱藏部分代碼，只對外提供指定服務，也就需要良好的接口定義并且顯示依賴，聲明式的服務依賴，不是使用了但不知道依賴來自哪里的糊涂賬。可以提高模塊的可讀性，明確服務的入口和依賴，減少服務循環依賴，按需打包，解決反射帶來的全可見危害，提高安全性。但是就目前而言模塊化帶來的收益遠低于遷移工作，目前大家都在用spring的全家桶應用項目，使用很方便，但是真正按照模塊化將其切分出來，并且能夠完全理清楚項目依賴，也是有一定門檻的，不過模塊化的方法和工具，jdk已然提供，模塊化的思維和想法是很值得學習的，相信在不久的將來，模塊化會更智能和完善。

6.附錄 

[1]項目hello  https://gitee.com/lifutian66/java9/tree/master/hello

[2]項目java9 https://gitee.com/lifutian66/java9/tree/master/java9

[3]生成hello.jmod https://gitee.com/lifutian66/java9/hello.jmod

[4]生成jre    https://gitee.com/lifutian66/java9/tree/master/jre

[5]jdk9 地址：https://www.oracle.com/java/technologies/javase/javase9-archive-downloads.html

[6]Modular Java: What Is It?https://www.infoq.com/articles/modular-java-what-is-it/

[7]參考文檔：java9模塊化開發核心原則和實踐

作者簡介

李福田，主機廠技術部-數科技術團隊。

2022年加入汽車之家，目前任職于數科品牌私享家后端技術團隊，主要負責品牌私享家后端相關業務技術開發。