Bagaimana cara membuat daftar file di dalam file JAR?

Saya memiliki kode ini yang membaca semua file dari direktori.

    File textFolder = new File("text_directory");

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

Ini bekerja dengan baik. Ini mengisi array dengan semua file yang diakhiri dengan ".txt" dari direktori "text_directory".

Bagaimana saya bisa membaca isi direktori dengan cara yang sama di dalam file JAR?

Jadi yang benar-benar ingin saya lakukan adalah, mencantumkan semua gambar di dalam file JAR saya, sehingga saya dapat memuatnya dengan:

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

(Yang itu berfungsi karena "CompanyLogo" adalah "hardcode" tetapi jumlah gambar di dalam file JAR bisa dari 10 hingga 200 panjang variabel.)

EDIT

Jadi saya kira masalah utama saya adalah: Bagaimana cara mengetahui nama file JAR dimana kelas utama saya tinggal?

Memang saya bisa membacanya menggunakan java.util.Zip.

Struktur saya seperti ini:

Mereka seperti:

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 

Sekarang saya bisa memuat misalnya "images / image01.png" menggunakan:

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

Tapi hanya karena saya tahu nama filenya, selebihnya saya harus memuatnya secara dinamis.

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

Perhatikan bahwa di Java 7, Anda dapat membuat FileSystemdari file JAR (zip), lalu menggunakan mekanisme berjalan dan pemfilteran direktori NIO untuk mencarinya. Ini akan mempermudah penulisan kode yang menangani JAR dan direktori "meledak".

Kode yang berfungsi untuk file IDE dan .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());
        }
    }
}

jawaban erickson bekerja dengan sempurna:

Inilah kode kerja.

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

Dan saya baru saja mengubah metode pemuatan saya dari ini:

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

Untuk ini:

String  [] webimages = ...

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

Saya ingin memperluas jawaban acheron55 , karena ini adalah solusi yang sangat tidak aman, karena beberapa alasan:

1. Itu tidak menutup FileSystemobjek.
2. Itu tidak memeriksa apakah FileSystemobjek sudah ada.
3. Ini tidak aman untuk benang.

Ini adalah solusi yang lebih aman:

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

Tidak perlu melakukan sinkronisasi melalui nama file; seseorang dapat dengan mudah melakukan sinkronisasi pada objek yang sama setiap saat (atau membuat metodesynchronized ), ini murni pengoptimalan.

Saya akan mengatakan bahwa ini masih merupakan solusi yang bermasalah, karena mungkin ada bagian lain dalam kode yang menggunakan FileSystemantarmuka di atas file yang sama, dan itu dapat mengganggu mereka (bahkan dalam satu aplikasi berulir).
Juga, itu tidak memeriksa nulls (misalnya, padagetClass().getResource() .

Antarmuka Java NIO khusus ini agak mengerikan, karena ia memperkenalkan sumber daya non-thread-safe global / tunggal, dan dokumentasinya sangat kabur (banyak yang tidak diketahui karena implementasi khusus penyedia). Hasil dapat berbeda untuk FileSystempenyedia lain (bukan JAR). Mungkin ada alasan bagus untuk itu; Saya tidak tahu, saya belum meneliti implementasinya.

Jadi saya kira masalah utama saya adalah, bagaimana mengetahui nama toples tempat kelas utama saya tinggal.

Dengan asumsi bahwa proyek Anda dikemas dalam Jar (tidak harus benar!), Anda dapat menggunakan ClassLoader.getResource () atau findResource () dengan nama kelas (diikuti oleh .class) untuk mendapatkan jar yang berisi kelas tertentu. Anda harus mengurai nama jar dari URL yang dikembalikan (tidak terlalu sulit), yang akan saya tinggalkan sebagai latihan untuk pembaca :-)

Pastikan untuk menguji kasus yang kelasnya bukan bagian dari toples.

