¿Cómo comprobar la versión del archivo jar?


91

Actualmente estoy trabajando en una aplicación de pulido J2ME, simplemente mejorándola. Encuentro dificultades para obtener la versión exacta del archivo jar. ¿Hay alguna forma de encontrar la versión del archivo jar para las importaciones realizadas en la clase? Quiero decir, si tienes algo, importa xyz; ¿Podemos saber la versión del paquete jar xy a la que pertenece?

Respuestas:


78

Descomprima el archivo JAR y busque el archivo de manifiesto ( META-INF\MANIFEST.MF). El archivo de manifiesto del archivo JAR puede contener un número de versión (pero no siempre se especifica una versión).


Como dije que estoy trabajando para mejorar la aplicación, he descargado los archivos jar y sé la versión de los archivos jar. Pero quería saber la versión del jar al que pertenece el paquete, espero que lo consigas.
Ritesh Mengji

Para explicarte más, tengo import xyz, sé que xy pertenece a a-4.1.jar, pero la aplicación en la que estoy trabajando se desarrolló hace mucho tiempo, y no sé qué versión de archivo a.jar han usado, Estoy preocupado por la versión porque, algunas de las clases se han depreciado del jar de la versión anterior (lo siento), porque, aunque tengo jar en la biblioteca, encuentro que la importación no se puede resolver
Ritesh Mengji

Entonces, ¿es que, si conoce la versión de jar que usaron al compilar la aplicación, también usaría la misma versión de jar para ejecutar la aplicación?
Vivek

1
Si ese es su requisito, entonces me temo que tendrá que reconstruir la aplicación excluyendo los archivos jar en desuso. Porque encontrar el número de versión asociado con un jar dado es como una función uno a uno. Solo un número de versión para un archivo jar. Pero encontrar qué versión de jar se usó en el momento del desarrollo de la aplicación me parece muy imposible a menos que el desarrollador adjunte los jar necesarios con la aplicación.
Vivek

1
La versión de grabación en MANIFEST.MF parece ser opcional. No hay una versión registrada en varios sqljdbc42.jararchivos que he usado con Cognos, pero Cognos puede informar una versión (4.2.6420.100). ¿De dónde obtiene esta versión si no está registrada en el manifiesto?
Nick.McDermaid

52

Necesita descomprimirlo y verificar su META-INF/MANIFEST.MFarchivo, por ejemplo

unzip -p file.jar | head

o más específico:

unzip -p file.jar META-INF/MANIFEST.MF

26

Solo para ampliar las respuestas anteriores, dentro del archivo META-INF / MANIFEST.MF en el JAR, es probable que vea una línea: Manifest-Version: 1.0 ← ¡Este NO es el número de versiones del jar!

Debe buscar Implementation-Versioncuál, si está presente, es una cadena de texto libre que depende completamente del autor del JAR en cuanto a lo que encontrará allí. Consulte también los documentos de Oracle y las especificaciones de la versión del paquete.


Esta respuesta (y otras) se discute
Thomas Weller

17

Solo para completar la respuesta anterior.

El archivo de manifiesto se encuentra dentro de jar en la META-INF\MANIFEST.MFruta.

Puede examinar el contenido de jar en cualquier archivador que admita zip.


2
Esta respuesta (y otras) se discute
Thomas Weller

11

Cada versión de jar tiene una suma de comprobación única. Puede calcular la suma de comprobación para su jar (que no tenía información de versión) y compararla con las diferentes versiones del jar. También podemos buscar un frasco usando suma de comprobación.

Consulte esta pregunta para calcular la suma de verificación: ¿Cuál es la mejor manera de calcular una suma de verificación para un archivo que está en mi máquina?


5
Calculé el tarro md5 y lo pegué en google. Funcionó muy bien, muchas gracias!
mik01aj

7

Básicamente, debes usar la java.lang.Packageclase que usa el cargador de clases para darte información sobre tus clases.

ejemplo:

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

Creo que se sabe que el logback usa esta función para rastrear el nombre / versión JAR de cada clase en sus trazas de pila producidas.

ver también http://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html#wp90779


3

Este programa simple enumerará todos los casos para la versión de jar, a saber

  • Versión encontrada en el archivo de manifiesto
  • No se encontró ninguna versión en el manifiesto e incluso del nombre del jar
  • Archivo de manifiesto no 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);
    

Utiliza el jar javaxt-core que se puede descargar desde http://www.javaxt.com/downloads/


Gracias por la referencia a javaxt, acabo de usar la muestra de código más simple de javaxt.com/Tutorials/Jar/…
David

1
Para su información, para aquellos que prefieren maven para extraer javaxt-core en lugar de descargar el JAR, pueden hacer cualquiera de estos enfoques: gist.github.com/daluu/dda7b29cb5b6e0fbfbaec664eb759739 , gist.github.com/daluu/52af7eef52563ddf78fe
David

2

Llego tarde, pero puedes probar los siguientes dos métodos

usando estas clases necesarias

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

Estos métodos me permiten acceder a los atributos del jar. Me gusta ser compatible con versiones anteriores y usar lo último. Entonces usé esto

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;
}

Esto funciona bien cuando usa maven y necesita detalles de pom para clases conocidas. Espero que esto ayude.


1

Para Linux, intente lo siguiente:

encontrar . -name "YOUR_JAR_FILE.jar" -exec zipgrep "Versión de implementación:" '{}' \; | awk -F ':' '{print $ 2}'


1

Si tiene winrar, abra el frasco con winrar, haga doble clic para abrir la carpeta META-INF . Extraiga MANIFEST.MFy CHANGESarchive a cualquier ubicación (digamos escritorio).

Abra los archivos extraídos en un editor de texto: verá Versión de implementación o versión de lanzamiento.



0

Pensé que daría una respuesta más reciente ya que esta pregunta todavía aparece bastante alta en las búsquedas.

Comprobación de la versión CLi JAR:

Ejecute lo siguiente en el archivo jar CLi:

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

Salida de ejemplo:

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

La versión CLi se enumera arriba.

Para obtener la versión del servidor, ejecute lo siguiente:

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

(lo anterior variará en función de su implementación de autenticación, cambie en consecuencia)

Salida de ejemplo:

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.