如何列出 JAR 文件中的文件？

Question

我有这段代码可以从目录中读取所有文件。

    File textFolder = new File("text_directory");

    File [] texFiles = textFolder.listFiles( new FileFilter() {
           public boolean accept( File file ) {
               return file.getName().endsWith(".txt");
           }
    });

效果很好。它使用目录“text_directory”中以“.txt”结尾的所有文件填充数组。

如何在 JAR 文件中以类似的方式读取目录的内容？

所以我真正想做的是，列出 JAR 文件中的所有图像，这样我就可以加载它们：（

ImageIO.read(this.getClass().getResource("CompanyLogo.png"));

该方法有效，因为“CompanyLogo”是“硬编码的”，但 JAR 文件中的图像数量可能是从 10 到 200 个可变长度。）

编辑

所以我想我的主要问题是：如何知道我的主类所在的JAR 文件的名称？

当然，我可以使用 java.util.Zip 来阅读它。

我的结构是这样的：

它们就像：

my.jar!/Main.class
my.jar!/Aux.class
my.jar!/Other.class
my.jar!/images/image01.png
my.jar!/images/image02a.png
my.jar!/images/imwge034.png
my.jar!/images/imagAe01q.png
my.jar!/META-INF/manifest 

现在我可以使用以下方式加载例如“images/image01.png”：

    ImageIO.read(this.getClass().getResource("images/image01.png));

但只是因为我知道文件名，其余的我必须动态加载它们。

Answer 1

需要提一下的是，如果您已经在使用 Spring，则可以利用 PathMatchingResourcePatternResolver。

例如，从资源中的 images 文件夹中获取所有 PNG 文件

ClassLoader cl = this.getClass().getClassLoader(); 
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl);
Resource[] resources = resolver.getResources("images/*.png");
for (Resource r: resources){
    logger.info(r.getFilename());
    // From your example
    // ImageIO.read(cl.getResource("images/" + r.getFilename()));
}

Answer 2

下面是一个使用 Reflections 库通过正则表达式名称模式递归扫描类路径的示例，并添加了几个 Guava 有助于获取资源内容：

Reflections reflections = new Reflections("com.example.package", new ResourcesScanner());
Set<String> paths = reflections.getResources(Pattern.compile(".*\\.template$"));

Map<String, String> templates = new LinkedHashMap<>();
for (String path : paths) {
    log.info("Found " + path);
    String templateName = Files.getNameWithoutExtension(path);
    URL resource = getClass().getClassLoader().getResource(path);
    String text = Resources.toString(resource, StandardCharsets.UTF_8);
    templates.put(templateName, text);
}

这适用于 jar 和分解类。

Answer 3

这是我为“运行包下的所有 JUnit”编写的方法。您应该能够根据您的需要进行调整。

private static void findClassesInJar(List<String> classFiles, String path) throws IOException {
    final String[] parts = path.split("\\Q.jar\\\\E");
    if (parts.length == 2) {
        String jarFilename = parts[0] + ".jar";
        String relativePath = parts[1].replace(File.separatorChar, '/');
        JarFile jarFile = new JarFile(jarFilename);
        final Enumeration<JarEntry> entries = jarFile.entries();
        while (entries.hasMoreElements()) {
            final JarEntry entry = entries.nextElement();
            final String entryName = entry.getName();
            if (entryName.startsWith(relativePath)) {
                classFiles.add(entryName.replace('/', File.separatorChar));
            }
        }
    }
}

编辑：
啊，在这种情况下，您可能也需要这个片段（相同的用例:)）

private static File findClassesDir(Class<?> clazz) {
    try {
        String path = clazz.getProtectionDomain().getCodeSource().getLocation().getFile();
        final String codeSourcePath = URLDecoder.decode(path, "UTF-8");
        final String thisClassPath = new File(codeSourcePath, clazz.getPackage().getName().repalce('.', File.separatorChar));
    } catch (UnsupportedEncodingException e) {
        throw new AssertionError("impossible", e);
    }
}

Answer 4

jar 文件只是一个带有结构化清单的 zip 文件。您可以使用常用的 java zip 工具打开 jar 文件，并以这种方式扫描文件内容、膨胀流等。然后在 getResourceAsStream 调用中使用它，这一切都应该很顺利。

