Wie überprüfe ich die Version der JAR-Datei?

Ich arbeite derzeit an einer J2ME-Polieranwendung und verbessere sie nur. Ich habe Schwierigkeiten, die genaue Version der JAR-Datei zu erhalten. Gibt es eine Möglichkeit, die Version der JAR-Datei für die in der Klasse durchgeführten Importe zu finden? Ich meine, wenn Sie etwas haben, importieren Sie xyz; Können wir wissen, zu welcher Version des jar xy-Pakets gehört?

Dekomprimieren Sie die JAR-Datei und suchen Sie nach der Manifestdatei ( META-INF\MANIFEST.MF). Die Manifestdatei der JAR-Datei enthält möglicherweise eine Versionsnummer (es wird jedoch nicht immer eine Version angegeben).

Sie müssen es entpacken und seine META-INF/MANIFEST.MFDatei überprüfen , z

unzip -p file.jar | head

oder genauer:

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

Um die obigen Antworten zu erweitern, wird in der Datei META-INF / MANIFEST.MF im JAR wahrscheinlich eine Zeile Manifest-Version: 1.0 angezeigt : ← Dies ist NICHT die JAR-Versionsnummer!

Sie müssen suchen Implementation-Version, ob es sich, falls vorhanden, um eine Freitextzeichenfolge handelt, die dem Autor der JAR so vollständig überlassen bleibt, was Sie dort finden. Siehe auch Oracle-Dokumente und Paketversionsspezifikation

Nur um die obige Antwort zu vervollständigen.

Die Manifestdatei befindet sich im jar am META-INF\MANIFEST.MFPfad.

Sie können den Inhalt von jar in jedem Archivierer untersuchen, der zip unterstützt.

Jede Glasversion hat eine eindeutige Prüfsumme. Sie können die Prüfsumme für Ihr Glas berechnen (das keine Versionsinformationen hatte) und sie mit den verschiedenen Versionen des Glases vergleichen. Wir können ein Glas auch mit Prüfsumme durchsuchen.

Beziehen Sie sich auf diese Frage, um die Prüfsumme zu berechnen: Wie kann eine Prüfsumme für eine Datei auf meinem Computer am besten berechnet werden?

Grundsätzlich sollten Sie die java.lang.PackageKlasse verwenden, die den Klassenladeprogramm verwendet, um Informationen über Ihre Klassen zu erhalten.

Beispiel:

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

Ich denke, dass Logback diese Funktion verwendet, um den JAR-Namen / die JAR-Version jeder Klasse in ihren erstellten Stacktraces zu verfolgen.

Siehe auch http://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html#wp90779

Dieses einfache Programm listet nämlich alle Fälle für die Version von jar auf

• Version in Manifest-Datei gefunden
• Keine Version in Manifest und sogar aus dem Namen des Glases gefunden

• Manifestdatei nicht gefunden

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

Es verwendet das Javaxt-Core-JAR, das von http://www.javaxt.com/downloads/ heruntergeladen werden kann.

Ich bin spät dran, aber Sie können die folgenden zwei Methoden ausprobieren

mit diesen benötigten Klassen

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

Mit diesen Methoden kann ich auf die jar-Attribute zugreifen. Ich mag es abwärtskompatibel zu sein und die neuesten zu verwenden. Also habe ich das benutzt

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

Dies funktioniert gut, wenn Sie Maven verwenden und POM-Details für bekannte Klassen benötigen. Hoffe das hilft.

Sie können die Version aus der MANIFEST-Datei mit filtern

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

Wenn Sie winrar haben, öffnen Sie das Glas mit winrar und doppelklicken Sie, um den Ordner zu öffnen META-INF. Extrahieren MANIFEST.MFund CHANGESDateien an einen beliebigen Ort (z. B. Desktop).

Öffnen Sie die extrahierten Dateien in einem Texteditor: Sie sehen Implementierungsversion oder Release-Version.

Versuchen Sie unter Linux Folgendes:

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

Ich dachte, ich würde eine neuere Antwort geben, da diese Frage bei Suchanfragen immer noch ziemlich hoch auftaucht.

Überprüfen der CLi JAR-Version:

Führen Sie in der CLi-JAR-Datei Folgendes aus:

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

Beispielausgabe:

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

Die CLi-Version ist oben aufgeführt.

Führen Sie Folgendes aus, um die Serverversion abzurufen:

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

(Die obigen Angaben variieren je nach Implementierung der Authentifizierung. Bitte ändern Sie sie entsprechend.)

Beispielausgabe:

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

Es kann mit einem Befehl überprüft werden java -jar jarname