Java >> Java Program >  >> Java

Självstudie för Java 9 Jigsaw Project

I denna handledning kommer vi att få en kort introduktion till Java 9 Jigsaw-funktionen i form av ett enkelt projekt. Detta projekt kommer att demonstrera några av funktionerna i det nya modulsystemet (Jigsaw) som introduceras i Java 9 och hur man går tillväga för att strukturera projekt på ett sätt som kommer att dra nytta av funktionerna och följa kraven i Jigsaw.

Vi kommer att täcka mekaniken för hur modulsystemet kommer att fungera för nya projekt och hur befintliga projekt och bibliotek kan eftermonteras (om det behövs) för att dra nytta av det nya modulsystemet.

Vi kommer också att demonstrera att strukturera, bygga och paketera vårt enkla projekt både från kommandoraden och via det populära verktyget för bygg- och beroendehantering, Maven, för att dra nytta av det nya modulsystemet Jigsaw.

Innehållsförteckning

1. Inledning
2. Teknik som används
3. Konfiguration
4. Mål av Jigsaw
4.1 Starkare inkapsling
4.2 Pålitlig konfiguration
4.3 Minska paketets fotavtryck
5. Moduler
5.1 Automatiska moduler
5.2 Applikationsmoduler
5.3 Plattformsmoduler
5.4 Namnlös modul
6. Modulbeskrivning
7. Verktyg
7.1 JDeps
7.2 JLink
8. Bygga provapplikationen
8.1 Manuell konstruktion
8.2 Maven Build
9. Köra exempelapplikationen
10. Runtime Image
11. Sammanfattning
12. Ladda ner källkoden

1. Inledning

Project Jigsaw är en modularisering av JDK och introduktion av ett modulsystem för Java som ger starkare inkapsling, mindre paketutrymme och pålitlig konfiguration för Java-applikationer.

2. Teknik som används

Exempelkoden i den här artikeln byggdes och kördes med:

  • Java 9
  • Maven 3.3.9
  • Eclipse Oxygen (4.7.0)
  • Ubuntu 16.04 (Windows, Mac eller Linux fungerar bra)

3. Konfiguration

För att följa med i den här handledningen behöver vi bara Java 9 och maven 3.3.9 installerade med båda bin mappar tillgängliga på sökvägen. Även din JAVA_HOME variabeln måste ställas in på Java 9-installationen. För att verifiera:

  • JAVA_HOME :problem echo $JAVA_HOME och sökvägen till din Java 9-installation bör visas på skärmen
  • jdeps :problem jdeps --version
  • jlink :problem jlink --version
  • jar :nummer jar --version
  • javac :problem javac --version
  • java :problem java --version
  • mvn :problem mvn --version

Att utfärda dessa kommandon bör ge utdata som liknar nedan:

Utmatning från installationskommandon

export JAVA_HOME=/home/jean-jay/runtimes/jdk-9
echo $JAVA_HOME
/home/jean-jay/runtimes/jdk-9
jdeps --version
9
jlink --version
9
jar --version
jar 9
javac --version
javac 9
java --version
java 9
Java(TM) SE Runtime Environment (build 9+180)
Java HotSpot(TM) 64-Bit Server VM (build 9+180, mixed mode)
mvn --version
Apache Maven 3.3.9
Maven home: /usr/share/maven
Java version: 9, vendor: Oracle Corporation
Java home: /home/jean-jay/runtimes/jdk-9
Default locale: en_ZA, platform encoding: UTF-8
OS name: "linux", version: "4.10.0-33-generic", arch: "amd64", family: "unix"

Lägg till en toolchains.xml fil i din .m2 mapp för maven. (ersätt jdkHome platser med din lokala sökväg till Java 9-installation)

ToolChains-konfiguration för Maven

<toolchains>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.9</version>
      <vendor>oracle</vendor>
    </provides>
    <configuration>
      <jdkHome>/home/jean-jay/runtimes/jdk-9</jdkHome>
    </configuration>
  </toolchain>
  <toolchain>
    <type>jdk</type>
    <provides>
      <version>1.8</version>
      <vendor>oracle</vendor>
    </provides>
    <configuration>
      <jdkHome>/home/jean-jay/runtimes/jdk1.8.0_101</jdkHome>
    </configuration>
  </toolchain>
