apri la risorsa con relativo percorso in java

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 class resourceloader che caricherà le mie risorse (directory e file).

Per quanto riguarda il file, ho provato

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

per ottenere il vero percorso, ma in questo modo non funziona.

Non ho idea di come fare la directory.

Fornisci il percorso relativo al classloader, non alla class da cui stai caricando il caricatore. Per esempio:

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

Ho avuto problemi con l’utilizzo del getClass().getResource("filename.txt") . Leggendo le istruzioni dei documenti Java, se la tua risorsa non si trova nello stesso pacchetto della class a cui stai tentando di accedere alla risorsa, devi dargli il percorso relativo che inizia con '/' . La strategia raccomandata consiste nel mettere i file delle risorse in una cartella “risorse” nella directory principale. Quindi per esempio se hai la struttura:

 src/main/com/mycompany/myapp 

quindi puoi aggiungere una cartella delle risorse come consigliato da Maven in:

 src/main/resources 

inoltre è ansible aggiungere sottocartelle nella cartella delle risorse

 src/main/resources/textfiles 

e dì che il tuo file si chiama myfile.txt così hai

 src/main/resources/textfiles/myfile.txt 

Ora è qui che entra in gioco lo stupido problema. Dì che hai una class nel tuo com.mycompany.myapp package e vuoi accedere al file myfile.txt dalla tua cartella delle risorse. Alcuni dicono che devi dare il:

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

o

 "/resources/textfiles/myfile.txt" 

entrambi sono sbagliati. Dopo aver eseguito mvn clean compile , i file e le cartelle vengono copiati nel:

 myapp/target/classs 

cartella. Ma la cartella delle risorse non è lì, solo le cartelle nella cartella delle risorse. Quindi hai:

 myapp/target/classs/textfiles/myfile.txt myapp/target/classs/com/mycompany/myapp/* 

quindi il percorso corretto da dare al getClass().getResource("") è:

 "/textfiles/myfile.txt" 

Ecco qui:

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

Questo non restituirà più nulla, ma restituirà la tua class. Spero che questo aiuti qualcuno. È strano per me che la cartella "resources" non venga copiata, ma solo le sottocartelle e i file direttamente nella cartella "resources" . Mi sembra logico che la cartella "resources" sia trovata anche in "myapp/target/classs"

Nella speranza di fornire ulteriori informazioni a coloro che non lo ritengono così veloce come gli altri, vorrei fornire il mio scenario in quanto ha una configurazione leggermente diversa. Il mio progetto è stato configurato con la seguente struttura di directory (usando Eclipse):

 Progetto/
   src / // codice sorgente dell'applicazione
     org /
       il mio progetto/
         MyClass.java
   test / // test di unità
   res / // risorse
     images / // immagini PNG per icone
       my-image.png
     xml / // File XSD per la convalida di file XML con JAXB
       my-schema.xsd
     conf / // file .conf predefinito per Log4j
       log4j.conf
   librerie lib / // aggiunte a build-path tramite le impostazioni del progetto

Stavo riscontrando problemi nel caricare le mie risorse dalla directory res . Volevo che tutte le mie risorse si separassero dal mio codice sorgente (semplicemente per scopi di gestione / organizzazione). Quindi, quello che dovevo fare era aggiungere la directory di ricerca al percorso di costruzione e quindi accedere alla risorsa tramite:

 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 dall’inizio della stringa di risorse perché sto usando ClassLoader.getResource (String) invece di Class.getResource (String) .

@GianCarlo: puoi provare a chiamare la proprietà System.dir.utente che ti darà la radice del tuo progetto java e quindi aggiungere questo percorso al tuo 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); 

Quando si utilizza ‘getResource’ su una class, un percorso relativo viene risolto in base al pacchetto in cui si trova la class. Quando si utilizza ‘getResource’ su un ClassLoader, viene risolto un percorso relativo basato sulla cartella principale.

Se si utilizza un percorso assoluto, entrambi i metodi ‘getResource’ inizieranno nella cartella principale.

Per chi usa eclipse + maven. Dì che provi ad accedere al file images/pic.jpg in src/main/resources . Facendolo 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 del puntatore nullo. Sembra che Eclipse non riconosca subito le cartelle nella struttura di directory di Maven come cartelle di origine. Rimuovendo e rimuovendo la cartella src/main/resources dall’elenco delle cartelle di origine del progetto e rimettendola (progetto> proprietà> percorso java build> origine> rimuovi / aggiungi cartella), sono stato in grado di risolverlo.

 resourcesloader.class.getClass() 

Può essere suddiviso in:

 Class clazz = resourceloader.class; Class classClass = clazz.getClass(); 

Il che significa che stai provando a caricare la risorsa usando una class bootstrap.

Invece probabilmente vorresti qualcosa come:

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

Se solo javac avesse avvertito di chiamare metodi statici su contesti non statici …

Doe il seguente lavoro?

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

C’è un motivo per cui non è ansible specificare il percorso completo incluso il pacchetto?

Andando con le due risposte come menzionato sopra. 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 stessa cosa?

Ho apportato una piccola modifica al file di @ jonathan.cone (aggiungendo .getFile() ) per evitare l’eccezione del puntatore nullo e impostare il percorso della directory dei 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(); 

Usa questo:

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