编辑/澄清后

我花了一分钟的时间来记住所有的点点滴滴，我确信有更干净的方法来做到这一点，但我想看看我没有疯。在我的项目中，image.jpg 是主 jar 文件某些部分中的一个文件。我获取主类的类加载器（SomeClass 是入口点）并使用它来发现 image.jpg 资源。然后使用一些流魔法将其放入 ImageInputStream 中，一切都很好。

InputStream inputStream = SomeClass.class.getClassLoader().getResourceAsStream("image.jpg");
JPEGImageReaderSpi imageReaderSpi = new JPEGImageReaderSpi();
ImageReader ir = imageReaderSpi.createReaderInstance();
ImageInputStream iis = new MemoryCacheImageInputStream(inputStream);
ir.setInput(iis);
....
ir.read(0); //will hand us a buffered image

Answer 5

给定一个实际的 JAR 文件，您可以使用 JarFile.entries() 列出内容。不过，您需要知道 JAR 文件的位置 - 您不能只要求类加载器列出它可以获得的所有内容。

您应该能够根据 ThisClassName.class.getResource("ThisClassName.class") 返回的 URL 计算出 JAR 文件的位置，但这可能有点麻烦。

Answer 6

前段时间我做了一个从 JAR 内部获取类的函数：

public static Class[] getClasses(String packageName) 
throws ClassNotFoundException{
    ArrayList<Class> classes = new ArrayList<Class> ();

    packageName = packageName.replaceAll("\\." , "/");
    File f = new File(jarName);
    if(f.exists()){
        try{
            JarInputStream jarFile = new JarInputStream(
                    new FileInputStream (jarName));
            JarEntry jarEntry;

            while(true) {
                jarEntry=jarFile.getNextJarEntry ();
                if(jarEntry == null){
                    break;
                }
                if((jarEntry.getName ().startsWith (packageName)) &&
                        (jarEntry.getName ().endsWith (".class")) ) {
                    classes.add(Class.forName(jarEntry.getName().
                            replaceAll("/", "\\.").
                            substring(0, jarEntry.getName().length() - 6)));
                }
            }
        }
        catch( Exception e){
            e.printStackTrace ();
        }
        Class[] classesA = new Class[classes.size()];
        classes.toArray(classesA);
        return classesA;
    }else
        return null;
}

Answer 7

public static ArrayList<String> listItems(String path) throws Exception{
    InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(path);
    byte[] b = new byte[in.available()];
    in.read(b);
    String data = new String(b);
    String[] s = data.split("\n");
    List<String> a = Arrays.asList(s);
    ArrayList<String> m = new ArrayList<>(a);
    return m;
}

Answer 8

有两个非常有用的实用程序都称为 JarScan：

1. www.inetfeedback.com/jarscan

2. jarscan.dev.java.net

另请参阅这个问题：JarScan，扫描所有子文件夹中的所有 JAR 文件特定类别

Answer 9

目前列出类路径中所有资源的最强大的机制是 将此模式与 ClassGraph 结合使用，因为它处理 尽可能广泛的类路径规范机制，包括新的 JPMS 模块系统。 （我是 ClassGraph 的作者。）

如何知道我的主类所在的 JAR 文件的名称？

URI mainClasspathElementURI;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("x.y.z")
        .enableClassInfo().scan()) {
    mainClasspathElementURI =
            scanResult.getClassInfo("x.y.z.MainClass").getClasspathElementURI();
}

如何在 JAR 文件中以类似的方式读取目录的内容？

List<String> classpathElementResourcePaths;
try (ScanResult scanResult = new ClassGraph().overrideClasspath(mainClasspathElementURI)
        .scan()) {
    classpathElementResourcePaths = scanResult.getAllResources().getPaths();
}

还有许多其他处理资源的方法。

Answer 10

另一条道路在匹配特定文件名方面更加灵活，因为它使用通配符通配符。在功能风格中，这可能类似于：

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.FileSystem;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.function.Consumer;

import static java.nio.file.FileSystems.getDefault;
import static java.nio.file.FileSystems.newFileSystem;
import static java.util.Collections.emptyMap;

/**
 * Responsible for finding file resources.
 */
