OpenJDK-1.8.0.60

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 forunir un environnement d'exécution complet pour lancer des programmes Java.

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

[Note]

Note

Un greffon de navigateur et une implémentation de webstart, aussi bien que le moteur de sons pulseaudio sont fournis par le projet Icedtea. Pour fournir une implémentation complète, vous devrez installer plus tard IcedTea-Web-1.6.1 et IcedTea-Sound-1.0.1.

OpenJDK est du code 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 tierces à utiliser des classes fournit par des programmes libres sans l'obligation que le programme tierce soit également libre. Comme avec la LGPL, toutes les modifications faite dans des parties d'un programme libre d'une application tierce,doit également être librement disponible.

[Note]

Note

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

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 fournit sur la page java-1.8.0.60 comme le JVM construit avec les instructions suivantes ont été testée avec TCK. Toutes les versions qui seront construites en utilisant les instructions données, ne pourront pas revendiquer d'être compatible avec le JDK propriétaire, sans que l'utilisateur demande, et réussissent 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/jdk8u60/archive/jdk8u60-b27.tar.bz2
    Somme de contrôle MD5 du téléchargement : bcaf6f51627e8f052eff0fdcd8578b4f
    Taille de téléchargement: 395 Ko

  • En supplément du paquet principal, les instructions suivantes commenent par télécharger sept archives de sous-projet, pour une taille totale de 52 Mo.

  • Estimation de l'espace disque requis : 3.7 Go (additional 371 Mo for tests)

  • Estimation du temps de construction : 12 SBU (additional 100 SBU for tests)

Téléchargements supplémentaires

Dépendances de OpenJDK

Dépendances requises

Un binaire existant ( java-1.8.0.60 ou une version construite récente de ce paquet, ALSA-Library-1.0.29, cpio-2.11, Cups-2.1.0, UnZip-6.0, which-2.21, Xorg Libraries et Zip-3.0.

Recommandées

Facultatives

mercurial-3.5.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 téléchargements. Vous devez commencer par extraire les sources racines depuis le fichier jdk8u60-b27.tar.bz2, allez dans le répertoire extrait, ensuite continuez avec les instruction suivantes :

cat > subprojects.md5 << EOF &&
002432f496bab8c85f6baf61d65dca27  corba.tar.bz2
a4ebec7c61aa154804761127a1f75eae  hotspot.tar.bz2
9a7b2a534b4a01ebb559b60023882809  jaxp.tar.bz2
7ff3e1154d79d208ae89c24355254b49  jaxws.tar.bz2
57ccac8dc86d993e64ff920feb9e54ab  langtools.tar.bz2
2f5874a62c2bc74b99118f66d82886da  jdk.tar.bz2
a8fccf7be7451205e6048b9b2fcd5b24  nashorn.tar.bz2
EOF
for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
  wget -c http://hg.openjdk.java.net/jdk8u/jdk8u60/${subproject}/archive/jdk8u60-b27.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 recommandée, décompressez la également:

tar -xf ../jtreg-4.1-b12-389.tar.gz
[Note]

Note

Avant de continuer, vous devez vous assurer que votre variable d'environnement PATH contient l'endroit 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éveloppeur 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=60   \
   --with-build-number=b27    \
   --with-milestone=BLFS      \
   --enable-unlimited-crypto  \
   --with-zlib=system         \
   --with-giflib=system       &&
make DEBUG_BINARIES=true 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, pas seulement ces tests échoueront, mais le nettoyage des tests laissera des JVM orphelines lancées. Il y en aura beaucoup. Rédémarrer peut être la solution la plus simple.

Tester la nouvelle version construite de JVM implique quelques étapes. En premier, il est mieux de lancer la suite de test dans un frame buffer 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écéssaire 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é comme suivant:

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

Les résultats des tests peuvent être comparé avec ces résultats , bien qu'ils soient lancés sur une nouvelle version. Quelques échecs peuvent être rencontrés, le nombre dépend de nombreuses condition, comme si l'ordinateur est connecté sur un résau. Ausi, certain test peuvent dépasser le temps si la machine est sous chargé.

Ensuite quelques nettoyages doivent être fait. Les instructions suivantes arrêtent seulement le frame buffer, mais il a été signalé que quelque 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.60 &&
chown -R root:root /opt/OpenJDK-1.8.0.60

Il y a maintenant deux SDK d'OpenJDK installé 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, faite la ligne suivante en tant qu'utilisateur root :

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

Si vous le souhaitez, vous pouvez installer un fichier .desktop correspondant à une netrée dans le menu du bureau pour policytool. En premier, vous devez obtenir un icone de IcedTea-Web-1.6.1:

tar -xf ../icedtea-web-1.6.1.tar.gz  \
        icedtea-web-1.6.1/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]= » données par votre traduction.

