comment vérifier la version du fichier jar?

Je travaille actuellement sur une application polish J2ME, je ne fais que l'améliorer. Je rencontre des difficultés pour obtenir la version exacte du fichier jar. Existe-t-il un moyen de trouver la version du fichier jar pour les importations effectuées dans la classe? Je veux dire si vous avez quelque chose, importez xyz; pouvons-nous savoir à quelle version appartient le package jar xy?

Décompressez le fichier JAR et recherchez le fichier manifeste ( META-INF\MANIFEST.MF). Le fichier manifeste du fichier JAR peut contenir un numéro de version (mais pas toujours une version est spécifiée).

Vous devez le décompresser et vérifier son META-INF/MANIFEST.MFfichier, par exemple

unzip -p file.jar | head

ou plus spécifique:

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

Juste pour développer les réponses ci-dessus, dans le fichier META-INF / MANIFEST.MF dans le JAR, vous verrez probablement une ligne: Manifest-Version: 1.0 ← Ce n'est PAS le numéro de version du jar!

Vous devez rechercher Implementation-Versionquelle, si elle est présente, est une chaîne de texte libre qui appartient entièrement à l'auteur du JAR quant à ce que vous y trouverez. Voir aussi la documentation Oracle et la spécification de la version du package

Juste pour compléter la réponse ci-dessus.

Le fichier manifeste est situé dans le fichier jar au META-INF\MANIFEST.MFchemin.

Vous pouvez examiner le contenu de jar dans n'importe quel archiveur prenant en charge le zip.

Chaque version de pot a une somme de contrôle unique. Vous pouvez calculer la somme de contrôle pour votre fichier jar (qui n'avait aucune information de version) et le comparer avec les différentes versions du fichier jar. Nous pouvons également rechercher un pot en utilisant la somme de contrôle.

Référez-vous à cette question pour calculer la somme de contrôle: Quelle est la meilleure façon de calculer une somme de contrôle pour un fichier qui se trouve sur ma machine?

En gros, vous devriez utiliser la java.lang.Packageclasse qui utilise le classloader pour vous donner des informations sur vos classes.

exemple:

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

Je pense que logback est connu pour utiliser cette fonctionnalité pour tracer le nom / la version JAR de chaque classe dans ses stacktraces produites.

voir également http://docs.oracle.com/javase/8/docs/technotes/guides/versioning/spec/versioning2.html#wp90779

Ce programme simple listera tous les cas pour la version de jar à savoir

• Version trouvée dans le fichier manifeste
• Aucune version trouvée dans le manifeste et même à partir du nom du pot

• Fichier manifeste introuvable

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

Il utilise le jar javaxt-core qui peut être téléchargé à partir de http://www.javaxt.com/downloads/

Je suis en retard mais vous pouvez essayer les deux méthodes suivantes

en utilisant ces classes nécessaires

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

Ces méthodes me permettent d'accéder aux attributs jar. J'aime être rétrocompatible et utiliser la dernière. Alors j'ai utilisé ça

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

Cela fonctionne bien lorsque vous utilisez maven et avez besoin de détails pom pour les classes connues. J'espère que cela t'aides.

Pour Linux, essayez ce qui suit:

trouver . -name "VOTRE_FICHIER_JAR.jar" -exec zipgrep "Version-d'implémentation:" '{}' \; | awk -F ':' '{print $ 2}'

Si vous avez winrar, ouvrez le bocal avec winrar, double-cliquez pour ouvrir le dossier META-INF. Extrayez MANIFEST.MFet CHANGESfichiers à n'importe quel emplacement (par exemple, bureau)

Ouvrez les fichiers extraits dans un éditeur de texte: vous verrez la version d'implémentation ou la version de publication.

Vous pouvez filtrer la version du fichier MANIFEST en utilisant

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

Je pensais que je donnerais une réponse plus récente car cette question revient toujours assez haut dans les recherches.

Vérification de la version CLi JAR:

Exécutez ce qui suit sur le fichier jar CLi:

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

Exemple de sortie:

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 version CLi est répertoriée ci-dessus.

Pour obtenir la version du serveur, exécutez ce qui suit:

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

(ce qui précède variera en fonction de votre implémentation de l'authentification, veuillez changer en conséquence)

Exemple de sortie:

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

Il peut être vérifié avec une commande java -jar jarname