Saya telah mentransfer jawaban acheron55 ke Java 7 dan menutup FileSystemobjek. Kode ini bekerja di IDE, di file jar dan di jar di dalam perang melawan Tomcat 7; tetapi perhatikan bahwa itu tidak berfungsi di stoples di dalam perang terhadap JBoss 7 (itu memberi FileSystemNotFoundException: Provider "vfs" not installed, lihat juga posting ini ). Selain itu, seperti kode aslinya, ini bukan thread safe, seperti yang disarankan oleh errr . Untuk alasan ini saya telah meninggalkan solusi ini; namun, jika Anda dapat menerima masalah ini, berikut adalah kode siap pakai saya:

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

Berikut adalah metode yang saya tulis untuk "menjalankan semua JUnits di bawah paket". Anda harus bisa menyesuaikannya dengan kebutuhan Anda.

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

Edit: Ah, dalam hal ini, Anda mungkin menginginkan cuplikan ini juga (kasus penggunaan yang sama :))

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

Berikut adalah contoh penggunaan pustaka Refleksi untuk memindai jalur kelas secara rekursif dengan pola nama regex yang ditambah dengan beberapa fasilitas Guava untuk mengambil konten sumber daya:

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

Ini bekerja dengan toples dan kelas yang meledak.

File jar hanyalah file zip dengan manifes terstruktur. Anda dapat membuka file jar dengan alat java zip biasa dan memindai isi file dengan cara itu, memompa aliran, dll. Kemudian menggunakannya dalam panggilan getResourceAsStream, dan itu harus semua keren dory.

EDIT / setelah klarifikasi

Saya butuh satu menit untuk mengingat semua bagian dan saya yakin ada cara yang lebih bersih untuk melakukannya, tetapi saya ingin melihat bahwa saya tidak gila. Dalam proyek saya image.jpg adalah file di beberapa bagian dari file jar utama. Saya mendapatkan pemuat kelas dari kelas utama (SomeClass adalah titik masuk) dan menggunakannya untuk menemukan sumber daya image.jpg. Kemudian beberapa keajaiban aliran untuk memasukkannya ke dalam hal ImageInputStream ini dan semuanya baik-baik saja.

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

Diberikan file JAR yang sebenarnya, Anda dapat membuat daftar isinya menggunakan JarFile.entries(). Anda perlu mengetahui lokasi file JAR - Anda tidak bisa hanya meminta classloader untuk mencantumkan semua yang bisa didapatnya.

Anda harus dapat menentukan lokasi file JAR berdasarkan URL yang dikembalikan dari ThisClassName.class.getResource("ThisClassName.class"), tetapi ini mungkin sedikit rumit.

Beberapa waktu lalu saya membuat sebuah fungsi yang mendapat classess dari dalam 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;
}

Ada dua utilitas yang sangat berguna yang disebut JarScan:

1. www.inetfeedback.com/jarscan

2. jarscan.dev.java.net

Lihat juga pertanyaan ini: JarScan, pindai semua file JAR di semua subfolder untuk kelas tertentu

Mekanisme paling kuat untuk mencantumkan semua resource di classpath saat ini menggunakan pola ini dengan ClassGraph , karena pola ini menangani larik mekanisme spesifikasi classpath seluas mungkin , termasuk sistem modul JPMS yang baru. (Saya adalah penulis ClassGraph.)

Bagaimana cara mengetahui nama file JAR tempat kelas utama saya tinggal?

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

Bagaimana saya bisa membaca isi direktori dengan cara yang sama di dalam file JAR?

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

Ada banyak cara lain untuk menangani sumber daya juga.

Hanya cara yang berbeda untuk mendaftar / membaca file dari URL jar dan melakukannya secara rekursif untuk toples bersarang

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

Satu lagi untuk jalan:

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

Ini sedikit lebih fleksibel untuk mencocokkan nama file tertentu karena menggunakan penggabungan karakter pengganti.

Gaya yang lebih fungsional:

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