OpenJDK-1.8.0.141

Introduction à OpenJDK

OpenJDK est une implémentation libre de la plateforme d'édition standard Java d'Oracle. OpenJDK est utile pour développer des programmes Java, et fournir un environnement d'exécution complet pour lancer des programmes Java.

Ce paquet est connu pour se construire correctement sur une plateforme LFS-8.1.

[Note]

Note

Un greffon de navigateur et une implémentation de webstart sont fournis par le projet Icedtea. Pour fournir une implémentation complète, vous devrez installer plus tard IcedTea-Web-1.7.

OpenJDK est sous GPL, cependant, il convient de préciser qu'il y a eu une exception spéciale pour les projets non-libres d'utiliser ces classes dans leurs produits propriétaires. De façon similaire à la LGPL, qui autorise des programmes non-libre à lier des bibliothèques fournit par des programmes libres, La GNU General Public License, version 2, avec l'exception des chemins de classe autorise des programmes tiers à utiliser des classes fournies par des programmes libres sans l'obligation que le programme tiers soit également libre. Comme avec la LGPL, toutes les modifications faites dans des parties d'un programme libre d'une application tierce, doit également être librement disponible.

[Note]

Note

Les sources de OpenJDK incluent une suite de tests très complète et open source appelée JTreg. Les instructions de tests suivantes permettent de tester le JDK tout juste construit pour une compatibilité raisonnable avec le JDK fermé d'Oracle. Cependant, pour qu'une implémentation indépendante revendique la compatibilité, elle doit passer une suite de tests fermée JCK/TCK. Aucune revendication de compatibilité, même une compatibilité partielle, peut être faite sans passer une suite de tests approuvée.

Oracle fournit un accès libre communautaire, au cas par cas, à des outils fermés pour assurer une compatibilité à 100 % avec leur JDK propriétaire. Cependant la version binaire fournie sur la page Java-1.8.0.141 comme la JVM construit avec les instructions suivantes n'ont pas été testées avec TCK. Aucune version qui serait construite en utilisant les instructions données, ne pourra revendiquer d'être compatible avec le JDK propriétaire, sans que l'utilisateur demande, et réussisse les tests de compatibilités.

Avec cela en tête, les binaires produits en utilisant cette méthode de construction sont régulièrement testé avec le TCK par les membres listés sur le site au-dessus. En supplément de la licence communautaire, une licence pour l'éducation, non-commerciale pour TCK peut être obtenue ici.

