como verificar a versão do arquivo jar?

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?

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).

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

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

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.

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?

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

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/

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.

Para Linux, tente seguir:

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

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.

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

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

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

Pode ser verificado com um comando java -jar jarname