尽管存在FileNotFoundException，Java Spring引导配置文件仍被正确处理

FileNotFoundException for

owners.json

文件，尽管它正在读取和填充数据库，但在

mvn clean install

和/或

mvn spring boot:run

但

java-jar./target/car-api-0.0.1-SNAPSHOT.jar

期间

使用Java 1.8、Spring Boot、JPA，我创建了一个Spring Boot微服务，在微服务启动期间从文件加载json数据：

---

---

src/main/resources/data/owner.json：

[
  {
    "name": "Tom Brady"
  },
  {
    "name": "Kobe Bryant"
  },
  {
    "name": "Mike Tyson"
  },
  {
    "name": "Scottie Pippen"
  },
  {
    "name": "John Madden"
  },
  {
    "name": "Arnold Palmer"
  },
  {
    "name": "Tiger Woods"
  },
  {
    "name": "Magic Johnson"
  },
  {
    "name": "George Foreman"
  },
  {
    "name": "Charles Barkley"
  }

]

---

所以，当我运行这个：

mvn clean install

一切正常

但当我随后这样做时：

java -jar ./target/car-api-0.0.1-SNAPSHOT.jar

我在IntelliJ IDEA的标准中看到：

java.io.FileNotFoundException: class path resource [data/owners.json] cannot be resolved to absolute file path because it does not reside in the file system: jar:file:/Owners/myowner/car-api/target/car-api-0.0.1-SNAPSHOT.jar!/BOOT-INF/classes!/data/owners.json
    at org.springframework.util.ResourceUtils.getFile(ResourceUtils.java:217)
    at org.springframework.core.io.AbstractFileResolvingResource.getFile(AbstractFileResolvingResource.java:154)
    at com.myapi.bootstrap.DataInserter.onApplicationEvent(DataInserter.java:50)
    at com.myapi.bootstrap.DataInserter.onApplicationEvent(DataInserter.java:24)
    at org.springframework.context.event.SimpleApplicationEventMulticaster.doInvokeListener(SimpleApplicationEventMulticaster.java:172)
    at org.springframework.context.event.SimpleApplicationEventMulticaster.invokeListener(SimpleApplicationEventMulticaster.java:165)
    at org.springframework.context.event.SimpleApplicationEventMulticaster.multicastEvent(SimpleApplicationEventMulticaster.java:139)
    at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:403)
    at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:360)
    at org.springframework.context.support.AbstractApplicationContext.finishRefresh(AbstractApplicationContext.java:897)
    at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.finishRefresh(ServletWebServerApplicationContext.java:162)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:553)
    at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:141)
    at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:747)
    at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:397)
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1226)
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1215)
    at com.nuvve.CarApplication.main(CarApplication.java:12)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.springframework.boot.loader.MainMethodRunner.run(MainMethodRunner.java:48)
    at org.springframework.boot.loader.Launcher.launch(Launcher.java:87)
    at org.springframework.boot.loader.Launcher.launch(Launcher.java:51)
    at org.springframework.boot.loader.JarLauncher.main(JarLauncher.java:52)

---

现在，数据库仍然是空的，我无法通过任何HTTP Get请求访问我的数据

---

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.myapi</groupId>
    <artifactId>car-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>car-api</name>
    <description>Car REST API</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

---

业主单位：

@Entity
@Table(name = "owner")
public class Owner {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    private String name;


    @OneToMany(cascade = CascadeType.ALL,
                fetch = FetchType.EAGER,
                mappedBy = "owner")
    private List<Car> cars = new ArrayList<>();

    public Owner() {
    }

    // Getter & Setters omitted for brevity.
}

---

业主地址：

@Repository
public interface OwnerRepository extends JpaRepository<Owner, Long> {
}

@Repository
public interface CarRepository extends JpaRepository<Car, Long> {
}

---

CarServiceImpl：

@Service
public class OwnerServiceImpl implements OwnerService {


    @Autowired
    OwnerRepository ownerRepository;

    @Autowired
    CarRepository carRepository;

