Comment vérifier la version de JRE avant le lancement?
https://stackoverflow.com/questions/222187
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quel est le meilleur moyen de déterminer si la version de JRE installée sur une machine est suffisamment élevée pour l'application que l'utilisateur souhaite exécuter? Y a-t-il un moyen de le faire en utilisant des outils exclusivement Java? J'aimerais que la solution fonctionne sous Windows / Linux / MacOSX - si la version de JRE est trop basse, un message devrait s'afficher. Actuellement, je reçois une exception si j'essaie de l'exécuter sur Java 1.5 (l'application est conçue pour Java 1.6). S'il n'y a pas de solution universelle, quel est le meilleur moyen de le faire sous Windows?
La solution
Une application créée pour un JRE de version supérieure ne s'exécutera pas sur un JRE de version inférieure. Vous ne pourrez donc pas simplement ajouter du code à votre application pour vérifier la version de JRE. Si la version de JRE était incompatible, votre code de vérification de version JRE ne serait pas exécuté en premier lieu.
Ce que vous devez faire est d’avoir une sorte d’application de lancement construite pour un JRE de version inférieure (1.3?) qui vérifie la version et lance ensuite votre application si nécessaire. Cela me semble un peu ridicule.
Qu'en est-il de la vérification de la version lors de l'installation? Est-ce que vous installez l’application de manière à pouvoir vérifier les variables d’environnement ou à utiliser un script quelconque?
Autres conseils
Vous pouvez le faire en utilisant la réflexion et deux compilateurs. Compilez une classe principale avec la version la plus ancienne de Java que vous voulez pouvoir exécuter. Il vérifie la version à l'aide de System.getProperty ("java.version") , ou peu importe, puis utilise la réflexion pour charger votre vraie classe principale si cette vérification réussit, éventuellement même en chargeant le pot directement. Le JRE ne doit charger aucune classe non référencée par votre classe principale externe au moment de la compilation.
Vous pourriez envisager de Webstart Java . Même si le nom implique quelque chose comme des applets, il s'agit d'applications autonomes. Webstart est un lanceur qui vérifie un fichier JNLP (un simple fichier XML, dans lequel vous configurez l'emplacement de téléchargement de votre application, la version Java requise et d'autres métadonnées) et lance votre application avec le JRE approprié. Il met même à jour l'application, si une version plus récente est disponible. L'inconvénient est que vous devez écrire un fichier JNLP. Voici un exemple:
<?xml version="1.0" encoding="utf-8"?>
<!--
###############################################################################
#
# @(#)draw.jnlp 1.6 02/09/11
#
# JNLP File for Draw Demo Application
#
###############################################################################
-->
<jnlp spec="0.2 1.0"
codebase="http://java.sun.com/javase/technologies/desktop/javawebstart/apps"
href="draw.jnlp">
<information>
<title>Draw 4 App</title>
<vendor>Sun Microsystems, Inc.</vendor>
<homepage href="http://java.sun.com/javase/technologies/desktop/javawebstart/demos.html"/>
<description>A minimalist drawing application along the lines of Illustrator</description>
<description kind="short">Draw Demo Short Description</description>
<icon href="images/draw.jpg"/>
<offline-allowed/>
</information>
<resources>
<j2se version="1.3+" href="http://java.sun.com/products/autodl/j2se"/>
<j2se version="1.3+"/>
<jar href="draw.jar" main="true" download="eager"/>
</resources>
<application-desc main-class="Draw"/>
</jnlp>
Une deuxième possibilité consiste à utiliser un programme de lancement. Par exemple, le lanceur Apache Commons . Vous pouvez également écrire vous-même une application de lancement, mais cela ne vaut généralement pas la peine.
Vous pouvez également envisager d'utiliser Commons-Launcher, qui vous permet de configurer divers paramètres d'environnement ou d'effectuer des vérifications préalables avant d'appeler votre application.
En général, nous avons abordé cette question avec un wrapper C ou (uniquement sous Unix). Pas sûr que cela fonctionne vraiment pour vous.
Nous abordons également cette question en intégrant le JRE dans notre produit. S'occupe de 99,9% des cas (l'autre 0,1% du temps est un utilisateur qui modifie explicitement notre configuration pour utiliser une machine virtuelle différente). Encore une fois, je ne suis pas sûr que ce soit une solution raisonnable pour vous.
Dans notre cas, il existe une grande quantité de code natif (JNI ou autre). Il est donc indispensable de personnaliser une image installable pour chaque plate-forme prise en charge. Mais si vous utilisez une solution purement Java, vous devrez peut-être simplement documenter votre minimum et dire aux gens de se familiariser avec le programme (sans jeu de mots) s'ils exécutent vos tâches. C'est un peu comme si les gens se plaignaient du fait que mon Mac ne fonctionnerait pas sous MSVC ou que ma machine Linux avait des problèmes sous World of Warcraft. Ce n’est tout simplement pas la machine (virtuelle) pour laquelle le logiciel est destiné - vous devez basculer. Au moins dans le monde Java, nous pouvons vraiment appeler cela une mise à niveau, sans pour autant nuire aux sentiments religieux de l'OS. (Essayez de demander à l'utilisateur Mac de "mettre à niveau" Windows XP pour exécuter MSVC. Il y a une attente imminente.)
Vous pouvez exiger une version Java lors de l'exécution de la commande Java, par exemple. java -version: 1.6 * com.me.MyClass . Vous ne savez pas si cela fonctionne sur toutes les versions de Java, mais cela fonctionne quand même sur 1.6.
Pour le programme de lancement - Vérifiez la version à cet endroit.
À l'intérieur de l'APP; comme ci-dessus, utilisez System.getProperties ();
Properties sProp = java.lang.System.getProperties();
String sVersion = sProp.getProperty("java.version");
sVersion = sVersion.substring(0, 3);
Float f = Float.valueOf(sVersion);
if (f.floatValue() < (float) 1.4) {
System.out.println("Java version too low ....");
System.exit(1);
}
...
Compilez une classe de lancement pour Java 1.2 qui appelle la real main () dans vos classes 1.6. Si une exception de classe non prise en charge est levée, ils l'attrapent et affichent un beau message d'erreur.
Voici le code pour obtenir la version de JRE installée sur un système.
var list = deployJava.getJREs();
var result = "";
result = list[0];
for (var i=1; i<list.length; i++)
{
result += ", " + list[i];
}
document.write("jre version : "+result);
System.getProperties () vous donne une liste des propriétés de la machine virtuelle Java, y compris les différents ID de version de JRE, de la machine virtuelle Java et de la spécification. Ceci implémenté pour toutes les versions de Java devrait donc fonctionner quelle que soit la version compilée et l'exécution dans la version, ou l'implémentation.
Si vous écrivez une classe de base pour tester la version, vous pouvez l'appeler d'abord dans votre classe de lancement main (). Ce doit vraiment être une fonctionnalité de base, sinon vous risquez de la casser.
Hmm ... appelez-moi un gars ennuyeux, mais qu'est-ce qui ne va pas avec Launch4J ou tout autre lanceur natif, par exemple.
Utilisez un programme de lancement natif pour vérifier la version de la machine virtuelle Java avant d'exécuter votre code. Les solutions Java uniquement (dans mon livre) n'ont de sens que lorsque vous traitez avec des développeurs; Une fois que vous atteignez les utilisateurs finaux, vous réaliserez qu'ils ne se soucient pas de Java ou de ses détails techniques. Si vous aviez écrit votre application dans GW-Basic, ils ne s'en soucieraient pas tant que votre application fonctionnerait.
Si Java 1.6 n'est pas installé, lauchner4j indiquera à l'utilisateur la page de téléchargement du JDK 1.6. C’est probablement plus adapté à votre problème que de faire de la magie en Java.
Je trouve que WinRun4J fonctionne assez bien pour moi (mais encore une fois, je peux soyez partial depuis que je l'ai écrit :-)). Cela vous permet de spécifier une version minimale et / ou maximale de Java autorisée. Un message apparaîtra à l'utilisateur si une version JRE appropriée n'est pas trouvée (et que le message est personnalisable).
Tous ceux ci-dessus sont trop compliqués. Allez juste:
Properties props = System.getProperties()
props.list(System.out)
Et vous verrez tout ce qui concerne votre JVM, votre JRE, votre JDK et votre personnel. Ou obtenez une valeur spécifique en utilisant:
//full list of possible props you can see if u run code above
String props = System.getProperty(prop)
