Come posso ottenere una "cartella" di risorse dall'interno del mio file jar?

Ho una cartella / pacchetto di risorse nella radice del mio progetto, "non" voglio caricare un determinato file. Se volessi caricare un certo file, userei class.getResourceAsStream e andrei bene !! Quello che voglio effettivamente fare è caricare una "Cartella" all'interno della cartella delle risorse, eseguire il ciclo sui File all'interno di quella Cartella e ottenere uno Stream su ciascun file e leggere il contenuto ... Supponiamo che i nomi dei File non siano determinati prima del runtime ... Cosa dovrei fare? C'è un modo per ottenere un elenco dei file all'interno di una cartella nel file jar? Si noti che il file Jar con le risorse è lo stesso file jar da cui viene eseguito il codice ...

Grazie in anticipo...

Alla fine ho trovato la soluzione:

final String path = "sample/folder";
final File jarFile = new File(getClass().getProtectionDomain().getCodeSource().getLocation().getPath());

if(jarFile.isFile()) {  // Run with JAR file
    final JarFile jar = new JarFile(jarFile);
    final Enumeration<JarEntry> entries = jar.entries(); //gives ALL entries in jar
    while(entries.hasMoreElements()) {
        final String name = entries.nextElement().getName();
        if (name.startsWith(path + "/")) { //filter according to the path
            System.out.println(name);
        }
    }
    jar.close();
} else { // Run with IDE
    final URL url = Launcher.class.getResource("/" + path);
    if (url != null) {
        try {
            final File apps = new File(url.toURI());
            for (File app : apps.listFiles()) {
                System.out.println(app);
            }
        } catch (URISyntaxException ex) {
            // never happens
        }
    }
}

Il secondo blocco funziona solo quando esegui l'applicazione su IDE (non con file jar), puoi rimuoverlo se non ti piace.

Prova quanto segue.
Crea il percorso delle risorse "<PathRelativeToThisClassFile>/<ResourceDirectory>" Ad esempio se il percorso della tua classe è com.abc.package.MyClass e i tuoi file di risoluzione sono all'interno di src / com / abc / package / resources /:

URL url = MyClass.class.getResource("resources/");
if (url == null) {
     // error - missing folder
} else {
    File dir = new File(url.toURI());
    for (File nextFile : dir.listFiles()) {
        // Do something with nextFile
    }
}

Puoi anche usare

URL url = MyClass.class.getResource("/com/abc/package/resources/");

So che è molti anni fa. Ma solo per le altre persone si imbattono in questo argomento. Quello che potresti fare è usare il getResourceAsStream()metodo con il percorso della directory, e lo Stream di input avrà tutti i nomi dei file da quella directory. Successivamente è possibile concaticare il percorso dir con ciascun nome di file e chiamare getResourceAsStream per ciascun file in un ciclo.

Ho avuto lo stesso problema a portata di mano mentre stavo tentando di caricare alcune configurazioni hadoop dalle risorse contenute nel vaso ... sia sull'IDE che sul vaso (versione di rilascio).

Ho scoperto java.nio.file.DirectoryStreamdi funzionare al meglio per scorrere i contenuti della directory sia sul filesystem locale che sul jar.

String fooFolder = "/foo/folder";
....

ClassLoader classLoader = foofClass.class.getClassLoader();
try {
    uri = classLoader.getResource(fooFolder).toURI();
} catch (URISyntaxException e) {
    throw new FooException(e.getMessage());
} catch (NullPointerException e){
    throw new FooException(e.getMessage());
}

if(uri == null){
    throw new FooException("something is wrong directory or files missing");
}

