OpenJDK-1.7.0.65/IcedTea-2.5.2

Introduction à OpenJDK et IcedTea

IcedTea fournit un harnais de construction pour le paquet OpenJDK, Oracle a ouvert le code de l'environnement de développement Java. Afin de fournir un environnement d'exécution complètement libre, similaire à la distribution fermée d'Oracle, Le harnais de construction IcedTea devient également libre, et sans doute des versions meilleures de JDK qui n'a pas été ouvert à ce jour. OpenJDK est utilisé pour développer des programmes Java et fournit un environnement d'exécution complet pour lancer des programmes Java.

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

[Note]

Note

Le greffon du navigateur et l'implémentation webstart ont été séparé en différent projet. Pour fournir une implémentation complète, vous aurez besoin d'installer plus tard IcedTea-Web-1.5.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

L'environnement de construction IcedTea inclu une très complète, open source suite de tests appelée JTreg. JTreg est prévue pour tester le JDK fraichement 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 OpenJDK, 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. La version binaire fournit ici n'a pas été testé 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

La suite peut être téléchargé séparément ou être fait en tant que partie du processus make. Par confort les auteurs de BLFS ont rendu les fichiers disponibles sur le site web LFS. Ces fichiers ne sont pas distribués avec les versions, mais extraits depuis le système de contrôle de version de OpenJDK aux points spécifiés (tagged).

Téléchargements supplémentaires

Correctifs requis

Jar requis

Paquet facultatif (pour obtenir un icone pour le fichier openjdk-7-policytool.desktop )

Dépendances de OpenJDK

Dépendances requises

