como verificar a versão do arquivo jar?

92

Atualmente estou trabalhando em um aplicativo J2ME polonês, apenas aprimorando-o. Estou encontrando dificuldades para obter a versão exata do arquivo jar. Existe alguma maneira de encontrar a versão do arquivo jar para as importações feitas na aula? Quer dizer, se você tiver alguma coisa, importe xyz; podemos saber a que versão do pacote jar xy pertence?

Ritesh Mengji
fonte

Respostas:

79

Descompacte o arquivo JAR e procure o arquivo de manifesto ( META-INF\MANIFEST.MF). O arquivo de manifesto do arquivo JAR pode conter um número de versão (mas nem sempre uma versão é especificada).

Vivek
fonte
Como disse que estou trabalhando para aprimorar o aplicativo, baixei os arquivos jar e conheço a versão dos arquivos jar. Mas eu queria saber a versão do jar a qual pertence o pacote, espero que você tenha entendido
Ritesh Mengji
Para explicar mais, importei xyz, sei que xy pertence a a-4.1.jar, mas o aplicativo que estou trabalhando foi desenvolvido há muito tempo e não sei qual versão do arquivo a.jar eles usaram, eu estou preocupado com a versão porque algumas das classes foram depreciadas do jar da versão mais antiga (acho que sim), porque, embora eu tenha o jar na biblioteca, acho que a importação não pode ser resolvida
Ritesh Mengji
Então, se você souber a versão do jar que eles usaram ao construir o aplicativo, você também usará a mesma versão do jar para executar o aplicativo?
Vivek
1
Se esse é o seu requisito, temo que você terá que reconstruir o aplicativo com a exclusão de jars obsoletos. Porque encontrar o número da versão associado a um determinado jar é como uma função um para um. Apenas um número de versão para um arquivo jar. Mas descobrir qual versão do jar foi usada no momento do desenvolvimento do aplicativo parece altamente impossível para mim, a menos que o desenvolvedor anexe os jars necessários com o aplicativo.
Vivek
1
A versão de gravação em MANIFEST.MF parece ser opcional. Não há versão registrada em vários sqljdbc42.jararquivos que usei com o Cognos, mas o Cognos é capaz de relatar uma versão (4.2.6420.100). De onde ele está obtendo essa versão se não estiver gravada no manifesto?
Nick.McDermaid
54

Você precisa descompactá-lo e verificar seu META-INF/MANIFEST.MFarquivo, por exemplo

unzip -p file.jar | head

ou mais específico:

unzip -p file.jar META-INF/MANIFEST.MF
Kenorb
fonte
27

Apenas para expandir as respostas acima, dentro do arquivo META-INF / MANIFEST.MF no JAR, você provavelmente verá uma linha: Manifest-Version: 1.0 ← Este NÃO é o número das versões do jar!

Você precisa procurar Implementation-Versionqual, se presente, é uma string de texto livre que depende inteiramente do autor do JAR quanto ao que você encontrará lá. Consulte também documentos da Oracle e especificações de versão do pacote

Joth
fonte
Esta resposta (e outras) é discutida
Thomas Weller,
17

Apenas para completar a resposta acima.

O arquivo de manifesto está localizado dentro do jar no META-INF\MANIFEST.MFcaminho.

Você pode examinar o conteúdo do jar em qualquer arquivador que suporte zip.

Vadzim
fonte
2
Esta resposta (e outras) é discutida
Thomas Weller,
11

Cada versão do jar possui uma soma de verificação exclusiva. Você pode calcular a soma de verificação para seu jar (que não tinha informações de versão) e compará-la com as diferentes versões do jar. Também podemos pesquisar um jar usando checksum.

Consulte esta pergunta para calcular a soma de verificação: Qual é a melhor maneira de calcular a soma de verificação de um arquivo que está em minha máquina?

vijay
fonte
5
Eu apenas calculei o jar md5 e colei no google. Funcionou muito bem, muito obrigado!
mik01aj
8

Basicamente, você deve usar o java.lang.Package classe que usa o carregador de classe para fornecer informações sobre suas classes.

exemplo:

String.class.getPackage().getImplementationVersion();
Package.getPackage(this).getImplementationVersion();
Package.getPackage("java.lang.String").getImplementationVersion();

Acho que o logback é conhecido por usar esse recurso para rastrear o nome / versão JAR de cada classe em seus rastreamentos de pilha produzidos.

consulte também http://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html#wp90779

Donatello
fonte
3

