Lesen einer Ressourcendatei aus dem Glas

Ich möchte eine Ressource aus meinem Glas so lesen:

File file;
file = new File(getClass().getResource("/file.txt").toURI());
BufferredReader reader = new BufferedReader(new FileReader(file));

//Read the file

und es funktioniert gut, wenn es in Eclipse ausgeführt wird, aber wenn ich es in ein JAR exportiere, gibt es eine IllegalArgumentException:

Exception in thread "Thread-2"
java.lang.IllegalArgumentException: URI is not hierarchical

und ich weiß wirklich nicht warum, aber bei einigen Tests habe ich festgestellt, ob ich mich ändere

file = new File(getClass().getResource("/file.txt").toURI());

zu

file = new File(getClass().getResource("/folder/file.txt").toURI());

dann funktioniert es umgekehrt (es funktioniert im Glas, aber nicht in der Finsternis).

Ich verwende Eclipse und der Ordner mit meiner Datei befindet sich in einem Klassenordner.

Anstatt zu versuchen, die Ressource als Datei zu adressieren, bitten Sie den ClassLoader , stattdessen über getResourceAsStream einen InputStream für die Ressource zurückzugeben :

InputStream in = getClass().getResourceAsStream("/file.txt"); 
BufferedReader reader = new BufferedReader(new InputStreamReader(in));

Solange die file.txtRessource im Klassenpfad verfügbar ist, funktioniert dieser Ansatz auf dieselbe Weise, unabhängig davon, ob sich die file.txtRessource in einem classes/Verzeichnis oder in einem befindet jar.

Das URI is not hierarchicaltritt auf, weil die URI für eine Ressource innerhalb einer JAR - Datei wird in etwa so aussehen werde: file:/example.jar!/file.txt. Sie können die Einträge in einer jar(einer zipDatei) nicht lesen, als wäre es eine einfache alte Datei .

Dies wird gut erklärt durch die Antworten auf:

• Wie lese ich eine Ressourcendatei aus einer Java-JAR-Datei?
• Java Jar-Datei: Ressourcenfehler verwenden: URI ist nicht hierarchisch

Um auf eine Datei in einem Glas zuzugreifen, haben Sie zwei Möglichkeiten:

• Platzieren Sie die Datei in einer Verzeichnisstruktur, die Ihrem Paketnamen entspricht (nach dem Extrahieren der JAR-Datei sollte sie sich im selben Verzeichnis wie die .class-Datei befinden), und greifen Sie dann mit darauf zu getClass().getResourceAsStream("file.txt")

• Platzieren Sie die Datei im Stammverzeichnis (nach dem Extrahieren der JAR-Datei sollte sie sich im Stammverzeichnis befinden) und greifen Sie dann mit darauf zu Thread.currentThread().getContextClassLoader().getResourceAsStream("file.txt")

Die erste Option funktioniert möglicherweise nicht, wenn jar als Plugin verwendet wird.

Ich hatte dieses Problem schon einmal und habe einen Fallback-Weg zum Laden gemacht. Grundsätzlich funktioniert der erste Weg innerhalb einer JAR-Datei und der zweite Weg innerhalb von Eclipse oder einer anderen IDE.

public class MyClass {

    public static InputStream accessFile() {
        String resource = "my-file-located-in-resources.txt";

        // this is the path within the jar file
        InputStream input = MyClass.class.getResourceAsStream("/resources/" + resource);
        if (input == null) {
            // this is how we load file within editor (eg eclipse)
            input = MyClass.class.getClassLoader().getResourceAsStream(resource);
        }

        return input;
    }
}

Bis jetzt (Dezember 2017) ist dies die einzige Lösung, die ich gefunden habe und die sowohl innerhalb als auch außerhalb der IDE funktioniert .

Verwenden Sie PathMatchingResourcePatternResolver

Hinweis: Es funktioniert auch im Spring-Boot

In diesem Beispiel lese ich einige Dateien in src / main / resources / my_folder :

try {
    // Get all the files under this inner resource folder: my_folder
    String scannedPackage = "my_folder/*";
    PathMatchingResourcePatternResolver scanner = new PathMatchingResourcePatternResolver();
    Resource[] resources = scanner.getResources(scannedPackage);

    if (resources == null || resources.length == 0)
        log.warn("Warning: could not find any resources in this scanned package: " + scannedPackage);
    else {
        for (Resource resource : resources) {
            log.info(resource.getFilename());
            // Read the file content (I used BufferedReader, but there are other solutions for that):
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.getInputStream()));
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                // ...
                // ...                      
            }
            bufferedReader.close();
        }
    }
} catch (Exception e) {
    throw new Exception("Failed to read the resources folder: " + e.getMessage(), e);
}

