risorsa aperta con il percorso relativo a Java

Question

Nella mia app Java ho bisogno di ottenere alcuni file e directory.

Questa è la struttura del programma:

./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 carica la classe resourcesloader che caricherà le mie risorse (file e directory).

Per quanto riguarda il file, ho provato

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

al fine di ottenere il percorso vero e proprio, ma in questo modo non funziona.

Non ho idea di come fare la directory.

Answer 1

Fornire il percorso relativo al programma di caricamento classe, non la classe che stai ricevendo il caricatore da. Per esempio:

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

Answer 2

ho avuto problemi con l'utilizzo del metodo getClass().getResource("filename.txt"). Dopo aver letto la documentazione istruzioni Java, se la risorsa non è nello stesso pacchetto come la classe che si sta tentando di accedere alla risorsa da, allora dovete dare percorso relativo inizia con '/'. La strategia consigliata è quella di mettere i file di risorse in una cartella "risorse" nella directory principale. Così, per esempio, se si ha la struttura:

src/main/com/mycompany/myapp

allora si può aggiungere una cartella di risorse come raccomandato da Maven in:

src/main/resources

Inoltre è possibile aggiungere sottocartelle nella cartella risorse

src/main/resources/textfiles

e dire che il file si chiama myfile.txt in modo da avere

src/main/resources/textfiles/myfile.txt

Ora qui è dove il problema percorso stupido entra in gioco. Diciamo che avete un classe nel com.mycompany.myapp package, e si desidera accedere al file myfile.txt dalla cartella delle risorse. Alcuni dicono che è necessario dare il:

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

o

"/resources/textfiles/myfile.txt"

entrambi questi sono sbagliato. Dopo mi sono imbattuto mvn clean compile, i file e le cartelle vengono copiati in:

myapp/target/classes 

cartella. Ma la cartella risorse non è lì, solo le cartelle nella cartella risorse. In modo da avere:

myapp/target/classes/textfiles/myfile.txt

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

in modo che il percorso corretto per dare al metodo getClass().getResource("") è:

"/textfiles/myfile.txt"

qui è:

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

Questo non sarà più tornare null, ma restituirà la vostra classe. Spero che questo aiuta qualcuno. E 'strano per me, che la cartella "resources" non viene copiato pure, ma solo le sottocartelle ei file direttamente nella cartella "resources". Sembrerebbe logico per me che la cartella "resources" sarebbe anche trovato sotto "myapp/target/classes"

Answer 3

Nella speranza di fornire ulteriori informazioni per chi non scegliere questo il più rapidamente gli altri, vorrei offrire il mio scenario in quanto ha una configurazione leggermente diversa. Il mio progetto è stato impostato con la seguente struttura di directory (con 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

ho avuto problemi di caricamento mie risorse dal res di directory. Ho voluto tutte le mie risorse separano dal mio codice sorgente (solo per scopi di managment / organizzazione). Quindi, quello che dovevo fare era aggiungere il res directory al build-percorso e quindi accedere alla risorsa attraverso:

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

Nota: Il / è omesso a partire dall'inizio della stringa di risorsa perché sto usando ClassLoader.getResource (String) invece di Class.getResource (String) .

Answer 4

@GianCarlo: Si può provare a chiamare user.dir proprietà del sistema che vi darà radice del proprio progetto Java e quindi non aggiungere questo percorso del percorso relativo, ad esempio:

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

Quando si utilizza 'getResource' su una classe, un percorso relativo è stato risolto sulla base del pacchetto la classe è in. Quando si utilizza 'getResource' su un ClassLoader, un percorso relativo viene risolto in base alla cartella principale.

Se si utilizza un percorso assoluto, metodi sia 'getResource' inizieranno alla cartella principale.

Answer 6

Per coloro che utilizzano Eclipse + Maven. Diciamo che tenta di accedere al file images/pic.jpg in src/main/resources. Facendo in questo modo:

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

è perfettamente corretto, ma può causare un'eccezione di puntatore nullo. Sembra che Eclipse non riconosce le cartelle nella struttura di directory Maven come cartelle di origine subito. Con la rimozione e la cartella src/main/resources dalla lista cartelle di origine del progetto e rimetterlo (progetto> proprietà> java percorso di generazione> fonte> rimuovere / Aggiungi cartella), sono stato in grado di risolvere questo.

Answer 7

resourcesloader.class.getClass()

Può essere ripartiti in:

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

Il che significa che si sta cercando di caricare la risorsa utilizzando una classe di bootstrap.

Invece probabilmente si desidera qualcosa di simile:

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

Se solo javac avvertito di chiamare i metodi statici in contesti non-statiche ...

Answer 8

Doe i seguenti lavori?

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

C'è una ragione per cui non è possibile specificare il percorso completo compreso il pacchetto?

Answer 9

Vuoi utilizzare i due risposte come accennato in precedenza. Il primo

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

Dovrebbe essere una e stessa cosa?

Answer 10

Ho fatto una piccola modifica su un rivestimento di @ jonathan.cone (aggiungendo .getFile()) per evitare eccezione puntatore nullo, e l'impostazione del percorso di directory di dati. Ecco cosa ha funzionato per me:

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

Answer 11

Utilizzare questa:

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

Answer 12

Al fine di ottenere reali percorso del file si può provare questo:

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

Resourceloader è nomeclasse qui. "Le risorse / repository / SSL-chiave / cert.jks" è il percorso relativo al file. Se avete avuto la vostra guiclass in ./package1/java con resto della struttura delle cartelle rimanenti, si dovrebbe prendere "../resources/repository/SSL-Key/cert.jks" come percorso relativo a causa di regole che definiscono percorso relativo.

In questo modo è possibile leggere il file con BufferedReader. NON utilizzare la stringa per identificare il percorso del file, perché se si dispone di spazi o alcuni personaggi non alfabeto inglese nel percorso, si otterrà i problemi e non sarà trovato il file.

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