This is an automated email from the ASF dual-hosted git repository.
slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-compiler-plugin.git
The following commit(s) were added to refs/heads/master by this push:
new 5885d5fc Move the Java target, toolchain and multi-release pages to
the Maven site
5885d5fc is described below
commit 5885d5fccab998cfc6d94a85b4e841e34c173add
Author: Sylwester Lachiewicz <[email protected]>
AuthorDate: Sat Oct 31 20:00:32 2026 +0000
Move the Java target, toolchain and multi-release pages to the Maven site
---
.../examples/compile-using-different-jdk.md.vm | 97 -----------
.../markdown/examples/set-compiler-release.md.vm | 123 --------------
.../examples/set-compiler-source-and-target.md.vm | 73 ---------
src/site/markdown/index.md.vm | 8 +-
src/site/markdown/multirelease.md | 179 ---------------------
src/site/site.xml | 9 +-
6 files changed, 9 insertions(+), 480 deletions(-)
diff --git a/src/site/markdown/examples/compile-using-different-jdk.md.vm
b/src/site/markdown/examples/compile-using-different-jdk.md.vm
deleted file mode 100644
index 250cab13..00000000
--- a/src/site/markdown/examples/compile-using-different-jdk.md.vm
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: Compiling Sources Using A Different JDK
-author:
- - Edwin Punzalan
-date: 2006-07-05
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Compiling Sources Using A Different JDK
-
-Using Maven Toolchains
-----------------------
-
-The preferable way to use a different JDK is to use the toolchains mechanism.
During the build of a project, Maven, without toolchains, will use the JDK to
perform various steps, like compiling the Java sources, generate the Javadoc,
run unit tests or sign JARs. Each of those plugins need a tool of the JDK to
operate: `javac`, `javadoc`, `jarsigner`, etc. A toolchain is a way to specify
the path to the JDK to use for all of those plugins in a centralized manner,
independent from the one [...]
-
-To set this up, refer to the [Guide to Using
Toolchains](/guides/mini/guide-using-toolchains.html), which makes use of the
[Maven Toolchains Plugin](/plugins/maven-toolchains-plugin/).
-
-With the maven-toolchains-plugin you configure 1 default JDK toolchain for all
related maven-plugins. Since maven-compiler-plugin 3.6.0 when using with Maven
3.3.1+ it is also possible to give the plugin its own toolchain, which can be
useful in case of different JDK calls per execution block (e.g. the test
sources require a different compiler compared to the main sources).
-
-Configuring the Compiler Plugin
--------------------------------
-
-Outside of a toolchain, it is still possible to tell the Compiler Plugin the
specific JDK to use during compilation. Note that such configuration will be
specific to this plugin, and will not affect others.
-
-The `compilerVersion` parameter can be used to specify the version of the
compiler that the plugin will use. However, you also need to set `fork` to
`true` for this to work. For example:
-
-```unknown
-<project>
- [...]
- <build>
- [...]
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>${project.version}</version>
- <configuration>
- <verbose>true</verbose>
- <fork>true</fork>
- <executable><!-- path-to-javac --></executable>
- <compilerVersion>1.3</compilerVersion>
- </configuration>
- </plugin>
- </plugins>
- [...]
- </build>
- [...]
-</project>
-```
-
-To avoid hard-coding a filesystem path for the executable, you can use a
property. For example:
-
-```unknown
- <executable>${JAVA_1_4_HOME}/bin/javac</executable>
-```
-
-Each developer then defines this property in
[settings.xml](http://maven.apache.org/ref/current/maven-settings/settings.html),
or sets an environment variable, so that the build remains portable.
-
-```unknown
-<settings>
- [...]
- <profiles>
- [...]
- <profile>
- <id>compiler</id>
- <properties>
- <JAVA_1_4_HOME>C:\Program Files\Java\j2sdk1.4.2_09</JAVA_1_4_HOME>
- </properties>
- </profile>
- </profiles>
- [...]
- <activeProfiles>
- <activeProfile>compiler</activeProfile>
- </activeProfiles>
-</settings>
-```
-
-If you build with a different JDK, you may want to [
customize](http://maven.apache.org/plugins/maven-jar-plugin/examples/manifest-customization.html)
the jar file manifest.
-
diff --git a/src/site/markdown/examples/set-compiler-release.md.vm
b/src/site/markdown/examples/set-compiler-release.md.vm
deleted file mode 100644
index aed7fc93..00000000
--- a/src/site/markdown/examples/set-compiler-release.md.vm
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: Setting the --release of the Java Compiler
-author:
- - Mahmoud Anouti
-date: 2019-12-20
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Setting the `--release` of the Java Compiler
-
-Starting with JDK 9, the `javac` executable can accept the `--release` option
to specify against which Java SE release you want to build the project. For
example, you have JDK 11 installed and used by Maven, but you want to build the
project against Java 8. The `--release` option ensures that the code is
compiled following the rules of the programming language of the specified
release, and that generated classes target the release as well as the public
API of that release. This means tha [...]
-
-Since version 3.6 of the Compiler Plugin, this option can be provided either
via a property:
-
-```unknown
-<project>
- [...]
- <properties>
- <maven.compiler.release>8</maven.compiler.release>
- </properties>
- [...]
-</project>
-```
-
-or by configuring the plugin directly:
-
-```unknown
-<project>
- [...]
- <build>
- [...]
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>${project.version}</version>
- <configuration>
- <release>8</release>
- </configuration>
- </plugin>
- </plugins>
- [...]
- </build>
- [...]
-</project>
-```
-
-**Note:** The value in the `release` parameter follows [Java's new
Version-String Scheme (JEP 223)](https://openjdk.org/jeps/223)} adopted since
Java 9. As such, the release number does not start with 1.x anymore. Also note
that the supported `release` targets include the release of the currently used
JDK plus a limited number of previous releases.
-
-Usage on JDK 8
---------------
-
-The `--release` option is not supported using JDK 8. However, since Compiler
plugin version `3.13.0` you can use the `release` property also on JDK 8. The
plugin will convert it to `source` and `target` automatically.
-
-To enable a project that targets Java 8 to be built using JDK 8 and also JDK 9
or later requires the conditional usage of the `--release` option, when using a
plugin version below `3.13.0` or compilerId different that `javac`.
-
-This may be done through the use of a profile:
-
-```unknown
-<project>
- [...]
- <profiles>
- [...]
- <profile>
- <id>set-compiler-release</id>
- <activation>
- <jdk>[9,)</jdk>
- </activation>
- <properties>
- <maven.compiler.release>8</maven.compiler.release>
- </properties>
- </profile>
- [...]
- </profiles>
- [...]
-</project>
-```
-
-Since version `3.13.0` of the Compiler Plugin together with the default
`javac` compilerId you don't need conditional parametrisation of `release`. The
`release` parameter will only be effective for Java 9 or above, otherwise the
`source` and `target` will be passed to the compiler.
-
-So you can simply configure as:
-
-```unknown
-<project>
- [...]
- <build>
- [...]
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>${project.version}</version>
- <configuration>
- <release>8</release>
- <source>8</source>
- <target>8</target>
- </configuration>
- </plugin>
- </plugins>
- [...]
- </build>
- [...]
-</project>
-```
-
diff --git a/src/site/markdown/examples/set-compiler-source-and-target.md.vm
b/src/site/markdown/examples/set-compiler-source-and-target.md.vm
deleted file mode 100644
index cd8644a4..00000000
--- a/src/site/markdown/examples/set-compiler-source-and-target.md.vm
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: Setting the -source and -target of the Java Compiler
-author:
- - Edwin Punzalan
-date: 2006-07-05
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Setting the `-source` and `-target` of the Java Compiler
-
-(If you're are using version `3.13.0` or newer of the Compiler Plugin, use the
recommended [`maven.compiler.release`
property](../examples/set-compiler-release.html).)
-
-Sometimes when you may need to compile a certain project to a different
version than what you are currently using. The `javac` can accept such command
using `-source` and `-target`. The Compiler Plugin can also be configured to
provide these options during compilation. You have to set the version following
[Java's new Version-String Scheme (JEP 223)](https://openjdk.org/jeps/223)}.
-
-For example, if you want to use the Java 8 language features and also want the
compiled classes to be compatible with JVM 8 (former 1.8) you can either add
the two following properties, which are the default property names for the
plugin parameters:
-
-```unknown
-<project>
- [...]
- <properties>
- <maven.compiler.source>8</maven.compiler.source>
- <maven.compiler.target>8</maven.compiler.target>
- </properties>
- [...]
-</project>
-```
-
-or configure the plugin directly:
-
-```unknown
-<project>
- [...]
- <build>
- [...]
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>${project.version}</version>
- <configuration>
- <source>8</source>
- <target>8</target>
- </configuration>
- </plugin>
- </plugins>
- [...]
- </build>
- [...]
-</project>
-```
-
-**Note:** Merely setting the `target` option does not guarantee that your code
actually runs on a JRE with the specified version. The pitfall is unintended
usage of APIs that only exist in later JREs which would make your code fail at
runtime with a linkage error. To avoid this issue, you can either configure the
compiler's boot classpath to match the target JRE, or use the [Animal Sniffer
Maven
Plugin](http://www.mojohaus.org/animal-sniffer/animal-sniffer-maven-plugin/) to
verify your c [...]
-
-In the same way, setting the `source` option does not guarantee that your code
actually compiles on a JDK with the specified version. To compile your code
with a specific JDK version, different than the one used to launch Maven, refer
to the [Compile Using A Different
JDK](../examples/compile-using-different-jdk.html) example.
-
diff --git a/src/site/markdown/index.md.vm b/src/site/markdown/index.md.vm
index a7e9ba04..74c9f4ee 100644
--- a/src/site/markdown/index.md.vm
+++ b/src/site/markdown/index.md.vm
@@ -28,7 +28,7 @@ under the License.
The Compiler Plugin is used to compile the sources of your project. The
default compiler used to compile Java sources is `javac`. If you want to use
another compiler, refer to the [ guide: Using Non-Javac
Compilers](./non-javac-compilers).
-At present the default `source` and the default `target` setting are both `8`,
independently of the JDK you run Maven with. You are highly encouraged to
change these defaults by setting the `release` option as described in the
[guide: Compile Using The `--release` javac
Option](./examples/set-compiler-release.html).
+At present the default `source` and the default `target` setting are both `8`,
independently of the JDK you run Maven with. You are highly encouraged to
change these defaults by setting the `release` option as described in the
[Guide to Targeting a Java
Version](https://maven.apache.org/guides/mini/guide-java-target.html).
**NOTE:** _To know more about the JDK javac, please see:
[https://docs.oracle.com/javase/8/docs/technotes/guides/javac/index.html](https://docs.oracle.com/javase/8/docs/technotes/guides/javac/index.html)._
@@ -54,8 +54,8 @@ Examples
To provide you with better understanding on some usages of the Compiler
Plugin, you can take a look into the following examples:
-- [Compile Using A Different JDK](./examples/compile-using-different-jdk.html)
-- [Compile Using -source and -target javac
Options](./examples/set-compiler-source-and-target.html)
-- [Compile Using The \-\-release javac
Option](./examples/set-compiler-release.html)
+- [Compile Using A Different
JDK](https://maven.apache.org/guides/mini/guide-using-toolchains.html)
+- [Compile Using -source and -target javac Options or the \-\-release
Option](https://maven.apache.org/guides/mini/guide-java-target.html)
+- [Build a Multi-Release
JAR](https://maven.apache.org/guides/mini/guide-multi-release-jars.html)
- [Compile Using Memory Allocation
Enhancement](./examples/compile-with-memory-enhancements.html)
- [Pass Compiler Arguments](./examples/pass-compiler-arguments.html)
diff --git a/src/site/markdown/multirelease.md
b/src/site/markdown/multirelease.md
deleted file mode 100644
index 12234774..00000000
--- a/src/site/markdown/multirelease.md
+++ /dev/null
@@ -1,179 +0,0 @@
----
-title: Multi Release
-author:
- - Robert Scholte
-date: 2018-05-08
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements. See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership. The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied. See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Multi Release
-
-With [JEP-238](http://openjdk.java.net/jeps/238) the support of multirelease
jars was introduced. This means that you can have Java version dependent
classes inside one jar. Based on the runtime it will pick up the best matching
version of a class.
-
-JEP-238 Introduction
---------------------
-
-### The "forward compatibility" problem
-
-The problem this JEP is trying to solve is to make it possible to use new JDK
features even though the codebase must stay compatible with earlier versions.
-
-Let's try to make this concrete with a real world example: In Java 7
`java.nio` was added, which was much better in File handling. In those days
Maven still required Java 6 to run, however they wanted to make use of these
new features when Maven was running on Java 7 or beyond.
-
-Up until Java 8 there were 2 solutions:
-
-1. Compile with the targeted JDK (i.e. Java 6) and use reflection. You can
ensure that the code is Java 6 compatible, but the reflection-part is hard to
verify.
-
- ```
- if ( isAtLeastJava7() ) {
- Method toPathMethod = f.getClass().getMethod( "toPath" );
- Object toPathInstance = toPathMethod.invoke( f );
- Method isSymbolicLink = Class.forName( "java.nio.file.Files"
).getMethod( "isSymbolicLink" );
- ...
- }
- else {
- // compare absoluteFile with canonicalFile
- ...
- }
- ```
-
-1. Compile with the required JDK (i.e. Java 7), but use source/target of the
lowest version (i.e. 1.6). The danger here is that you cannot ensure that all
code is Java 6 compatible. Depending on the code structure [Animal
Sniffer](https://www.mojohaus.org/animal-sniffer/) might help.
-
- ```
- if ( isAtLeastJava7() ) {
- return Files.isSymbolicLink( f.toPath() );
- }
- else {
- // compare absoluteFile with canonicalFile
- ...
- }
- ```
-
-### The "forward compatibility" solution
-
-```
-A.class
-B.class
-C.class
-D.class
-META-INF/MANIFEST.MF { Multi-Release: true }
- versions/9/A.class
- B.class
- 10/A.class
- C.class
-
-```
-
-With the `Multi-Release: true` flag in the MANIFEST file, the Java runtime
will also look inside `META-INF/versions` for version specific classes,
otherwise only the base classes are used.
-
-Challenges
-----------
-
-The theory behind multi release jars is quite simple, but in practice it can
become quite complex. You must ensure that all classes stay in sync; if you add
a method to one class, don't forget to add it to the other classes as well.
There are some options which should reduce problems at this level: Let all
multirelease classes implement an interface and in the basecode instantiate the
class but only call the interface methods. The best is to test the \*jar\* with
all targeted Java versio [...]
-
-There are a couple of important facts one should know when creating Multi
Release jars.
-
-- The Java compiler must be called for every different version. The solutions
solve this either by having multiple Maven Projects/Modules or by adding extra
compiler execution-blocks to the POM (like [older projects with
module-info](./examples/module-info.html)).
-- The `Multi-Release: true` attribute is only recognized when the classes are
in a jar. In other words, you cannot test the classes put in
`target/classes/META-INF/versions/${release}/`.
-- Up until the moment of writing all IDEs can only have one JDK per Maven
Project, whereas with multi release you want to specify it per source folder.
-# Pattern 1: [Maven Multimodule](https://github.com/hboutemy/maven-jep238)
-
-This is the first pattern provided by the Maven team themselves. They had the
following requirements:
-
-- Only one Maven call to compile, test and package the Multi Release jar
-- It must work with IDEs
-- Developers should not change their way of work / simple configuration
-
-The only solution to cover the first two bullets was to split the code into a
Maven multimodule project. Now every Maven module is just a standard Maven
project with close to no specific adjustments in the pom. There are several
ways you can run this project:
-
-- Use the highest required version of the JDK to build the project. You can
use `release` to ensure the code only uses matching code and syntax. Since the
version-code is isolated you can run surefire with a higher Java runtime.
-- Use toolchains if you really want to compile and test with the matching Java
version.
-
-The downside it that a hierarchical structure is required even though the
result is just 1 artifact.
-
-# Pattern 2: [Multi Project](http://word-bits.flurg.com/multrelease-jars/)
-
-This solution is a response to the previous Maven multimodule setup. The
requirements are almost the same
-
-- Do not require the project to switch to a multi-module format
-- Developers should not change their way of work / simple configuration
-
-The first requirements implies that the projects now are separate Maven
projects. One Maven project contains the base-code and in the end this will
also be the multirelease jar. When building such project for the first time,
you'll need to call Maven at least 3 times: first the base needs to be
compiled, next all version specific projects must be built and finally the main
project needs to be built again, now including the version specific classes
extracted from their jars. This setup is [...]
-
-# Pattern 3: Single Project
-
-By now there are 3 solutions, each inspired by their previous version.
-
-Main goal:
-
-- Do not require the project to switch to a multi-module format
-- Only one Maven call to compile and package the Multi Release jar
-
-[Single
Project](http://in.relation.to/2017/02/13/building-multi-release-jars-with-maven/)
-------------------------------------------------------------------------------------------
-
-In this case everything stays inside one Maven project. Every specific Java
version gets its own source folder and output folder, and just before packaging
they are combined. What's not covered is how to test every class.
-
-[Multi-Release
Parent](http://www.russgold.net/sw/2018/04/easier-than-it-looks/)
---------------------------------------------------------------------------------
-
-This approach replaces the maven-ant-plugin with extra exucution blocks in the
maven-compiler-plugin. It has been setup as a parent, so other projects can use
it. It uses toolchains to be able to build all classes with their matching Java
version, so you always get the multi release jar. Because of the huge
configuration and since Maven doesn't support mixins yet, it makes sense to put
it all in a parent. However, at the same time surefire is only called once.
-
-[CI-server](https://github.com/codehaus-plexus/plexus-languages)
-----------------------------------------------------------------
-
-This approach reduces the previous solution by only specifying execution
blocks for sources for a specific Java version. It doesn't use toolchains, but
the JDK used to run Maven. This means that only the sources up to the specific
Java version are compiled and tested. This solution relies heavily on a
CI-server where every targeted Java version is available. If the CI-server
succeeds, then all classes are tested with their matching Java version.
-
-# Pattern 4: [Maven extension +
plugin](https://github.com/metlos/multi-release-jar-maven-plugin)
-
-This approach introduces a new packaging type and an extra plugin takes care
of the multiple executions of the maven-compiler-plugin, but these are now
handled by the `perReleaseConfiguration` of the
`multi-release-jar-maven-plugin`. What's not covered is how to test every class.
-
-# Patterns Summary
-
-For every pattern there are integration tests created, based on the same set
of sourcefiles. See
[https://github.com/apache/maven-compiler-plugin/tree/master/src/it/multirelease-patterns](https://github.com/apache/maven-compiler-plugin/tree/master/src/it/multirelease-patterns)
-
-||Maven Multimodule|Multi Project|Single project (runtime)|Single project
(toolchains)|Maven extension+plugin|
-|:---:|:---:|:---:|:---:|:---:|:---:|
-|\# projects|1|1 + #javaVersions|1|1|1|
-|\# builds to package|1|2 + #javaVersions|1|1|1|
-|\# builds/project to test|1|1|#javaVersions|1|N/A (a)|
-|Simple Maven Project Layout|No|Yes|Yes|Yes|Yes|
-|Additional POM adjustments(b)|1
(c)|#javaVersions(d)|#javaVersions(e)|??(f)|#javaVersions(g)|
-|Include module descriptor|No (h)|No (h)|Yes|Yes|Yes|
-|IDE support (i)|Yes|Yes|No|No|No|
-
-(a) Project can only be executed with highest required JDK, hence you can't
test the code for all JDKs
-
-(b) Additional POM adjustments: # of executions added to the default
lifecycle. This reflects the complexity of the POM.
-
-(c) Maven multimodule uses maven-assembly-plugin to assemble to multirelease
jar
-
-(d) Multi project uses the maven-dependency-plugin to unpack java specific
dependency to its matching outputDirectory
-
-(e) There's a profile for every Java version required which contains an extra
execution-block for that Java version.
-
-(f)
-
-(g) Maven extension+plugin hides the multiple executions in the
`perReleaseConfiguration` configuration
-
-(h) Requires a \-\-patch-module on a dependency
-
-(i) IDE Support: All classes are recognized and can be tested within the IDE.
-
diff --git a/src/site/site.xml b/src/site/site.xml
index 0d6d833b..46ca9498 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -33,14 +33,15 @@ under the License.
<item name="Download" href="download.html"/>
</menu>
<menu name="Examples">
- <item name="Compile Using A Different JDK"
href="examples/compile-using-different-jdk.html"/>
- <item name="Compile Using -source and -target javac Options"
href="examples/set-compiler-source-and-target.html"/>
- <item name="Compile Using the --release javac Option"
href="examples/set-compiler-release.html"/>
<item name="Compile Using Memory Allocation Enhancements"
href="examples/compile-with-memory-enhancements.html"/>
<item name="Pass Compiler Arguments"
href="examples/pass-compiler-arguments.html"/>
<item name="Non-javac compilerIds" href="non-javac-compilers.html"/>
<item name="Older projects with module-info"
href="examples/module-info.html"/>
- <item name="MultiRelease" href="multirelease.html"/>
+ </menu>
+ <menu name="See Also">
+ <item name="Targeting a Java Version"
href="https://maven.apache.org/guides/mini/guide-java-target.html"/>
+ <item name="Using Toolchains"
href="https://maven.apache.org/guides/mini/guide-using-toolchains.html"/>
+ <item name="Building Multi-Release JARs"
href="https://maven.apache.org/guides/mini/guide-multi-release-jars.html"/>
</menu>
</body>
</project>