Come carico un file dalla cartella delle risorse?

Il mio progetto ha la seguente struttura:

/src/main/java/ /src/main/resources/ /src/test/java/ /src/test/resources/ 

Ho un file in /src/test/resources/test.csv e voglio caricare il file da un test di unità in /src/test/java/MyTest.java

Ho questo codice che non ha funzionato. Si lamenta “Nessun file o directory”.

 BufferedReader br = new BufferedReader (new FileReader(test.csv)) 

Ho anche provato questo

 InputStream is = (InputStream) MyTest.class.getResourcesAsStream(test.csv)) 

Anche questo non funziona. Restituisce null . Sto usando Maven per build il mio progetto.

Prova il prossimo:

 ClassLoader classloader = Thread.currentThread().getContextClassLoader(); InputStream is = classloader.getResourceAsStream("test.csv"); 

Se quanto sopra non funziona, vari progetti sono stati aggiunti alla seguente class: ClassLoaderUtil 1 (codice qui ). 2

Ecco alcuni esempi di come viene usata quella class:

  src \ Main \ java \ com \ società \ test \ YourCallingClass.java 
  src \ Main \ java \ com \ OpenSymphony \ xwork2 \ util \ ClassLoaderUtil.java 
  src \ principali risorse \ \ test.csv 
 // java.net.URL URL url = ClassLoaderUtil.getResource("test.csv", YourCallingClass.class); Path path = Paths.get(url.toURI()); List lines = Files.readAllLines(path, StandardCharsets.UTF_8); 
 // java.io.InputStream InputStream inputStream = ClassLoaderUtil.getResourceAsStream("test.csv", YourCallingClass.class); InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8); BufferedReader reader = new BufferedReader(streamReader); for (String line; (line = reader.readLine()) != null;) { // Process line } 

Gli appunti

  1. Guardalo in The Wayback Machine .
  2. Anche in GitHub .

Provare:

 InputStream is = MyTest.class.getResourceAsStream("/test.csv"); 

IIRC getResourceAsStream() per impostazione predefinita è relativo al pacchetto della class.

Ecco una soluzione rapida con l’uso di Guava :

 import com.google.common.base.Charsets; import com.google.common.io.Resources; public String readResource(final String fileName, Charset charset) throws IOException { return Resources.toString(Resources.getResource(fileName), charset); } 

Uso:

 String fixture = this.readResource("filename.txt", Charsets.UTF_8) 

Prova i codici di Flowing sul progetto Spring

 ClassPathResource resource = new ClassPathResource("fileName"); InputStream inputStream = resource.getInputStream(); 

O su un progetto non di spring

  ClassLoader classLoader = getClass().getClassLoader(); File file = new File(classLoader.getResource("fileName").getFile()); InputStream inputStream = new FileInputStream(file); 

Ora sto illustrando il codice sorgente per leggere un font dalla directory delle risorse create da maven,

scr / main / risorse / calibril.ttf

inserisci la descrizione dell'immagine qui

 Font getCalibriLightFont(int fontSize){ Font font = null; try{ URL fontURL = OneMethod.class.getResource("/calibril.ttf"); InputStream fontStream = fontURL.openStream(); font = new Font(Font.createFont(Font.TRUETYPE_FONT, fontStream).getFamily(), Font.PLAIN, fontSize); fontStream.close(); }catch(IOException | FontFormatException ief){ font = new Font("Arial", Font.PLAIN, fontSize); ief.printStackTrace(); } return font; } 

Ha funzionato per me e spero che anche l’intero codice sorgente ti aiuti, divertiti!

 ClassLoader loader = Thread.currentThread().getContextClassLoader(); InputStream is = loader.getResourceAsStream("test.csv"); 

Se si utilizza il contesto ClassLoader per trovare una risorsa, sicuramente le prestazioni dell’applicazione saranno costate.

Il codice funziona quando non si esegue il jar di Maven-build, ad esempio quando si esegue dall’IDE? In tal caso, assicurati che il file sia effettivamente incluso nel contenitore. La cartella delle risorse dovrebbe essere inclusa nel file pom, in .

La seguente class può essere utilizzata per caricare una resource dal classpath e ricevere anche un messaggio di errore appropriato nel caso in cui ci sia un problema con il filePath .

 import java.io.InputStream; import java.nio.file.NoSuchFileException; public class ResourceLoader { private String filePath; public ResourceLoader(String filePath) { this.filePath = filePath; if(filePath.startsWith("/")) { throw new IllegalArgumentException("Relative paths may not have a leading slash!"); } } public InputStream getResource() throws NoSuchFileException { ClassLoader classLoader = this.getClass().getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream(filePath); if(inputStream == null) { throw new NoSuchFileException("Resource file not found. Note that the current directory is the source folder!"); } return inputStream; } } 

getResource () funzionava bene con i file di risorse inseriti solo in src/main/resources . Per ottenere un file che si trova sul percorso diverso da src/main/resources dire src/test/java è necessario crearlo in modo esplicito.

il seguente esempio può aiutarti

 import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.net.URISyntaxException; import java.net.URL; public class Main { public static void main(String[] args) throws URISyntaxException, IOException { URL location = Main.class.getProtectionDomain().getCodeSource().getLocation(); BufferedReader br = new BufferedReader(new FileReader(location.getPath().toString().replace("/target/classs/", "/src/test/java/youfilename.txt"))); } } 

Ho risolto questo problema aggiungendo la cartella /scr/main/resources al mio Java Build Path

inserisci la descrizione dell'immagine qui

Ho capito che funziona senza alcun riferimento a “class” o “ClassLoader”.

Diciamo che abbiamo tre scenari con la posizione del file ‘example.file’ e la tua directory di lavoro (dove viene eseguita l’app) è home / mydocuments / program / projects / myapp:

a) Una sottocartella discendente alla directory di lavoro: myapp / res / files / example.file

b) Una sottocartella non discendente alla directory di lavoro: projects / files / example.file

b2) Un’altra sottocartella non discendente alla directory di lavoro: programma / file / esempio.file

c) Una cartella radice: home / mydocuments / files / example.file (Linux; in Windows sostituire home / con C 🙂

1) Ottieni il percorso giusto: a) String path = "res/files/example.file"; b) String path = "../projects/files/example.file" b2) String path = "../../program/files/example.file" c) String path = "/home/mydocuments/files/example.file"

In sostanza, se si tratta di una cartella radice, avviare il nome del percorso con una barra iniziale. Se si tratta di una sottocartella, non deve esserci alcuna barra prima del nome del percorso. Se la sottocartella non è discendente alla directory di lavoro, devi eseguirne il cd usando “../”. Questo dice al sistema di andare su una cartella.

2) Creare un object File passando il percorso corretto:

 File file = new File(path); 

3) Ora sei a posto:

 BufferedReader br = new BufferedReader(new FileReader(file));