Datei-Upload mit Spring MVC

1. Übersicht

In früheren Artikeln haben wir die Grundlagen der Formularbehandlung vorgestellt und die Formular-Tag-Bibliothek in Spring MVC untersucht.

In diesem Artikel konzentrieren wir uns auf das, was Spring für die Unterstützung von mehrteiligen (Datei-Upload) in Webanwendungen bietet .

Mit Spring können wir diese mehrteilige Unterstützung mit steckbaren MultipartResolver- Objekten aktivieren . Das Framework bietet eine MultipartResolver- Implementierung zur Verwendung mit Commons FileUpload und eine andere zur Verwendung mit der mehrteiligen Analyse von Servlet 3.0- Anforderungen.

Nach der Konfiguration des MultipartResolver erfahren Sie, wie Sie eine einzelne Datei und mehrere Dateien hochladen.

Wir werden auch auf Spring Boot eingehen.

2. Commons FileUpload

Um CommonsMultipartResolver für den Datei-Upload zu verwenden, müssen Sie die folgende Abhängigkeit hinzufügen:

 commons-fileupload commons-fileupload 1.3.1 

Jetzt können wir die CommonsMultipartResolver- Bean in unserer Spring-Konfiguration definieren.

Dieser MultipartResolver enthält eine Reihe von Set- Methoden zum Definieren von Eigenschaften wie der maximalen Größe für Uploads:

@Bean(name = "multipartResolver") public CommonsMultipartResolver multipartResolver() { CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(); multipartResolver.setMaxUploadSize(100000); return multipartResolver; }

Hier müssen wir verschiedene Eigenschaften von CommonsMultipartResolver in der Bean-Definition selbst steuern .

3. Mit Servlet 3.0

Um die mehrteilige Analyse von Servlet 3.0 verwenden zu können , müssen einige Teile der Anwendung konfiguriert werden. Zuerst müssen wir ein MultipartConfigElement in unserer DispatcherServlet- Registrierung festlegen :

public class MainWebAppInitializer implements WebApplicationInitializer { private String TMP_FOLDER = "/tmp"; private int MAX_UPLOAD_SIZE = 5 * 1024 * 1024; @Override public void onStartup(ServletContext sc) throws ServletException { ServletRegistration.Dynamic appServlet = sc.addServlet("mvc", new DispatcherServlet( new GenericWebApplicationContext())); appServlet.setLoadOnStartup(1); MultipartConfigElement multipartConfigElement = new MultipartConfigElement(TMP_FOLDER, MAX_UPLOAD_SIZE, MAX_UPLOAD_SIZE * 2, MAX_UPLOAD_SIZE / 2); appServlet.setMultipartConfig(multipartConfigElement); } }

Im MultipartConfigElement- Objekt haben wir den Speicherort, die maximale Größe der einzelnen Dateien, die maximale Anforderungsgröße (bei mehreren Dateien in einer einzelnen Anforderung) und die Größe konfiguriert, bei der der Fortschritt des Datei-Uploads auf den Speicherort übertragen wird.

Diese Einstellungen müssen auf der Servlet-Registrierungsebene angewendet werden, da Servlet 3.0 nicht zulässt, dass sie im MultipartResolver registriert werden, wie dies bei CommonsMultipartResolver der Fall ist.

Sobald dies erledigt ist, können wir den StandardServletMultipartResolver zu unserer Spring-Konfiguration hinzufügen :

@Bean public StandardServletMultipartResolver multipartResolver() { return new StandardServletMultipartResolver(); }

4. Hochladen einer Datei

Um unsere Datei hochzuladen, können wir eine einfache Form erstellen, in der wir ein HTML- Eingabe- Tag mit dem Typ = 'Datei' verwenden.

Unabhängig von der von uns gewählten Konfiguration für die Upload-Verarbeitung müssen wir das Codierungsattribut des Formulars auf Multipart / Formulardaten setzen. Dadurch weiß der Browser, wie das Formular codiert wird:


    
Select a file to upload

Zum Speichern der hochgeladenen Datei können wir eine MultipartFile- Variable verwenden. Wir können diese Variable aus dem Anforderungsparameter in der Methode unseres Controllers abrufen:

@RequestMapping(value = "/uploadFile", method = RequestMethod.POST) public String submit(@RequestParam("file") MultipartFile file, ModelMap modelMap) { modelMap.addAttribute("file", file); return "fileUploadView"; } 