Explications des commandes

sh configure...: Le niveau supérieur de configure est une enveloppe pour autotools. Ce n'est pas un éxé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écéssaire si java est trouvé dans le PATH.

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

--with-build-number: De nouveau, le sysètme de construction n'inclu 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: A cause des limitations de l'usage de la cryptographie dans certain pays, il y a le possibilité de limiter la taille des clés de codage et l'utilisation de certains algorythmes dans un fichier de filtrage. Ce paramètre permet de garder un fichier de filtrage sans restriction. Il est de la responsabilité de l'utilisateur de s'assurer de son propre 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-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 nomvre de processeurs . Notez que si vous spécifiez N=1, certaines parallélisations peuvent être utilisées pendant la construction. Les SBU donnés sont avec les travaux parallèles désactivés, sur un simple processeur, simple coeur, sur une machine virtuelle.

--with-cacerts-file=...: Spécifie ou trouver un fichier cacerts, typiquement /opt/jdk/jre/lib/security. sinon, un fichier vide est créé. Vous pouvez l'avoir eu avec une précédente version du paquet, ou utiliser le script suivant pour le générer.

make DEBUG_BINARIES=true all: La constuction échoue sur les machines 32 bits si DEBUG_BINARIES n'est pas initialisé à true.

find ... -iname '*.diz' -delete: Cette comande suppriment les fichier redondants.

Configuration de OpenJDK

Information de configuration

Normallement, l'environnement JAVA a été configurée après l'installation de la version binaire, et peut être utilisé avec le paquet fraichement construit aussi bien. Regardez Configuring the JAVA environment dans le cas ou vous voudriez modifier quelque chose.

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

Installez ou mettez à jour les fichiers "JRE Certificate Authority Certificates" (cacerts)

OpenJDK utilise son propre format pour les certificats CA. Ces certificats sont placés dans un fichier nommé /opt/jdk/jre/lib/security/cacerts. Ce fichier peut être généré depuis un fichier installé en utilisant les instructions de la page Certificate Authority Certificates, en utilisant la procedure suivante Commencez par générer le script mkcacerts en tant qu'utilisateur root :

cat > /opt/jdk/bin/mkcacerts << "EOF"
#!/bin/sh
# Simple script to extract x509 certificates and create a JRE cacerts file.
function get_args()
    {
        if test -z "${1}" ; then
            showhelp
            exit 1
        fi
        while test -n "${1}" ; do
            case "${1}" in
                -f | --cafile)
                    check_arg $1 $2
                    CAFILE="${2}"
                    shift 2
                    ;;
                -d | --cadir)
                    check_arg $1 $2
                    CADIR="${2}"
                    shift 2
                    ;;
                -o | --outfile)
                    check_arg $1 $2
                    OUTFILE="${2}"
                    shift 2
                    ;;
                -k | --keytool)
                    check_arg $1 $2
                    KEYTOOL="${2}"
                    shift 2
                    ;;
                -s | --openssl)
                    check_arg $1 $2
                    OPENSSL="${2}"
                    shift 2
                    ;;
                -h | --help)
                    showhelp
                    exit 0
                    ;;
                *)
                    showhelp
                    exit 1
                    ;;
            esac
        done
    }
