Come verificare la versione di JRE prima del lancio?
https://stackoverflow.com/questions/222187
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Qual è il modo migliore per determinare se la versione di JRE installata su una macchina è abbastanza alta per l'applicazione che l'utente vuole eseguire? C'è un modo per farlo usando roba solo per Java? Vorrei che la soluzione funzionasse su Windows / Linux / MacOSX - se la versione di JRE è troppo bassa dovrebbe essere visualizzato un messaggio. Attualmente sto ricevendo un'eccezione se provo a eseguirlo su Java 1.5 (l'app è costruita per Java 1.6). Se non esiste una soluzione universale, qual è il modo migliore per farlo su Windows?
Soluzione
Un'applicazione creata per un JRE versione successiva non verrà eseguita su un JRE versione precedente. Quindi non saresti in grado di aggiungere semplicemente codice alla tua applicazione per verificare la versione di JRE - se la versione di JRE fosse incompatibile, il tuo codice di controllo della versione di JRE non verrebbe eseguito in primo luogo.
Quello che dovresti fare è avere una sorta di applicazione di avvio creata per un JRE versione inferiore (1.3?) che controlla la versione e quindi avvia l'app se necessario. Questo suona un po 'kludgy per me.
Che ne dici di controllare la versione durante l'installazione? Stai installando l'app in un modo che ti consenta di controllare le variabili di ambiente o eseguire qualsiasi tipo di scripting?
Altri suggerimenti
Puoi farlo usando reflection e due compilatori. Compila una classe principale con la versione java più vecchia con cui vuoi essere in grado di eseguire. Controlla la versione usando System.getProperty (" java.version ") o qualsiasi altra cosa, e quindi usa la riflessione per caricare la tua classe principale reale se quel controllo passa, possibilmente persino caricando direttamente il vaso. Il JRE non dovrebbe caricare alcuna classe a cui la classe principale esterna non faceva riferimento al momento della compilazione.
Potresti prendere in considerazione Java Webstart . Anche se il nome implica qualcosa come applet, si tratta di applicazioni standalone. Webstart è un programma di avvio che controlla un file JNLP (un semplice file XML, in cui si configura il percorso di download dell'app, la versione Java necessaria e alcuni altri metadati) e avvia l'app con il JRE corretto. Aggiorna anche l'applicazione, se è disponibile una versione più recente. L'aspetto negativo è che devi scrivere un file JNLP. Ecco un esempio:
<?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>
Una seconda possibilità è quella di utilizzare un programma di avvio. Un esempio è il Apache Commons Launcher . Puoi anche scrivere alcune app di avvio tu stesso, ma di solito non vale la pena.
Potresti anche prendere in considerazione l'uso di Commons-Launcher, che ti consente di configurare varie impostazioni ambientali o di eseguire controlli preliminari prima di chiamare l'applicazione.
Generalmente, ci siamo avvicinati a questo con un involucro di shell C o (quando solo unix). Non sono sicuro che questo funzionerà davvero per te.
Ci avviciniamo anche a questo incorporando il JRE nel nostro prodotto. Si occupa del 99,9% dei casi (l'altro 0,1% delle volte è un utente che modifica esplicitamente la nostra configurazione per utilizzare una JVM diversa). Ancora una volta, non sono sicuro che questa sia una soluzione ragionevole per te.
Nel nostro caso, esistono quantità significative di codice nativo (JNI e non), quindi è necessario personalizzare un'immagine installabile per ogni piattaforma che supportiamo. Ma se hai a che fare con una soluzione Java pura, potresti semplicemente dover documentare il tuo minimo e dire alle persone di andare con il programma (senza intendere il gioco di parole) se vogliono eseguire le tue cose. È come se le persone si lamentassero del fatto che il mio Mac non eseguisse MSVC o che la mia macchina Linux avesse problemi con World of Warcraft. Non è solo la macchina (virtuale) a cui è destinato il software: è necessario cambiare. Almeno nel mondo Java, possiamo davvero definirlo un aggiornamento, tuttavia, senza danneggiare i sentimenti religiosi del sistema operativo di nessuno. (Prova a dire all'utente Mac di " aggiorna " a Windows XP per eseguire MSVC: c'è un malfunzionamento in attesa che accada.)
È possibile richiedere una versione Java quando si esegue il comando Java, ad es. java -version: 1.6 * com.me.MyClass . Non sono sicuro che funzioni su tutte le versioni di Java, ma funziona comunque bene su 1.6.
Per il programma di avvio: controlla la versione lì dentro.
All'interno dell'APP; come sopra usa 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);
}
...
Fai compilare una classe di lancio per Java 1.2 che invoca il reale main () nelle tue classi 1.6. Se viene generata un'eccezione di classe non supportata, la catturano e visualizzano un bel messaggio di errore.
Ecco il codice per ottenere la versione JRE installata in un sistema.
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 () fornisce un elenco di proprietà JVM, inclusi i diversi ID versione di JRE, JVM e specifiche. Questo implementato per tutte le versioni di Java, quindi dovrebbe funzionare indipendentemente dalla versione compilata e dalla versione eseguita o dall'implementazione.
Se scrivi una classe base per testare la versione, puoi chiamarla prima nella classe di avvio main (). Deve essere davvero una funzionalità di base o potresti rischiare di romperla.
Hmm .. chiamami un ragazzo noioso, ma cosa c'è di sbagliato nell'usare Launch4J o qualsiasi altro lanciatore nativo, per esempio.
Utilizza un launcher nativo per verificare la versione di JVM prima di eseguire effettivamente il tuo codice. Le soluzioni solo Java (nel mio libro) hanno senso solo quando hai a che fare con gli sviluppatori; una volta che colpisci gli utenti finali, ti renderai conto che non si preoccupano affatto di Java o dei suoi dettagli tecnici. Se avessi scritto la tua applicazione in GW-Basic, non gliene importerebbe meno finché l'applicazione funzionerà.
Se Java 1.6 non è installato, lauchner4j indirizzerà l'utente alla pagina di download per JDK 1.6. Questo è probabilmente più adatto al tuo problema che fare magie in Java.
Trovo che WinRun4J funziona abbastanza bene per me (ma poi potrei essere di parte da quando l'ho scritto :-)). Ciò consente di specificare una versione minima e / o massima di java consentita. Apparirà una finestra di messaggio all'utente se non viene trovata una versione JRE adatta (e il messaggio è personalizzabile).
Tutti quelli sopra sono troppo dannatamente complicati. Basta andare:
Properties props = System.getProperties()
props.list(System.out)
E vedrai tutto sulla tua JVM, JRE, JDK e il tuo staff. O ottieni un valore specifico usando:
//full list of possible props you can see if u run code above
String props = System.getProperty(prop)