Die MultipartFile- Klasse bietet Zugriff auf Details zur hochgeladenen Datei , einschließlich Dateiname, Dateityp usw. Wir können eine einfache HTML-Seite verwenden, um diese Informationen anzuzeigen:

Submitted File

OriginalFileName: ${file.originalFilename}
Type: ${file.contentType}

5. Hochladen mehrerer Dateien

Um mehrere Dateien in einer einzigen Anfrage hochzuladen, fügen wir einfach mehrere Felder für Eingabedateien in das Formular ein:


    
Select a file to upload
Select a file to upload
Select a file to upload

Wir müssen darauf achten, dass jedes Eingabefeld denselben Namen hat, damit auf es als Array von MultipartFile zugegriffen werden kann :

@RequestMapping(value = "/uploadMultiFile", method = RequestMethod.POST) public String submit(@RequestParam("files") MultipartFile[] files, ModelMap modelMap) { modelMap.addAttribute("files", files); return "fileUploadView"; } 

Jetzt können wir einfach über dieses Array iterieren, um Dateiinformationen anzuzeigen:

   Spring MVC File Upload   

Submitted Files

OriginalFileName: ${file.originalFilename}
Type: ${file.contentType}

6. Hochladen von Dateien mit zusätzlichen Formulardaten

Wir können auch zusätzliche Informationen zusammen mit der hochgeladenen Datei an den Server senden. Wir müssen nur die erforderlichen Felder in das Formular aufnehmen:


    
Name
Email
Select a file to upload

Im Controller können wir alle Formulardaten mithilfe der Annotation @RequestParam abrufen :

@PostMapping("/uploadFileWithAddtionalData") public String submit( @RequestParam MultipartFile file, @RequestParam String name, @RequestParam String email, ModelMap modelMap) { modelMap.addAttribute("name", name); modelMap.addAttribute("email", email); modelMap.addAttribute("file", file); return "fileUploadView"; }

Ähnlich wie in den vorherigen Abschnitten können wir die HTML-Seite mit JSTL- Tags verwenden, um die Informationen anzuzeigen.

Wir können auch alle Formularfelder in einer Modellklasse kapseln und die Annotation @ModelAttribute im Controller verwenden. Dies wäre hilfreich, wenn neben der Datei viele zusätzliche Felder vorhanden sind. Schauen wir uns den Code an:

public class FormDataWithFile { private String name; private String email; private MultipartFile file; // standard getters and setters }
@PostMapping("/uploadFileModelAttribute") public String submit(@ModelAttribute FormDataWithFile formDataWithFile, ModelMap modelMap) { modelMap.addAttribute("formDataWithFile", formDataWithFile); return "fileUploadView"; }

7. Spring Boot File Upload

Wenn wir Spring Boot verwenden, gilt immer noch alles, was wir bisher gesehen haben.

Spring Boot macht es jedoch noch einfacher, alles mit wenig Aufwand zu konfigurieren und zu starten.

Insbesondere ist es nicht erforderlich, ein Servlet zu konfigurieren, da Boot es registriert und für uns konfiguriert, vorausgesetzt, wir nehmen das Webmodul in unsere Abhängigkeiten auf:

 org.springframework.boot spring-boot-starter-web 2.1.8.RELEASE 

Wir finden die neueste Version von Spring-Boot-Starter-Web auf Maven Central.

Wenn wir die maximale Größe des Datei-Uploads steuern möchten, können wir unsere application.properties bearbeiten :

spring.servlet.multipart.max-file-size=128KB spring.servlet.multipart.max-request-size=128KB

Wir können auch steuern, ob das Hochladen von Dateien aktiviert ist, und den Speicherort für das Hochladen von Dateien:

spring.servlet.multipart.enabled=true spring.servlet.multipart.location=${java.io.tmpdir}

Beachten Sie, dass wir $ {java.io.tmpdir} verwendet haben , um den Upload-Speicherort zu definieren, damit wir den temporären Speicherort für verschiedene Betriebssysteme verwenden können.

8. Fazit

In diesem Artikel haben wir uns verschiedene Möglichkeiten angesehen, um die Unterstützung mehrerer Teile im Frühjahr zu konfigurieren. Mit diesen können wir das Hochladen von Dateien in unseren Webanwendungen unterstützen.

Die Implementierung dieses Tutorials finden Sie in einem GitHub-Projekt. Wenn das Projekt lokal ausgeführt wird, kann auf das Formularbeispiel unter // localhost: 8080 / spring-mvc-java / fileUpload zugegriffen werden