no problem to move it to this thread. It is indeed about "The Maven
Way", although we may need to start from the beginning, explaining
the
issue we're facing.
Let's use ASM as an example, their 6.0_ALPHA has been built like
this,
although without Maven.
ASM is an all purpose Java bytecode manipulation and analysis
framework.
IIRC their code is compatible with Java 1.2, but they've also added
a
module-info for those who want to use this dependency within a
Java9/Jigsaw project.
module-info MUST be built with Java9 with source/target or release =
9.
Other sources must be built with an older JDK with source/target 1.2
There are several ways to solve this:
- multi-module project and multi release jar like Paul suggest.
However,
IIRC the specs say that the module-info MUST exist in the root.
- 2 source folders, src/main/java and src/main/jigsaw, both writing
to
target/classes. Here it is quite clear what happens per
source-folder.
- 1 source folder and all the magic of calling javac twice in the
maven-compiler-plugin. I started with this, but I don't like it.
Details
are below.
- 1 source folder and 2 execution blocks (one excluding module-info,
one
only including module-info).
We shouldn't be looking at Maven alone, but also at IDE support.
AFAIK
Netbeans and IntelliJ simply call Maven. Eclipse is probably hard
due to
the m2eclipse extensions.
Now back to Pauls suggestion. I don't think we make developers very
happy if they are advised to have a multimodule project just to be
able
to compile the module-info file.
I am aware that this is mainly an issue for library builders, end
users
simply build everything with Java9, no problems there. From library
builders you can expect that they don't mind adding extra
configuration to
build their jar, but forcing them to set up a Maven multimodule
project is
not really nice.
I would expect the module-info close to the related sourcefiles, so
I
would prefer in the same (single) MavenProject.
*Unless* IDEs are so strong with handling multi release jars that it
looks like I'm adjusting the module-info, even though it is
actually
located somewhere else.
So let's see the opinions from others.
thanks,
Robert
On Wed, 31 Aug 2016 15:59:04 +0200, Paul Benedict
<[email protected]>
wrote:
Robert, I'm responding to dev@maven so we can discuss Maven
philosophies...
I believe the pattern should be based on a multi-module project.
Each
module should target the expected JDK version. Then introduce a new
"mrjar"
type for the parent that knows how to bind them all together into a
Multi-Release JAR.
Cheers,
Paul
On Wed, Aug 31, 2016 at 6:10 AM, Robert Scholte
<[email protected]>
wrote:
I've been working on the implementation of this in the
maven-compiler-plugin, but I'm not really pleased with the result.
The problem is that in the worst case scenario we have to work
with 3
different versions of Java:
- The Maven Runtime (set as JAVA_HOME)
- JDK for the module-info.java
- JDK for all other source files.
The example below worked because all three were set to JDK9.
But based on the source/target of 1.6 I cannot predict which JDK
is
used,
only that it is at least JDK6. Should the plugin switch to another
JDK?
And if you want to compile with source/target 1.5 or less, you're
in
trouble. There's something called toolchain, where you can specify
the
JavaHome per version, but in case of maven-compiler-plugin it
assumes
that
all java-related plugins and execution blocks want to use the same
toolchain through the whole Maven project.
The good news is that for the maven-jdeps-plugin I improved this
part in
Maven 3.3.1, since this plugin only works with Java8 and above,
which
doesn't have to be the same JDK to compile the sources with. Now
you can
simple say: I want the toolchain for version X. This feature needs
to be
added to the plugin.
That said I think I will write a recipe for this. This is first of
all
an
issue for library writers who want to have their jar compatible
with
multiple Java versions for their end users.
Result: One javac call per execution block as it was meant to be.
thanks,
Robert
On Fri, 26 Aug 2016 15:31:07 +0200, Oliver Gondža
<[email protected]>
wrote:
Thank you all for your suggestions. I managed to get the project
to
build
with following maven setup:
```
<!--
When using compiler from java 8 and older, ignore module
files
altogether.
Otherwise, use 2 phase compilation to build
- all classes for target version and
- module-info.java with 9+ source and target level
-->
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
<executions>
<execution>
<id>default-compile</id>
<configuration>
<excludes>
<exclude>**/module-info.java</exclude>
</excludes>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<profiles>
<profile>
<id>jigsaw</id>
<activation>
<jdk>[1.9,)</jdk>
</activation>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.9</source>
<target>1.9</target>
</configuration>
<executions>
<execution>
<id>module-infos</id>
<phase>compile</phase>
<goals>
<goal>compile</goal>
</goals>
<configuration>
<includes>
<include>**/module-info.java</include>
</includes>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
```
It does compile with older javac versions as a bonus. Given this
is
nothing else than using `-source 9 -target 9` for
module-info.java if
present, I dare to say maven-compiler-plugin can be adapted to
figure
this
out on its own.
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
