Làm cách nào để liệt kê các tệp bên trong tệp JAR?

Tôi có mã này đọc tất cả các tệp từ một thư mục.

    File textFolder = new File("text_directory");

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

Nó hoạt động tuyệt vời. Nó lấp đầy mảng với tất cả các tệp kết thúc bằng ".txt" từ thư mục "text_directory".

Làm cách nào tôi có thể đọc nội dung của một thư mục theo cách tương tự trong tệp JAR?

Vì vậy, điều tôi thực sự muốn làm là liệt kê tất cả các hình ảnh bên trong tệp JAR của mình, để tôi có thể tải chúng bằng:

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

(Cái đó hoạt động vì "CompanyLogo" là "mã cứng" nhưng số lượng hình ảnh bên trong tệp JAR có thể có độ dài thay đổi từ 10 đến 200.)

BIÊN TẬP

Vì vậy, tôi đoán vấn đề chính của tôi sẽ là: Làm thế nào để biết tên của tệp JAR nơi lớp chính của tôi sống?

Tôi có thể đọc nó bằng cách sử dụng java.util.Zip.

Cấu trúc của tôi như thế này:

Họ là như thế:

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 

Ngay bây giờ tôi có thể tải ví dụ: "images / image01.png" bằng cách sử dụng:

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

Nhưng chỉ vì tôi biết tên tệp, phần còn lại tôi phải tải chúng động.

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... */
}

Lưu ý rằng trong Java 7, bạn có thể tạo một FileSystemtừ tệp JAR (zip), sau đó sử dụng cơ chế lọc và đi bộ thư mục của NIO để tìm kiếm trong đó. Điều này sẽ giúp viết mã xử lý các JAR và các thư mục "bùng nổ" dễ dàng hơn.

Mã hoạt động cho cả tệp IDE và .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());
        }
    }
}

Câu trả lời của erickson hoạt động hoàn hảo:

Đây là mã làm việc.

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

Và tôi vừa sửa đổi phương thức tải của mình từ điều này:

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

Về điều này:

String  [] webimages = ...

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

Tôi muốn mở rộng câu trả lời của acheron55 , vì nó là một giải pháp rất không an toàn, vì một số lý do:

1. Nó không đóng FileSystemđối tượng.
2. Nó không kiểm tra xem FileSystemđối tượng đã tồn tại hay chưa.
3. Nó không an toàn theo luồng.

Đây là một giải pháp an toàn hơn:

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

Không cần thực sự đồng bộ hóa qua tên tệp; người ta có thể đơn giản đồng bộ hóa trên cùng một đối tượng mọi lúc (hoặc tạo phương thức synchronized), đó hoàn toàn là một sự tối ưu hóa.

Tôi muốn nói rằng đây vẫn là một giải pháp có vấn đề, vì có thể có các phần khác trong mã sử dụng FileSystemgiao diện trên các tệp giống nhau và nó có thể can thiệp vào chúng (ngay cả trong một ứng dụng luồng đơn).
Ngoài ra, nó không kiểm tra nulls (ví dụ: bật getClass().getResource().

Giao diện Java NIO cụ thể này khá khủng khiếp, vì nó giới thiệu một tài nguyên toàn cầu / singleton không an toàn theo luồng và tài liệu của nó cực kỳ mơ hồ (rất nhiều ẩn số do các triển khai cụ thể của nhà cung cấp). Kết quả có thể khác nhau đối với các FileSystemnhà cung cấp khác (không phải JAR). Có lẽ có một lý do chính đáng cho việc đó là như vậy; Tôi không biết, tôi chưa nghiên cứu việc triển khai.

Vì vậy, tôi đoán vấn đề chính của tôi sẽ là, làm thế nào để biết tên của cái lọ nơi lớp chính của tôi sống.

Giả sử rằng dự án của bạn được đóng gói trong một Jar (không nhất thiết phải đúng!), Bạn có thể sử dụng ClassLoader.getResource () hoặc findResource () với tên lớp (theo sau là .class) để lấy jar chứa một lớp nhất định. Bạn sẽ phải phân tích cú pháp tên jar từ URL được trả về (không khó lắm), tôi sẽ để lại như một bài tập cho người đọc :-)

Đảm bảo kiểm tra trường hợp lớp không phải là một phần của bình.

Tôi đã chuyển câu trả lời của acheron55 sang Java 7 và đóng FileSystemđối tượng. Mã này hoạt động trong IDE, trong các tệp jar và trong một cái lọ bên trong cuộc chiến trên Tomcat 7; nhưng lưu ý rằng nó không hoạt động trong một cái lọ bên trong cuộc chiến trên JBoss 7 (nó mang lại FileSystemNotFoundException: Provider "vfs" not installed, xem thêm bài đăng này ). Hơn nữa, giống như mã gốc, nó không an toàn cho luồng, như đề xuất của errr . Vì những lý do này, tôi đã từ bỏ giải pháp này; tuy nhiên, nếu bạn có thể chấp nhận những vấn đề này, đây là mã tạo sẵn của tôi:

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

Đây là một phương pháp tôi đã viết để "chạy tất cả các JUnits trong một gói". Bạn sẽ có thể điều chỉnh nó theo nhu cầu của mình.

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

