CODEWITHSUNDEEP
javaeclipsemavenjavafxmaven-compiler-plugin
John Miller
John Miller

Reputation: 74

Maven compiling with different JDK versions

My application is split between users on Java 1.6u45 and Java 1.8. Our problem is that we cannot specify the project system library and have two different compiler settings for the code at the same time.

Project Structure:

Project >
    > src/main/java/com/us/javafx/... (Java 8 code)
    > src/main/java/com/us/... (Java 6 code)
    > src/main/resources/...

Our POM.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.us</groupId>
   <artifactId>PROJECT</artifactId>
   <version>1.0.0</version>
   <packaging>jar</packaging>
   <name>PROJECT</name>
   <description>DESCR</description>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>

</dependencies>

<build>
    <plugins>
        <!-- Copy all dependencies to jars directory -->
          <plugin> 
              <artifactId>maven-dependency-plugin</artifactId> 
                  <executions> 
                      <execution> 
                          <phase>package</phase> 
                          <goals> 
                              <goal>copy-dependencies</goal> 
                          </goals> 
                          <configuration> 
                              <outputDirectory>${project.build.directory}/jars</outputDirectory> 
                          </configuration> 
                      </execution> 
                  </executions> 
          </plugin>


            <!-- Maven Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>  
                <configuration>
                    <!-- Necessary to avoid setting JRE on Maven project update! -->
                    <!-- SEE PHOTO FOR WHY THIS IS HERE -->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>            
                <executions>

                    <!-- Compile Java 6 directory -->
                    <execution>
                        <id>java6</id>
                        <configuration>
                            <excludes>
                                <exclude>com/us/javafx/**/*</exclude>
                            </excludes>
                            <!-- Non working attempt to set compiler version -->
                            <source>1.6</source>
                            <target>1.6</target>
                        </configuration>
                    </execution>

                    <!-- Compile Java 8 directory -->
                    <execution>
                        <id>java8</id>
                        <configuration>
                            <includes>
                                <include>com/us/javafx/**/*</include>
                            </includes>
                            <!-- Non working attempt to set compiler version -->
                            <source>1.8</source>
                            <target>1.8</target>
                        </configuration>
                    </execution>

                </executions>
            </plugin>

            <!-- Create JAR in jars folder -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <outputDirectory>${project.build.directory}/jars</outputDirectory> 
                </configuration>
              </plugin>

        </plugins>
</build>

If we tell the Maven compiler plugin to use Java 1.8, Java 1.6 users get the unsupported major minor version error. Or we tell the Maven compiler plugin to use Java 1.6 but our Java 8 code will complain about errors when performing Right Click Project > Maven > Update Project... (which causes the screen shot below):

enter image description here

Is there a way we can achieve both:

1) Compile Java 6 and 8 code with their respective compilers

2) Choose Java 8 as our project's JRE System Library

Upvotes: 2

Views: 3875

Answers (2)

wromma
wromma

Reputation: 51

Maven profiles is the simplest and most effective one. You can elect and run them from your IDE too. You design a profile for each different JDK you need. You put in each different JDK profile :

  • properties like source code target
  • dependencies that are specialised for that profile.
Project
    +properties
    +dependencies
    +Profiles
        Profile JDK8
            +jdk8-properties
                jdk.version
                maven.compiler.source
                maven.compiler.target   
            +jdk8-dependencies
        Profile JDK11
            +jdk11-properties
                jdk.version
                maven.compiler.source
                maven.compiler.target   
            +jdk11-dependencies

Picture of maven profiles tree

And an example

<project>
    <name>x</name>
    <dependencies>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>2.1.210</version>
        </dependency>
    </dependencies>

    <profiles>
        <!-- different Java versions -->
        <profile>
            <id>jdk8</id>
            <activation>
                <activeByDefault>false</activeByDefault>
            </activation>
            <properties>
                <jdk.version>1.8</jdk.version>
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
            </properties>
            <dependencies>
                <dependency>
                    <groupId>org.hibernate</groupId>
                    <artifactId>hibernate-core-jakarta</artifactId>
                    <version>5.6.10.Final</version>
                </dependency>
                <!-- needed if jakarta is used -->
                <dependency>
                    <groupId>javax.enterprise</groupId>
                    <artifactId>cdi-api</artifactId>
                    <version>2.0</version>
                    <scope>provided</scope>
                </dependency>
                <dependency>
                    <groupId>org.postgresql</groupId>
                    <artifactId>postgresql</artifactId>
                    <version>42.2.25</version>
                </dependency>
            </dependencies>
        </profile>

        <profile>
            <id>jdk11</id>
            <properties>
                <jdk.version>11</jdk.version>
                <maven.compiler.source>11</maven.compiler.source>
                <maven.compiler.target>11</maven.compiler.target>
            </properties>

            <dependencies>
                <dependency>
                    <groupId>org.hibernate.orm</groupId>
                    <artifactId>hibernate-core</artifactId>
                    <version>6.1.2.Final</version>
                </dependency>
                <dependency>
                    <groupId>org.postgresql</groupId>
                    <artifactId>postgresql</artifactId>
                    <version>42.4.2</version>
                </dependency>

            </dependencies>
        </profile>
    </profiles>
    <properties>
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <junit-version>4.13.2</junit-version>
    </properties>
</project>

Upvotes: 0

Ondrej Burkert
Ondrej Burkert

Reputation: 7262

I recently learned about toolchains.xml. Maven has it even documented and supports it from 2.0.9! See toolchains documentation

So I added a toolchain.xml file to my ~/.m2/ folder with following content:

<toolchains xmlns="http://maven.apache.org/TOOLCHAINS/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/TOOLCHAINS/1.1.0 http://maven.apache.org/xsd/toolchains-1.1.0.xsd">
 <!-- JDK toolchains -->
 <toolchain>
   <type>jdk</type>
   <provides>
     <version>1.8</version>
     <vendor>sun</vendor>
   </provides>
   <configuration>
     <jdkHome>/opt/java8</jdkHome>
   </configuration>
 </toolchain>
 <toolchain>
   <type>jdk</type>
   <provides>
     <version>1.7</version>
     <vendor>sun</vendor>
   </provides>
   <configuration>
     <jdkHome>/opt/java7</jdkHome>
   </configuration>
 </toolchain>
</toolchains>

It allows you to define what different JDKs Maven can use to build the project irrespective of the JDK Maven runs with. Sort of like when you define JDK on project level in IDE. I used it when I needed to build another project with Java 7 while having Java 8 as a default.

I guess this can solve your issue.

Upvotes: 2

Related Questions