SpringBoot项目中resources文件读取实践

InputStream inputStream = getClass().getClassLoader().getResourceAsStream("config/sample.txt");

InputStream inputStream = getClass().getResourceAsStream("/config/sample.txt");

@Resourceprivate 
ResourceLoader resourceLoader;

File file = ResourceUtils.getFile("classpath:config/sample.txt");

@Resourceprivate 
ApplicationContext context;

@Resourceprivate 
ServletContext servletContext;

File file = new File("src/main/resources/config/sample.txt");

Path path = Paths.get("src/main/resources/config/sample.txt");

ClassPathResource resource = new ClassPathResource("config/sample.txt");

package com.icoderoad.resources.controller;

import jakarta.annotation.Resource;
import jakarta.servlet.ServletContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Controller;
import org.springframework.util.FileCopyUtils;
import org.springframework.util.ResourceUtils;
import org.springframework.web.bind.annotation.*;

import java.io.*;
import java.nio.file.*;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/resource/read")
public class ResourceReadController {

    @Autowired
    private ResourceLoader resourceLoader;

    @Autowired
    private ApplicationContext applicationContext;

    @Autowired
    private ServletContext servletContext;

    private final String filePath = "config/sample.txt";

    @GetMapping("/{method}")
    public Map<String, Object> readFile(@PathVariable String method) {
        Map<String, Object> result = new HashMap<>();
        try {
            String content = switch (method) {
                case "classloader" -> readByClassLoader();
                case "class" -> readByClass();
                case "loader" -> readByResourceLoader();
                case "utils" -> readByResourceUtils();
                case "context" -> readByApplicationContext();
                case "servlet" -> readByServletContext();
                case "file" -> readByFile();
                case "nio" -> readByNio();
                case "classpath" -> readByClassPathResource();
                default -> "Unsupported method!";
            };
            result.put("method", method);
            result.put("content", content);
        } catch (Exception e) {
            result.put("error", e.getMessage());
        }
        return result;
    }

    private String readByClassLoader() throws IOException {
        try (InputStream in = getClass().getClassLoader().getResourceAsStream(filePath)) {
            return streamToString(in);
        }
    }

    private String readByClass() throws IOException {
        try (InputStream in = getClass().getResourceAsStream("/" + filePath)) {
            return streamToString(in);
        }
    }

    private String readByResourceLoader() throws IOException {
        org.springframework.core.io.Resource resource = resourceLoader.getResource("classpath:" + filePath);
        try (InputStream in = resource.getInputStream()) {
            return streamToString(in);
        }
    }

    private String readByResourceUtils() throws IOException {
        File file = ResourceUtils.getFile("classpath:" + filePath);
        try (InputStream in = new FileInputStream(file)) {
            return streamToString(in);
        }
    }

    private String readByApplicationContext() throws IOException {
        org.springframework.core.io.Resource resource = applicationContext.getResource("classpath:" + filePath);
        try (InputStream in = resource.getInputStream()) {
            return streamToString(in);
        }
    }

    private String readByServletContext() throws IOException {
        // 仅适用于传统部署模式，如 war 包放入 Tomcat 时
        try (InputStream in = servletContext.getResourceAsStream("/WEB-INF/classes/" + filePath)) {
            return streamToString(in);
        }
    }

    private String readByFile() throws IOException {
        File file = new File("src/main/resources/" + filePath);
        try (InputStream in = new FileInputStream(file)) {
            return streamToString(in);
        }
    }

    private String readByNio() throws IOException {
        Path path = Paths.get("src/main/resources/" + filePath);
        try (InputStream in = Files.newInputStream(path)) {
            return streamToString(in);
        }
    }

    private String readByClassPathResource() throws IOException {
        ClassPathResource resource = new ClassPathResource(filePath);
        try (InputStream in = resource.getInputStream()) {
            return streamToString(in);
        }
    }

    private String streamToString(InputStream in) throws IOException {
        return new String(FileCopyUtils.copyToByteArray(in));
    }
}