如何从资源文件夹加载文件？

Question

我的项目具有以下结构：

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

我在/src/test/resources/test.csv 中有一个文件，我想从/src/test/java中的单元测试中加载文件/mytest.java

我有此代码，该代码不起作用。它抱怨“没有这样的文件或目录”。

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

我也尝试过

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

这也行不通。它返回 null 。我正在使用Maven来构建我的项目。

Answer 1

尝试下一个：

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

---

如果以上不起作用，则添加了以下类别的各个项目： classLoaderutil ¹ （代码在这里）。 ²

这是一些如何使用该类的示例：

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
}

---

notes

1. 在中看到它 Wayback Machine 。
2. 同样在 github 。

Answer 2

尝试：

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

IIRC getResourceasStream（）默认情况下是相对于类的软件包。

正如@terran所指出的，不要忘记在文件名开始时添加/

Answer 3

尝试遵循春季项目

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

或非春季项目上的代码

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

Answer 4

这是一个快速解决方案，使用 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);
}

用法：

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

Answer 5

非春季项目：

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

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

或者

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

InputStream in = new FileInputStream(filePath);

对于春季项目，您还可以使用一个行代码在Resources文件夹下获取任何文件：

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

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

Answer 6

对于Java 1.7

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

另外，如果您在Spring Echosystem中可以使用Spring Utils，可以使用Spring

final val file = ResourceUtils.getFile("classpath:json/abcd.json");

Utils，以了解更多现场，请在博客

https://todzhang.com/blogs/tech/en/save_resources_to_files

Answer 7

我面对同一问题。

该文件是由类加载程序找到的，这意味着它没有包装到工件中（JAR）。您需要构建项目。例如，使用Maven：

mvn clean package

因此，您添加到Resources文件夹的文件将进入Maven构建，并可用于应用程序。

我想保持答案：它没有解释如何读取文件（其他答案确实解释了），它回答为什么 inputStream 或资源>代码>是 null 。类似答案在这里。

Answer 8

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

如果您使用上下文classloader查找资源，那么它肯定会花费应用程序性能。

Answer 9

现在，我说明了读取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;
}

​你，享受！

Answer 10

导入以下内容：

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

以下方法返回字符串阵列列表中的文件：

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

Answer 11

您可以使用com.google.common.io.resources.getResource读取文件的URL，然后使用java.nio.file.files获取文件内容以读取文件的内容。

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

Answer 12

如果要以静态方法加载文件，则
classloader classloader = getClass（）。getClassloader（）;
这可能会给您带来错误。

你可以尝试这个
例如，您要从资源加载的文件是资源＆gt;＆gt;图像＆gt;＆gt; test.gif

import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

Resource resource = new ClassPathResource("Images/Test.gif");

File file = resource.getFile();

Answer 13

GetResource（）仅在 src/main/resources 中放置的资源文件工作正常。要获取 src/main/resources Say src/test/java 以外的路径上的文件，您需要先于固定地创建它。

以下示例可能会帮助您

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

Answer 14

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

Answer 15

要从SRC/Resources文件夹中读取文件，然后尝试以下操作：

DataSource fds = new FileDataSource(getFileHandle("images/sample.jpeg"));

public static File getFileHandle(String fileName){
       return new File(YourClassName.class.getClassLoader().getResource(fileName).getFile());
}

如果没有静态参考：

return new File(getClass().getClassLoader().getResource(fileName).getFile());

Answer 16

对于Kotlin，我正在做以下操作：

1. 我在项目中创建了一个资产文件夹
   （对于Android Studio，转到文件 - ＆gt; new-＆gt; folder - ＆gt; Assets文件夹）
2. 将我的资产（.txt文件）复制到此文件夹中
3. ，然后我使用下面的代码

导入这些项目：

    import android.content.Context
    import android.util.Log
    import java.io.FileNotFoundException

我创建了这样的函数：这​​样：

    fun loadBook(context: Context) {
       val assetManager = context.assets
       try {
          val inputStream = assetManager?.open("19-Psalms.usfm")
          val lineList = mutableListOf<String>()

          inputStream?.bufferedReader()?.forEachLine { lineList.add(it) }
          lineList.forEach{println(">  $it")}
      }
      catch (e:FileNotFoundException) {
          Log.e("FileNotFoundException","File not found")
      }
    }
 

Answer 17

