Using JDK8 to compile for target JRE7

Question

Up until today I was under the impression that -target argument on the compile would be enough to ensure that my application would execute on JRE7 even if compiled with a JDK8 javac.

I soon got wiser as I learned about how Sun/Oracle changes method signatures from one release to another.

My aim is - using JDK8 tool chain - to create a binary that will execute with both JRE7 and JRE8. Our build farms where I work are multi-OS, meaning some are Windows, some are Solaris, etc. I cannot predict beforehand where my application is going to build.

I understand the recommended solution is to use -Xbootclasspath on the compile step. I'm using Maven so I'll need something like this:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.1</version>
      <configuration>
        <source>1.7</source>
        <target>1.7</target>
        <compilerArguments>
          <bootclasspath>XXXX</bootclasspath>
        </compilerArguments>
      </configuration>
    </plugin>
  </plugins>
</build>

What I don't understand is how to set XXXX so that my application will build anywhere and not just on my own workstation. Essentially I would like XXXX to be an artifact or a dependency if you like. I do not have control over target build machines but I can upload third party artifacts to our corporate Maven repo. How to solve this issue?

The other problem I see is that XXXX is really a list. It is not a single jar. (as far as I understand - to be safe - it is really the value of sun.boot.class.path from the target JRE, meaning it is more than just rt.jar as some literature seems to suggest). How do I set XXXX in a way so that it is OS independent, given that ";" is used as list item separator on Windows whereas ":" is used on Unix/Linux. How to solve that ?

Answer 1

You can try profiles

<profiles>
    <profile>
        <id>default</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <bootclasspath>xxx</bootclasspath>
        </properties>
    </profile>
    <profile>
        <id>win</id>
        <activation>
            <os>
                <family>Windows</family>
            </os>
        </activation>
        <properties>
            <bootclasspath>yyy</bootclasspath>
        </properties>
    </profile>
</profiles>

Answer 2

I suggest not to cross-compile, but to actually use the JDK you want to build against.

If this JDK version differs from the rest of your project, then use the Maven Toolchain Plugin.

Answer 3

Assuming that the maven itself runs under JDK 8 but the intention is to compile a module to be compatible with JDK 7.

The proper cross-compilation requires that the target JDK is present. Consider the following approach to configure cross-compilation for a particular Maven module:

• Allow compilation even when the target JDK is not present.
• Automatically use cross-compilation when the target JDK is present.

The Maven is unable to detect the presence of other JDKs by itself, so you will have to define the environment property (JDK7_HOME in the example below) which will trigger the cross-compilation profile and provide the base path for bootclasspath configuration.

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
            </plugin>
        </plugins>
    </pluginManagement>

    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <!--
                the base config should generate class files
                with the proper version number
                even in the absence of cross-compilation JDK
                -->
                <source>1.7</source>
                <target>1.7</target>
            </configuration>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile>
        <id>cross-compile-jdk7</id>
        <activation>
            <property>
                <!--
                the proper cross-compilation is triggered
                when the cross-compilation JDK is really present
                -->
                <name>env.JDK7_HOME</name>
            </property>
        </activation>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <!--
                        the advanced config not only generates class files
                        with the proper version number
                        but also uses correct bootclasspath
                        -->
                        <source>1.7</source>
                        <target>1.7</target>
                        <!--
                        forking is required for when changing bootclasspath
                        -->
                        <fork>true</fork>
                        <!--
                        the following monstrosity is the most paranoid way
                        to get correct file and path separators

                        this particular example includes rt.jar and jsse.jar
                        from the target JDK
                        -->
                        <compilerArgs>
                            <arg>-bootclasspath</arg>
                            <arg>${env.JDK7_HOME}${file.separator}jre${file.separator}lib${file.separator}rt.jar${path.separator}${env.JDK7_HOME}${file.separator}jre${file.separator}lib${file.separator}jsse.jar</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>