Information sur le paquet source

  • Paquet des sources OpenJDK
    Téléchargement : http://hg.openjdk.java.net/jdk8u/jdk8u/archive/jdk8u141-b15.tar.bz2
    Somme de contrôle MD5 du téléchargement : df3504e95d6e88924babb3821d4210a6
    Taille de téléchargement : 498 Ko

  • En plus du paquet principal, les instructions suivantes commecent par télécharger sept archives de sous-projet, pour une taille totale de 63 Mo.

  • Estimation de l'espace disque requis : 3.5 Go (529 Mo supplémentaires pour les tests)

  • Estimation du temps de construction : 4.3 SBU avec 8 tâches en parallèle (jusqu'à 120 SBU supplémentaires pour les tests)

Téléchargements supplémentaires

Dépendances de OpenJDK

Dépendances de Required

Un binaire existant (Java-1.8.0.141 ou une version construite récente de ce paquet. Les instructions qui suivent considèrent que vous utilisez Configuration de l'environnement JAVA) alsa-lib-1.1.4.1, cpio-2.12, Cups-2.2.4, UnZip-6.0, Which-2.21, Bibliothèques Xorg et Zip-3.0.

Recommandées

Facultatives

Mercurial-4.3.1 et un gestionnaire de fenêtres X comme twm-1.0.9 (pour les tests)

Notes utilisateur : http://wiki.linuxfromscratch.org/blfs/wiki/openjdk

Installation de OpenJDK

Contrairement aux autres paquets dans BLFS, les sources de OpenJDK sont distribuées dans de multiples archives. Vous devez commencer par extraire les sources racines depuis le fichier jdk8u141-b15.tar.bz2. Allez dans le répertoire extrait, puis continuez avec les instructions suivantes :

cat > subprojects.md5 << EOF &&
4061c0f2dc553cf92847e4a39a03ea4e  corba.tar.bz2
269a0fde90b9ab5ca19fa82bdb3d6485  hotspot.tar.bz2
a1dfcd15119dd10db6e91dc2019f14e7  jaxp.tar.bz2
16f904d990cb6a3c84ebb81bd6bea1e7  jaxws.tar.bz2
4fb652cdd6fee5f2873b00404e9a01f3  langtools.tar.bz2
c4a99c9c5293bb5c174366664843c8ce  jdk.tar.bz2
c2f06cd8d6e90f3dcc57bec53f419afe  nashorn.tar.bz2
EOF

for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
  wget -c http://hg.openjdk.java.net/jdk8u/jdk8u/${subproject}/archive/jdk8u141-b15.tar.bz2 \
       -O ${subproject}.tar.bz2
done &&

md5sum -c subprojects.md5 &&

for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
  mkdir -pv ${subproject} &&
  tar -xf ${subproject}.tar.bz2 --strip-components=1 -C ${subproject}
done

Si vous avez téléchargé la suite de tests facultative, décompressez-la également :

tar -xf ../jtreg-4.2-b08-891.tar.gz
[Note]

Note

Avant de continuer, vous devez vous assurer que votre variable d'environnement PATH contient le dossier du compilateur Java utilisé pour boostrapper OpenJDK. C'est le seul impératif pour l'environnement. Les installations modernes de Java n'ont pas besoin de JAVA_HOME et CLASSPATH n'est pas utilisé ici. De plus les développeurs d'OpenJDK recommandent de ne pas initialiser JAVA_HOME.

Le système de construction ne supporte pas le paramètre -j dans MAKEFLAGS.

Configurez et construisez le paquet avec les commandes suivantes (la valeur --with-milestone peut être modifiée selon les préférences de l'utilisateur) :

unset JAVA_HOME               &&
sh ./configure                \
   --with-update-version=141  \
   --with-build-number=b15    \
   --with-milestone=BLFS      \
   --enable-unlimited-crypto  \
   --with-zlib=system         \
   --with-giflib=system       \
   --with-extra-cflags="-std=c++98 -Wno-error -fno-delete-null-pointer-checks -fno-lifetime-dse" \
   --with-extra-cxxflags="-std=c++98 -fno-delete-null-pointer-checks -fno-lifetime-dse" &&
make DEBUG_BINARIES=true SCTP_WERROR= all  &&
find build/*/images/j2sdk-image -iname \*.diz -delete
[Note]

Note

Les tests impliqueront des communications entre paires de JVM en utilisant des interfaces réseaux, donc le réseau doit être démarré. Sinon, non seulement ces tests échoueront, mais le nettoyage des tests laissera des JVM orphelines lancées. Il y en aura beaucoup. Redémarrer peut être la solution la plus simple.

Tester la nouvelle version construite de la JVM implique quelques étapes. En premier, il vaut mieux lancer la suite de test dans un framebuffer sur un affichage différent, en utilisant Xvfb :

if [ -n "$DISPLAY" ]; then
  OLD_DISP=$DISPLAY
fi
export DISPLAY=:20
nohup Xvfb $DISPLAY                              \
           -fbdir $(pwd)                         \
           -pixdepths 8 16 24 32 > Xvfb.out 2>&1 &
echo $! > Xvfb.pid
echo Waiting for Xvfb to initialize; sleep 1
nohup twm -display $DISPLAY \
          -f /dev/null > twm.out 2>&1            &
echo $! > twm.pid
echo Waiting for twm to initialize; sleep 1
xhost +

Ensuite, il est nécessaire de modifier quelques fichiers :

echo -e "
jdk_all = :jdk_core           \\
          :jdk_svc            \\
          :jdk_beans          \\
          :jdk_imageio        \\
          :jdk_sound          \\
          :jdk_sctp           \\
          com/sun/awt         \\
          javax/accessibility \\
          javax/print         \\
          sun/pisces          \\
          com/sun/java/swing" >> jdk/test/TEST.groups &&
sed -e 's/all:.*jck.*/all: jtreg/'      \
    -e '/^JTREG /s@\$(JT_PLATFORM)/@@'  \
    -i langtools/test/Makefile

Quelques variables doivent être initialisée :

JT_JAVA=$(type -p javac | sed 's@/bin.*@@') &&
JT_HOME=$(pwd)/jtreg                        &&
PRODUCT_HOME=$(echo $(pwd)/build/*/images/j2sdk-image)

Les tests sont lancés comme ceci :

LANG=C make -k -C test                       \
            JT_HOME=${JT_HOME}               \
            JT_JAVA=${JT_JAVA}               \
            PRODUCT_HOME=${PRODUCT_HOME} all || true
LANG=C ${JT_HOME}/bin/jtreg -a -v:fail,error \
                -dir:$(pwd)/hotspot/test     \
                -k:\!ignore                  \
                -jdk:${PRODUCT_HOME}         \
                :jdk || true

La durée des tests dépend de divers facteurs comme la vitesse du réseau et le nombre de VM concurrentes, ce qui est calculé à partir du nombre de cœurs et de threads, et la quantité de RAM installée. Un maximum de 120 SBU a été observé, mais il peut être aussi « bas » que 80 SBU.

Les résultats des tests peuvent être comparés avec ces résultats, bien qu'ils soient généralement lancés sur une nouvelle version. Une trentaine de tests sont connus pour échouer, mais le nombre dépend de nombreuses conditions, comme si l'ordinateur est connecté sur un réseau ou une imprimante, et des options passées à configure (--enable-unlimited-crypto est connu pour causer des échecs, mais cela vient du code dans les tests, pas de l'installation). Aussi, certains tests peuvent dépasser le temps si la machine est chargée.

Ensuite quelques nettoyages doivent être faits. Les instructions suivantes arrêtent seulement le framebuffer, mais il a été signalé que quelques VM java peuvent rester lancées après les tests, il est donc nécessaire de vérifier les processus orphelins.

kill -9 `cat twm.pid`  &&
kill -9 `cat Xvfb.pid` &&
rm -f Xvfb.out twm.out &&
rm -f Xvfb.pid twm.pid &&
if [ -n "$OLD_DISP" ]; then
  DISPLAY=$OLD_DISP
fi

Installez le paquet avec les commandes suivantes en tant qu'utilisateur root :

cp -RT build/*/images/j2sdk-image /opt/OpenJDK-1.8.0.141 &&
chown -R root:root /opt/OpenJDK-1.8.0.141

Il y a maintenant deux SDK d'OpenJDK installés dans /opt. Vous pouvez décider de laquelle vous voulez utiliser par défaut. Normalement, vous devez opter pour la version OpenJDK que vous venez d'installer. Dans ce cas, exécutez la ligne suivante en tant qu'utilisateur root :

ln -v -nsf OpenJDK-1.8.0.141 /opt/jdk

Si vous le souhaitez, vous pouvez installer un fichier .desktop correspondant à une entrée dans le menu du bureau pour policytool. D'abord, vous devez obtenir une icône de IcedTea-Web-1.7 :

tar -xf ../icedtea-web-1.7.tar.gz  \
        icedtea-web-1.7/javaws.png \
        --strip-components=1

Maintenant, en tant qu'utilisateur root :

mkdir -pv /usr/share/applications &&

cat > /usr/share/applications/openjdk-8-policytool.desktop << "EOF" &&
[Desktop Entry]
Name=OpenJDK Java Policy Tool
Name[pt_BR]=OpenJDK Java - Ferramenta de Política
Comment=OpenJDK Java Policy Tool
Comment[pt_BR]=OpenJDK Java - Ferramenta de Política
Exec=/opt/jdk/bin/policytool
Terminal=false
Type=Application
Icon=javaws
Categories=Settings;
EOF

install -v -Dm0644 javaws.png /usr/share/pixmaps/javaws.png

Le choix de pt_BR est juste un exemple. Vous pouvez ajouter des traductions en ajoutant les lignes correspondantes à votre locale, par exemple fr_FR, avec les valeurs « Name[fr_FR]= » et « Comment[fr_FR]= » appropriées pour la langue.

Explication des commandes

sh configure... : Le niveau supérieur de configure est une enveloppe pour autotools. Ce n'est pas un exécutable et il doit être lancé avec sh.

--with-boot-jdk : Ce paramètre fournit l'emplacement du JDK temporaire. Ce n'est normalement pas nécessaire si java est trouvé dans le PATH.

--with-update-version : Actuellement, le système de construction n'inclut pas le numéro de mise à jour dans la chaîne de version. Il est spécifié ici.

--with-build-number : De nouveau, le système de construction n'inclut pas le numéro de construction dans la chaîne de version. Il est spécifié ici également.

--with-milestone : Utilisé pour personnaliser la chaîne de version.

--enable-unlimited-crypto : À cause des limitations de l'usage de la cryptographie dans certains pays, on peut limiter la taille des clés de cryptographie et l'utilisation de certains algorithmes dans un fichier de politique. Ce paramètre permet de garder un fichier de politique sans restriction. Il est de la responsabilité de l'utilisateur de s'assurer du bon respect de la loi.

--with-zlib=system, --with-giflib=system : Permet d'utiliser les bibliothèques du système au lieu de celles livrées.

--with-extra-cflags=... --with-extra-cxxflags=... : Contourne certains défauts dans le code mis en lumière par la vérification plus rigoureuse de GCC 6 dans les constructions C/C++. Supprimez ces paramètres si vous compilez avec GCC 5.

--with-jobs=N : Permet d'initialiser le nombre de travaux pour make à N. Par défaut, il s'agit du résultat du calcul prenant en compte la mémoire disponible et le nombre de processeurs. Notez que même si vous spécifiez N=1, certaines parallélisations peuvent être utilisées pendant la construction. Les SBU sont donnés pour N=4, sur une machine virtuelle avec un simple processeur, 4 cœurs et 4 Go de mémoire.

--with-cacerts-file=... : Spécifie où trouver un fichier cacerts, /etc/ssl/java/cacerts sur un système BLFS. Sinon, un fichier vide est créé. Vous pouvez utiliser la commande make-ca.sh --force pour le générer, une fois que vous avez installé les binaires Java.

make DEBUG_BINARIES=true SCTP_WERROR= all : La construction échoue sur les machines 32 bits si DEBUG_BINARIES n'est pas initialisé à true. Rendre indéfini SCTP_WERROR fait partie du contournement pour utiliser GCC 6. Vous pouvez omettre cette partie de la commande si vous utilisez GCC 5.

find ... -iname '*.diz' -delete : Cette commande supprime les fichiers redondants.

Configuration de OpenJDK

Information de configuration

Normalement, l'environnement JAVA a été configuré après l'installation de la version binaire, et peut être utilisé avec le paquet fraîchement construit. Regardez Configuration de l'environnement JAVA dans le cas où vous voudriez modifier quelque chose.

Pour tester que les pages de manuel sont correctement installées, tapez source /etc/profile et man java pour afficher les pages de manuel respectives.

Installez ou mettez à jour les fichiers "Certificats d'autorité de certification pour JRE" (cacerts)

OpenJDK utilise son propre format pour les certificats de CA. Ces certificats sont placés dans un fichier nommé /etc/ssl/java/cacerts. Ce fichier devrait être généré à partir du magasin de confiance PKI du système. Les instructions sur la page Certificats d'autorité de certification devraient être utilisées pour mettre à jour le fichier dans /etc/ssl/java. Installez un lien symbolique à l'emplacement par défaut en tant qu'utilisateur root :

ln -sfv /etc/ssl/java/cacerts /opt/jdk/jre/lib/security/cacerts

Utilisez les commandes suivantes pour vérifier si le fichier cacerts a été installé avec succès :

cd /opt/jdk
bin/keytool -list -keystore /etc/ssl/java/cacerts

À l'invite "Enter keystore password:", entrez "changeit" (la valeur par défaut). Si le fichier cacerts a été correctement installé, vous verrez une liste de certificats avec des informations relatives à chacun. Sinon, vous devez les réinstaller.

Contenu

Programmes installés: appletviewer, extcheck, idlj, jar, jarsigner, java, javac, javadoc, javah, javap, java-rmi.cgi, jcmd, jconsole, jdb, jdeps, jhat, jinfo, jjs, jmap, jps, jrunscript, jsadebugd, jstack, jstat, jstatd, keytool, native2ascii, orbd, pack200, policytool, rmic, rmid, rmiregistry, schemagen, serialver, servertool, tnameserv, unpack200, wsgen, wsimport et xjc
Bibliothèques installées: /opt/OpenJDK-1.8.0.141/lib/* et /opt/OpenJDK-1.8.0.141/jre/lib/*
Répertoire installé: /opt/OpenJDK-1.8.0.141

Descriptions courtes

appletviewer

permet le lancement des applets en dehors du navigateur web.

extcheck

vérifie un fichier jar spécifié pour les conflits de titre et de version avec toutes les extensions installées dans le logiciel OpenJDK.

idlj

génère les liaisons Java depuis un fichier IDL donné.

jar

combine des fichiers différents en une seule archive jar.

jarsigner

signe les fichiers jar et vérifie la signature et l'intégrité d'un fichier jar signé.

java

lance une application Java en démarrant l'environnement d'exécution Java, chargeant une classe spécifiée et invoquant sa méthode main.

javac

lit les définitions de classe et d'interface, écrit dans le langage de programmation Java, et les compile en des fichiers de classe en bytecode.

javadoc

analyse les déclarations et les commentaires de documentation dans un ensemble de fichiers source Java et produit l'ensemble correspondant des pages HTML décrivant les classes, les interfaces, les méthodes de constructions et les champs.

javah

génère les entêtes C et les fichiers sources qui sont nécessaires pour implémenter des méthodes natives.

javap

désassemble un fichier de classe Java.

java-rmi.cgi

est le client RMI de Java.

jcmd

est un utilitaire pour envoyer les demandes de diagnostic à une machine virtuelle Java.

jconsole

est un outil graphique de console pour surveiller et gérer les applications Java locales et distantes et les machines virtuelles.

jdb

est un simple débogueur en ligne de commande pour les classes Java.

jdeps

montre les dépendances en termes de paquets ou de classes des fichiers de classes Java.

jhat

analyse un fichier Java de heap dump et permet de le voir dans un navigateur web.

jinfo

affiche les informations de configuration de Java pour un processus Java donné, un fichier core, ou un serveur de débogage distant.

jjs

est un outil en ligne de commande utilisé pour appeler le moteur Nashorn. Il peut être utilisé pour interpréter un ou plusieurs fichiers de script, ou les lancer dans un shell interactif.

jmap

affiche les cartes mémoires des objets partagés ou les détails mémoire d'un processus donné, d'un fichier core, ou d'un serveur de débogage distant.

jps

liste les JVM instrumentées sur le système cible.

jrunscript

est un script shell en ligne de commandes.

jsadebugd

s'attache à un processus Java ou à un fichier core et agit en tant que serveur de débogage.

jstack

affiche la pile des traces JAVA, des treads Java pour un processus Java donné, un fichier core, ou un serveur de débogage distant.

jstat

affiche les statistiques de performance pour une JVM instrumentée.

jstatd

est une application serveur RMI qui surveille la création et l'arrêt des JVM instrumentés.

keytool

est un utilitaire de gestion des clés et certificats.

native2ascii

convertit les fichiers qui contiennent des caractères non supportés par l'encodage en des fichiers contenant des caractères Latin-1 ou Unicode.

orbd

est utilisé pour activer les clients pour trouver de façon transparente et invoquer les objets persistants sur les serveurs dans un environnement CORBA.

pack200

est une application Java qui transforme un fichier jar en un fichier compressé pack200 un utilisant un compacteur gzip.

policytool

crée et gère les fichiers de politique graphiquement.

rmic

génère des fichiers de classes vides et squelettes pour des objets distants depuis le nom des classes JAVA compilées qui contiennent des implémentations d'objets distants.

rmid

démarre le démon d'activation du système.

rmiregistry

crée et démarre un registre d'objet distant sur le port spécifié de l'hôte actuel.

schemagen

est un générateur de schéma de liaison Java XML.

serialver

retourne le serialVersionUID pour une ou plusieurs classes sous une forme appropriée pour la copie dans une classe évolutive.

servertool

fournit une interface facile à utiliser pour les programmeurs d'applications pour inscrire, désinscrire, démarrer et arrêter un serveur.

tnameserv

démarre le serveur de nom Java IDL.

unpack200

est une implémentation native qui transforme un fichier produit par pack200 en un fichier jar.

wsgen

génère des artefacts portables JAX-WS utilisés dans les services web JAX-WS.

wsimport

génère des artefacts JAX-WS portables.

xjc

est un compilateur de liaison Java XML.

Last updated on 2017-08-31 02:11:31 +0200