function check_arg()
    {
        echo "${2}" | grep -v "^-" > /dev/null
        if [ -z "$?" -o ! -n "$2" ]; then
            echo "Error:  $1 requires a valid argument."
            exit 1
        fi
    }
# The date binary is not reliable on 32bit systems for dates after 2038
function mydate()
    {
        local y=$( echo $1 | cut -d" " -f4 )
        local M=$( echo $1 | cut -d" " -f1 )
        local d=$( echo $1 | cut -d" " -f2 )
        local m
        if [ ${d} -lt 10 ]; then d="0${d}"; fi
        case $M in
            Jan) m="01";;
            Feb) m="02";;
            Mar) m="03";;
            Apr) m="04";;
            May) m="05";;
            Jun) m="06";;
            Jul) m="07";;
            Aug) m="08";;
            Sep) m="09";;
            Oct) m="10";;
            Nov) m="11";;
            Dec) m="12";;
        esac
        certdate="${y}${m}${d}"
    }
function showhelp()
    {
        echo "`basename ${0}` creates a valid cacerts file for use with IcedTea."
        echo ""
        echo "        -f  --cafile     The path to a file containing PEM"
        echo "                         formated CA certificates. May not be"
        echo "                         used with -d/--cadir."
        echo ""
        echo "        -d  --cadir      The path to a directory of PEM formatted"
        echo "                         CA certificates. May not be used with"
        echo "                         -f/--cafile."
        echo ""
        echo "        -o  --outfile    The path to the output file."
        echo ""
        echo "        -k  --keytool    The path to the java keytool utility."
        echo ""
        echo "        -s  --openssl    The path to the openssl utility."
        echo ""
        echo "        -h  --help       Show this help message and exit."
        echo ""
        echo ""
    }
# Initialize empty variables so that the shell does not pollute the script
CAFILE=""
CADIR=""
OUTFILE=""
OPENSSL=""
KEYTOOL=""
certdate=""
date=""
today=$( date +%Y%m%d )
# Process command line arguments
get_args ${@}
# Handle common errors
if test "${CAFILE}x" == "x" -a "${CADIR}x" == "x" ; then
    echo "ERROR!  You must provide an x509 certificate store!"
    echo "\'$(basename ${0}) --help\' for more info."
    echo ""
    exit 1
fi
if test "${CAFILE}x" != "x" -a "${CADIR}x" != "x" ; then
    echo "ERROR!  You cannot provide two x509 certificate stores!"
    echo "\'$(basename ${0}) --help\' for more info."
    echo ""
    exit 1
fi
if test "${KEYTOOL}x" == "x" ; then
    echo "ERROR!  You must provide a valid keytool program!"
    echo "\'$(basename ${0}) --help\' for more info."
    echo ""
    exit 1
fi
if test "${OPENSSL}x" == "x" ; then
    echo "ERROR!  You must provide a valid path to openssl!"
    echo "\'$(basename ${0}) --help\' for more info."
    echo ""
    exit 1
fi
if test "${OUTFILE}x" == "x" ; then
    echo "ERROR!  You must provide a valid output file!"
    echo "\'$(basename ${0}) --help\' for more info."
    echo ""
    exit 1