</toolchains>

4. Mål för Jigsaw

Målen för Jigsaw är:

  • Ge en starkare inkapsling av komponenter som sträcker sig utöver vad JDK tillhandahåller för närvarande.
  • Tillförlitlig konfiguration av moduler i en applikation.
  • Reducera fotavtrycket för körtidsbilden för en applikation till vad som bara behövs.

4.1 Starkare inkapsling

Som en sammanfattning tillhandahåller JDK åtkomstmodifierare som hjälper oss att främja inkapsling och information/beteende som gömmer sig mellan klasser och medlemmar av klasser på klassvägen. Dessa är (i ordning av mest synligt till minst synligt):

  • offentliga
  • skyddad
  • paket privat
  • privat

Nu är detta ganska rikligt från en jar filens perspektiv (dvs inom en jar). ) men i det ögonblick vi går bortom jar (d.v.s. samarbete mellan burkar på klassvägen) möter vi en begränsning. Det som en gång var offentligt för jar är nu faktiskt offentlig för hela klassvägen och det kanske inte är det vi vill ha. Bekvämt klasser som är public inom en jar (domän) men var inte avsedda för användning utanför den jar (domän) är nu fria att användas / missbrukas av konsumenter av nämnda jar .

4.2 Tillförlitlig konfiguration

Det som tidigare inte var möjligt är nu möjligt via Jigsaw. Våra Java-applikationer kommer att kunna verifiera beroenden under körning och upprätthålla integriteten hos det.

Även om tvetydighet i versionshanteringen fortfarande är en öppen fråga (två identiska burkar med olika versioner), går Jigsaw långt med att upprätthålla beroendeintegritet genom att garantera att ett beroende är tillgängligt och att det inte finns några cykliska beroenden mellan burkar/moduler.

4.3 Minska paketets fotavtryck

Genom att krympa in JDK och applikationskodbasen (inklusive beroenden) till en samling av det som bara behövs, kan vi skicka mycket mindre paket när vi distribuerar våra applikationer. Detta är särskilt användbart när det gäller enheter/plattformar med resursbegränsningar.

5. Moduler

En modul är en jar fil som deklarerar dess beroenden och "public" API via en modulbeskrivningsfil med namnet module-info.java . module-info.java fil anger följande:

  • Namnet på modulen.
  • Paketen den exporterar.
  • Andra moduler det beror på.

Moduler kan vara 1 av 4 typer:

5.1 Automatiska moduler

Bakåtkompatibilitet har aldrig varit en eftertanke när det kommer till Java och med Jigsaw är det inte annorlunda. Som vi nämnde tidigare är en modul en jar fil med en modulbeskrivning i den som anger det offentliga kontraktet, men de flesta, om inte alla tredje parts bibliotek som används idag, har ingen modulbeskrivning och är därför inte moduler.

En metod för att tillåta oss att använda tredje parts bibliotek i modulariserade applikationer är via det "automatiska modulsystemet". Vad detta betyder är att någon jar fil som inte uttryckligen har köpts in i modulsystemet (ingen module-info.java ), som råkar vara på "modulsökvägen" kommer att bli en "automatisk modul" där hela innehållet kommer att göras public till alla andra moduler och har därefter även tillgång till alla andra moduler inklusive den "unnamed modulen".

JDK kommer att publicera namnet på jar (exklusive version och förlängning med mellanslag mellan ord) som modulnamn. På så sätt kan vi referera till det som ett beroende i våra egna anpassade modulbeskrivningar.

5.2 Applikationsmoduler

Dessa är den ortodoxa modulen jar filer som innehåller en modulbeskrivning och publicerar deras offentliga kontrakt (beroenden och API).

5.3 Plattformsmoduler

Dessa moduler är "inbyggda" i JDK och utgör i princip nettoeffekten av att modularisera JDK. t.ex.:java.base (implicititet beror på av valfri modul) eller java.xml .

