使用JAVA从jar文件中读取MANIFEST.MF文件

Question

有什么方法可以读取 jar 文件的内容吗？我想读取清单文件以便找到 jar 文件的创建者和版本。有什么办法可以实现吗？

Answer 1

下一个代码应该有所帮助：

JarInputStream jarStream = new JarInputStream(stream);
Manifest mf = jarStream.getManifest();

异常处理留给你了:)

Answer 2

我建议进行以下操作：

Package aPackage = MyClassName.class.getPackage();
String implementationVersion = aPackage.getImplementationVersion();
String implementationVendor = aPackage.getImplementationVendor();

其中 MyClassName 可以是您编写的应用程序中的任何类。

Answer 3

您可以使用这样的方法：

public static String getManifestInfo() {
    Enumeration resEnum;
    try {
        resEnum = Thread.currentThread().getContextClassLoader().getResources(JarFile.MANIFEST_NAME);
        while (resEnum.hasMoreElements()) {
            try {
                URL url = (URL)resEnum.nextElement();
                InputStream is = url.openStream();
                if (is != null) {
                    Manifest manifest = new Manifest(is);
                    Attributes mainAttribs = manifest.getMainAttributes();
                    String version = mainAttribs.getValue("Implementation-Version");
                    if(version != null) {
                        return version;
                    }
                }
            }
            catch (Exception e) {
                // Silently ignore wrong manifests on classpath?
            }
        }
    } catch (IOException e1) {
        // Silently ignore wrong manifests on classpath?
    }
    return null; 
}

要获取清单属性，您可以迭代变量“mainAttribs”，或者如果您知道密钥，则可以直接检索所需的属性。

此代码循环遍历类路径上的每个 jar 并读取每个 jar 的 MANIFEST。如果您知道 jar 的名称，您可能只想查看 URL（如果它包含（）您感兴趣的 jar 的名称）。

Answer 4

我根据 stackoverflow 的一些想法实现了一个 AppVersion 类，这里我只是分享整个类：

import java.io.File;
import java.net.URL;
import java.util.jar.Attributes;
import java.util.jar.Manifest;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AppVersion {
  private static final Logger log = LoggerFactory.getLogger(AppVersion.class);

  private static String version;

  public static String get() {
    if (StringUtils.isBlank(version)) {
      Class<?> clazz = AppVersion.class;
      String className = clazz.getSimpleName() + ".class";
      String classPath = clazz.getResource(className).toString();
      if (!classPath.startsWith("jar")) {
        // Class not from JAR
        String relativePath = clazz.getName().replace('.', File.separatorChar) + ".class";
        String classFolder = classPath.substring(0, classPath.length() - relativePath.length() - 1);
        String manifestPath = classFolder + "/META-INF/MANIFEST.MF";
        log.debug("manifestPath={}", manifestPath);
        version = readVersionFrom(manifestPath);
      } else {
        String manifestPath = classPath.substring(0, classPath.lastIndexOf("!") + 1) + "/META-INF/MANIFEST.MF";
        log.debug("manifestPath={}", manifestPath);
        version = readVersionFrom(manifestPath);
      }
    }
    return version;
  }

  private static String readVersionFrom(String manifestPath) {
    Manifest manifest = null;
    try {
      manifest = new Manifest(new URL(manifestPath).openStream());
      Attributes attrs = manifest.getMainAttributes();

      String implementationVersion = attrs.getValue("Implementation-Version");
      implementationVersion = StringUtils.replace(implementationVersion, "-SNAPSHOT", "");
      log.debug("Read Implementation-Version: {}", implementationVersion);

      String implementationBuild = attrs.getValue("Implementation-Build");
      log.debug("Read Implementation-Build: {}", implementationBuild);

      String version = implementationVersion;
      if (StringUtils.isNotBlank(implementationBuild)) {
        version = StringUtils.join(new String[] { implementationVersion, implementationBuild }, '.');
      }
      return version;
    } catch (Exception e) {
      log.error(e.getMessage(), e);
    }
    return StringUtils.EMPTY;
  }
}

基本上，这个类可以从它自己的 JAR 文件的清单或它的类文件夹中的清单中读取版本信息。希望它可以在不同的平台上运行，但到目前为止我只在 Mac OS X 上进行了测试。

我希望这对其他人有用。

Answer 5

通过这种简单的方式实现属性

    public static String  getMainClasFromJarFile(String jarFilePath) throws Exception{
    // Path example: "C:\\Users\\GIGABYTE\\.m2\\repository\\domolin\\DeviceTest\\1.0-SNAPSHOT\\DeviceTest-1.0-SNAPSHOT.jar";
    JarInputStream jarStream = new JarInputStream(new FileInputStream(jarFilePath));
    Manifest mf = jarStream.getManifest();
    Attributes attributes = mf.getMainAttributes();
    // Manifest-Version: 1.0
    // Built-By: GIGABYTE
    // Created-By: Apache Maven 3.0.5
    // Build-Jdk: 1.8.0_144
    // Main-Class: domolin.devicetest.DeviceTest
    String mainClass = attributes.getValue("Main-Class");
    //String mainClass = attributes.getValue("Created-By");
    //  Output: domolin.devicetest.DeviceTest
    return mainClass;
}

