Como verificar a versão JRE antes do lançamento?
https://stackoverflow.com/questions/222187
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Qual é a melhor maneira de determinar se a versão do JRE instalado em uma máquina é alta o suficiente para a aplicação que o usuário deseja executar? Existe uma maneira de fazê-lo usando o material só de java? Eu gostaria a solução para trabalhar em Windows / Linux / MacOSX - se a versão JRE é muito baixa uma mensagem deve ser exibida. Atualmente estou recebendo uma exceção se eu tentar executá-lo em Java 1.5 (o aplicativo é construído para Java 1.6). Se não houver nenhuma solução universal, qual é a melhor maneira de fazer isso no Windows?
Solução
Uma aplicação construída para um de maior versão do JRE não será executado em um menor versão do JRE. Então, você não seria capaz de simplesmente adicionar o código ao seu aplicativo para verificar a versão do JRE -. Se a versão JRE incompatível, o JRE-verificação de versão de código não iria correr em primeiro lugar
O que você tem a fazer é ter algum tipo de lançador de aplicação que é construída para uma menor versão do JRE (1,3?), Que verifica a versão e, em seguida, lança seu aplicativo, se necessário. Isso soa tipo de kludgy para mim.
O que sobre a verificação da versão durante a instalação? Você está instalando o aplicativo de uma forma que permite que você verifique as variáveis ??de ambiente, ou fazer qualquer tipo de scripting?
Outras dicas
Você pode fazer isso usando a reflexão e dois compiladores. Compilar uma classe principal com a mais antiga versão java você quer ser capaz de correr em tudo com. Ele verifica a versão usando System.getProperty("java.version"), ou o que quer, e depois usa reflexão para carregar o real classe principal, se o cheque passa, possivelmente, até mesmo carregar o jar diretamente. O JRE não deve carregar todas as classes que não foram referenciados por sua classe principal exterior em tempo de compilação.
Você pode considerar Java Webstart . Mesmo que o nome implica algo como applets, é sobre standalone aplicações. Webstart é um lançador, que verifica um arquivo JNLP (a XML-file simples, onde você configurar o download-localização do seu aplicativo, o necessário Java-versão e alguns outros metadados) e inicia seu aplicativo com o JRE correto. Ele ainda atualiza o aplicativo, se uma nova versão estiver disponível. A desvantagem é, você tem que escrever um arquivo JNLP. Aqui está um exemplo:
<?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>
Uma segunda possibilidade é a utilização de um programa de lançador. Um exemplo é a Apache Commons Lançador . Você também pode escrever um aplicativo lançador de si mesmo, mas isso é geralmente não vale o esforço.
Você também pode considerar o uso Commons-Launcher, que permite configurar várias configurações de ambiente, ou realizar pré-verificações antes de chamar a sua aplicação.
Geralmente, temos abordado este com um C ou (quando unix-only) shell wrapper. Não sei se este trabalho vai realmente para você.
Nós também abordar esta embutindo o JRE em nosso produto. Cuida de 99,9% dos casos (a outro de 0,1% do tempo é um utilizador mudando explicitamente a configuração a utilizar uma JVM diferente). Novamente, não tenho certeza de que esta é uma solução razoável para você.
No nosso caso, não há quantidades significativas de código nativo (JNI e outros), assim alfaiataria uma imagem instalável para cada suporte de plataforma que é exigido de qualquer maneira. Mas se você está lidando com uma solução pura em Java, você pode simplesmente ter de documentar o seu mínimo e dizer às pessoas para começar com o programa (sem trocadilhos) se eles estão a executar as suas coisas. É meio como pessoas reclamando que o meu Mac não será executado MSVC, ou que a minha caixa de Linux está tendo problemas para executar World of Warcraft. Isso não é apenas a máquina (virtual) o software é direcionado para - você precisa mudar. Pelo menos no mundo Java, nós realmente podemos chamar isso de uma atualização, porém, sem ferir os sentimentos OS-religiosa de ninguém. (Tente dizer que o usuário Mac para "upgrade" para o Windows XP para executar MSVC -. Há uma batida para baixo à espera de acontecer)
Você pode exigir uma versão Java ao executar o comando Java, por exemplo, java -version:1.6* com.me.MyClass. Não tenho certeza se isso funciona em todas as versões do Java, mas funciona OK em 1,6 de qualquer maneira.
Para o lançador -. Verifique a versão lá
Dentro da APP; como System.getProperties uso acima ();
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);
}
...
Tenha uma classe lançamento compilado para Java 1.2 que chama reais main () em seus 1,6 classes. Se uma exceção de classe não suportada é jogado-los pegá-lo e exibir uma mensagem de erro agradável.
Aqui está o código para obter a versão JRE instalado em um 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 () dá-lhe uma lista de propriedades da JVM incluindo os diferentes ids versão do JRE, JVM e especificação. Este implementado para todas as versões do Java assim deve funcionar independentemente da versão compilada e versão run in, ou a implementação.
Se você escrever uma classe básica para testar a versão, você pode chamar este primeiro em sua principal) classe (lançando. Deve ser realmente funcionalidade básica embora ou você pode arriscar quebrá-lo.
Hmm .. me chamar de um cara chato, mas o que há de errado com o uso de Launch4J ou qualquer outro lançador nativa, por exemplo.
Use um lançador nativa para verificar a versão JVM antes de realmente executar o código. Java únicas soluções (em meu livro) só fazem sentido quando se lida com os desenvolvedores; depois de bater os usuários finais, você vai perceber que eles não se importam com Java ou seus detalhes técnicos em tudo. Se você teria escrito a sua aplicação em GW-Basic que não iria me importar menos, desde que o aplicativo funciona.
Se o Java 1.6 não estiver instalado, lauchner4j irá apontar o usuário para a página de download do JDK 1.6. Isso é provavelmente mais adequado para seu problema do que fazer mágica em Java.
Eu acho que WinRun4J funciona muito bem para mim (mas, novamente eu puder ser tendenciosa desde que eu escrevi :-)). Isso permite que você especificar uma versão máximo de java mínimo e / ou permitido. Vai aparecer uma caixa de mensagem para o usuário se uma versão JRE adequado não for encontrado (e a mensagem é personalizável).
Todos os acima é também extremamente complicado. Basta ir:
Properties props = System.getProperties()
props.list(System.out)
E você vai ver tudo sobre o seu JVM, JRE, JDK e funcionários. Ou obter um valor específico usando:
//full list of possible props you can see if u run code above
String props = System.getProperty(prop)