5.4 Namnlös modul

En modul som representerar konsolideringen av alla jar filer (moduler och icke-moduler) på klasssökvägen och har inget modulnamn, därav "unnamed". Den kan inte refereras av andra moduler men kan komma åt alla andra moduler.

6. Modulbeskrivning

Modulbeskrivningen är module-info.java fil. Den anger modulens publika API. (dvs:vad det kräver och vad det beror på)

Obligatoriska moduler är inte transitivt tillgängliga för transitiva konsumenter, (dvs:A kräver B kräver C betyder att A inte ser C automatiskt) om inte requires transitive är specificerad. Moduler krävs och paket exporteras.

Följande exempel på modulbeskrivningar inkluderar commons-lang3 (genererad med hjälp av jdeps och lappade till den binära commons-lang3 jar fil) och jigsaw.date.service som anger ett beroende av commons.lang3 .

Commons-lang3 automatisk modul

module commons.lang3 {
    exports org.apache.commons.lang3;
    exports org.apache.commons.lang3.builder;
    exports org.apache.commons.lang3.concurrent;
    exports org.apache.commons.lang3.event;
    exports org.apache.commons.lang3.exception;
    exports org.apache.commons.lang3.math;
    exports org.apache.commons.lang3.mutable;
    exports org.apache.commons.lang3.reflect;
    exports org.apache.commons.lang3.text;
    exports org.apache.commons.lang3.text.translate;
    exports org.apache.commons.lang3.time;
    exports org.apache.commons.lang3.tuple;
}


Jigsaw Date Service Application Module

module jigsaw.date.service {
	requires commons.lang3;
	exports com.javacodegeeks.jigsaw.date.service;
}

7. Verktyg

En kort primer om några verktyg som finns tillgängliga i JDK som hjälper oss att bygga, paketera och köra vår applikation med hjälp av Jigsaw-funktioner.

7.1 JDeps

Ett Java kommandoradsdrivet verktyg för hantering av statiskt beroende för jar filer. Resultaten kan filtreras och paketeras på package nivå eller jar filnivå.

Den finns i bin mapp för din JDK och har funnits sedan Java 8. Bekräftar versionen av jdeps är lika enkelt som att köra jdeps --version . För hjälp med jdeps kör helt enkelt jdeps --help . Kör jdeps commons-lang3-3.4.jar kommer att avslöja alla beroenden för commons-lang3 aggregerade per paket.

Jdeps-utdata på Commons-Lang3

   org.apache.commons.lang3.mutable                   -> java.io                                            java.base
   org.apache.commons.lang3.mutable                   -> java.lang                                          java.base
   org.apache.commons.lang3.mutable                   -> org.apache.commons.lang3                           commons-lang3-3.4.jar
   org.apache.commons.lang3.mutable                   -> org.apache.commons.lang3.math                      commons-lang3-3.4.jar
   org.apache.commons.lang3.reflect                   -> java.lang                                          java.base
   org.apache.commons.lang3.reflect                   -> java.lang.annotation                               java.base
   org.apache.commons.lang3.reflect                   -> java.lang.reflect                                  java.base
   org.apache.commons.lang3.reflect                   -> java.util                                          java.base
   org.apache.commons.lang3.reflect                   -> org.apache.commons.lang3                           commons-lang3-3.4.jar
   org.apache.commons.lang3.reflect                   -> org.apache.commons.lang3.builder                   commons-lang3-3.4.jar
   org.apache.commons.lang3.text                      -> java.io                                            java.base
   org.apache.commons.lang3.text                      -> java.lang                                          java.base
   org.apache.commons.lang3.text                      -> java.nio                                           java.base
   org.apache.commons.lang3.text                      -> java.text                                          java.base
   org.apache.commons.lang3.text                      -> java.util                                          java.base
   org.apache.commons.lang3.text                      -> org.apache.commons.lang3                           commons-lang3-3.4.jar
   org.apache.commons.lang3.text                      -> org.apache.commons.lang3.builder                   commons-lang3-3.4.jar
   org.apache.commons.lang3.text.translate            -> java.io                                            java.base
   org.apache.commons.lang3.text.translate            -> java.lang                                          java.base
   org.apache.commons.lang3.text.translate            -> java.util                                          java.base
   org.apache.commons.lang3.text.translate            -> org.apache.commons.lang3                           commons-lang3-3.4.jar
   org.apache.commons.lang3.time                      -> java.io                                            java.base

