Se préparer à l’arrivée de Java 9 avec docker et maven

Comme vous le savez peut-être, Java 9 se rapproche (feature complete annoncé pour le 10 décembre 2015 et general availability le 22 septembre 2016, plus d’infos sur la page du projet jdk9).

Il est donc temps de commencer à s’y intéresser, mais peut-être préférez-vous ne pas « polluer » votre environnement avec cette installation, alors pourquoi ne pas utiliser docker ?

Dans ce post, nous allons préparer un conteneur docker fournissant :

la version en cours du jdk 9
et maven 3.3.3

Création d’un conteneur docker pour le JDK 9

Autant ne pas réinventer la roue, je suis parti d’un Dockerfile défini dans l’article suivant :Build OpenJDK 9 using Docker

J’ai un peu refactoré l’ensemble pour regrouper les installations de package et défini un utilisateur dédié au développement pour ne pas travailler en root.

Voici le résultat :

FROM phusion/baseimage:latest

# Pre-install
RUN \
apt-get update && \
apt-get install -y \
libxt-dev zip pkg-config libX11-dev libxext-dev \
libxrender-dev libxtst-dev libasound2-dev libcups2-dev libfreetype6-dev \
mercurial ca-certificates-java build-essential wget && \
rm -rf /var/lib/apt/lists/*

# User
RUN export uid=1000 gid=1000 && \
mkdir -p /home/javadev && \
echo « javadev:x:${uid}:${gid}:JavaDev,,,:/home/javadev:/bin/bash » >> /etc/passwd && \
echo « javadev:x:${uid}: » >> /etc/group && \
echo « javadev ALL=(ALL) NOPASSWD: ALL » > /etc/sudoers.d/javadev && \
chmod 0440 /etc/sudoers.d/javadev && \
chown ${uid}:${gid} -R /home/javadev

ENV JAVA_HOME=/opt/java-bin
ENV PATH=$JAVA_HOME/bin:$PATH

# We need JDK8 to build
RUN \
wget –no-check-certificate –header « Cookie: oraclelicense=accept-securebackup-cookie » http://download.oracle.com/otn-pub/java/jdk/8u65-b17/jdk-8u65-linux-x64.tar.gz

RUN \
tar zxvf jdk-8u65-linux-x64.tar.gz -C /opt

# Let’s get JDK9
RUN \
cd /tmp && \
hg clone http://hg.openjdk.java.net/jdk9/jdk9 openjdk9 && \
cd openjdk9 && \
sh ./get_source.sh

RUN \
cd /tmp/openjdk9 && \
bash ./configure –with-cacerts-file=/etc/ssl/certs/java/cacerts –with-boot-jdk=/opt/jdk1.8.0_65

RUN \
cd /tmp/openjdk9 && \
make clean images

RUN \
cd /tmp/openjdk9 && \
cp -a build/linux-x86_64-normal-server-release/images/jdk \
/opt/openjdk9

RUN \
cd /tmp/openjdk9 && \
find /opt/openjdk9 -type f -exec chmod a+r {} + && \
find /opt/openjdk9 -type d -exec chmod a+rx {} +

ENV PATH /opt/openjdk9/bin:$PATH
ENV JAVA_HOME /opt/openjdk9

# Maven
RUN mkdir /apache-maven
RUN curl -fSL http://apache.mirrors.ovh.net/ftp.apache.org/dist/maven/maven-3/3.3.3/binaries/apache-maven-3.3.3-bin.tar.gz -o maven.tar.gz \
&& tar -xvf maven.tar.gz -C apache-maven –strip-components=1 \
&& rm maven.tar.gz*

ENV PATH /opt/openjdk9/bin:/opt/apache-maven/bin:$PATH

USER javadev
WORKDIR /home/javadev
VOLUME /home/javadev

(aussi disponible sur github : docker-jdk9-maven)

La création du conteneur est classique :

> docker build -t gcastel/openjdk9 .

à lancer dans le répertoire du Dockerfile.

Utilisation du conteneur

Tout s’est bien déroulé, pas d’erreurs ?
Il s’agit à l’heure actuelle d’un work in progress, on peut donc toujours avoir des surprises.

Si tout va bien, nous pouvons tester ce conteneur :

> docker run -it gcastel/openjdk9 java -version
openjdk version « 1.9.0-internal »
OpenJDK Runtime Environment (build 1.9.0-internal-_2015_10_20_08_31-b00)
OpenJDK 64-Bit Server VM (build 1.9.0-internal-_2015_10_20_08_31-b00, mixed mode)

Voilà, vous pouvez désormais compiler vos projets avec ce container, par exemple en montant un répertoire de travail local (localdir) comme répertoire home :

> docker run -v localdir:/home/javadev -it gcastel/openjdk9 bash

Cool ! Maintenant, occupons-nous de maven avec un petit projet utilisant une fonctionnalité de java 9 (la nouvelle API Process).

J’ai créé un petit projet de test disponible sur github.

La classe principale sera toute simple :

package fr.gcastel;

public class TestProcessAPI {
  public static void main(String[] args) throws Exception {
        System.out.println("Your pid is " + ProcessHandle.current().getPid());
  }
}

Pas besoin de dépendances particulières, on se contentera de prévenir maven qu’on est en java 9, cf. pom.xml:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
      <source>1.9</source>
      <target>1.9</target>
    </configuration>
  </plugin>

Allons-y, nous pouvons tester :

> mvn compile

Et si tout est ok :

> cd target/classes
> java fr.gcastel.TestProcessAPI
Your pid is 24

Une dernière chose : si vous souhaitez aider la communauté java, mettez en place un jenkins dédié à la compilation de vos projets avec le JDK 9 dès qu’il sera disponible en release candidate. N’hésitez pas, ça peut permettre d’éviter des problèmes tels que ceux rencontrés par lucene à la sortie de Java 7.

Références :

Build OpenJDK 9 using Docker

Complete Java development environment with Eclipse

JDK 9