public class ResourceWalker {
  /**
   * Globbing pattern to match font names.
   */
  public static final String GLOB_FONTS = "**.{ttf,otf}";

  /**
   * @param directory The root directory to scan for files matching the glob.
   * @param c         The consumer function to call for each matching path
   *                  found.
   * @throws URISyntaxException Could not convert the resource to a URI.
   * @throws IOException        Could not walk the tree.
   */
  public static void walk(
    final String directory, final String glob, final Consumer<Path> c )
    throws URISyntaxException, IOException {
    final var resource = ResourceWalker.class.getResource( directory );
    final var matcher = getDefault().getPathMatcher( "glob:" + glob );

    if( resource != null ) {
      final var uri = resource.toURI();
      final Path path;
      FileSystem fs = null;

      if( "jar".equals( uri.getScheme() ) ) {
        fs = newFileSystem( uri, emptyMap() );
        path = fs.getPath( directory );
      }
      else {
        path = Paths.get( uri );
      }

      try( final var walk = Files.walk( path, 10 ) ) {
        for( final var it = walk.iterator(); it.hasNext(); ) {
          final Path p = it.next();
          if( matcher.matches( p ) ) {
            c.accept( p );
          }
        }
      } finally {
        if( fs != null ) { fs.close(); }
      }
    }
  }
}

考虑参数化文件扩展名，为读者留下一个练习。

请小心 Files.walk。根据文档：

此方法必须在 try-with-resources 语句或类似的控制结构中使用，以确保在流的操作完成后立即关闭流的打开目录。

同样，newFileSystem 必须关闭，但必须在 walker 有机会访问文件系统路径之前关闭。

Answer 11

只是从 jar URL 列出/读取文件的不同方式，它对嵌套 jar 递归执行

https:// gist.github.com/trung/2cd90faab7f75b3bcbaa

URL urlResource = Thead.currentThread().getContextClassLoader().getResource("foo");
JarReader.read(urlResource, new InputStreamCallback() {
    @Override
    public void onFile(String name, InputStream is) throws IOException {
        // got file name and content stream 
    }
});

Answer 12

CodeSource src = MyClass.class.getProtectionDomain().getCodeSource();
if (src != null) {
  URL jar = src.getLocation();
  ZipInputStream zip = new ZipInputStream(jar.openStream());
  while(true) {
    ZipEntry e = zip.getNextEntry();
    if (e == null)
      break;
    String name = e.getName();
    if (name.startsWith("path/to/your/dir/")) {
      /* Do something with this entry. */
      ...
    }
  }
} 
else {
  /* Fail... */
}

请注意，在 Java 7 中，您可以从 JAR (zip) 文件创建一个 FileSystem，然后使用 NIO 的目录遍历和过滤机制来搜索它。这将使编写处理 JAR 和“分解”目录的代码变得更容易。

Answer 13

适用于 IDE 和 .jar 文件的代码：

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class ResourceWalker {
    public static void main(String[] args) throws URISyntaxException, IOException {
        URI uri = ResourceWalker.class.getResource("/resources").toURI();
        Path myPath;
        if (uri.getScheme().equals("jar")) {
            FileSystem fileSystem = FileSystems.newFileSystem(uri, Collections.<String, Object>emptyMap());
            myPath = fileSystem.getPath("/resources");
        } else {
            myPath = Paths.get(uri);
        }
        Stream<Path> walk = Files.walk(myPath, 1);
        for (Iterator<Path> it = walk.iterator(); it.hasNext();){
            System.out.println(it.next());
        }
    }
}

Answer 14

埃里克森的答案工作得很好：

这是工作代码。

CodeSource src = MyClass.class.getProtectionDomain().getCodeSource();
List<String> list = new ArrayList<String>();

if( src != null ) {
    URL jar = src.getLocation();
    ZipInputStream zip = new ZipInputStream( jar.openStream());
    ZipEntry ze = null;

    while( ( ze = zip.getNextEntry() ) != null ) {
        String entryName = ze.getName();
        if( entryName.startsWith("images") &&  entryName.endsWith(".png") ) {
            list.add( entryName  );
        }
    }

 }
 webimages = list.toArray( new String[ list.size() ] );

我刚刚将我的加载方法从以下修改

