offene Ressource mit relativem Pfad in Java

Question

In meiner Java-Anwendung muß ich einige Dateien und Verzeichnisse erhalten.

Dies ist die Programmstruktur:

./main.java
./package1/guiclass.java
./package1/resources/resourcesloader.java
./package1/resources/repository/modules/   -> this is the dir I need to get
./package1/resources/repository/SSL-Key/cert.jks    -> this is the file I need to get

guiclass lädt die resourcesloader Klasse, die meine Ressourcen geladen werden (Verzeichnis und Datei).

In Bezug auf die Datei habe ich versucht,

resourcesloader.class.getClass().getResource("repository/SSL-Key/cert.jks").toString()

, um den wirklichen Weg zu bekommen, aber auf diese Weise nicht funktioniert.

Ich habe keine Ahnung, wie das Verzeichnis zu tun.

Answer 1

Geben Sie den Pfad in Bezug auf die Klassenlader, nicht die Klasse, Sie bekommen die Lader aus. Zum Beispiel:

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();

Answer 2

hatte ich Probleme mit der getClass().getResource("filename.txt") Methode. Beim Lesen der Java-Dokumentation Anweisungen, wenn Ihre Ressource nicht in demselben Paket ist wie die Klasse, die Sie von der Ressource zuzugreifen versuchen, dann haben Sie ihm relativen Pfad zu geben, mit '/' beginnen. Die empfohlene Strategie ist Ihre Ressource-Dateien unter „Ressourcen“ Ordner im Stammverzeichnis zu setzen. So zum Beispiel, wenn Sie haben die Struktur:

src/main/com/mycompany/myapp

dann können Sie einen Ressourcen-Ordner hinzufügen, wie von Maven empfohlen in:

src/main/resources

Darüber hinaus können Sie Unterordner im Ressourcen-Ordner hinzufügen

src/main/resources/textfiles

und sagen, dass Ihre Datei myfile.txt genannt wird, so dass Sie haben

src/main/resources/textfiles/myfile.txt

Jetzt ist hier, wo das dumme Wege-Problem kommt in. Sagen Sie bitte eine Klasse in Ihrem com.mycompany.myapp package haben, und Sie mögen die myfile.txt Datei von Ihren Ressource-Ordnern zugreifen. Einige sagen, dass Sie das geben:

"/main/resources/textfiles/myfile.txt" path

oder

"/resources/textfiles/myfile.txt"

Beide sind falsch. Nachdem ich mvn clean compile lief, werden die Dateien und Ordner in die kopiert:

myapp/target/classes 

Ordner. Aber die Ressourcen-Ordner gibt es nicht, nur die Ordner in den Ordner Ressourcen. So haben Sie:

myapp/target/classes/textfiles/myfile.txt

