spring怎么加载json文件路径

Spring Boot 中优雅加载 JSON 文件的多种路径实现方式**

在 Spring Boot 应用开发中，我们经常需要加载外部的 JSON 配置文件、数据文件或模板文件，Spring 框架提供了多种灵活的方式来加载这些 JSON 文件，这些方法可以让我们在不同场景下选择最合适的方案，本文将详细介绍几种在 Spring 中加载 JSON 文件路径的常用方法。

使用 `@Value` 注解加载（适用于简单场景）

@Value 注解是 Spring 提供的用于注入配置值的便捷方式，它也可以直接用于加载 JSON 文件的内容，前提是 JSON 文件的内容能够被直接解析为字符串。

适用场景：JSON 文件内容较小，且只需要将其作为字符串读取，或者配合 @ConfigurationProperties 进行进一步绑定。

实现步骤：

放置 JSON 文件：将 JSON 文件放置在 src/main/resources 目录下。config/data.json。

使用 @Value 读取：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class JsonConfigLoader {
    @Value("classpath:config/data.json") // 使用 classpath: 前缀
    private String jsonData; // 读取为字符串
    public void printJsonData() {
        System.out.println("Loaded JSON data as string:");
        System.out.println(jsonData);
        // 这里可以使用如 Jackson, Gson 等库将字符串解析为对象
        //  ObjectMapper objectMapper = new ObjectMapper();
        // MyDataObject data = objectMapper.readValue(jsonData, MyDataObject.class);
    }
}

说明：

classpath: 前缀表示从 classpath 根目录下查找文件，如果文件在 src/main/resources 下，直接写 filename.json 即可。
这种方式读取的是文件的全部内容作为字符串。

使用 `ResourceLoader` 或 `@Autowired` 注入 `Resource`（更灵活）

当需要更灵活地控制资源加载，或者获取 Resource 对象进行进一步操作（如获取文件输入流）时，可以使用 ResourceLoader 或直接注入 Resource。

适用场景：需要获取 Resource 对象本身，或者需要手动处理文件输入流,例如读取较大文件或进行复杂操作。

实现步骤：

注入 ResourceLoader：

import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.io.InputStream;
@Component
public class JsonResourceLoader {
    private final ResourceLoader resourceLoader;
    @Autowired // 或者使用构造器注入
    public JsonResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
    public void loadAndProcessJson() {
        try {
            // Resource 可以是 classpath 文件或文件系统文件
            Resource resource = resourceLoader.getResource("classpath:config/data.json");
            if (resource.exists()) {
                System.out.println("Resource found: " + resource.getFilename());
                System.out.println("Resource URL: " + resource.getURL());
                try (InputStream inputStream = resource.getInputStream()) {
                    // 使用 inputStream 读取 JSON 文件内容
                    // 使用 ObjectMapper.readValue(inputStream, MyDataObject.class)
                    System.out.println("Successfully got input stream from JSON resource.");
                }
            } else {
                System.out.println("Resource not found!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

直接注入 Resource（结合 @Value）：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Component;
import java.io.IOException;
@Component
public class JsonDirectResourceLoader {
    @Value("classpath:config/data.json")
    private Resource jsonResource;
    public void processJsonResource() {
        try {
            if (jsonResource.exists()) {
                System.out.println("Direct Resource loaded: " + jsonResource.getFilename());
                // 使用 Jackson 等库直接读取 Resource
                // ObjectMapper objectMapper = new ObjectMapper();
                // MyDataObject data = objectMapper.readValue(jsonResource.getInputStream(), MyDataObject.class);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

说明：

ResourceLoader 提供了更通用的资源加载能力，支持多种资源协议（classpath:, file:, http: 等）。
Resource 对象封装了底层资源，可以方便地获取文件名、URL、输入流等信息。

使用 `@ConfigurationProperties` 绑定（推荐用于配置类）

JSON 文件的结构与 Java 对象（POJO/DTO）的结构对应，那么使用 @ConfigurationProperties 是最优雅的方式，Spring Boot 会自动将 JSON 文件的内容绑定到配置属性类上。

适用场景：JSON 文件是配置文件，其结构与 Java 类属性一一对应。

实现步骤：

创建 JSON 文件：src/main/resources/config/app-config.json

{
  "app-name": "My Spring App",
  "version": "1.0.0",
  "features": {
    "enable-logging": true,
    "max-connections": 100
  }
}

创建配置属性类：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@ConfigurationProperties // 默认从 application.properties/yml 读取，结合 @PropertySource 指定 JSON 文件
@PropertySource(name = "appConfig", value = "classpath:config/app-config.json") // Spring Boot 2.4+ 推荐使用这种方式
public class AppConfigProperties {
    private String appName;
    private String version;
    private Features features;
    // 内部类对应 JSON 中的嵌套对象
    public static class Features {
        private boolean enableLogging;
        private int maxConnections;
        // getters and setters
        public boolean isEnableLogging() { return enableLogging; }
        public void setEnableLogging(boolean enableLogging) { this.enableLogging = enableLogging; }
        public int getMaxConnections() { return maxConnections; }
        public void setMaxConnections(int maxConnections) { this.maxConnections = maxConnections; }
    }
    // getters and setters
    public String getAppName() { return appName; }
    public void setAppName(String appName) { this.appName = appName; }
    public String getVersion() { return version; }
    public void setVersion(String version) { this.version = version; }
    public Features getFeatures() { return features; }
    public void setFeatures(Features features) { this.features = features; }
}

使用配置属性：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class AppService {
    private final AppConfigProperties appConfigProperties;
    @Autowired
    public AppService(AppConfigProperties appConfigProperties) {
        this.appConfigProperties = appConfigProperties;
    }
    public void displayConfig() {
        System.out.println("App Name: " + appConfigProperties.getAppName());
        System.out.println("Version: " + appConfigProperties.getVersion());
        System.out.println("Enable Logging: " + appConfigProperties.getFeatures().isEnableLogging());
    }
}

说明：

@PropertySource 默认不支持 JSON 文件，但在 Spring Boot 2.4+ 中，通过引入 spring-boot-configuration-processor 和正确配置，可以支持，或者，可以使用自定义的 JsonPropertySourceFactory。
更推荐的方式是将 JSON 文件放在 application-{profile}.json 的位置，Spring Boot 会自动加载，或者使用 spring.config.import 属性（Spring Boot 2.4+）来导入 JSON 配置文件。

使用 `Jackson` 或 `Gson` 手动解析（灵活但需手动管理）

对于更复杂的 JSON 处理，或者不希望依赖 Spring 的自动绑定机制时，可以直接使用 Jackson 或 Gson 等库手动解析。

适用场景：需要复杂的 JSON 映射逻辑，或者 JSON 文件结构多变，不便于用固定的 POJO 表示。

实现步骤（以 Jackson 为例）：

添加依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

手动加载和解析：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Component;
import java.io.File;
import java.io.IOException;
@Component
public class JsonManualParser {
    public void parseJsonFromFile() {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 方法1：使用 ClassPathResource
            ClassPathResource resource = new Class

正文

spring怎么加载json文件路径

使用 `@Value` 注解加载（适用于简单场景）

使用 `ResourceLoader` 或 `@Autowired` 注入 `Resource`（更灵活）

使用 `@ConfigurationProperties` 绑定（推荐用于配置类）

使用 `Jackson` 或 `Gson` 手动解析（灵活但需手动管理）

相关阅读

json的payload是什么

怎么去掉json重复key