Un binaire existant ( java-1.7.0.65 ou une version construite récente de ce paquet, ALSA-Library-1.0.28, apache-ant-1.9.4, Certificate Authority Certificates, cpio-2.11, Cups-1.7.5, gtk+-2.24.24, giflib-5.1.0, UnZip-6.0, Wget-1.15, which-2.20, Xorg Libraries et Zip-3.0.

Recommandées

Facultatives

libxslt-1.1.28, lsb_release-1.4, mercurial-3.1.1, MIT Kerberos V5-1.12.2, et Xorg-Server-1.16.0 (pour les tests)

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

Installation de OpenJDK

[Note]

Note

La construction des sources de OpenJDK demande apache-ant-1.9.4. Vus aurez besoin de le construire afin de satisfaire la dépendance circulaire, et revenir à cette section pour continuer la construction de OpenJDK.

Contrairement aux autres paquets dans BLFS, les sources de OpenJDK sont distribuées dans de multiples téléchargements. Depuis que le harnais de construction de IcedTea doit être utilisé pour construire OpenJDK, commencez par extraire le paquet IcedTea et allez dans le répertoire d'extraction.

La distribution de IcedTea OpenJDK demande que js.jar (du paquet Rhino) soit en place pour fournir une implémentation java-script pour le JDK libre. Si vous n'avez pas installé le fichier js.jar, faite le avec les commandes suivantes en tant qu'utilisateur root :

unzip ../rhino1_7R4.zip             &&
install -v -d -m755 /usr/share/java &&
install -v -m755 rhino1_7R4/*.jar /usr/share/java

Comme mentionné précédemment, OpenJDK est composé de plusieurs projets individuels de la version propriétaire de JDK qui ont été relicencié en une licence open-source. Si vous avez téléchargé précédemment pour les composants individuels, mettez tous les composants individuels dans l'arbre des sources avec les commandes suivantes

cp -v ../corba.tar.bz2     . &&
cp -v ../hotspot.tar.bz2   . &&
cp -v ../jaxp.tar.bz2      . &&
cp -v ../jaxws.tar.bz2     . &&
cp -v ../jdk.tar.bz2       . &&
cp -v ../langtools.tar.bz2 . &&
cp -v ../openjdk.tar.bz2   .

Appliquez un correctif pour générer un fichier cacerts valide en utilisant le système de certificats CA:

patch -Np1 -i ../icedtea-2.5.2-add_cacerts-1.patch

Appliquez un correctif pour remplacer les chemins corrigés par des plus appropriée pour BLFS:

patch -Np1 -i ../icedtea-2.5.2-fixed_paths-1.patch

Appliquez un correctif pour adapter le code à la nouvelle API de giflib :

patch -Np1 -i ../icedtea-2.5.2-fix_new_giflib-1.patch

Appliquez un correctif pour exclure des tests connus pour échouer de la suite de testse:

patch -Np1 -i ../icedtea-2.5.2-fix_tests-1.patch
[Note]

Note

Avant de continuer, vous devez vous assurer que votre environnement est correctement initialisé pour construire OpenJDK. D'abord, vérifiez le contenu de la variable ANT_HOME. En second, la variable PATH doit contenir le chemin pour les exécutables java et ant. Enfin, la variable CLASSPATH doit être initialisée comme expliqué dans les pages java-1.7.0.65 et JUnit-4.11.

Configurez et construisez le paquet avec les commandes suivantes (les valeurs de with-pkgversion et de with-version-suffix peuvent être modifiées selon les préférences de l'utilisateur):

unset JAVA_HOME                                               &&
./autogen.sh                                                  &&
./configure --with-jdk-home=/opt/OpenJDK-1.7.0.65-bin         \
            --with-version-suffix=BLFS                        \
            --enable-nss                                      \
            --disable-system-kerberos                         \
            --with-parallel-jobs                              &&
make
[Note]

Note

Si vous n'avez pas installé l'archive spécifiée précédemment, elle sera automatiquement téléchargée ici.

Pour tester le résultat, tapez : make jtregcheck. La version incluse dans jtreg est ancienne, et la suite de tests est également très dépendante du système hôte et de l'environnement qui la lance. Vous devez vous attendre à voir n'importe où entre 40 et 100 échecs dans jdk avec plus de 10 erreurs dans les tests eux-mêmes. La majorité des plus de 6000 tests doivent réussir. La raison pour la grande variété des résultats est dû à comment l'environnement doit être strict. Des architectures différentes, des versions différentes des bibliothèques dépendantes, un environnement X Window et un gestionnaire de fenêtres inattendus, le certificat utilisé pour générer le fichier cacerts, et même toutes les entrées de l'utilisateur, ou la gestion de l'énergie, ou les interruptions de l'économiseur d'écrans pendant les tests peuvent créer de nombreux échecs. Comme les tests cassés connus ont été enlevé, avec le correctif fix_tests, les échecs aux tests graphiques ne peuvent pas être prévues (sauf à les enlever tous). La meilleure façon pour un résultat complètement propre est de lancer la suite de tests dans un sur un écran différent (Xvfb). Et même encore, les I/O du disque peuvent créer des échecs.

export DISPLAY=:20     &&
Xvfb :20 -screen 0 1x1x24 -ac&
echo $!>  Xvfb.pid     &&
make -k jtregcheck     &&
kill -9 `cat Xvfb.pid` &&
unset DISPLAY          &&
rm -f Xvfb.pid

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

chmod 0644 openjdk.build/j2sdk-image/lib/sa-jdi.jar   &&
cp -R openjdk.build/j2sdk-image /opt/OpenJDK-1.7.0.65 &&
chown -R root:root /opt/OpenJDK-1.7.0.65

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.5.1:

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

Maintenant, en tant qu'utilisateur root :

mkdir -pv /usr/share/applications &&
cat > /usr/share/applications/openjdk-7-policytool.desktop << "EOF" &&
[Desktop Entry]
Name=OpenJDK Java 7 Policy Tool
Name[pt_BR]=OpenJDK Java 7 - Ferramenta de Política
Comment=OpenJDK Java 7 Policy Tool
Comment[pt_BR]=OpenJDK Java 7 - 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

./autogen.sh : Cette commande force la reconstruction des fichiers auto-générés pour tenir compte des nouvelles options ajoutés dans configure.

--with-jdk-home : Ce paramètre fournit l'emplacement du JDK temporaire.

--with-pkgversion: Ce paramètre peut être utilisé pour modifier la chaîne de version en supplément de "IcedTea".

--with-version-suffix: Ce paramètre ajoute le texte donné dans la chaîne de version de JDK.

--enable-nss: Active l'inclusion du fournisseur de sécurité NSS.

--disable-system-kerberos: Enlevez cette option si MIT Kerberos V5-1.12.2 est installé.

--with-parallel-jobs: Permet d'initialiser le nombre de travaux pour make égal au nombre de processeurs plus un. Notez que par défaut la valeur est 2 si cette option n'est pas spécifiée. Vous devez explicitement initialiser --with-parallel-jobs=1 pour désactiver les travaux parallèles. La SBU donné est avec les travaux parallèles désactivés.

chmod -v 0644 ...sa-jdi.jar : Corrige les permissions dans un fichier généré pour que tous les utilisateurs puissent y accéder.

Configuration de OpenJDK

Information de configuration

Il y a maintenant deux SDK OpenJDK installés dans /opt. Vous devez décider lequel vous voulez utiliser par défaut. Par exemple, si vous décidez d'utiliser la version précompilée de OpenJDK, faite les commandes suivantes en tant qu'utilisateur root :

ln -v -nsf OpenJDK-1.7.0.65-bin /opt/jdk

L'information ci dessous suppose que votre système est initialisé en utilisant les instructions trouvées à « Les fichiers de démarrage du shell Bash ». Vous devez extraire l'information pertinente dessous et l'incorporer dans votre fichier de démarrage du système si votre système est initialisé différemment.

Ajoutez le fichier suivant de démarrage de openjdk.sh dans le répertoire /etc/profile.d avec les commandes suivantes en tant qu'utilisateur root :

cat > /etc/profile.d/openjdk.sh << "EOF"
# Begin /etc/profile.d/openjdk.sh
# Set JAVA_HOME directory
JAVA_HOME=/opt/jdk
# Set ANT_HOME directory
ANT_HOME=/opt/ant
# Adjust PATH
pathappend $JAVA_HOME/bin PATH
pathappend $ANT_HOME/bin PATH
# Auto Java CLASSPATH
# Copy jar files to, or create symlinks in this directory
AUTO_CLASSPATH_DIR=/usr/share/java
pathprepend . CLASSPATH
for dir in `find ${AUTO_CLASSPATH_DIR} -type d 2>/dev/null`; do
    pathappend $dir CLASSPATH
done
for jar in `find ${AUTO_CLASSPATH_DIR} -name "*.jar" 2>/dev/null`; do
    pathappend $jar CLASSPATH
done
export JAVA_HOME ANT_HOME CLASSPATH
unset AUTO_CLASSPATH_DIR dir jar
# End /etc/profile.d/openjdk.sh
EOF

Finalement, ajoutez les pages de man dans la configuration de man_db. En tant qu'utilisateur root :

cat >> /etc/profile.d/extrapaths.sh << "EOF" &&
# Begin Java addition
pathappend /opt/jdk/man       MANPATH
# End Java addition
EOF
cat >> /etc/man_db.conf << "EOF" &&
# Begin Java addition
MANDATORY_MANPATH     /opt/jdk/man
MANPATH_MAP           /opt/jdk/bin     /opt/jdk/man
MANDB_MAP             /opt/jdk/man     /var/cache/man/jdk
# End Java addition
EOF
mandb -c /opt/jdk/man

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)

Utilisez la procédure suivante pour vérifier si le fichier cacerts a été correctement installé pendant l'installation de OpenJDK ou si Certificate Authority Certificates a été mis à jour, les instructions suivantes généreront un nouveau fichier JRE de cacerts. En premier, vérifiez si cacerts a été correctement installé:

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 mot de passe de défini. Si cacerts a été installé correctement, vous allez voir une liste de certificats avec des informations relatives à chacun d'eux. Si non, vous devrez les installer manuellement. En premier, génèrez 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.

Si vous avez besoin de générer un fichier cacerts, et qu'il y en a déjà un dans /opt/jdk/jre/lib/security, il est mieux de faire une sauvegarde. Ensuite vous pouvez en créer un nouveau, en tant qu'utilisateur root :

/opt/jdk/bin/mkcacerts            \
        -d "/etc/ssl/certs/"      \
        -k "/opt/jdk/bin/keytool" \
        -s "/usr/bin/openssl"     \
        -o "/opt/jdk/jre/lib/security/cacerts"

Contenu

Programmes installés: appletviewer, apt, extcheck, idlj, jar, jarsigner, java, javac, javadoc, javah, javap, java-rmi.cgi, jcmd, jconsole, jdb, jhat, jinfo, 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.7.0.65/lib/*, and /opt/OpenJDK-1.7.0.65/jre/lib/*
Répertoire installé: /opt/OpenJDK-1.7.0.65

Description courte

appletviewer

autorise de lancer des applets en dehors du navigateur web.

apt

est un outil de traitement des annotations.

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.

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.

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