fi
# Get on with the work
# If using a CAFILE, split it into individual files in a temp directory
if test "${CAFILE}x" != "x" ; then
    TEMPDIR=`mktemp -d`
    CADIR="${TEMPDIR}"
    # Get a list of staring lines for each cert
    CERTLIST=`grep -n "^-----BEGIN" "${CAFILE}" | cut -d ":" -f 1`
    # Get a list of ending lines for each cert
    ENDCERTLIST=`grep -n "^-----END" "${CAFILE}" | cut -d ":" -f 1`
    # Start a loop
    for certbegin in `echo "${CERTLIST}"` ; do
        for certend in `echo "${ENDCERTLIST}"` ; do
            if test "${certend}" -gt "${certbegin}"; then
                break
            fi
        done
        sed -n "${certbegin},${certend}p" "${CAFILE}" > "${CADIR}/${certbegin}.pem"
        keyhash=`${OPENSSL} x509 -noout -in "${CADIR}/${certbegin}.pem" -hash`
        echo "Generated PEM file with hash:  ${keyhash}."
    done
fi
# Write the output file
for cert in `find "${CADIR}" -type f -name "*.pem" -o -name "*.crt"`
do
    # Make sure the certificate date is valid...
    date=$( ${OPENSSL} x509 -enddate -in "${cert}" -noout | sed 's/^notAfter=//' )
    mydate "${date}"
    if test "${certdate}" -lt "${today}" ; then
        echo "${cert} expired on ${certdate}! Skipping..."
        unset date certdate
        continue
    fi
    unset date certdate
    ls "${cert}"
    tempfile=`mktemp`
    certbegin=`grep -n "^-----BEGIN" "${cert}" | cut -d ":" -f 1`
    certend=`grep -n "^-----END" "${cert}" | cut -d ":" -f 1`
    sed -n "${certbegin},${certend}p" "${cert}" > "${tempfile}"
    echo yes | env LC_ALL=C "${KEYTOOL}" -import                     \
                                         -alias `basename "${cert}"` \
                                         -keystore "${OUTFILE}"      \
                                         -storepass 'changeit'       \
                                         -file "${tempfile}"
    rm "${tempfile}"
done
if test "${TEMPDIR}x" != "x" ; then
    rm -rf "${TEMPDIR}"
fi
exit 0
EOF
chmod -c 0755 /opt/jdk/bin/mkcacerts
[Note]

Note

Faire un très grand copier/coller directement dans un terminal peut donner un fichier corrompu.Copier depuis un éditeur peut contourner ce problème.

Générez le fichier cacerts de OpenJDK en tant qu'utilisateur root :

if [ -f /opt/jdk/jre/lib/security/cacerts ]; then
  mv /opt/jdk/jre/lib/security/cacerts \
     /opt/jdk/jre/lib/security/cacerts.bak
fi &&
/opt/jdk/bin/mkcacerts                 \
        -d "/etc/ssl/certs/"           \
        -k "/opt/jdk/bin/keytool"      \
        -s "/usr/bin/openssl"          \
        -o "/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 jre/lib/security/cacerts

A l'invite "Enter keystore password:", appuyez sur "Enter" s'il n'y a pas de mots de passe de défini. Si le fichier cacerts est installé correctement, 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.60/lib/*, and /opt/OpenJDK-1.8.0.60/jre/lib/*
Répertoire installé: /opt/OpenJDK-1.8.0.60

Description courte

appletviewer

autorise de lancer 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és 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 un langage de programmation Java, et les compiles en des fichiers de classe 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écéssaires 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 diagnostique à une machine virtuelle Java.

jconsole

est un outil graphique de la 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 (package-level ou class-level) 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éboguage 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 intéractif.

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éboguage distant.

jps

liste les JVM instrumenté 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éboguage.

jstack

affiche la pile des traces JAVA, des treads Java pour pour un processus Java donné, un fichier core, ou un serveur de déboguage 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.

mkcacerts

est un script simple pour extraire les certificats x509 et créer un fichier cacerts JRE en utilisant keytool.

native2ascii

converti les fichiers qui contiennent des caractères non-supporté 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 comptacteur gzip.

policytool

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

rmic

génère des fichiers de classes tampon et squelette 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 l'UID 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 artifactes portables JAX-WS utilisés dans les services web JAX-WS.

wsimport

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

xjc

est un compilateur de liaison Java XML.

Last updated on : 2013-01-15 03:50:02 +010