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

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?

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

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

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.

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.

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?

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

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/

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.

Para Linux, intente lo siguiente:

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

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.

Puede filtrar la versión del archivo MANIFEST usando

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

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

Se puede comprobar con un comando. java -jar jarname