¿Cómo comprobar la versión de JRE antes del lanzamiento?
https://stackoverflow.com/questions/222187
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cuál es la mejor manera de determinar si la versión de JRE instalada en una máquina es lo suficientemente alta para la aplicación que el usuario desea ejecutar? ¿Hay alguna forma de hacerlo usando solo java? Me gustaría que la solución funcione en Windows / Linux / MacOSX: si la versión de JRE es demasiado baja, se mostrará un mensaje. Actualmente obtengo una excepción si intento ejecutarlo en Java 1.5 (la aplicación está diseñada para Java 1.6). Si no hay una solución universal, ¿cuál es la mejor manera de hacerlo en Windows?
Solución
Una aplicación creada para un JRE de versión superior no se ejecutará en un JRE de versión inferior. Por lo tanto, no podría simplemente agregar código a su aplicación para verificar la versión de JRE; si la versión de JRE fuera incompatible, su código de verificación de versión de JRE no se ejecutaría en primer lugar.
Lo que tendrías que hacer es tener algún tipo de aplicación de inicio creada para un JRE de versión inferior (1.3?) que verifique la versión y luego inicie tu aplicación si es necesario. Esto me suena un tanto torpe.
¿Qué hay de verificar la versión durante la instalación? ¿Está instalando la aplicación de una manera que le permite verificar las variables de entorno, o hacer cualquier tipo de script?
Otros consejos
Podrías hacer esto usando la reflexión y dos compiladores. Compile una clase principal con la versión java más antigua con la que desea poder ejecutarse. Verifica la versión usando System.getProperty (" java.version ") , o lo que sea, y luego usa la reflexión para cargar su clase principal real si esa comprobación pasa, posiblemente Incluso cargando el tarro directamente. El JRE no debe cargar ninguna clase a la que no haya hecho referencia su clase principal externa en el momento de la compilación.
Puede considerar Java Webstart . Incluso si el nombre implica algo así como applets, se trata de aplicaciones independientes. Webstart es un lanzador, que comprueba un archivo JNLP (un archivo XML simple, donde configura la ubicación de descarga de su aplicación, la versión Java necesaria y algunos otros metadatos) e inicia su aplicación con el JRE correcto. Incluso actualiza la aplicación, si hay una versión más nueva disponible. El inconveniente es que tienes que escribir un archivo JNLP. Aquí hay un ejemplo:
<?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 segunda posibilidad es usar un programa lanzador. Un ejemplo es el Apache Commons Launcher . También puede escribir alguna aplicación de inicio usted mismo, pero por lo general no vale la pena el esfuerzo.
También puede considerar el uso de Commons-Launcher, que le permite configurar varios ajustes de entorno, o realizar comprobaciones previas antes de llamar a su aplicación.
En general, hemos abordado esto con una envoltura de shell C o (cuando es solo para Unix). No estoy seguro de que esto realmente funcione para ti.
También abordamos esto incorporando el JRE en nuestro producto. Se encarga del 99.9% de los casos (el otro 0.1% del tiempo es un usuario que cambia explícitamente nuestra configuración para usar una JVM diferente). Nuevamente, no estoy seguro de que esta sea una solución razonable para ti.
En nuestro caso, hay cantidades significativas de código nativo (JNI y de otro tipo), por lo que es necesario adaptar una imagen instalable para cada plataforma que admitimos. Pero si está tratando con una solución de Java pura, es posible que simplemente tenga que documentar su mínimo y decirle a las personas que se pongan en contacto con el programa (sin intención de hacerlo) si van a ejecutar sus cosas. Se parece a la gente que se queja de que mi Mac no funciona con MSVC, o que mi caja de Linux tiene problemas para ejecutar World of Warcraft. Esa no es la máquina (virtual) a la que se dirige el software, debe cambiar. Sin embargo, al menos en el mundo Java, podemos llamar a esto una actualización, sin dañar los sentimientos religiosos de nadie. (Intente decirle al usuario de Mac que " actualice " a Windows XP para que ejecute MSVC: hay una paliza a la espera de que suceda)
Puede requerir una versión de Java cuando ejecuta el comando de Java, por ejemplo. java -version: 1.6 * com.me.MyClass . No estoy seguro de si esto funciona en todas las versiones de Java, pero funciona bien en 1.6 de todos modos.
Para el iniciador: compruebe la versión allí.
Dentro de la APP; como antes, use 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);
}
...
Tenga una clase de lanzamiento compilada para Java 1.2 que invoque real main () en sus clases 1.6. Si se lanza una excepción de clase no compatible, cógela y muestra un buen mensaje de error.
Aquí está el código para obtener la versión de JRE instalada en 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 () le ofrece una lista de las propiedades de JVM que incluyen los diferentes identificadores de versión de JRE, JVM y especificación. Esto se implementó para todas las versiones de Java, por lo que debería funcionar independientemente de la versión compilada y la versión que se ejecute o de la implementación.
Si escribe una clase básica para probar la versión, puede llamarla primero en su clase de inicio main (). Sin embargo, debe ser realmente una funcionalidad básica o podría arriesgarse a romperla.
Hmm ... llámame aburrido, pero ¿qué tiene de malo usar Launch4J o cualquier otro lanzador nativo, por ejemplo?
Use un lanzador nativo para verificar la versión de JVM antes de ejecutar su código. Las soluciones solo de Java (en mi libro) solo tienen sentido cuando se trata de desarrolladores; Una vez que llegue a los usuarios finales, se dará cuenta de que no les importa Java ni sus detalles técnicos. Si hubieras escrito tu aplicación en GW-Basic, no les importaría menos mientras tu aplicación funcione.
Si Java 1.6 no está instalado, lauchner4j dirigirá al usuario a la página de descarga para JDK 1.6. Probablemente sea más adecuado para tu problema que hacer magia en Java.
Encuentro que WinRun4J funciona bastante bien para mí (pero de nuevo puedo ser parcial ya que lo escribí :-)). Esto le permite especificar una versión mínima y / o máxima de java permitida. Aparecerá un cuadro de mensaje al usuario si no se encuentra una versión JRE adecuada (y el mensaje es personalizable).
Todos los anteriores son demasiado complicados. Sólo ve:
Properties props = System.getProperties()
props.list(System.out)
Y verá todo sobre su JVM, JRE, JDK y su personal. O obtenga un valor específico utilizando:
//full list of possible props you can see if u run code above
String props = System.getProperty(prop)