myapp/target/classes/com/mycompany/myapp/*

so der korrekte Pfad zur getClass().getResource("") Methode zu geben:

"/textfiles/myfile.txt"

hier ist sie:

getClass().getResource("/textfiles/myfile.txt")

Das wird nicht mehr null zurück, sondern wird Ihre Klasse zurück. Ich hoffe, das jemand hilft. Es ist mir fremd, dass der "resources" Ordner nicht so gut kopiert, sondern nur die Unterordner und Dateien direkt im "resources" Ordner. Es scheint mir logisch, dass der "resources" Ordner würde auch unter "myapp/target/classes" gefunden werden

Answer 3

In der Hoffnung, die Bereitstellung zusätzliche Informationen für diejenigen, die dies so schnell nicht wie andere abholen, würde Ich mag mein Szenario schaffen, wie es ein etwas anderes Setup hat. Mein Projekt war Setup mit der folgenden Verzeichnisstruktur (mit Eclipse):

Project/
  src/                // application source code
    org/
      myproject/
        MyClass.java
  test/               // unit tests
  res/                // resources
    images/           // PNG images for icons
      my-image.png
    xml/              // XSD files for validating XML files with JAXB
      my-schema.xsd
    conf/             // default .conf file for Log4j
      log4j.conf
  lib/                // libraries added to build-path via project settings

Ich habe Probleme meine Ressourcen aus dem Laden res Verzeichnis. Ich wollte alle meine Ressourcen von meinem Quellcode trennen (nur für Managment / Organisation Zwecke). Also, was ich tun musste, war hinzufügen die res Verzeichnis des build-Pfad und dann Zugriff auf die Ressource über:

static final ClassLoader loader = MyClass.class.getClassLoader();

// in some function
loader.getResource("images/my-image.png");
loader.getResource("xml/my-schema.xsd");
loader.getResource("conf/log4j.conf");

Hinweis: Die / von Anfang an der Ressource String weggelassen, weil ich bin mit ClassLoader.getResource (String) anstelle von Class.getResource (String) .

Answer 4

@GianCarlo: Sie können versuchen, Systemeigenschaft user.dir aufrufen, die Sie Wurzel Ihrer Java-Projekt geben und dann diesen Weg beispielsweise an die relativen Pfad tun anhängen:

String root = System.getProperty("user.dir");
String filepath = "/path/to/yourfile.txt"; // in case of Windows: "\\path \\to\\yourfile.txt
String abspath = root+filepath;



// using above path read your file into byte []
File file = new File(abspath);
FileInputStream fis = new FileInputStream(file);
byte []filebytes = new byte[(int)file.length()];
fis.read(filebytes);

Answer 5

Wenn Sie auf einer Klasse ‚getResource‘ verwenden, wird ein relativer Pfad auf der Verpackung aufgelöst basiert die Klasse ist in. Wenn Sie auf einem Classloader ‚getResource‘ verwenden, um ein relativer Pfad basierend auf dem Stammordner aufgelöst wird.

Wenn Sie einen absoluten Pfad verwenden, die beide ‚getResource‘ Methoden im Stammordner gestartet werden.

Answer 6

Für diejenigen mit Eclipse + Maven. Angenommen, Sie versuchen, die Datei images/pic.jpg in src/main/resources zuzugreifen. Doing es so aus:

ClassLoader loader = MyClass.class.getClassLoader();
File file = new File(loader.getResource("images/pic.jpg").getFile());

ist vollkommen richtig, aber in einer Null-Zeiger Ausnahme führen. Scheint, wie Eclipse die Ordner in der Maven-Verzeichnisstruktur als Quellordner sofort nicht erkennt. Durch das Entfernen und die src/main/resources Ordner aus dem Quellordner Liste des Projektes und legt es zurück (Projekt> Eigenschaften> Java-Build-Pfad> source> entfernen / hinzufügen, Ordner), konnte ich dieses Problem zu lösen.

Answer 7

resourcesloader.class.getClass()

abgebaut werden kann:

Class<resourcesloader> clazz = resourceloader.class;
Class<Class> classClass = clazz.getClass();

Was bedeutet, Sie versuchen, die Ressource mit einer Bootstrap-Klasse zu laden.

Stattdessen möchten Sie wahrscheinlich so etwas wie:

resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

Wenn nur javac gewarnt Aufruf statische Methoden auf nicht-statischen Kontexten ...

Answer 8

Doe folgende Arbeiten?

resourcesloader.class.getClass().getResource("/package1/resources/repository/SSL-Key/cert.jks")

Gibt es einen Grund, warum Sie nicht den vollständigen Pfad einschließlich der Verpackung angeben können?

Answer 9

Möchten Sie die beiden Antworten, wie oben erwähnt. Die erste

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();
resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

Sollte ein und derselben Sache sein?

Answer 10

habe ich eine kleine Änderung an einer Auskleidung des @ jonathan.cone (von .getFile() Hinzufügen) Null-Zeiger-Ausnahme zu vermeiden, und den Pfad zum Datenverzeichnis einstellen. Hier ist, was für mich gearbeitet:

String realmID = new java.util.Scanner(new java.io.File(RandomDataGenerator.class.getClassLoader().getResource("data/aa-qa-id.csv").getFile().toString())).next();

Answer 11

verwenden:

resourcesloader.class.getClassLoader().getResource("/path/to/file").**getPath();**

Answer 12

Um echten Pfad zur Datei zu erhalten, können Sie dies versuchen:

URL fileUrl = Resourceloader.class.getResource("resources/repository/SSL-Key/cert.jks");
String pathToClass = fileUrl.getPath;    

Resource ist classname hier. "Ressourcen / repository / SSL-Key / cert.jks" ist relativ Pfad zur Datei. Wenn Sie Ihren guiclass in ./package1/java mit dem Rest der Ordnerstruktur verbleibenden hätten, würden Sie wegen Regeln definieren relativen Pfad „../resources/repository/SSL-Key/cert.jks“ als relativer Pfad nehmen.

So können Sie Ihre Datei mit BufferedReader lesen kann. NICHT DEN STRING verwenden Sie den Pfad zur Datei zu identifizieren, denn wenn man Räume haben oder einige Zeichen von nicht Englisch Alphabet in den Weg, gibt es Probleme, und die Datei wird nicht gefunden werden.

BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(fileUrl.openStream()));