Modulberoende syftar på att en modul är beroende av eller kräver en annan modul. Modulberoenden introducerades i Declaring Dependency on Other Modules avsnitt i artikeln "Utveckla en modul med Java 9 i Eclipse IDE, del 1." I den första av två artiklar, "Using Module Dependencies, Part 1", skapade vi två Java-projekt för två moduler, en huvudmodul och en beroendemodul. Vi kunde inte ha skapat båda modulerna i ett Java-projekt eftersom Eclipse IDE inte stöder flera moduler i ett enda projekt. Efter att ha skapat två projekt kommer vi i denna fortsättningsartikel att exportera varje projekt till en separat JAR-fil. Att exportera och använda en modul som en JAR-fil diskuteras i en tidigare handledning, "Använda en Java 9-modul som en JAR-fil." Att lägga till flera moduler i en enda JAR stöds för närvarande inte, men är planerat för en framtida Java-version. I den här artikeln kommer vi att diskutera konfigurering av de två Java-projekten och köra huvudmodulapplikationen för att visa modulberoende. Den här artikeln har följande avsnitt:

Ställa in byggvägen för Java-huvudprojektet
Exportera Java-huvudprojektet till en JAR-fil
Exportera Dependency Java-projektet till en JAR-fil
Lägga till en körkonfiguration
Köra huvudmodulens Java-applikation
Slutsats

Ställa in byggvägen för Java-huvudprojektet

De två Java-projekt som tidigare utvecklats har fel, vilket indikeras av de röda markörerna i figur 1. Felen indikeras eftersom de två modulerna är definierade i separata projekt och beroendeprojektet inte är i byggvägen för huvudprojektet.

Figur 1: Java-projekt med fel

I det här avsnittet ska vi konfigurera byggvägen för Huvudmodulen projekt för att lägga till HelloJavaModule projekt till byggvägen. Högerklicka på MainModule i Package Explorer och välj Build Path>Configure Build Path , som visas i figur 2.

Figur 2: Package Explorer>Bygg sökväg>Konfigurera byggsökväg

I Egenskaper fönstret, Java Build Path standardinställningarna visas, som visas i figur 3.

Figur 3: Java Build Path

Välj Projekt fliken och välj Modulsökväg , som visas i figur 4. Klicka på Lägg till...

Figur 4: Java Build Path>Projekt>Modulepath>Lägg till...

Obligatoriskt projektval fönstret visar beroendeprojektet HelloJavaModule , som visas i figur 5. Välj HelloJavaModule projekt och klicka på OK.

Figur 5: Välja ett projekt att lägga till

HelloJavaModule projektet läggs till i Modulepath (se figur 6). Klicka på Använd och stäng .

Figur 6: Java-projektet HelloJavaModule har lagts till i Modulepath

Felen och röda markeringar tas bort från Huvudmodulen projekt, som visas i figur 7.

Figur 7: Fel togs bort från MainModule

Exportera Java-huvudprojektet till en JAR-fil

Lägger till HelloJavaModule projekt till byggvägen för MainModule projektet tar bara bort bygg-/kompileringstidsfel. För runtime skulle vi behöva exportera var och en av modulerna till en JAR-fil och lägga till JAR-filerna till runtime-modulens sökväg för när projektet körs. JAR-filerna skulle behöva exporteras till samma mapp så att vi kan konfigurera modulsökvägen utan att referera till moduler över projekt. Som nämnts tidigare stöds ännu inte en JAR med flera moduler, men den är planerad att stödjas i en senare version av Java.

För att exportera MainModule projekt till en JAR-fil högerklickar du på MainModule i Package Explorer och välj Exportera , som visas i figur 8.

Figur 8: Package Explorer>MainModule>Exportera

I Exportera fönster väljer du Java>JAR-fil , som visas i figur 9, och klicka på Nästa.

Figur 9: Export>Java>JAR-fil>Nästa

I JAR-filspecifikation , välj resursen som ska exporteras som Huvudmodul , som visas i figur 10. Välj exportdestinationen som MainModulemodulesmainmodule.jar . Klicka på Nästa.

Figur 10: JAR-filspecifikation

Välj standard JAR-förpackningsalternativ (se figur 11) och klicka på Nästa.

Figur 11: Välja förpackningsalternativ

Anpassa sedan JAR Manifest-specifikationen , vilket inkluderar val av klass för applikationsingångspunkten. Klicka på Bläddra för Huvudklass , som visas i figur 12.

Figur 12: Huvudklass>Bläddra

I Välj huvudklass , välj MainModule klass i main.module paketet, som visas i figur 13, och klicka på OK.

