Spring Boot中动态更新文件读取与数据库持久化教程

InputStream inputStream = MasterList.class.getResourceAsStream("/json/file.json");

app.data.json-file-path=/path/to/your/external/json/file.json
# 或者使用相对路径，但需确保应用程序有权限访问
# app.data.json-file-path=./data/file.json

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.io.InputStream; // 仍然可以使用，但需要从Files.newInputStream获取

// ... 其他导入

@Value("${app.data.json-file-path}")
private String jsonFilePath;

public void readFileAndPersist() {
    ObjectMapper mapper = new ObjectMapper();
    TypeReference<List<Master>> typeReference = new TypeReference<List<Master>>(){};

    try {
        // 使用Files.newInputStream直接从文件系统读取
        try (InputStream inputStream = Files.newInputStream(Paths.get(jsonFilePath))) {
            List<Master> masters = mapper.readValue(inputStream, typeReference);
            System.out.println("读取到数据: " + masters);

            // 将数据保存到数据库
            masterService.save(masters);
            System.out.println("数据已保存到数据库。");
        }
    } catch (IOException e) {
        System.err.println("无法读取或保存数据: " + e.getMessage());
        // 实际应用中应记录更详细的日志
    }
}

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableScheduling // 启用定时任务
@EnableTransactionManagement
public class ReadAndWriteJsonApplication {
    public static void main(String[] args) {
        SpringApplication.run(ReadAndWriteJsonApplication.class, args);
    }
}

package com.example.demo;

import com.example.demo.Services.MasterService;
import com.example.demo.model.Master;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired; // 暂时保留，但后续会优化为构造器注入
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component; // 可以将此逻辑放入一个组件类

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

@Component // 将此逻辑封装在一个Spring组件中
public class FileProcessorScheduler {

    private final MasterService masterService;

    @Value("${app.data.json-file-path}")
    private String jsonFilePath;

    // 推荐使用构造器注入
    public FileProcessorScheduler(MasterService masterService) {
        this.masterService = masterService;
    }

    @Scheduled(fixedRate = 90000) // 每90秒执行一次
    public void readAndUpdateDatabase() {
        System.out.println("定时任务启动：尝试读取文件并更新数据库...");
        ObjectMapper mapper = new ObjectMapper();
        TypeReference<List<Master>> typeReference = new TypeReference<List<Master>>(){};

        try {
            // 使用Files.newInputStream直接从文件系统读取
            try (InputStream inputStream = Files.newInputStream(Paths.get(jsonFilePath))) {
                List<Master> masters = mapper.readValue(inputStream, typeReference);
                System.out.println("成功读取到 " + masters.size() + " 条数据。");

                // 将数据保存到数据库
                masterService.save(masters);
                System.out.println("数据已成功保存/更新到数据库。");
            }
        } catch (IOException e) {
            System.err.println("定时任务执行失败：无法读取或保存数据: " + e.getMessage());
            // 生产环境中应使用日志框架记录异常
        }
    }
}

package com.example.demo.Services;

import com.example.demo.Repository.MasterRepository;
import com.example.demo.model.Master;
import org.springframework.stereotype.Service;

import java.util.List;


@Service
public class MasterService {
    private final MasterRepository masterRepository; // 使用final修饰

    // 构造器注入
    public MasterService(MasterRepository masterRepository) {
        this.masterRepository = masterRepository;
    }

    public Iterable<Master> list() {
        return masterRepository.findAll();
    }

    public Master save(Master master){
        return masterRepository.save(master);
    }

    public Iterable<Master> save(List<Master> masters) {
        return masterRepository.saveAll(masters);
    }
}

package com.example.demo.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Data;

@Entity
@Data // Lombok注解，自动生成getter/setter/equals/hashCode/toString
public class Master {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int value;

    // JPA需要无参构造函数
    public Master() {}

    public Master(String name, int value) {
        this.name = name;
        this.value = value;
    }
}

package com.example.demo.Repository;

import com.example.demo.model.Master;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MasterRepository extends CrudRepository<Master, Long> {
}

# 数据库配置 (示例，请根据实际情况修改)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update # 生产环境请谨慎使用，建议为validate或none

# 外部JSON文件路径
# 请确保此路径存在且Spring Boot应用有读写权限
# 例如，在项目根目录下创建一个 'data' 文件夹，并在其中放置 'file.json'
app.data.json-file-path=./data/file.json

[
  {
    "name": "Item A",
    "value": 100
  },
  {
    "name": "Item B",
    "value": 200
  }
]

[
  {
    "name": "Item C",
    "value": 300
  },
  {
    "name": "Item D",
    "value": 400
  }
]