Wie kann ich eine Ressource "Ordner" aus meiner JAR-Datei abrufen?

Ich habe einen Ressourcenordner / ein Ressourcenpaket im Stammverzeichnis meines Projekts. Ich möchte eine bestimmte Datei "nicht" laden. Wenn ich eine bestimmte Datei laden wollte, würde ich class.getResourceAsStream verwenden und mir würde es gut gehen !! Was ich eigentlich tun möchte, ist, einen "Ordner" in den Ressourcenordner zu laden, die Dateien in diesem Ordner zu durchlaufen und einen Stream zu jeder Datei zu erhalten und den Inhalt einzulesen ... Angenommen, die Dateinamen werden nicht vor der Laufzeit bestimmt ... Was soll ich machen? Gibt es eine Möglichkeit, eine Liste der Dateien in einem Ordner in Ihrer JAR-Datei abzurufen? Beachten Sie, dass die Jar-Datei mit den Ressourcen dieselbe JAR-Datei ist, aus der der Code ausgeführt wird ...

Danke im Voraus...

Schließlich fand ich die Lösung:

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

Der zweite Block funktioniert nur, wenn Sie die Anwendung auf IDE ausführen (nicht mit JAR-Datei). Sie können ihn entfernen, wenn Ihnen das nicht gefällt.

Versuche Folgendes. Erstellen
Sie den Ressourcenpfad. "<PathRelativeToThisClassFile>/<ResourceDirectory>"Wenn Ihr Klassenpfad beispielsweise com.abc.package.MyClass lautet und sich Ihre Ressourcendateien in src / com / abc / package / resources / befinden:

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

Sie können auch verwenden

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

Ich weiß, das ist viele Jahre her. Aber nur für andere Leute stoßen Sie auf dieses Thema. Sie können eine getResourceAsStream()Methode mit dem Verzeichnispfad verwenden, und der Eingabestream enthält alle Dateinamen aus diesem Verzeichnis. Danach können Sie den Verzeichnispfad mit jedem Dateinamen verknüpfen und getResourceAsStream für jede Datei in einer Schleife aufrufen.

Ich hatte das gleiche Problem, als ich versuchte, einige Hadoop-Konfigurationen von Ressourcen zu laden, die in der JAR gepackt waren ... sowohl auf der IDE als auch auf der JAR (Release-Version).

Ich fand java.nio.file.DirectoryStreames am besten, Verzeichnisinhalte sowohl über das lokale Dateisystem als auch über das JAR zu durchlaufen.

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

Der folgende Code gibt den gewünschten "Ordner" als Pfad zurück, unabhängig davon, ob er sich in einem Glas befindet oder nicht.

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

Benötigt Java 7+.

Eine andere Lösung, die Sie folgendermaßen durchführen können ResourceLoader:

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

Einfach ... benutze OSGi. In OSGi können Sie die Einträge Ihres Bundles mit findEntries und findPaths durchlaufen.

In meiner JAR-Datei befand sich ein Ordner namens "Hochladen". In diesem Ordner befanden sich drei weitere Textdateien. Ich musste genau denselben Ordner und dieselben Dateien außerhalb der JAR-Datei haben. Ich habe den folgenden Code verwendet:

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

Wie die anderen Antworten zeigen, werden die Dinge wirklich hässlich, sobald sich die Ressourcen in einer JAR-Datei befinden. In unserem Fall ist diese Lösung:

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

funktioniert sehr gut in den Tests (da der Code beim Ausführen der Tests nicht in eine JAR-Datei gepackt wird), funktioniert aber nicht, wenn die App tatsächlich normal ausgeführt wird. Also habe ich ... die Liste der Dateien in der App fest codiert, aber ich habe einen Test, der die tatsächliche Liste von der Festplatte liest (kann dies tun, da dies in Tests funktioniert) und fehlschlägt, wenn die tatsächliche Liste nicht funktioniert stimmt nicht mit der Liste überein, die die App zurückgibt.

Auf diese Weise habe ich einfachen Code in meiner App (keine Tricks), und ich bin sicher, ich habe dank des Tests nicht vergessen, einen neuen Eintrag in die Liste aufzunehmen.

Dieser Link zeigt Ihnen, wie.

Die Magie ist die Methode getResourceAsStream ():

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