File[] webimages = ... 
BufferedImage image = ImageIO.read(this.getClass().getResource(webimages[nextIndex].getName() ));

为：

String  [] webimages = ...

BufferedImage image = ImageIO.read(this.getClass().getResource(webimages[nextIndex]));

Answer 15

我想扩展 acheron55 的 答案，因为它是一个非常不安全的解决方案，原因如下：

1. 它不会关闭 FileSystem 对象。
2. 它不会检查 FileSystem 对象是否已存在。
3. 它不是线程安全的。

这在某种程度上是一个更安全的解决方案：

private static ConcurrentMap<String, Object> locks = new ConcurrentHashMap<>();

public void walk(String path) throws Exception {

    URI uri = getClass().getResource(path).toURI();
    if ("jar".equals(uri.getScheme())) {
        safeWalkJar(path, uri);
    } else {
        Files.walk(Paths.get(path));
    }
}

private void safeWalkJar(String path, URI uri) throws Exception {

    synchronized (getLock(uri)) {    
        // this'll close the FileSystem object at the end
        try (FileSystem fs = getFileSystem(uri)) {
            Files.walk(fs.getPath(path));
        }
    }
}

private Object getLock(URI uri) {

    String fileName = parseFileName(uri);  
    locks.computeIfAbsent(fileName, s -> new Object());
    return locks.get(fileName);
}

private String parseFileName(URI uri) {
    
    String schemeSpecificPart = uri.getSchemeSpecificPart();
    return schemeSpecificPart.substring(0, schemeSpecificPart.indexOf("!"));
}

private FileSystem getFileSystem(URI uri) throws IOException {

    try {
        return FileSystems.getFileSystem(uri);
    } catch (FileSystemNotFoundException e) {
        return FileSystems.newFileSystem(uri, Collections.<String, String>emptyMap());
    }
}   

没有真正需要同步文件名；人们可以简单地每次同步同一个对象（或使方法同步），这纯粹是一种优化。

我想说这仍然是一个有问题的解决方案，因为代码中可能有其他部分在相同的文件上使用 FileSystem 接口，并且它可能会干扰它们（即使在单线程应用程序中） ).
另外，它不会检查 null（例如，在 getClass().getResource() 上）。

这个特定的 Java NIO 接口有点可怕，因为它引入了全局/单例非线程安全资源，其文档非常模糊（由于提供程序特定的实现，结果可能会有所不同）其他 FileSystem 提供程序（不是 JAR）。这样做的充分理由；我不知道，我还没有研究过这些实现。

Answer 16

<块引用>

所以我想我的主要问题是，如何知道我的主类所在的 jar 的名称。

假设您的项目打包在 Jar 中（不一定如此！），您可以使用 ClassLoader.getResource() 或 findResource() 以及类名（后跟 .class）来获取包含给定类的 jar。您必须从返回的 URL 中解析 jar 名称（不是那么难），我将把它作为练习留给读者:-)

请务必测试类不属于 jar 的情况。

Answer 17

我已经移植了 acheron55 的答案 到 Java 7 并关闭 FileSystem 对象。此代码可以在 IDE、jar 文件以及 Tomcat 7 上的 war 内的 jar 中运行；但请注意，它不能在JBoss 7上的战争中的jar中工作（它给出FileSystemNotFoundException：Provider“vfs”未安装，另请参阅这篇文章）。此外，与原始代码一样，它不是线程安全的，正如 错误。由于这些原因，我放弃了这个解决方案；但是，如果您可以接受这些问题，这里是我现成的代码：

import java.io.IOException;
import java.net.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Collections;

public class ResourceWalker {

    public static void main(String[] args) throws URISyntaxException, IOException {
        URI uri = ResourceWalker.class.getResource("/resources").toURI();
        System.out.println("Starting from: " + uri);
        try (FileSystem fileSystem = (uri.getScheme().equals("jar") ? FileSystems.newFileSystem(uri, Collections.<String, Object>emptyMap()) : null)) {
            Path myPath = Paths.get(uri);
            Files.walkFileTree(myPath, new SimpleFileVisitor<Path>() { 
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    System.out.println(file);
                    return FileVisitResult.CONTINUE;
                }
            });
        }
    }
}