how to check the version of jar file?

I am currently working on a J2ME polish application, just enhancing it. I am finding difficulties to get the exact version of the jar file. Is there any way to find the version of the jar file for the imports done in the class? I mean if you have some thing, import x.y.z; can we know the version of the jar x.y package belongs to?

Vivek

Decompress the JAR file and look for the manifest file (META-INF\MANIFEST.MF). The manifest file of JAR file might contain a version number (but not always a version is specified).

You need to unzip it and check its META-INF/MANIFEST.MF file, e.g.

unzip -p file.jar | head

or more specific:

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

Just to expand on the answers above, inside the META-INF/MANIFEST.MF file in the JAR, you will likely see a line: Manifest-Version: 1.0 ← This is NOT the jar versions number!

You need to look for Implementation-Version which, if present, is a free-text string so entirely up to the JAR's author as to what you'll find in there. See also Oracle docs and Package Version specificaion

Vadzim

Just to complete the above answer.

Manifest file is located inside jar at META-INF\MANIFEST.MF path.

You can examine jar's contents in any archiver that supports zip.

vijay

Each jar version has a unique checksum. You can calculate the checksum for you jar (that had no version info) and compare it with the different versions of the jar. We can also search a jar using checksum.

Refer this Question to calculate checksum: What is the best way to calculate a checksum for a file that is on my machine?

Basically you should use the java.lang.Package class which use the classloader to give you informations about your classes.

example:

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

I think logback is known to use this feature to trace the JAR name/version of each class in its produced stacktraces.

This simple program will list all the cases for version of jar namely

Version found in Manifest file
No version found in Manifest and even from jar name

Manifest file not found

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

It uses the javaxt-core jar which can be downloaded from http://www.javaxt.com/downloads/

I'm late this but you can try the following two methods

using these needed classes

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

These methods let me access the jar attributes. I like being backwards compatible and use the latest. So I used this

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

This works well when you are using maven and need pom details for known classes. Hope this helps.

You can filter version from the MANIFEST file using

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

For Linux, try following:

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

Akash Tolia

It can be checked with a command java -jar jarname

来源：https://stackoverflow.com/questions/5834794/how-to-check-the-version-of-jar-file

标签

jar