    @Override
    public List<Owner> getAllOwners() {
        return ownerRepository.findAll();
    }

    @Override
    public boolean createOwner(Owner owner) {
        boolean created = false;
        if (owner != null) {
            ownerRepository.save(owner);
            created = true;
        }
        return created;
    }

    @Override
    public Owner getOwnerByOwnerId(Long ownerId) {
        Optional<Owner> owner = null;
        if (ownerRepository.existsById(ownerId)) {
            owner = ownerRepository.findById(ownerId);
        }
        return owner.get();
    }
}

@Service
public class CarServiceImpl implements CarService {

    @Autowired
    OwnerRepository ownerRepository;

    @Autowired
    CarRepository carRepository;

    @Override
    public boolean createCar(Long ownerId, Car car) {
        boolean created = false;
        if (ownerRepository.existsById(ownerId)) {
            Optional<Owner> owner = ownerRepository.findById(ownerId);
            if (owner != null) {
                List<Car> cars = owner.get().getCars();
                cars.add(car);
                owner.get().setCars(cars);
                car.setOwner(owner.get());
                carRepository.save(car);
                created = true;
            }
        }
        return created;
    }

}

@服务
公共类CarServiceImpl实现了CarService{
@自动连线
所有者住所所有者住所；
@自动连线
进位进位进位进位；
@凌驾
公共汽车（长车主ID，汽车）{
布尔值=假；
if（ownerRepository.existsById（ownerId））{
可选owner=ownerRepository.findById（ownerId）；
如果（所有者！=null）{
List cars=owner.get（）.getCars（）；
cars.add（car）；
owner.get（）.setCars（cars）；
car.setOwner（owner.get（））；
carRepository.save（car）；
创建=真；
}
}
创建回报；
}
}

---

所有者控制器：

@RestController
public class OwnerController {


    private HttpHeaders headers = null;

    @Autowired
    OwnerService ownerService;

    public OwnerController() {
        headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
    }