Das Problem ist, dass bestimmte Bibliotheken von Drittanbietern Dateipfadnamen anstelle von Eingabestreams benötigen. Die meisten Antworten sprechen dieses Problem nicht an.

In diesem Fall besteht eine Problemumgehung darin, den Ressourceninhalt in eine temporäre Datei zu kopieren. Im folgenden Beispiel werden jUnits verwendet TemporaryFolder.

    private List<String> decomposePath(String path){
        List<String> reversed = Lists.newArrayList();
        File currFile = new File(path);
        while(currFile != null){
            reversed.add(currFile.getName());
            currFile = currFile.getParentFile();
        }
        return Lists.reverse(reversed);
    }

    private String writeResourceToFile(String resourceName) throws IOException {
        ClassLoader loader = getClass().getClassLoader();
        InputStream configStream = loader.getResourceAsStream(resourceName);
        List<String> pathComponents = decomposePath(resourceName);
        folder.newFolder(pathComponents.subList(0, pathComponents.size() - 1).toArray(new String[0]));
        File tmpFile = folder.newFile(resourceName);
        Files.copy(configStream, tmpFile.toPath(), REPLACE_EXISTING);
        return tmpFile.getAbsolutePath();
    }

Wenn Sie als Datei lesen möchten, gibt es meiner Meinung nach immer noch eine ähnliche Lösung:

    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource("file/test.xml").getFile());

Stellen Sie sicher, dass Sie mit dem richtigen Trennzeichen arbeiten. Ich habe alle /in einem relativen Pfad durch a ersetzt File.separator. Dies funktionierte in der IDE einwandfrei, in der Build-JAR jedoch nicht.

Ich denke, das sollte auch in Java funktionieren. Der folgende Code, den ich benutze, verwendet Kotlin.

val resource = Thread.currentThread().contextClassLoader.getResource('resources.txt')

Ich habe eine Lösung gefunden

BufferedReader br = new BufferedReader(new InputStreamReader(Main.class.getResourceAsStream(path)));

Ersetzen Sie "Main" durch die Java-Klasse, in der Sie es codiert haben. Ersetzen Sie "path" durch den Pfad in der JAR-Datei.

Wenn Sie beispielsweise State1.txt in das Paket com.issac.state einfügen, geben Sie den Pfad als "/ com / issac / state / State1" ein, wenn Sie Linux oder Mac ausführen. Wenn Sie Windows ausführen, geben Sie den Pfad als "\ com \ issac \ state \ State1" ein. Fügen Sie der Datei die Erweiterung .txt nur hinzu, wenn die Ausnahme Datei nicht gefunden auftritt.

Sie können den Klassenlader verwenden, der aus dem Klassenpfad als ROOT-Pfad liest (ohne "/" am Anfang).

InputStream in = getClass().getClassLoader().getResourceAsStream("file.txt"); 
BufferedReader reader = new BufferedReader(new InputStreamReader(in));

Wenn Sie spring verwenden, können Sie die folgende Methode verwenden, um Dateien aus src / main / resources zu lesen:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.springframework.core.io.ClassPathResource;

  public String readFileToString(String path) throws IOException {

    StringBuilder resultBuilder = new StringBuilder("");
    ClassPathResource resource = new ClassPathResource(path);

    try (
        InputStream inputStream = resource.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) {

      String line;

      while ((line = bufferedReader.readLine()) != null) {
        resultBuilder.append(line);
      }

    }

    return resultBuilder.toString();
  }

Aus irgendeinem Grund wurde classLoader.getResource()immer null zurückgegeben, wenn ich die Webanwendung für WildFly 14 bereitgestellt habe. ClassLoader von null wird abgerufen getClass().getClassLoader()oder Thread.currentThread().getContextClassLoader()zurückgegeben.

getClass().getClassLoader() API-Dokument sagt,

"Gibt den Klassenlader für die Klasse zurück. Einige Implementierungen verwenden möglicherweise null, um den Bootstrap-Klassenlader darzustellen. Diese Methode gibt in solchen Implementierungen null zurück, wenn diese Klasse vom Bootstrap-Klassenlader geladen wurde."

Wenn Sie WildFly und Ihre Webanwendung verwenden, versuchen Sie dies möglicherweise

request.getServletContext().getResource()gab die Ressourcen-URL zurück. Hier ist request ein Objekt von ServletRequest.

Der folgende Code funktioniert mit Spring Boot (Kotlin):

val authReader = InputStreamReader(javaClass.getResourceAsStream("/file1.json"))