comment vérifier la version du fichier jar?


91

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?

Réponses:


78

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


Comme je l'ai dit que je travaille sur l'amélioration de l'application, j'ai téléchargé les fichiers jar et je connais la version des fichiers jar. Mais je voulais connaître la version du fichier jar à laquelle appartient le paquet, j'espère que vous l'aurez.
Ritesh Mengji

Pour vous expliquer plus, j'ai import xyz, je sais que xy appartient à a-4.1.jar, mais l'application sur laquelle je travaille a été développée il y a longtemps, et je ne sais pas quelle version d'un fichier .jar ont-ils utilisé, je je m'inquiète pour la version parce que certaines classes ont été dépréciées du pot de l'ancienne version (je le sens), parce que, même si j'ai un pot dans la bibliothèque, je trouve que l'importation ne peut pas être résolue
Ritesh Mengji

Alors est-ce que, si vous connaissez la version de jar qu'ils ont utilisée lors de la construction de l'application, vous utiliseriez également la même version de jar pour exécuter l'application?
Vivek le

1
Si tel est votre besoin, vous craignez de devoir reconstruire l'application en excluant les fichiers JAR obsolètes. Parce que trouver le numéro de version associé à un fichier jar donné est comme une fonction une à une. Un seul numéro de version pour un fichier jar. Mais trouver quelle version de jar a été utilisée au moment du développement de l'application me semble très impossible à moins que le développeur n'attache les fichiers jar requis avec l'application.
Vivek le

1
La version d'enregistrement dans MANIFEST.MF semble être facultative. Il n'y a pas de version enregistrée dans divers sqljdbc42.jarfichiers que j'ai utilisés avec Cognos, mais Cognos est capable de signaler une version (4.2.6420.100). D'où vient cette version si elle n'est pas enregistrée dans le manifeste?
Nick.McDermaid le

52

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

26

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


Cette réponse (et d'autres) est actuellement discutée sur Meta
Thomas Weller

17

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.


2
Cette réponse (et d'autres) est actuellement discutée sur Meta
Thomas Weller

11

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?


5
Je viens de calculer le pot md5 et de le coller sur Google. A très bien fonctionné, merci beaucoup!
mik01aj

7

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


3

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/


Merci pour la référence à javaxt, je viens d'utiliser l'exemple de code plus simple de javaxt.com/Tutorials/Jar
David

1
Pour info, pour ceux qui préfèrent que maven tire javaxt-core plutôt que de télécharger le JAR, vous pouvez utiliser l'une de ces approches: gist.github.com/daluu/dda7b29cb5b6e0fbfbaec664eb759739 , gist.github.com/daluu/52af7eef52563ddf78fe
David

2

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.


1

Pour Linux, essayez ce qui suit:

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


1

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.


0

Vous pouvez filtrer la version du fichier MANIFEST en utilisant

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


Cela semble reproduire principalement cette ancienne réponse - stackoverflow.com/a/38313502/272387 - et les manifestes ne sont pas garantis Bundle-Version.
Richlv

0

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.