在 Spring Boot 应用开发中，资源文件的读取方式在本地调试与生产环境部署时存在显著差异。当应用以可执行 Jar 形式运行时，ClassPathResource.getFile() 方法会抛出异常，原因是 Jar 包内的资源条目无法映射为文件系统的物理路径。本文将系统梳理这一问题的技术背景，并提供五种经过验证的应对策略。

技术背景：类加载机制的差异

IDE 中运行时，Maven 将 src/main/resources 下的文件复制到 target/classes 目录，此时资源以独立文件形式存在。而打包后，所有内容被压缩为单一归档文件，操作系统无法直接解析 Jar 内部的条目路径。Java 类加载器设计为通过 InputStream 访问这类资源，而非提供 java.io.File 句柄。

关键代码对比：

// 本地运行：成功
// Jar 运行：失败，抛出 FileNotFoundException
File physicalFile = resource.getFile();

// 两种环境均适用
InputStream contentStream = resource.getInputStream();

方案一：基于输入流的通用读取

彻底放弃文件路径依赖，改用流式 API 处理资源内容。适用于配置文件解析、文本读取等场景。

import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;

@Component
public class ConfigLoader {
    
    private final ResourceLoader loader;
    
    public ConfigLoader(ResourceLoader loader) {
        this.loader = loader;
    }
    
    public Map<String, String> parseSettings(String location) throws IOException {
        org.springframework.core.io.Resource res = 
            loader.getResource("classpath:" + location);
        
        Map<String, String> result = new HashMap<>();
        
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(res.getInputStream(), StandardCharsets.UTF_8))) {
            
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.trim().isEmpty() || line.startsWith("#")) continue;
                String[] pair = line.split("=", 2);
                if (pair.length == 2) {
                    result.put(pair[0].trim(), pair[1].trim());
                }
            }
        }
        return result;
    }
}

方案二：利用 ResourceUtils 的兼容性封装

Spring 提供的 ResourceUtils 工具类封装了环境差异判断逻辑，可根据运行环境自动选择最优访问方式。

import org.springframework.util.ResourceUtils;

public byte[] fetchBinaryData(String path) throws IOException {
    java.io.File file;
    try {
        // 尝试获取物理文件（非 Jar 环境）
        file = ResourceUtils.getFile("classpath:" + path);
        return java.nio.file.Files.readAllBytes(file.toPath());
    } catch (FileNotFoundException ex) {
        // Jar 环境回退到流读取
        try (InputStream fallback = getClass()
                .getClassLoader()
                .getResourceAsStream(path)) {
            if (fallback == null) {
                throw new IOException("Resource unavailable: " + path);
            }
            return fallback.readAllBytes();
        }
    }
}

方案三：提取至临时文件系统

当第三方库强制要求 java.io.File 参数时，可将 Jar 内资源复制到临时目录。

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

@Component
public class TempFileExtractor {
    
    public java.io.File extractToFilesystem(String pattern) throws IOException {
        PathMatchingResourcePatternResolver resolver = 
            new PathMatchingResourcePatternResolver();
        
        Resource[] matches = resolver.getResources(pattern);
        if (matches.length == 0) {
            throw new FileNotFoundException("No match for: " + pattern);
        }
        
        Resource target = matches[0];
        String originalName = target.getFilename();
        
        // 创建临时文件并标记删除
        java.io.File temp = java.io.File.createTempFile("extracted_", "_" + originalName);
        temp.deleteOnExit();
        
        try (InputStream src = target.getInputStream();
             FileOutputStream dst = new FileOutputStream(temp)) {
            src.transferTo(dst);
        }
        
        return temp;
    }
}

方案四：Servlet 上下文路径适配

Web 应用可通过 ServletContext 获取资源的真实路径，适用于静态资源部署在可解压 WAR 的场景。

import jakarta.servlet.ServletContext;

@Service
public class WebResourceAccessor {
    
    @Autowired
    private ServletContext servletCtx;
    
    public Optional<String> resolveRealPath(String webPath) {
        String absolute = servletCtx.getRealPath(webPath);
        return Optional.ofNullable(absolute)
                     .filter(p -> new java.io.File(p).exists());
    }
    
    public void serveViaStream(String webPath, OutputStream out) throws IOException {
        try (InputStream in = servletCtx.getResourceAsStream(webPath)) {
            if (in == null) {
                throw new FileNotFoundException(webPath);
            }
            in.transferTo(out);
        }
    }
}

方案五：构建期资源预处理

在 Maven 构建阶段将关键资源输出到指定目录，运行时通过外部路径访问，彻底规避 Jar 内读取限制。

<!-- pom.xml 配置示例 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-external-config</id>
                    <phase>package</phase>
                    <goals><goal>copy-resources</goal></goals>
                    <configuration>
                        <outputDirectory>
                            ${project.build.directory}/external
                        </outputDirectory>
                        <resources>
                            <resource>
                                <directory>src/main/resources/config</directory>
                                <includes><include>**/*.properties</include></includes>
                            </resource>
                        </resources>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

运行时加载逻辑：

@Value("${external.config.location:./external}")
private String externalBase;

public Properties loadExternalSettings() throws IOException {
    java.nio.file.Path configDir = java.nio.file.Paths.get(externalBase);
    java.nio.file.Path target = configDir.resolve("application.properties");
    
    try (InputStream in = java.nio.file.Files.newInputStream(target)) {
        Properties p = new Properties();
        p.load(in);
        return p;
    }
}

策略选型建议

场景特征	推荐方案	注意事项
纯读取操作，无需文件句柄	方案一（流式读取）	避免重复打开流，使用 try-with-resources
需兼容本地与 Jar 两种模式	方案二（ResourceUtils）	异常处理分支需完整测试
第三方 API 强制要求 File 对象	方案三（临时提取）	及时清理临时文件，防止磁盘膨胀
传统 WAR 部署模式	方案四（ServletContext）	确认应用服务器是否解压部署
配置需运维人员动态调整	方案五（构建期分离）	外部目录权限与备份策略

理解 Jar 文件格式与类加载器的工作机制，是选择正确方案的前提。流式访问作为 JVM 的原生支持，应作为首选设计；仅在必要时才诉诸临时文件或外部化策略，以保持部署结构的简洁性。