I utdraget ovan kan vi se från vänster till höger:

  • vänster:paket med commons-lang3
  • mitten:paket det beror på
  • höger:moduler där paketen (mitten) kan hittas

7.2 JLink

Ett Java kommandoradsdrivet verktyg som länkar / sammanför alla nödvändiga moduler för en applikation till en körtidsbild.

Denna bild är vanligtvis drastiskt mindre i storlek, vilket bidrar till att minska applikationens fotavtryck eftersom hela JRE normalt inte behövs. jlink kommer också att lösa statiska beroenden mellan moduler vilket garanterar integriteten för varje modul vid körning. jlink kräver att alla artefakter är moduler med väldefinierade offentliga kontrakt (export, kräver etc), så "Automatiska" moduler kommer inte att räcka till.

Kör jlink --version avslöjar versionen och kör jlink --help tar fram hjälpmenyn.

8. Bygga provapplikationen

I det här avsnittet kommer vi att visa hur man bygger en mycket enkel datumtjänstapplikation med flera moduler. Applikationen ger oss väldigt bekvämt systemdatumet i ett snyggt format med FastDateFormatter finns i commons-lang3 . Applikationen har 2 huvudmoduler nämligen:

  • jigsaw.date.cli innehåller huvudklassens ingångspunkt för applikationen och beror på jigsaw.date.service .
  • jigsaw.date.service vilket beror på commons-lang3 . Denna modul definierar ett gränssnitt (DateUtil ), en implementering (SystemDate ) (privat paket) och en fabrik (DateUtilFactory ) som konstruerar implementeringen åt oss. Som Jigsaw exporterar vi paketet som innehåller gränssnittet och fabriken för konsumenter till require och använda. Även om implementeringen SystemDate är i samma paket är det paketprivat och är alltså inte synligt från utsidan av paketet.

När du laddar ner exempelkoden och extraherar den till ditt filsystem kommer du att märka två huvudmappar, nämligen maven-build och manual-build . Vi börjar med manual-build .

8.1. Manuell konstruktion

manual-build projektkatalogen har 2 mappar i sig, nämligen before och after . after representerar allt som är färdigt ända fram till skapandet av en körtidsbild och kan därför användas för referensändamål och används faktiskt också i delar av maven build-sektionen. Vårt fokus kommer att ligga på before mapp där vi kommer att köra en serie instruktioner för att bygga, paketera och köra vår exempelapplikation.

Navigerar in i before mapp kommer du att se följande struktur:

Manuell katalogstruktur (före mapp)


De två mapparna som finns i:
  • automatiska moduler:innehåller commons-lang3-3.4.jar
  • src:innehåller källkoden för vårt projekt jigsaw.date.cli och jigsaw.date.service och källkoden för commons-lang3-3.4.jar

Nästa steg blir att kompilera och bygga vårt projekt manuellt.

Instruktioner för att bygga och paketera projektet manuellt

