¿Cómo cargo un archivo de la carpeta de recursos?

Mi proyecto tiene la siguiente estructura:

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

Tengo un archivo /src/test/resources/test.csvy quiero cargar el archivo desde una prueba unitaria en/src/test/java/MyTest.java

Tengo este código que no funcionó. Se queja "No existe tal archivo o directorio".

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

También probé esto

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

Esto tampoco funciona. Vuelve null. Estoy usando Maven para construir mi proyecto.

Intenta lo siguiente:

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

Si lo anterior no funciona, se han agregado varios proyectos a la siguiente clase: ¹ (código aquí ). ²ClassLoaderUtil

Aquí hay algunos ejemplos de cómo se usa esa clase:

src \ main \ java \ com \ company \ test \ YourCallingClass.java
src \ main \ java \ com \ opensymphony \ xwork2 \ util \ ClassLoaderUtil.java
src \ main \ resources \ test.csv

// java.net.URL
URL url = ClassLoaderUtil.getResource("test.csv", YourCallingClass.class);
Path path = Paths.get(url.toURI());
List<String> 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
}

Notas

1. Véalo en The Wayback Machine .
2. También en GitHub .

Tratar:

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

IIRC getResourceAsStream()por defecto es relativo al paquete de la clase.

Como señaló @Terran, no olvide agregar el /al comienzo del nombre de archivo

Aquí hay una solución rápida con el uso de guayaba :

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)

Pruebe los códigos de flujo en el proyecto Spring

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

O en un proyecto que no sea de primavera

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

Proyecto no primaveral:

String filePath = Objects.requireNonNull(MyClass.class.getClassLoader().getResource("any.json")).getPath();

Stream<String> lines = Files.lines(Paths.get(filePath));

Para proyectos de primavera, también puede usar un código de línea para obtener cualquier archivo en la carpeta de recursos:

File file = ResourceUtils.getFile(ResourceUtils.CLASSPATH_URL_PREFIX + "any.json");

String content = new String(Files.readAllBytes(file.toPath()));

Ahora estoy ilustrando el código fuente para leer una fuente del directorio de recursos creados por Maven,

scr / main / resources / calibril.ttf

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;
}

Funcionó para mí y espero que todo el código fuente también te ayude, ¡Disfruta!

Para java después de 1.7

 List<String> lines = Files.readAllLines(Paths.get(getClass().getResource("test.csv").toURI()));

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

Si utiliza el ClassLoader de contexto para encontrar un recurso, definitivamente le costará el rendimiento de la aplicación.

Importa lo siguiente:

import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;

El siguiente método devuelve un archivo en una ArrayList of Strings:

public ArrayList<String> loadFile(String filename){

  ArrayList<String> lines = new ArrayList<String>();

  try{

    ClassLoader classloader = Thread.currentThread().getContextClassLoader();
    InputStream inputStream = classloader.getResourceAsStream(filename);
    InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    BufferedReader reader = new BufferedReader(streamReader);
    for (String line; (line = reader.readLine()) != null;) {
      lines.add(line);
    }

  }catch(FileNotFoundException fnfe){
    // process errors
  }catch(IOException ioe){
    // process errors
  }
  return lines;
}

Me enfrenté al mismo problema .

El cargador de clases no encontró el archivo, lo que significa que no estaba empaquetado en el artefacto (jar). Necesitas construir el proyecto . Por ejemplo, con maven:

mvn clean install

Por lo tanto, los archivos que agregó a la carpeta de recursos entrarán en la compilación de Maven y estarán disponibles para la aplicación.

Me gustaría conservar mi respuesta: no explica cómo leer un archivo (otras respuestas sí lo explican), responde por qué InputStream o resourcefue nulo . Una respuesta similar está aquí .

getResource () funcionaba bien con los archivos de recursos colocados src/main/resourcessolo. Para obtener un archivo que se encuentra en la ruta de acceso, aparte de src/main/resourcesdecir src/test/java, debe crearlo de forma explícita.

el siguiente ejemplo puede ayudarte

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/classes/", "/src/test/java/youfilename.txt")));
    }
}

¿Funciona el código cuando no se ejecuta el jar Maven-build, por ejemplo, cuando se ejecuta desde su IDE? Si es así, asegúrese de que el archivo esté realmente incluido en el jar. La carpeta de recursos debe incluirse en el archivo pom, en <build><resources>.

La siguiente clase se puede usar para cargar un resourcedesde classpathy también recibir un mensaje de error de ajuste en caso de que haya un problema con el dado 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;
    }
}

Resolví este problema agregando /scr/main/resourcescarpeta a miJava Build Path

Lo hice funcionar tanto en jar jar como en IDE escribiendo como

 InputStream schemaStream = ProductUtil.class.getClassLoader().getResourceAsStream(jsonSchemaPath);
            byte[] buffer = new byte[schemaStream.available()];
            schemaStream.read(buffer);

        File tempFile = File.createTempFile("com/package/schema/testSchema", "json");
        tempFile.deleteOnExit();
        FileOutputStream out = new FileOutputStream(tempFile);
        out.write(buffer);

this.getClass().getClassLoader().getResource("filename").getPath()

Puede usar com.google.common.io.Resources.getResource para leer la url del archivo y luego obtener el contenido del archivo usando java.nio.file.Files para leer el contenido del archivo.

URL urlPath = Resources.getResource("src/main/resource");
List<String> multilineContent= Files.readAllLines(Paths.get(urlPath.toURI()));

Lo hago funcionar sin ninguna referencia a "clase" o "ClassLoader".

Digamos que tenemos tres escenarios con la ubicación del archivo 'example.file' y su directorio de trabajo (donde se ejecuta su aplicación) es home / mydocuments / program / projects / myapp:

a) Una subcarpeta que desciende al directorio de trabajo: myapp / res / files / example.file

b) Una subcarpeta que no desciende al directorio de trabajo: projects / files / example.file

b2) Otra subcarpeta que no desciende al directorio de trabajo: program / files / example.file

c) Una carpeta raíz: home / mydocuments / files / example.file (Linux; en Windows reemplace home / con C :)

1) Obtenga el camino correcto: 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"

Básicamente, si se trata de una carpeta raíz, inicie el nombre de la ruta con una barra diagonal. Si es una subcarpeta, no debe haber una barra inclinada antes del nombre de la ruta. Si la subcarpeta no desciende al directorio de trabajo, debe cd a ella usando "../". Esto le dice al sistema que suba una carpeta.

2) Cree un objeto File pasando la ruta correcta:

File file = new File(path);

3) Ahora estás listo para ir:

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