/** i want to know if i am inside the jar or working on the IDE*/
if(uri.getScheme().contains("jar")){
    /** jar case */
    try{
        URL jar = FooClass.class.getProtectionDomain().getCodeSource().getLocation();
        //jar.toString() begins with file:
        //i want to trim it out...
        Path jarFile = Paths.get(jar.toString().substring("file:".length()));
        FileSystem fs = FileSystems.newFileSystem(jarFile, null);
        DirectoryStream<Path> directoryStream = Files.newDirectoryStream(fs.getPath(fooFolder));
        for(Path p: directoryStream){
            InputStream is = FooClass.class.getResourceAsStream(p.toString()) ;
        performFooOverInputStream(is);
        /** your logic here **/
            }
    }catch(IOException e) {
        throw new FooException(e.getMessage());     
    }
}
else{
    /** IDE case */
    Path path = Paths.get(uri);
    try {
        DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path);
        for(Path p : directoryStream){
            InputStream is = new FileInputStream(p.toFile());
            performFooOverInputStream(is);
        }
    } catch (IOException _e) {
        throw new FooException(_e.getMessage());
    }
}

Il codice seguente restituisce la "cartella" desiderata come Percorso indipendentemente dal fatto che si trovi all'interno di un vaso o meno.

  private Path getFolderPath() throws URISyntaxException, IOException {
    URI uri = getClass().getClassLoader().getResource("folder").toURI();
    if ("jar".equals(uri.getScheme())) {
      FileSystem fileSystem = FileSystems.newFileSystem(uri, Collections.emptyMap(), null);
      return fileSystem.getPath("path/to/folder/inside/jar");
    } else {
      return Paths.get(uri);
    }
  }

Richiede java 7+.

Un'altra soluzione, puoi farlo usando ResourceLoadercosì:

import org.springframework.core.io.Resource;
import org.apache.commons.io.FileUtils;

@Autowire
private ResourceLoader resourceLoader;

...

Resource resource = resourceLoader.getResource("classpath:/path/to/you/dir");
File file = resource.getFile();
Iterator<File> fi = FileUtils.iterateFiles(file, null, true);
while(fi.hasNext()) {
    load(fi.next())
}

Semplice ... usa OSGi. In OSGi puoi scorrere le voci del tuo pacchetto con findEntries e findPaths.

All'interno del mio file jar avevo una cartella chiamata Upload, questa cartella aveva tre altri file di testo al suo interno e avevo bisogno di avere esattamente la stessa cartella e file al di fuori del file jar, ho usato il codice qui sotto:

URL inputUrl = getClass().getResource("/upload/blabla1.txt");
File dest1 = new File("upload/blabla1.txt");
FileUtils.copyURLToFile(inputUrl, dest1);

URL inputUrl2 = getClass().getResource("/upload/blabla2.txt");
File dest2 = new File("upload/blabla2.txt");
FileUtils.copyURLToFile(inputUrl2, dest2);

URL inputUrl3 = getClass().getResource("/upload/blabla3.txt");
File dest3 = new File("upload/Bblabla3.txt");
FileUtils.copyURLToFile(inputUrl3, dest3);

Come indicano le altre risposte, una volta che le risorse sono all'interno di un file jar, le cose diventano davvero brutte. Nel nostro caso, questa soluzione:

https://stackoverflow.com/a/13227570/516188

funziona molto bene nei test (poiché quando i test vengono eseguiti il ​​codice non è impacchettato in un file jar), ma non funziona quando l'app viene effettivamente eseguita normalmente. Quindi quello che ho fatto è ... Ho hardcode l'elenco dei file nell'app, ma ho un test che legge l'elenco effettivo dal disco (può farlo dal momento che funziona nei test) e fallisce se l'elenco effettivo non lo fa non corrisponde all'elenco restituito dall'app.

In questo modo ho un semplice codice nella mia app (nessun trucco) e sono sicuro di non aver dimenticato di aggiungere una nuova voce nell'elenco grazie al test.

Questo link ti dice come.

La magia è il metodo getResourceAsStream ():

InputStream is = 
this.getClass().getClassLoader().getResourceAsStream("yourpackage/mypackage/myfile.xml")