Este programa simples irá listar todos os casos para a versão do jar, nomeadamente

  • Versão encontrada no arquivo Manifest
  • Nenhuma versão encontrada no Manifest e mesmo no nome do jar
  • Arquivo de manifesto não encontrado

    Map<String, String> jarsWithVersionFound   = new LinkedHashMap<String, String>();
    List<String> jarsWithNoManifest     = new LinkedList<String>();
    List<String> jarsWithNoVersionFound = new LinkedList<String>();
    
    //loop through the files in lib folder
    //pick a jar one by one and getVersion()
    //print in console..save to file(?)..maybe later
    
    File[] files = new File("path_to_jar_folder").listFiles();
    
    for(File file : files)
    {
        String fileName = file.getName();
    
    
        try
        {
            String jarVersion = new Jar(file).getVersion();
    
            if(jarVersion == null)
                jarsWithNoVersionFound.add(fileName);
            else
                jarsWithVersionFound.put(fileName, jarVersion);
    
        }
        catch(Exception ex)
        {
            jarsWithNoManifest.add(fileName);
        }
    }
    
    System.out.println("******* JARs with versions found *******");
    for(Entry<String, String> jarName : jarsWithVersionFound.entrySet())
        System.out.println(jarName.getKey() + " : " + jarName.getValue());
    
    System.out.println("\n \n ******* JARs with no versions found *******");
    for(String jarName : jarsWithNoVersionFound)
        System.out.println(jarName);
    
    System.out.println("\n \n ******* JARs with no manifest found *******");
    for(String jarName : jarsWithNoManifest)
        System.out.println(jarName);
    

Ele usa o jar javaxt-core, que pode ser baixado em http://www.javaxt.com/downloads/

Shanky_Gupta
fonte
Obrigado pela referência a javaxt, acabei de usar o exemplo de código mais simples de javaxt.com/Tutorials/Jar/…
David
1
Para sua informação, para aqueles que preferem maven para puxar javaxt-core em vez de baixar o JAR, você pode fazer uma destas abordagens: gist.github.com/daluu/dda7b29cb5b6e0fbfbaec664eb759739 , gist.github.com/daluu/52af7eef52563ddf78fe
David
2

Estou atrasado, mas você pode tentar os dois métodos a seguir

usando essas classes necessárias

import java.util.jar.Attributes;
import java.util.jar.Manifest;

Esses métodos me permitem acessar os atributos jar. Gosto de ser compatível com as versões anteriores e usar o mais recente. Então eu usei isso

public Attributes detectClassBuildInfoAttributes(Class sourceClass) throws MalformedURLException, IOException {
    String className = sourceClass.getSimpleName() + ".class";
    String classPath = sourceClass.getResource(className).toString();
    if (!classPath.startsWith("jar")) {
      // Class not from JAR
      return null;
    }
    String manifestPath = classPath.substring(0, classPath.lastIndexOf("!") + 1) + 
        "/META-INF/MANIFEST.MF";
    Manifest manifest = new Manifest(new URL(manifestPath).openStream());
    return manifest.getEntries().get("Build-Info");
}

public String retrieveClassInfoAttribute(Class sourceClass, String attributeName) throws MalformedURLException, IOException {
    Attributes version_attr = detectClassBuildInfoAttributes(sourceClass);

    String attribute = version_attr.getValue(attributeName);

    return attribute;
}

Isso funciona bem quando você está usando o maven e precisa de detalhes do pom para classes conhecidas. Espero que isto ajude.

GetBackerZ
fonte
1

Para Linux, tente seguir:

encontrar . -name "YOUR_JAR_FILE.jar" -exec zipgrep "Implementation-Version:" '{}' \; | awk -F ':' '{print $ 2}'

Bae Cheol Shin
fonte
1

Se você tiver winrar, abra o frasco com winrar e clique duas vezes para abrir a pasta META-INF. Extrair MANIFEST.MFeCHANGES arquivos para qualquer local (digamos desktop).

Abra os arquivos extraídos em um editor de texto: Você verá a versão de implementação ou versão de lançamento.

Ganesan R
fonte
0

Você pode filtrar a versão do arquivo MANIFESTO usando

unzip -p my.jar META-INF/MANIFEST.MF | grep 'Bundle-Version'

Sudheer Avula
fonte
Isso parece praticamente duplicar essa resposta mais antiga - stackoverflow.com/a/38313502/272387 - e não é garantido que os manifestos o tenham Bundle-Version.
Richlv
0

Pensei em dar uma resposta mais recente, pois essa pergunta ainda aparece em alta nas pesquisas.

Verificando a versão CLi JAR:

Execute o seguinte no arquivo jar CLi:

unzip -p jenkins-cli.jar META-INF/MANIFEST.MF

Exemplo de saída:

Manifest-Version: 1.0
Built-By: kohsuke
Jenkins-CLI-Version: 2.210  <--- Jenkins CLI Version
Created-By: Apache Maven 3.6.1
Build-Jdk: 1.8.0_144
Main-Class: hudson.cli.CLI

A versão CLi está listada acima.

Para obter a versão do servidor, execute o seguinte:

java -jar ./jenkins-cli.jar -s https://<Server_URL> -auth <email>@<domain>.com:<API Token> version

(o acima irá variar de acordo com sua implementação de autenticação, altere de acordo)

Exemplo de saída:

Dec 23, 2019 4:42:55 PM org.apache.sshd.common.util.security.AbstractSecurityProviderRegistrar getOrCreateProvider
INFO: getOrCreateProvider(EdDSA) created instance of net.i2p.crypto.eddsa.EdDSASecurityProvider
2.210  <-- Jenkins Server Version
DC.Skells
fonte
-14

Pode ser verificado com um comando java -jar jarname

Akash Tolia
fonte
6
Isso executará o main()método do JAR
Thomas Weller