在springboot项目中增加接口删除某个目录下文件，接口参数是多个/var/lib/file.txt列表

于 2024-07-23 20:59:24 发布
阅读量448 收藏 12
点赞数 13
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33192454/article/details/140646080
版权

在Spring Boot项目中添加一个删除指定目录下文件的接口，可以通过定义一个REST控制器来接收文件路径列表作为参数，并执行删除操作。以下是实现步骤：

1. 添加依赖

确保你的Spring Boot项目中包含了必要的依赖。在 pom.xml 中添加以下依赖：

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

2. 创建文件删除服务

创建一个服务类 FileService.java，用于处理文件删除操作：

import org.springframework.stereotype.Service;

import java.io.File;
import java.util.List;

@Service
public class FileService {

    public void deleteFiles(List<String> filePaths) {
        for (String filePath : filePaths) {
            File file = new File(filePath);
            if (file.exists() && file.isFile()) {
                if (file.delete()) {
                    System.out.println("File deleted: " + filePath);
                } else {
                    System.err.println("Failed to delete file: " + filePath);
                }
            } else {
                System.err.println("File not found or not a file: " + filePath);
            }
        }
    }
}

3. 创建控制器

创建一个控制器 `File

import org.springframework.stereotype.Service; import java.io.File; import java.util.List; @Service public class FileService { public void deleteFiles(List<String> filePaths) { for (String filePath : filePaths) { File file = new File(filePath); if (file.exists() && file.isFile()) { if (file.delete()) { System.out.println("File deleted: " + filePath); } else { System.err.println("Failed to delete file: " + 这个用postman请求怎么写怎么传递参数，删除成功返回状态200，状态信息为成功

为了让你的Spring Boot应用程序通过POST请求删除指定的文件，并在删除成功后返回状态200和成功信息，我们需要做以下几步：

  1. 修改服务类 FileService，确保它返回删除结果。
  2. 创建控制器 FileController，接收POST请求并调用 FileService 进行文件删除操作。
  3. 配置和启动Spring Boot应用。

1. 修改 FileService

我们将 FileService 修改为返回删除结果，以便控制器可以根据结果返回相应的响应。

import org.springframework.stereotype.Service;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

@Service
public class FileService {

    public List<String> deleteFiles(List<String> filePaths) {
        List<String> results = new ArrayList<>();
        for (String filePath : filePaths) {
            File file = new File(filePath);
            if (file.exists() && file.isFile()) {
                if (file.delete()) {
                    results.add("File deleted: " + filePath);
                } else {
                    results.add("Failed to delete file: " + filePath);
                }
            } else {
                results.add("File not found or not a file: " + filePath);
            }
        }
        return results;
    }
}

2. 创建控制器 FileController

创建一个控制器类 FileController，用来接收POST请求并调用 FileService：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/file")
public class FileController {

    @Autowired
    private FileService fileService;

    @PostMapping("/delete")
    public ResponseEntity<?> deleteFiles(@RequestBody List<String> filePaths) {
        List<String> results = fileService.deleteFiles(filePaths);
        boolean allSuccess = results.stream().allMatch(result -> result.startsWith("File deleted"));
        if (allSuccess) {
            return ResponseEntity.ok("All files deleted successfully");
        } else {
            return ResponseEntity.status(HttpStatus.MULTI_STATUS).body(results);
        }
    }
}

3. 配置和启动Spring Boot应用

确保你有主应用程序类来启动Spring Boot应用：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

4. 使用Postman进行测试

你可以通过以下步骤使用Postman来测试这个接口：

  1. 打开Postman。
  2. 创建一个新的POST请求。
  3. 在URL栏中输入：http://localhost:8080/file/delete（假设你的应用运行在本地8080端口）。
  4. 点击 "Body" 标签，选择 "raw" 并设置类型为 "JSON"。
  5. 在请求体中输入要删除的文件路径列表，例如：
json[ "/data/1.txt", "/var/2.txt", "/log/t.txt" ]
  1. 点击 "Send" 发送请求。

5. 处理响应

  • 如果所有文件删除成功，你会收到状态码 200 OK 和消息 "All files deleted successfully".
  • 如果有任何文件删除失败，返回状态码 207 Multi-Status 和具体失败信息。

这样，你就可以通过接口传递文件路径列表来删除文件，并在成功删除时返回状态200和成功消息了。

用上面的代码为啥监听txt文件然后复制到另一个目录下的时候另一个目录下的文件没有内容大小是0啊

要确保文件在复制时不会出现大小为0的情况，通常是由于文件在写入时尚未完成，而复制操作已经开始。在处理文件复制时，特别是从一个路径移动到另一个路径的情况下，我们需要确保文件完全写入。

我们可以通过在监听事件发生时，引入短暂的延迟来确保文件写入完成，或者通过文件大小稳定来判断文件写入是否完成，然后再进行复制操作。

下面是完整的Spring Boot项目的示例，其中包含文件监听和复制功能，确保文件复制时文件内容完整。

FileWatcherService 修改

import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Service
public class FileWatcherService {

    private final ExecutorService executorService = Executors.newFixedThreadPool(5);
    private final Map<WatchKey, Path> watchKeyPathMap = new HashMap<>();

    public void startWatching(List<String> directories) {
        for (String directory : directories) {
            executorService.execute(() -> {
                try {
                    Path dir = Paths.get(directory);
                    WatchService watchService = FileSystems.getDefault().newWatchService();
                    WatchKey watchKey = dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);
                    watchKeyPathMap.put(watchKey, dir);

                    WatchKey key;
                    while ((key = watchService.take()) != null) {
                        Path parentDirectory = watchKeyPathMap.get(key);
                        for (WatchEvent<?> event : key.pollEvents()) {
                            WatchEvent.Kind<?> kind = event.kind();
                            if (kind == StandardWatchEventKinds.ENTRY_CREATE) {
                                Path filePath = parentDirectory.resolve((Path) event.context());
                                if (isFileStable(filePath)) {
                                    Path targetDir = Paths.get("/data/file/");
                                    Path target = targetDir.resolve(filePath.getFileName());
                                    Files.copy(filePath, target, StandardCopyOption.REPLACE_EXISTING);
                                    System.out.println("File copied from " + filePath + " to " + target);
                                    key.cancel();
                                }
                            }
                        }
                        key.reset();
                    }
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    private boolean isFileStable(Path filePath) throws IOException {
        long initialSize = Files.size(filePath);
        try {
            Thread.sleep(1000); // Wait for 1 second to check if the file size is stable
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        long newSize = Files.size(filePath);
        return initialSize == newSize;
    }

    public void stopWatching() {
        executorService.shutdown();
        watchKeyPathMap.clear();
        System.out.println("File watching stopped.");
    }
}

FileController

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/file-watcher")
public class FileWatcherController {

    @Autowired
    private FileWatcherService fileWatcherService;

    @PostMapping("/start")
    public ResponseEntity<String> startWatching(@RequestBody List<String> directories) {
        fileWatcherService.startWatching(directories);
        return ResponseEntity.ok("File watching started for directories: " + directories);
    }

    @PostMapping("/stop")
    public ResponseEntity<String> stopWatching() {
        fileWatcherService.stopWatching();
        return ResponseEntity.ok("File watching stopped.");
    }
}

主应用程序

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

配置文件

无需配置文件，因为路径通过接口参数传递。

使用Postman进行测试

  1. 打开Postman。
  2. 创建一个新的POST请求。
  3. 在URL栏中输入：http://localhost:8080/file-watcher/start。
  4. 点击 "Body" 标签，选择 "raw" 并设置类型为 "JSON"。
  5. 在请求体中输入要监听的文件路径列表，例如：
json[ "/data/1.txt", "/var/2.txt", "/log/t.txt" ]
  1. 点击 "Send" 发送请求。
  2. 要停止监听任务，创建另一个POST请求，URL输入：http://localhost:8080/file-watcher/stop，然后点击 "Send"。

处理响应

  • 如果所有文件删除成功，你会收到状态码 200 OK 和消息 "All files deleted successfully"。
  • 如果有任何文件删除失败，返回状态码 207 Multi-Status 和具体失败信息。

这样，Spring Boot服务就可以启动，通过接口传递目录和文件名称进行监听，并在文件存在时复制文件到指定目录，确保文件内容完整。

public void startWatching(String path, String destDir) { if (watchTasks.containsKey(path)) { System.out.println("Already watching this path: " + path); return; } Future<?> future = executor.submit(() -> { try (WatchService watchService = FileSystems.getDefault().newWatchService()) { Path dir = Paths.get(path).getParent(); dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE); while (true) { WatchKey key; try { key = watchService.take(); } catch (InterruptedException ex) { return; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind<?> kind = event.kind(); if (kind == StandardWatchEventKinds.OVERFLOW) { continue; } WatchEvent<Path> ev = (WatchEvent<Path>) event; Path fileName = ev.context(); if (fileName.toString().equals(Paths.get(path).getFileName().toString())) { Files.copy(dir.resolve(fileName), Paths.get(destDir).resolve(fileName), StandardCopyOption.REPLACE_EXISTING); System.out.println("File copied to " + destDir); return; } } boolean valid = key.reset(); if (!valid) { break; } } } catch (IOException e) { e.printStackTrace(); } }); 用这个方法监听文件txt,为啥监听txt文件然后复制到另一个目录下的时候另一个目录下的文件没有内容大小有的时候是0啊

你遇到的问题可能是因为在文件写入完成之前，复制操作已经开始了。因此，复制的文件可能还没有完全写入，导致复制后的文件大小为0或内容不完整。

为了解决这个问题，可以在检测到文件创建事件后，等待文件写入完成，然后再执行复制操作。以下是改进后的代码：

  1. 添加一个方法来检查文件的稳定性，确保文件写入完成。
  2. 修改 startWatching 方法来使用这个检查方法。

代码实现

文件服务类 FileWatcherService
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

@Service
public class FileWatcherService {

    private final ExecutorService executor = Executors.newFixedThreadPool(5);
    private final ConcurrentHashMap<String, Future<?>> watchTasks = new ConcurrentHashMap<>();

    public void startWatching(String path, String destDir) {
        if (watchTasks.containsKey(path)) {
            System.out.println("Already watching this path: " + path);
            return;
        }

        Future<?> future = executor.submit(() -> {
            try (WatchService watchService = FileSystems.getDefault().newWatchService()) {
                Path dir = Paths.get(path).getParent();
                dir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);

                while (true) {
                    WatchKey key;
                    try {
                        key = watchService.take();
                    } catch (InterruptedException ex) {
                        return;
                    }

                    for (WatchEvent<?> event : key.pollEvents()) {
                        WatchEvent.Kind<?> kind = event.kind();

                        if (kind == StandardWatchEventKinds.OVERFLOW) {
                            continue;
                        }

                        WatchEvent<Path> ev = (WatchEvent<Path>) event;
                        Path fileName = ev.context();

                        if (fileName.toString().equals(Paths.get(path).getFileName().toString())) {
                            Path filePath = dir.resolve(fileName);
                            if (isFileStable(filePath)) {
                                Files.copy(filePath, Paths.get(destDir).resolve(fileName), StandardCopyOption.REPLACE_EXISTING);
                                System.out.println("File copied to " + destDir);
                                return;
                            }
                        }
                    }

                    boolean valid = key.reset();
                    if (!valid) {
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        watchTasks.put(path, future);
    }

    private boolean isFileStable(Path filePath) throws IOException {
        long initialSize = Files.size(filePath);
        try {
            Thread.sleep(1000); // Wait for 1 second to check if the file size is stable
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        long newSize = Files.size(filePath);
        return initialSize == newSize;
    }

    public void stopWatching(String path) {
        Future<?> future = watchTasks.remove(path);
        if (future != null) {
            future.cancel(true);
            System.out.println("Stopped watching path: " + path);
        } else {
            System.out.println("No active watch task for path: " + path);
        }
    }
}
控制器类 FileWatcherController
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/file-watcher")
public class FileWatcherController {

    @Autowired
    private FileWatcherService fileWatcherService;

    @PostMapping("/start")
    public ResponseEntity<String> startWatching(@RequestParam String path, @RequestParam String destDir) {
        fileWatcherService.startWatching(path, destDir);
        return ResponseEntity.ok("File watching started for path: " + path);
    }

    @PostMapping("/stop")
    public ResponseEntity<String> stopWatching(@RequestParam String path) {
        fileWatcherService.stopWatching(path);
        return ResponseEntity.ok("File watching stopped for path: " + path);
    }
}
主应用程序类 Application
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

使用Postman进行测试

  1. 启动监听：

    • 创建一个新的POST请求。
    • 在URL栏中输入：http://localhost:8080/file-watcher/start。
    • 在请求体中选择 form-data，添加两个字段：path 和 destDir，分别输入要监听的文件路径和目标目录。

  2. 停止监听：

    • 创建一个新的POST请求。
    • 在URL栏中输入：http://localhost:8080/file-watcher/stop。
    • 在请求体中选择 form-data，添加一个字段：path，输入要停止监听的文件路径。

通过这种方式，可以确保文件在复制前已经完全写入，从而避免文件复制后内容为空的问题。

qq_33192454
关注
  • 13
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值