Answer 6

您可以使用实用程序类 Manifests 来自 jcabi-manifests：

final String value = Manifests.read("My-Version");

该类将查找所有 MANIFEST.MF 文件在类路径中可用，并从其中之一读取您要查找的属性。另请阅读：http://www.yegor256.com/2014/07/03/how-to-read-manifest-mf.html yegor256.com/2014/07/03/how-to-read-manifest-mf.html

Answer 7

1. 阅读版本；
2. 我们将 MANIFEST.MF 从 jar 复制到用户主目录。

    public void processManifestFile() {
        String version = this.getClass().getPackage().getImplementationVersion();
        LOG.info("Version: {}", version);
        Path targetFile = Paths.get(System.getProperty("user.home"), "my-project", "MANIFEST.MF");

        try {
            URL url = this.getClass().getProtectionDomain().getCodeSource().getLocation();
            JarFile jarFile = new JarFile(url.getFile());
            Manifest manifest = jarFile.getManifest();
            try(FileWriter fw = new FileWriter(targetFile.toFile())) {
                manifest.getMainAttributes().entrySet().stream().forEach( x -> {
                    try {
                        fw.write(x.getKey() + ": " + x.getValue() + "\n");
                        LOG.info("{}: {}", x.getKey(), x.getValue());
                    } catch (IOException e) {
                        LOG.error("error in write manifest, {}", e.getMessage());
                    }
                });
            }
            LOG.info("Copy MANIFEST.MF to {}", targetFile);
        } catch (Exception e) {
            LOG.error("Error in processing MANIFEST.MF file", e);
        }
    }

Answer 8

保持简单。 JAR 也是一个 ZIP，因此任何 ZIP 代码都可用于读取 MAINFEST.MF：

public static String readManifest(String sourceJARFile) throws IOException
{
    ZipFile zipFile = new ZipFile(sourceJARFile);
    Enumeration entries = zipFile.entries();

    while (entries.hasMoreElements())
    {
        ZipEntry zipEntry = (ZipEntry) entries.nextElement();
        if (zipEntry.getName().equals("META-INF/MANIFEST.MF"))
        {
            return toString(zipFile.getInputStream(zipEntry));
        }
    }

    throw new IllegalStateException("Manifest not found");
}

private static String toString(InputStream inputStream) throws IOException
{
    StringBuilder stringBuilder = new StringBuilder();
    try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream)))
    {
        String line;
        while ((line = bufferedReader.readLine()) != null)
        {
            stringBuilder.append(line);
            stringBuilder.append(System.lineSeparator());
        }
    }

    return stringBuilder.toString().trim() + System.lineSeparator();
}

尽管灵活性，对于仅读取数据这个答案是最好的。

Answer 9

我很惊讶没有其他人提出这个解决方案：

File jar = ...;
try (JarFile jarFile = new JarFile(jar)) {
    Manifest manifest = jarFile.getManifest();
    // ...
}

Answer 10

如果您需要的只是版本，请使用此：

//java
public class Version {
    public static final String ver=Version.class.getPackage().getImplementationVersion();
}//use as Version.ver

//kotlin
object Version{
    val ver=this::class.java.`package`.implementationVersion
}//use as Version.ver

还有 implementationVendor 和 implementationTitle。对于规范*也是如此。

---

要读取清单本身，请通过 ClassLoader 将其作为 InputStream 获取，然后初始化 Manifest 对象，eg：

//java
public class DemoJava{
    public static void main(String[] args) {
        try (var ins = ClassLoader.getSystemResourceAsStream(JarFile.MANIFEST_NAME)) {
            if (ins != null) {
                for(var entry:new Manifest(ins).getMainAttributes().entrySet()){
                    System.out.println(entry);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//kotlin
fun main() {
    ClassLoader.getSystemResourceAsStream(JarFile.MANIFEST_NAME)?.use {
        Manifest(it).mainAttributes.forEach { println(it) }
    }
}

读取清单也允许读取自定义属性，例如发布分支提交 ID（如果已添加）。

---

要读取 jar 本身，请使用 CodeSource，然后初始化一个 JarFile 对象，例如：

//java
public class DemoJava{
    public static void main(String[] args) {
        var location = DemoJava.class.getProtectionDomain().getCodeSource().getLocation();
        if (location != null) {
            try (var jarFile = new JarFile(location.toURI().getPath())) {
                for(var entry:jarFile.getManifest().getMainAttributes().entrySet()){
                    System.out.println(entry);
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//kotlin
object DummyClass
fun main(){
    DummyClass::class.java.protectionDomain.codeSource.location?.toURI()?.path.let {
        JarFile(it).manifest.mainAttributes.forEach { println(it) }
    }
}

---

注意：在 IDE 环境中，代码可能从 IDE 的构建目录运行而不是来自打包的 jar/构建的工件，在这种情况下，上述某些方法（或此处的其他答案）可能会产生错误的结果。使用 IDE 的工件/出版物来找到该 jar。