So implementieren Sie Datei- und Speicherdienste über Spring Boot

Mit der Entwicklung der Internettechnologie sind Datei- und Speicherdienste zu notwendigen Bestandteilen verschiedener Anwendungen geworden. Als Framework für die schnelle Erstellung von Java-Anwendungen auf Unternehmensebene bietet es auch einzigartige Vorteile bei der Realisierung von Datei- und Speicherdiensten. In diesem Artikel wird erläutert, wie Sie Datei- und Speicherdienste über Spring Boot implementieren.

1. Dateiverarbeitung in Spring Boot

Spring Boot bietet eine Reihe von Dateiverarbeitungsmethoden. Über die Ressourcen- und ResourceLoader-Schnittstellen von Spring können wir lokale Dateien, Dateien unter dem Klassenpfad, Netzwerkressourcen usw. abrufen.

1.1 Lokale Dateioperation

Im Spring Boot-Entwicklungsprozess verwenden wir die getResource-Methode der ResourceLoader-Schnittstelle, um das Ressourcenobjekt der angegebenen Datei abzurufen. Das Codebeispiel lautet wie folgt:

@ResourceLoader
ResourceLoader resourceLoader;

File file = new File("D:/image.jpg"); //指定文件路径（绝对路径）
Resource resource = resourceLoader.getResource("file:" + file.getAbsolutePath()); //获取文件Resource对象
InputStream inputStream = resource.getInputStream(); //获取文件输入流

Unter ihnen ist ResourceLoader Von Spring bereitgestellte Ressourcenladeschnittstelle. Sie können die Annotation @ResourceLoader markieren, um automatisch Instanzen ihrer Implementierungsklassen über Autowired einzufügen. Die Methode getResource() wird verwendet, um das Ressourcenobjekt des angegebenen Dateipfads abzurufen. Hier geben wir den absoluten Pfad über das Protokoll „file:“ an.

1.2 Klassenpfaddateibetrieb

In der Spring Boot-Anwendung können wir die Ressourcendateien, die sich auf das Webprojekt beziehen (z. B. Konfigurationsdateien), unter den Klassenpfad stellen und die Ressourcenreferenz über ClassPathResource abrufen. Das Codebeispiel lautet wie folgt:

ClassPathResource classPathResource = new ClassPathResource("config.properties"); //获取配置文件Resource对象
InputStream inputStream = classPathResource.getInputStream(); //获取配置文件输入流

Die ClassPathResource-Klasse lädt Ressourcen aus dem Anwendungsklassenpfad und unterstützt Dateisystempräfixe wie „classpath:“ und „file:“. Dieser Code demonstriert die Verwendung des Dateisystempräfixes relativ zum Standardpfadpräfix „file:“. ist nicht angegeben.

1.3 Netzwerkdateibetrieb

Zusätzlich zu Dateien im lokalen Pfad und im Klassenpfadpfad kann Spring Boot auch Dateien im Netzwerk über URLResource-Objekte bedienen. Das Codebeispiel lautet wie folgt:

String url = "http://img.iplaysoft.com/wp-content/uploads/2019/free-images/free_stock_photo.jpg";
Resource resource = new UrlResource(url); //获取网络资源Resource对象
InputStream inputStream = resource.getInputStream(); //获取网络资源输入流

Unter diesen kann die UrlResource-Klasse Ressourcen abrufen Aus der Netzwerkdatei müssen Sie die Netzwerkadressen-URL als Parameter des Konstruktors übergeben.

2. Datei-Upload in Spring Boot

Bei der tatsächlichen Entwicklung von Spring Boot-Anwendungen ist das Hochladen von Dateien eine häufige Anforderung. In Spring Boot können wir die MultipartFile-Klasse und den MultipartResolver-Parser verwenden, um den Datei-Upload-Vorgang abzuschließen.

2.1 MultipartFile-Klasse

Die MultipartFile-Klasse von Spring bietet eine einfache und konsistente Möglichkeit, eine oder mehrere Dateien hochzuladen. Dies ist der Parametertyp der MVC-Verarbeitungsmethode, die unter der Annotation @RequestParam verwendet wird, wie zum Beispiel:

@PostMapping("/upload")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile file) {
    //具体文件上传操作
    return "success";
}

Beim Hochladen einer Datei müssen Sie den spezifischen Upload-Vorgang angeben und zugehörige Parameter wie den Dateispeicherpfad festlegen Das Codebeispiel lautet wie folgt:

@PostMapping("/upload")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile file) {
    // 获取文件名
    String fileName = file.getOriginalFilename();
    // 设置保存路径
    String filePath = "D:/upload/";
    File dest = new File(filePath + fileName);
    try {
        file.transferTo(dest);
        // 具体业务操作
        return "success";
    } catch (IOException e) {
        e.printStackTrace();
        return "failure";
    }
}

2.2 MultipartResolver Resolver

MultipartResolver ist eine Schnittstelle im Spring MVC-Framework, die zum Parsen von Datei-Upload-Daten in POST-Anfragen verwendet wird. In Spring Boot können wir die integrierte CommonsMultipartResolver-Klasse verwenden, um Datei-Upload-Analysevorgänge zu implementieren. Im Spring Boot-Projekt müssen Sie nur das MultipartResolver-Objekt in der Spring-Konfigurationsdatei konfigurieren. Das spezifische Codebeispiel lautet wie folgt:

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public MultipartResolver multipartResolver() {
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setMaxUploadSize(1000000);
        return multipartResolver;
    }
}

Dieses Beispiel konfiguriert eine CommonsMultipartResolver-Klasseninstanz und begrenzt die maximale Größe der hochgeladenen Datei auf 1.000.000 Bytes . Beachten Sie, dass wir @EnableWebMvc aktivieren müssen, um das adaptive Verhalten von Spring MVC zu aktivieren, damit die Klasseninstanz CommonsMultipartResolver ordnungsgemäß funktioniert.

3. Das Herunterladen von Dateien in Spring Boot

Bei der Entwicklung von Spring Boot-Anwendungen ist das Herunterladen von Dateien ebenfalls eine häufige Anforderung. Spring Boot stellt eine ResponseEntity zur Darstellung der gesamten HTTP-Antwort bereit, die den entsprechenden Statuscode, Header und Body enthält. Wir können den Namen und Typ der Download-Datei angeben, indem wir Content-Disposition festlegen.

3.1 Datei-Download implementieren

Wir können die Annotation @ResponseBody verwenden, um den Dateiinhalt zu verarbeiten, der durch das von der Methode zurückgegebene Byte-Array dargestellt wird, und dann ResponseEntity verwenden, um den gesamten HTTP-Antworttext zurückzugeben.

@GetMapping("/download")
public ResponseEntity<byte[]> download() throws IOException {
    String filePath = "D:/image.jpg";
    File file = new File(filePath);
    HttpHeaders headers = new HttpHeaders();
    headers.add("Content-Disposition", "attachment;filename=" + file.getName());
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    byte[] bytes = FileUtils.readFileToByteArray(file);
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, HttpStatus.OK);
    return responseEntity;
}

Im obigen Code verwenden wir FileUtils, um die Datei als Byte-Array zu lesen, setzen das Array auf eine HttpEntity und geben es zurück. In der zurückgegebenen HttpEntity geben wir außerdem den Namen und Typ der Datei an, damit der Client-Browser diese Informationen im Download-Fenster anzeigen kann.

3.2 Download mehrerer Dateien erreichen

In manchen Fällen müssen wir mehrere Dateien herunterladen. Wir können mehrere Dateien in eine ZIP-Datei packen, um den Download mehrerer Dateien zu erreichen. Spring Boot verwendet die vom Paket java.util.zip bereitgestellte ZipOutputStream-Klasse, um ZIP-Dateioperationen einfach zu implementieren. Das Codebeispiel lautet wie folgt:

@GetMapping("/download_multi")
public ResponseEntity<byte[]> downloadMulti() throws IOException {
    String base = "D:/test/";
    File directoryToZip = new File(base);
    List<File> fileList = new ArrayList<>();
    getAllFiles(directoryToZip, fileList);
    byte[] zipBytes = getZipBytes(fileList, base);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    headers.add("Content-Disposition", "attachment; filename="files.zip"");
    headers.setContentLength(zipBytes.length);
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(zipBytes, headers, HttpStatus.OK);
    return responseEntity;
}

private byte[] getZipBytes(List<File> fileList, String basePath) throws IOException {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
    for (File file : fileList) {
        String filePath = file.getAbsolutePath().substring(basePath.length());
        ZipEntry zipEntry = new ZipEntry(filePath);
        zipOutputStream.putNextEntry(zipEntry);
        FileInputStream inputStream = new FileInputStream(file);
        IOUtils.copy(inputStream, zipOutputStream);
        inputStream.close();
        zipOutputStream.closeEntry();
    }
    zipOutputStream.close();
    byte[] bytes = outputStream.toByteArray();
    outputStream.close();
    return bytes;
}