$ javac --module-path automatic-modules -d modules/jigsaw.date.service/ src/jigsaw.date.service/module-info.java src/jigsaw.date.service/com/javacodegeeks/jigsaw/date/service/*.java
$ javac --module-path automatic-modules:modules -d modules/jigsaw.date.cli/ src/jigsaw.date.cli/module-info.java src/jigsaw.date.cli/com/javacodegeeks/jigsaw/date/cli/*.java

$ java --module-path automatic-modules:modules -m jigsaw.date.cli/com.javacodegeeks.jigsaw.date.cli.Main
System date is : 09-09-2017
System date is : 09-09-2017

$ jdeps --generate-module-info tmp automatic-modules/commons-lang3-3.4.jar
writing to tmp/commons.lang3/module-info.java

$ javac -d tmp/commons.lang3/ --source-path src/3rd-party/commons-lang3/ tmp/commons.lang3/module-info.java
tmp/commons.lang3/module-info.java:1: warning: [module] module name component lang3 should avoid terminal digits
module commons.lang3 {
              ^
1 warning

$ mkdir patched-automatic-modules
$ cp automatic-modules/commons-lang3-3.4.jar patched-automatic-modules

$ jar --update --file patched-automatic-modules/commons-lang3-3.4.jar --module-version=3.3.4-module -C tmp/commons.lang3/ module-info.class

$ mkdir application-modules

$ jar --create --file=application-modules/[email protected] --module-version=1.0 -C modules/jigsaw.date.service/ .
$ jar --create --main-class=com.javacodegeeks.jigsaw.date.cli.Main --file=application-modules/[email protected] --module-version=1.0 -C modules/jigsaw.date.cli/ .

$ jar --describe-module --file=application-modules/[email protected]
[email protected] jar:file:///home/jean-jay/Documents/projects/codegeeks/java9-jigsaw-project/manual-build/before/application-modules/[email protected]/!module-info.class
exports com.javacodegeeks.jigsaw.date.service
requires commons.lang3
requires java.base mandated

$ jar --describe-module --file=application-modules/[email protected]
[email protected] jar:file:///home/jean-jay/Documents/projects/codegeeks/java9-jigsaw-project/manual-build/before/application-modules/[email protected]/!module-info.class
requires java.base mandated
requires jigsaw.date.service
contains com.javacodegeeks.jigsaw.date.cli
main-class com.javacodegeeks.jigsaw.date.cli.Main

$ java -p application-modules:patched-automatic-modules -m jigsaw.date.cli
System date is : 09-09-2017
System date is : 09-09-2017
  • rad 1 och 2:vi bygger jigsaw.date.service och jigsaw.date.cli projekt respektive. Observera att vi anger module-path (där nödvändiga moduler kan hittas) som automatic-modules mapp eftersom vi kräver commons-lang3-3.4 . Java 9 (Jigsaw) är tillräckligt bra för att konvertera den till en automatisk modul. Vi anger också att utdatamappen för de kompilerade modulerna ska vara modules .
  • rad 4-6:vi kör vår huvudklassmodul och specificerar återigen module-path men den här gången är det en kombination av automatic-modules och modules .
  • rad 8:vi genererar en module-info.java fil för commons-lang3-3.4.jar med jdeps och placera module-info.java fil i tmp mapp.
  • rad 11:vi kompilerar vår module-info.java fil till en module-info.class fil med källkoden för commons-lang3-3.4.jar finns i src mapp.
  • rad 18:vi kopierar originalet commons-lang3-3.4.jar fil från automatic-modules mappen till patched-automatic-modules mapp efter att mappen skapats.
  • rad 20:vi uppdaterar commons-lang3-3.4.jar inuti patched-automatic-modules med den kompilerade module-info.class fil.
  • rad 24 och 25:vi gör 2 jar filer från våra applikationsmoduler jigsaw.date.service och jigsaw.date.cli .
  • rad 27-38:vi använder jar describe verktyg för att beskriva modulerna och deras API:er för oss för bekräftelse.
  • rad 40-42:vi kör modulerna.

Skapandet av en module-info.java och efterföljande kompilering av nämnda modulbeskrivning och patchning av commons-lang3-3.4.jar krävs endast för körtidsbilden som vi kommer att skapa i slutet av handledningen.

8.2 Maven Build

maven-build projektkatalogen har följande struktur:(exklusive target som target mapp kommer att genereras på maven build)

Katalogstruktur för maven-build-projektet

Innan vi kör någon build måste vi publicera den korrigerade automatiska jar (commons-lang3-3.4.jar ) från manual-build projekt till vårt lokala maven-förråd. Detta måste göras så att när vi kör maven build mvn clean install package maven kommer att använda den justerade commons-lang3-3.4.jar (innehåller en module-info.class ) för vår maven-build version av projektet.

Den korrigerade automatiska burken finns i <project-root-folder>/manual-build/after/patched-automatic-modules/commons-lang3-3.4.jar och kan installeras på vårt lokala maven-förråd med följande kommando:(ersätt filsökväg på lämpligt sätt)

Installerar vår korrigerade automatiska modul

mvn install:install-file -Dfile=<path-toproject>/java9-jigsaw-project/manual-build/after/patched-automatic-modules/commons-lang3-3.4.jar -DgroupId=org.apache.commons -DartifactId=commons-lang3 -Dversion=3.4-module -Dpackaging=jar

Utdrag av pom.xml filerna följer för det överordnade maven-projektet och varje maven-modul:

Snippet of Jigsaw Date pom.xml (Moderprojekt)

...
<modules>
		<module>jigsaw-date-cli</module>
		<module>jigsaw-date-service</module>
	</modules>

	<properties>
		<maven.compiler.plugin>3.6.0</maven.compiler.plugin>
		<maven.toolchains.plugin>1.1</maven.toolchains.plugin>
		<maven.jar.plugin>2.3.1</maven.jar.plugin>
		<maven.dependency.plugin.version>3.0.1</maven.dependency.plugin.version>

		<maven.compiler.source>1.9</maven.compiler.source>
		<maven.compiler.target>1.9</maven.compiler.target>
		<maven.compiler.release>9</maven.compiler.release>
	</properties>

	<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>${maven.compiler.plugin}</version>
				</plugin>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-toolchains-plugin</artifactId>
					<version>${maven.toolchains.plugin}</version>
				</plugin>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-jar-plugin</artifactId>
					<version>${maven.jar.plugin}</version>
				</plugin>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-dependency-plugin</artifactId>
					<version>${maven.dependency.plugin.version}</version>
				</plugin>
			</plugins>
		</pluginManagement>

		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-toolchains-plugin</artifactId>
				<configuration>
					<toolchains>
						<jdk>
							<version>1.9</version>
							<vendor>oracle</vendor>
						</jdk>
					</toolchains>
				</configuration>
				<executions>
					<execution>
						<?m2e ignore ?>
						<goals>
							<goal>toolchain</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
...


Snippet of Jigsaw Date Service pom.xml

...
<properties>
		<org.apache.commons.lang.version>3.4-module</org.apache.commons.lang.version>
	</properties>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.apache.commons</groupId>
				<artifactId>commons-lang3</artifactId>
				<version>${org.apache.commons.lang.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<dependencies>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<configuration>
					<outputDirectory>${project.build.directory}/../../target/modules</outputDirectory>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/../../target/modules</outputDirectory>
							<overWriteReleases>false</overWriteReleases>
							<overWriteSnapshots>false</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
...
  • rad 3:vi anger ett beroende av den korrigerade automatiska modulen
  • rad 29 och 43:vi anger att byggartefakten och eventuella beroenden ska kopieras till <project-root-folder>/maven-build/target/modules


Snippet of Jigsaw Date Cli pom.xml

...
<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>com.javacodegeeks</groupId>
				<artifactId>jigsaw-date-service</artifactId>
				<version>${project.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<dependencies>
		<dependency>
			<groupId>com.javacodegeeks</groupId>
			<artifactId>jigsaw-date-service</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<configuration>
					<outputDirectory>${project.build.directory}/../../target/modules</outputDirectory>
					<archive>
						<manifest>
							<mainClass>com.javacodegeeks.jigsaw.date.cli.Main</mainClass>
						</manifest>
					</archive>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/../../target/modules</outputDirectory>
							<overWriteReleases>false</overWriteReleases>
							<overWriteSnapshots>false</overWriteSnapshots>
							<overWriteIfNewer>true</overWriteIfNewer>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
...
  • raderna 12-17:vi anger ett beroende av jigsaw.date.service modul
  • rad 29 och 43:vi anger att byggartefakten och eventuella beroenden ska kopieras till <project-root-folder>/maven-build/target/modules

Se till att du är i <project-root-folder>/maven-build och kör mvn clean install package . Projektet kommer att byggas och alla byggda artefakter kommer att deponeras i <project-root-folder>/maven-build/target/modules . Du bör se 3 modulburkar om det lyckas:

  • jigsaw-date-cli-0.0.1-SNAPSHOT.jar
  • jigsaw-date-service-0.0.1-SNAPSHOT.jar
  • commons-lang3-3.4-module.jar

9. Köra exempelapplikationen

Kör maven-build version (när den är byggd) kan göras genom att navigera in i följande mapp <project-root-folder>/maven-build och kör:

Kör ett mavenbyggt projekt

java -jar --module-path target/modules -m jigsaw.date.cli/com.javacodegeeks.jigsaw.date.cli.Main
System date is : 09-09-2017
System date is : 09-09-2017

10. Runtime Image

I det här avsnittet kommer vi att skapa en körtidsbild från vår manual-build projekt. Detta kan endast göras när alla föregående steg för den manuella konstruktionen har slutförts framgångsrikt, därför kommer vi att använda after mapp i manual-build vilket garanterar att alla tidigare steg har slutförts framgångsrikt.

När bilden har byggts upp en ny mapp image.jigsaw.date.cli borde ha skapats i after mapp. På mitt system är mappstorleken ungefär 47,3 MB vilket bevisar hur mycket jlink kan drastiskt minska storleken på en Java-körtidsbild som behövs.

Bygga och köra en körtidsbild

$ jlink -v --module-path $JAVA_HOME/jmods:patched-automatic-modules:modules --add-modules jigsaw.date.cli,jigsaw.date.service --output image.jigsaw.date.cli  --launcher launch=jigsaw.date.cli/com.javacodegeeks.jigsaw.date.cli.Main
commons.lang3 file:///home/jean-jay/Documents/projects/codegeeks/java9-jigsaw-project/manual-build/after/patched-automatic-modules/commons-lang3-3.4.jar
java.base file:///home/jean-jay/runtimes/jdk-9/jmods/java.base.jmod
jigsaw.date.cli file:///home/jean-jay/Documents/projects/codegeeks/java9-jigsaw-project/manual-build/after/modules/jigsaw.date.cli/
jigsaw.date.service file:///home/jean-jay/Documents/projects/codegeeks/java9-jigsaw-project/manual-build/after/modules/jigsaw.date.service/

Providers:
  java.base provides java.nio.file.spi.FileSystemProvider used by java.base
$ ./image.jigsaw.date.cli/bin/java --list-modules
[email protected]
java.base@9
jigsaw.date.cli
jigsaw.date.service
$ ./image.jigsaw.date.cli/bin/launch
System date is : 09-09-2017
System date is : 09-09-2017
  • rad 1:vi utfärdar jlink kommando som anger modulsökvägen inklusive vår applikationsmodul, lappad automatisk modul och JDK (jmod / plattformsmoduler). Vi anger även utdatamappen image.jigsaw.date.cli och ett startskript som heter launcher pekar på vår huvudklass. Launcher-skriptet gör det möjligt för oss att bekvämt köra vår applikation från den. Eftersom vi har angett utförlig utdata kommer vi att se alla moduler som läggs till i bilden och platserna där de togs matas ut på skärmen.
  • rad 9:vi anropar java körbar inifrån bilden och be den att lista dess moduler för bekräftelse.
  • rad 14:vi anropar launch skript inuti bilden och vi kan se vårt systemdatum matas ut på ett snyggt formaterat sätt.

11. Sammanfattning

I den här handledningen täckte vi vad projekt Jigsaw innebär och vad det tillför Java-plattformen. Vi dök ner i mekaniken i det och demonstrerade hur man strukturerar, bygger och paketerar ett exempelprojekt både från kommandoraden och med det populära verktyget för att bygga ett beroendehanteringsverktyg, Maven.

12. Ladda ner källkoden

Detta var ett Java 9 Jigsaw Project Tutorialjava 9 java 9 moduler

Java-tagg