Figur 13: Väljer huvudklass

Med Huvudklass markerat, klicka på Slutför, som visas i figur 14.

Figur 14: JAR Export>Slutför

mainmodule.jar exporteras till MainModule/moduler katalog, som visas i Package Explorer i figur 15.

Figur 15: Exporterade JAR mainmodule.jar

Exportera Dependency Java-projektet till en JAR-fil

I det här avsnittet kommer vi att exportera beroendeprojektet HelloJavaModule till en JAR-fil i samma katalog som huvudmodulen JAR exporteras till. För att exportera HelloJavaModule projekt till en JAR-fil, högerklicka på projektet i Package Explorer och välj Exportera (se figur 16).

Figur 16: Package Explorer>HelloJavaModule>Exportera

I Exportera fönster väljer du Java>JAR-fil , som visas i figur 17, och klicka på Nästa.

Figur 17: Export>Java>JAR-fil>Nästa

I JAR-filspecifikation , välj resursen som ska exporteras som HelloJavaModule , som visas i figur 18. Välj exportdestination på samma sätt som för huvudmodulen JAR, som är MainModulemodules katalog. JAR-filnamnet måste vara ett annat och är helloJavaModule.jar . Klicka på Nästa.

Figur 18: JAR-filspecifikation för beroende JAR

Välj standard JAR-förpackningsalternativ, som visas i figur 19, och klicka på Nästa.

Figur 19: Välja förpackningsalternativ

Anpassa sedan JAR Manifest-specifikationen. Eftersom beroendeprojektet inte innehåller en klass för en applikationsingångspunkt, behåll Huvudklassen fältet är tomt, som visas i figur 20, och klicka på Slutför.

Figur 20: Ingen huvudklass för beroendeprojekt

helloJavaModule.jar exporteras till MainModule/moduler katalog, som visas i Package Explorer i figur 21.

Figur 21: Exporterade JAR helloJavaModule.jar

Lägga till en körkonfiguration

För att köra huvudmodulens Java-applikation måste vi skapa en körkonfiguration för MainModule projekt. Högerklicka på MainModule i Package Explorer och välj Egenskaper , som visas i figur 22.

Figur 22: Package Explorer>MainModule>Egenskaper

I fönstret Egenskaper väljer du Kör/Felsökningsinställningar och klicka på Ny... för att skapa en ny startkonfiguration, som visas i figur 23.

Figur 23: Egenskaper>Kör felsökningsinställningar>Ny...

I Välj konfigurationstyp , välj Java-program , som visas i figur 24.

Figur 24: Välja konfigurationstyp som Java-program

I konfigurationsguiden, ange ett namn (MainModuleConfig ) i Namn och med projektet valt som MainModule klicka på Sök... för Huvudklass , som visas i figur 25.

Figur 25: Ställa in Launch Configuration Properties

I Välj huvudtyp , välj main.module.MainModule typ (se figur 26) och klicka på OK.

Figur 26: Välja huvudtyp

Med Huvudklass markerat klickar du på Argument fliken för att välja VM-argen nästa, som visas i figur 27.

Figur 27: Välj fliken Argument

Lägg till följande VM-argument till VM-argumentfältet, som visas i figur 28.

--module-path modules/helloJavaModule.jar;modules/mainmodule.jar
   -m mainModule/main.module.MainModule

--modul-sökvägen arg ställer in modulsökvägen till de två JAR:erna för de två modulerna. -m arg ställer in modulen. Klicka på Använd , som visas i figur 28.

Figur 28: Använder Run Configuration Settings

Klicka på OK, som visas i figur 29, för att slutföra körningskonfigurationen.

Figur 29: Slutför körkonfiguration

En ny körkonfiguration, MainModuleConfig , skapas, som visas i figur 30. Klicka på Använd och stäng i fönstret Egenskaper.

Figur 30: Tillämpa egenskaper för MainModule Project

Köra huvudmodulens Java-applikation

Därefter ska vi testa om huvudmodulen anropar beroendemodulen genom att köra huvudmodulapplikationen. Högerklicka på MainModule.java i Package Explorer och välj Kör som>Java Application (se figur 31).

Figur 31: Package Explorer>MainModule>Kör som>Java-applikation

Utdata från Java-applikationen visas i konsolen , som visas i figur 32. Meddelandet "Hej från" från huvudmodulen kombineras med meddelandet "Exporterad Java-modul!" från beroendemodulen för att mata ut meddelandet "Hej från exporterad Java-modul!".

Figur 32: Konsolutgång

Slutsats