例如，从IDE运行时，该代码在不运行maven-build jar时是否有效？如果是这样，请确保文件实际上包含在JAR中。资源文件夹应包含在＆lt;构建中的POM文件中。

Answer 18

以下类可用于从 classPath 中加载资源，并且还会收到一条拟合错误消息，以防给定 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;
    }
}

Answer 19

即使我遵循答案，也找不到我在测试文件夹中的文件。它通过重建项目来解决。似乎Intellij并未自动识别新文件。很讨厌找出答案。

Answer 20

我通过写作作为在运行罐子和IDE上的工作

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

Answer 21

我目前正在这样做。

这是我的结构。

final String path =   "src/test/resources/archivos/B-163.txt";
final Path filePath = Path.of( path );
final String documento = Files.readString( filePath );
         
log.debug("DOCUMENTO: {}" , document); 

我正在与Java 11一起工作。

Answer 22

对于Kotlin：

import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.Paths

val lines = Files.readAllLines(
    Paths.get((object {}).javaClass.getResource("videos.txt").toURI()),
    StandardCharsets.UTF_8
)

lines // will contain list of lines in a file

Answer 23

如果要获取文件对象：

File file = new File(this.getClass().getClassLoader().getResource("test.csv").toURI())

Answer 24

从资源文件夹中加载文件作为流，

以便在资源文件夹中访问文件，您应该使用方法

// From non-static context
InputStream is = getClass().getClassLoader().getResourceAsStream("test.txt");

// From static context
InputStream is = MyClass.class.getClassLoader().getResourceAsStream("test.txt");

无论您的应用程序正在开发，测试还是构建，这种方法都可以访问资源。实际上，当使用Maven或Gradle等构建工具时，将资源从 ../ src/main/resources 复制到 target/class/class 或构建的根部/类。基本上， getResourCeasStream（）方法以独立于代码的位置的方式授予您通过类代码访问资源。

从资源文件夹中加载文件java.io.file

或者，如果您需要一个 java.io.file ，您可以使用 方法将资源检索为 url ，并创建一个文件来自资源路径或URI。但是，使用URI需要处理 urisyntaxexception 。

// From non-static context
File f1 = new File(getClass().getClassLoader().getResource("test.txt").getPath());
File f2 = new File(getClass().getClassLoader().getResource("test.txt").toURI());

// From static context
File f1 = new File(MyClass.class.getClassLoader().getResource("test.txt").getPath());
File f2 = new File(MyClass.class.getClassLoader().getResource("test.txt").toURI());

从资源文件夹加载文件java.nio.file.path

，如果您需要一个 java.nio.file.path ，您可以使用静态方法 path.of（） （来自JDK 11）带有资源URI的路径。

// From non-static context
Path p = Path.of(getClass().getClassLoader().getResource("test.txt").toURI());

// From static context
Path p = Path.of(Main.class.getClassLoader().getResource("test.txt").toURI());

Answer 25

这对我来说很好：

InputStream in = getClass().getResourceAsStream("/main/resources/xxx.xxx");
InputStreamReader streamReader = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(streamReader);
String content = "";
for (String line; (line = reader.readLine()) != null;) {
    content += line;
}

Answer 26

我可以将其工作起作用，而无需提及“类”或“ ClassLoader”。

假设我们有三种情况，即文件“示例”的位置，您的工作目录（您的应用程序执行）是Home/myDocuments/program/projection/myapp：

a）工作目录的子文件夹后代：
myApp/res/files/xplove.file

b）一个非后代的子文件夹：工作目录：
projects/files/example.file

b2）另一个子文件夹不是工作目录的后代：
程序/文件/示例。文件

c）根文件夹：
home/mydocuments/files/example.file（linux;在Windows中替换为Home/c :)

1）获取正确的路径：
a）字符串路径=“ res/files/example.file”;
b）字符串路径=“ ../ projects/files/example.file”
b2）字符串路径=“ ../../ program/files/example.file”
c）字符串路径=“/home/mydocuments/files/example.file”

基本上，如果它是根文件夹，请使用领先的斜杠启动路径名。
如果是子文件夹，则不得在路径名之前进行斜杠。如果子文件夹不是工作目录的后代，则必须使用“ ../”来cd。这告诉系统上一个文件夹。

2）通过传递正确的路径来创建文件对象：

File file = new File(path);

3）您现在很好：

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