    @RequestMapping(value = { "/owners" }, method = RequestMethod.POST, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> createOwner(@Valid @RequestBody Owner owner) {
        boolean isCreated = ownerService.createOwner(owner);
        if (isCreated) {
            return new ResponseEntity<Object>(headers, HttpStatus.OK);
        }
        else {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
    }


    @RequestMapping(value = { "/owners" }, method = RequestMethod.GET, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> getAllOwners() {
        List<Owner> owners = ownerService.getAllOwners();

        if (owners.isEmpty()) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Object>(owners, headers, HttpStatus.OK);
    }


    @RequestMapping(value = { "/owners/{ownerId}" }, method = RequestMethod.GET, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> getOwnerByOwnerId(@PathVariable Long ownerId) {
        if (null == ownerId || "".equals(ownerId)) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        Owner owner = ownerService.getOwnerByOwnerId(ownerId);
        return new ResponseEntity<Object>(owner, headers, HttpStatus.OK);
    }

}

@RestController
public class CarController {

    private HttpHeaders headers = null;

    @Autowired
    CarService carService;

    public CarController() {
        headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
    }

    @RequestMapping(value = { "/cars/{ownerId}" }, method = RequestMethod.POST, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> createCarBasedOnOwnerId(@Valid @RequestBody Car car, Long ownerId) {
        boolean isCreated = carService.createCar(ownerId, car);
        if (isCreated) {
            return new ResponseEntity<Object>(headers, HttpStatus.OK);
        }
        else {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
    }

@RestController
公共类所有者控制器{
私有HttpHeaders=null；
@自动连线
所有者服务所有者服务；
公共所有者控制器（）{
headers=新的HttpHeaders（）；
添加（“内容类型”、“应用程序/json”）；
}
@RequestMapping（value={“/owners”}，method=RequestMethod.POST，products=“APPLICATION/JSON”）
public ResponseEntity createOwner（@Valid@RequestBody-Owner）{
布尔值isCreated=ownerService.createOwner（所有者）；
如果（已创建）{
返回新的响应属性（标题，HttpStatus.OK）；
}
否则{
返回新的ResponseEntity（未找到HttpStatus.NOT_）；
}
}
@RequestMapping（value={“/owners”}，method=RequestMethod.GET，products=“APPLICATION/JSON”）
公共响应获得所有人（）{
List owners=ownerService.getAllOwners（）；
if（owners.isEmpty（））{
返回新的ResponseEntity（未找到HttpStatus.NOT_）；
}
返回新的响应属性（所有者、标题、HttpStatus.OK）；
}
@RequestMapping（value={/owners/{ownerId}}，method=RequestMethod.GET，products=“APPLICATION/JSON”）
公共响应属性getOwnerByOwnerId（@PathVariable Long ownerId）{
如果（null==ownerId | |“”.equals（ownerId））{
返回新的ResponseEntity（未找到HttpStatus.NOT_）；
}
Owner=ownerService.getOwnerByOwnerId（ownerId）；
返回新的响应属性（所有者、标题、HttpStatus.OK）；
}
}

---

车辆控制员：

@RestController
public class OwnerController {


    private HttpHeaders headers = null;

    @Autowired
    OwnerService ownerService;

    public OwnerController() {
        headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
    }

    @RequestMapping(value = { "/owners" }, method = RequestMethod.POST, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> createOwner(@Valid @RequestBody Owner owner) {
        boolean isCreated = ownerService.createOwner(owner);
        if (isCreated) {
            return new ResponseEntity<Object>(headers, HttpStatus.OK);
        }
        else {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
    }


    @RequestMapping(value = { "/owners" }, method = RequestMethod.GET, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> getAllOwners() {
        List<Owner> owners = ownerService.getAllOwners();

        if (owners.isEmpty()) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Object>(owners, headers, HttpStatus.OK);
    }


    @RequestMapping(value = { "/owners/{ownerId}" }, method = RequestMethod.GET, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> getOwnerByOwnerId(@PathVariable Long ownerId) {
        if (null == ownerId || "".equals(ownerId)) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        Owner owner = ownerService.getOwnerByOwnerId(ownerId);
        return new ResponseEntity<Object>(owner, headers, HttpStatus.OK);
    }

}

@RestController
public class CarController {

    private HttpHeaders headers = null;

    @Autowired
    CarService carService;

    public CarController() {
        headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
    }

    @RequestMapping(value = { "/cars/{ownerId}" }, method = RequestMethod.POST, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> createCarBasedOnOwnerId(@Valid @RequestBody Car car, Long ownerId) {
        boolean isCreated = carService.createCar(ownerId, car);
        if (isCreated) {
            return new ResponseEntity<Object>(headers, HttpStatus.OK);
        }
        else {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
    }

@RestController
公共类汽车控制器{
私有HttpHeaders=null；
@自动连线
汽车服务；
公共车辆控制员（）{
headers=新的HttpHeaders（）；
添加（“内容类型”、“应用程序/json”）；
}
@RequestMapping（value={/cars/{ownerId}}，method=RequestMethod.POST，products=“APPLICATION/JSON”）
公共响应Entity createCarBasedOnOwnerId（@Valid@RequestBody Car，Long ownerId）{
布尔值isCreated=carService.createCar（ownerId，car）；
如果（已创建）{
返回新的响应属性（标题，HttpStatus.OK）；
}
否则{
返回新的ResponseEntity（未找到HttpStatus.NOT_）；
}
}

---

为什么在发出

mvn clean install

和/或

mvn spring boot:run

但引发此FileNotFoundException时，它会正确填充数据库

---

它必须使用

java-jar./target/car-api-0.0.1-SNAPSHOT.jar

，因为这是运行JUnit测试以及在Linux/Unix（临时和生产服务器）上设置服务守护进程的唯一方法.

它不起作用，因为owner.json文件嵌入在Spring Boot jar中，并且jar没有展开：

 jar:file:/Owners/myowner/car-api/target/car-api-0.0.1-SNAPSHOT.jar!/BOOT-INF/classes!/data/owners.json
    at org.springframework.util.ResourceUtils.getFile(ResourceUtils.java:217)
    at org.springframework.core.io.AbstractFileResolvingResource.getFile(AbstractFileResolvingResource.java:154)

---

我提出的解决方法是将json数据文件外部化为外部目录

---

src/main/application.properties：

server.servlet.context-path=/car-api
server.port=8080
server.error.whitelabel.enabled=false

# Database specific
spring.jpa.hibernate.ddl-auto=create
spring.datasource.url=jdbc:mysql://localhost:3306/car_db?useSSL=false
spring.datasource.ownername=root
spring.datasource.password=

owners.datafile=/ext/car-api/owners.json
cars.datafile=/ext/car-api/cars.json

---

@组件
公共类数据插入器实现ApplicationListener{
@值（“${owner.datafile}”）
文件所有者文件；
@值（“${cars.datafile}”）
文件卡文件；
@自动连线
私人所有者服务所有者服务；
@自动连线
私家车服务；
@凌驾
ApplicationEvent（ContextRefreshedEvent ContextRefreshedEvent）上的公共无效{
List populatedOwners=new ArrayList（）；
试一试{
所有者；
String ownersString=新字符串（Files.readAllBytes（ownersFile.toPath（））；
String carsString=新字符串（Files.readAllBytes（carsFile.toPath（））；
ObjectMapper mapper=新的ObjectMapper（）；
List owners=Arrays.asList（mapper.readValue（ownersString，Owner[].class））；
List cars=Arrays.asList（mapper.readValue（carsString，cars[].class））；
//逐个填充所有者
用于（所有者：所有者）{
AOOwner=新所有者（Owner.getName（））；
ownerService.createOwner（AOOwner）；
填充所有者。添加（AOOwner）；
}
//逐个填充车主车辆
对于（int i=0；i@RestController
public class CarController {

    private HttpHeaders headers = null;

    @Autowired
    CarService carService;

    public CarController() {
        headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
    }

    @RequestMapping(value = { "/cars/{ownerId}" }, method = RequestMethod.POST, produces = "APPLICATION/JSON")
    public ResponseEntity<Object> createCarBasedOnOwnerId(@Valid @RequestBody Car car, Long ownerId) {
        boolean isCreated = carService.createCar(ownerId, car);
        if (isCreated) {
            return new ResponseEntity<Object>(headers, HttpStatus.OK);
        }
        else {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
    }

 jar:file:/Owners/myowner/car-api/target/car-api-0.0.1-SNAPSHOT.jar!/BOOT-INF/classes!/data/owners.json
    at org.springframework.util.ResourceUtils.getFile(ResourceUtils.java:217)
    at org.springframework.core.io.AbstractFileResolvingResource.getFile(AbstractFileResolvingResource.java:154)

owners.datafile=/ext/car-api/owners.json
cars.datafile=/ext/car-api/cars.json

@Component
public class DataInserter implements ApplicationListener<ContextRefreshedEvent> {


    @Value("${owners.datafile}")
    File ownersFile;

    @Value("${cars.datafile}")
    File carsFile;

    @Autowired
    private OwnerService ownerService;

    @Autowired
    private CarsService carService;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        List<Owner> populatedOwners = new ArrayList<>();
        try {
            Owner aOwner;

            String ownersString = new String(Files.readAllBytes(ownersFile.toPath()));
            String carsString = new String(Files.readAllBytes(carsFile.toPath()));

            ObjectMapper mapper = new ObjectMapper();
            List<Owner> owners = Arrays.asList(mapper.readValue(ownersString, Owner[].class));
            List<Car> cars = Arrays.asList(mapper.readValue(carsString, Cars[].class));

            // Populate owners one by one
            for (Owner owner : owners) {
                aOwner = new Owner(owner.getName());
                ownerService.createOwner(aOwner);
                populatedOwners.add(aOwner);
            }

            // Populate owner cars one by one
            for (int i = 0; i < populatedOwners.size(); i++) {
                carService.createCars(populatedOwners.get(i).getId(), cars.get(i));
            }

        }
        catch(IOException ioe) {
            ioe.printStackTrace();;
        }
    }
}