Chỉnh sửa: À, trong trường hợp đó, bạn cũng có thể muốn đoạn mã này (cùng một trường hợp sử dụng :))

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

Dưới đây là một ví dụ về việc sử dụng thư viện Reflections để quét đệ quy classpath theo mẫu tên regex được tăng cường với một vài đặc quyền của Guava để tìm nạp nội dung tài nguyên:

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

Điều này hoạt động với cả bình và các lớp phát nổ.

Tệp jar chỉ là tệp zip có tệp kê khai có cấu trúc. Bạn có thể mở tệp jar bằng các công cụ java zip thông thường và quét nội dung tệp theo cách đó, thổi phồng luồng, v.v. Sau đó, sử dụng tệp đó trong lệnh gọi getResourceAsStream và tất cả phải là hunky dory.

CHỈNH SỬA / sau khi làm rõ

Tôi mất một phút để nhớ tất cả các mảnh và mảnh ghép và tôi chắc chắn rằng có nhiều cách tốt hơn để làm điều đó, nhưng tôi muốn thấy rằng tôi không điên. Trong dự án của tôi, image.jpg là một tệp nằm trong một số phần của tệp jar chính. Tôi lấy trình tải lớp của lớp chính (SomeClass là điểm nhập) và sử dụng nó để khám phá tài nguyên image.jpg. Sau đó, một số phép thuật phát trực tiếp để đưa nó vào thứ ImageInputStream này và mọi thứ đều ổn.

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

Với một tệp JAR thực tế, bạn có thể liệt kê nội dung bằng cách sử dụng JarFile.entries(). Mặc dù vậy, bạn sẽ cần biết vị trí của tệp JAR - bạn không thể chỉ yêu cầu trình tải lớp liệt kê mọi thứ mà nó có thể nhận được.

Bạn sẽ có thể tìm ra vị trí của tệp JAR dựa trên URL được trả về từ đó ThisClassName.class.getResource("ThisClassName.class"), nhưng nó có thể hơi khó hiểu.

Cách đây một thời gian, tôi đã tạo một hàm nhận classess từ bên trong 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;
}

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

Có hai tiện ích rất hữu ích được gọi là JarScan:

1. www.inetfeedback.com/jarscan

2. jarcan.dev.java.net

Xem thêm câu hỏi này: JarScan, quét tất cả các tệp JAR trong tất cả các thư mục con cho lớp cụ thể

Cơ chế mạnh mẽ nhất để liệt kê tất cả các tài nguyên trong classpath hiện là sử dụng mẫu này với ClassGraph , vì nó xử lý mảng cơ chế đặc tả classpath rộng nhất có thể , bao gồm cả hệ thống mô-đun JPMS mới. (Tôi là tác giả của ClassGraph.)

Làm thế nào để biết tên của tệp JAR nơi lớp chính của tôi sống?

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

Làm cách nào tôi có thể đọc nội dung của một thư mục theo cách tương tự trong tệp JAR?

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

Có rất nhiều cách khác để xử lý tài nguyên .

Chỉ là một cách khác để liệt kê / đọc tệp từ URL jar và nó thực hiện đệ quy cho các lọ lồng nhau

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

Một nữa cho con đường:

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.*;
import java.util.ArrayList;
import java.util.List;

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

public class ResourceWalker {
  private static final PathMatcher FILE_MATCHER =
      FileSystems.getDefault().getPathMatcher( "glob:**.ttf" );

  public static List<Path> walk( final String directory )
      throws URISyntaxException, IOException {
    final List<Path> filenames = new ArrayList<>();
    final var resource = ResourceWalker.class.getResource( directory );

    if( resource != null ) {
      final var uri = resource.toURI();
      final var path = uri.getScheme().equals( "jar" )
          ? newFileSystem( uri, emptyMap() ).getPath( directory )
          : Paths.get( uri );
      final var walk = Files.walk( path, 10 );

      for( final var it = walk.iterator(); it.hasNext(); ) {
        final Path p = it.next();
        if( FILE_MATCHER.matches( p ) ) {
          filenames.add( p );
        }
      }
    }

    return filenames;
  }
}

Điều này linh hoạt hơn một chút để đối sánh với các tên tệp cụ thể vì nó sử dụng ký tự đại diện globbing.

Một phong cách chức năng hơn:

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.*;
import java.util.function.Consumer;

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

/**
 * Responsible for finding file resources.
 */
public class ResourceWalker {
  private static final PathMatcher FILE_MATCHER =
      FileSystems.getDefault().getPathMatcher( "glob:**.ttf" );

  public static void walk( final String dirName, final Consumer<Path> f )
      throws URISyntaxException, IOException {
    final var resource = ResourceWalker.class.getResource( dirName );

    if( resource != null ) {
      final var uri = resource.toURI();
      final var path = uri.getScheme().equals( "jar" )
          ? newFileSystem( uri, emptyMap() ).getPath( dirName )
          : Paths.get( uri );
      final var walk = Files.walk( path, 10 );

      for( final var it = walk.iterator(); it.hasNext(); ) {
        final Path p = it.next();
        if( FILE_MATCHER.matches( p ) ) {
          f.accept( p );
        }
      }
    }
  }
}