private void getAllFiles(File dir, List<File> fileList) {
    File[] files = dir.listFiles();
    for (File file : files) {
        if (file.isDirectory()) {
            getAllFiles(file, fileList);
        } else {
            fileList.add(file);
        }
    }
}

Im obigen Code verwenden wir die ZipOutputStream-Klasse und ByteArrayOutputStream, um mehrere Dateien in eine zu packen ZIP-Datei und geben Sie den gesamten HTTP-Antworttext über ResponseEntity zurück, einschließlich des Byte-Arrays der ZIP-Datei, des Dateinamens und des Dateityps, damit der Client-Browser diese Informationen im Download-Fenster anzeigen kann.

4. Dateispeicherung in Spring Boot

In praktischen Anwendungen ist die Dateispeicherung ebenfalls ein wichtiger Link. Wir können Dateien an verschiedenen Orten speichern, z. B. im lokalen Speicher, im FTP-Speicher und im Objektspeicher. Hier verwenden wir den lokalen Speicher als Beispiel, um die Implementierung der Dateispeicherung über Spring Boot vorzustellen.

4.1 Erstellen Sie ein Speicherverzeichnis

Zuerst müssen wir ein Verzeichnis für den Speicherdienst erstellen. Das Codebeispiel lautet wie folgt:

String fileRoot = "/data/files/";
Path rootPath = Paths.get(fileRoot).normalize().toAbsolutePath();
if (!Files.exists(rootPath)) {
    Files.createDirectories(rootPath);
}

Im obigen Code erstellen wir ein Stammverzeichnis /data/files/ zum Speichern von Dateien und überprüfen Sie das Verzeichnis. Existiert es? Erstellen Sie es, wenn es nicht existiert.

4.2 实现文件存储服务

在Spring Boot中，实现文件存储服务也非常简单，我们可以创建一个类实现存储服务接口，具体代码示例如下：

@Service
public class FileStorageService {

    private Path fileStorageLocation;

    @Autowired
    public FileStorageService(@Value("${file.upload-dir}") String fileRoot) {
        this.fileStorageLocation = Paths.get(fileRoot).normalize().toAbsolutePath();
        try {
            Files.createDirectories(this.fileStorageLocation);
        } catch (Exception e) {
            throw new FileStorageException("Could not create the directory where the uploaded files will be stored.", e);
        }
    }

    public String storeFile(MultipartFile file) {
        String fileName = StringUtils.cleanPath(file.getOriginalFilename());
        try {
            if (fileName.contains("..")) {
                throw new FileStorageException("Sorry! Filename contains invalid path sequence " + fileName);
            }
            Path targetLocation = this.fileStorageLocation.resolve(fileName);
            Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
            return fileName;
        } catch (IOException ex) {
            throw new FileStorageException("Could not store file " + fileName + ". Please try again!", ex);
        }
    }

    public Resource loadFileAsResource(String fileName) {
        try {
            Path filePath = this.fileStorageLocation.resolve(fileName).normalize();
            Resource resource = new UrlResource(filePath.toUri());
            if (resource.exists()) {
                return resource;
            } else {
                throw new MyFileNotFoundException("File not found " + fileName);
            }
        } catch (MalformedURLException ex) {
            throw new MyFileNotFoundException("File not found " + fileName, ex);
        }
    }
}

上述代码中，我们创建了一个FileStorageService类，用于实现文件存储服务，包含storeFile()和loadFileAsResource()两个方法，其中：

storeFile()方法用于存储上传的文件，可以获取文件的输入流，将文件存储到指定的存储目录中；

loadFileAsResource()方法用于加载指定文件的Resource对象，通过提供的文件名获取文件的Resource对象。

注意，我们使用@Autowired注解注入了config.properties中对应的配置文件路径，使其自动配置为文件存储的目录。

结语

通过Spring Boot的文件和存储服务，我们可以轻松实现文件操作、上传、下载和存储等操作，简单高效，可以应用于各类企业级Java应用。希望本文对大家对Spring Boot文件和存储服务的理解和实践有所帮助。

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Datei- und Speicherdienste über Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!