Upload af fil med Spring MVC

1. Oversigt

I tidligere artikler introducerede vi det grundlæggende i formhåndtering og udforskede formtag-biblioteket i Spring MVC.

I denne artikel fokuserer vi på, hvad Spring tilbyder til multipart (fil upload) support i webapplikationer.

Foråret giver os mulighed for at aktivere denne multipart-support med tilslutning MultipartResolver genstande. Rammen giver en MultipartResolver implementering til brug med Commons FileUpload og en anden til brug med Servlet 3.0 flerdelt anmodningsparsering.

Efter konfiguration af MultipartResolver vi ser, hvordan man uploader en enkelt fil og flere filer.

Vi rører også ved Spring Boot.

2. Commons FileUpload

At bruge CommonsMultipartResolver for at håndtere filoverførslen skal vi tilføje følgende afhængighed:

 commons-fileupload commons-fileupload 1.3.1 

Nu kan vi definere CommonsMultipartResolver bønne i vores forårskonfiguration.

Det her MultipartResolver leveres med en række sæt metode til at definere egenskaber såsom den maksimale størrelse for uploads:

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

Her er vi nødt til at kontrollere forskellige egenskaber af CommonsMultipartResolver i selve Bean-definitionen.

3. Med Servlet 3.0

For at bruge Servlet 3.0 flerdelt parsing, skal vi konfigurere et par stykker af applikationen. Først skal vi indstille en MultipartConfigElement i vores DispatcherServletregistrering:

offentlig klasse MainWebAppInitializer implementerer WebApplicationInitializer {private String TMP_FOLDER = "/ tmp"; privat int MAX_UPLOAD_SIZE = 5 * 1024 * 1024; @ Overstyr offentlig tomrum påStartup (ServletContext sc) kaster ServletException {ServletRegistration.Dynamic appServlet = sc.addServlet ("mvc", ny DispatcherServlet (ny GenericWebApplicationContext ())); appServlet.setLoadOnStartup (1); MultipartConfigElement multipartConfigElement = nyt MultipartConfigElement (TMP_FOLDER, MAX_UPLOAD_SIZE, MAX_UPLOAD_SIZE * 2, MAX_UPLOAD_SIZE / 2); appServlet.setMultipartConfig (multipartConfigElement); }}

I MultipartConfigElement objekt, har vi konfigureret lagerplaceringen, maksimal individuel filstørrelse, maksimal anmodningsstørrelse (i tilfælde af flere filer i en enkelt anmodning) og størrelsen, hvormed filoverførselsforløbet skylles til lagerplaceringen.

Disse indstillinger skal anvendes på servletregistreringsniveauet som Servlet 3.0 tillader ikke, at de bliver registreret i MultipartResolver som det er tilfældet med CommonsMultipartResolver.

Når dette er gjort, vi kan tilføje StandardServletMultipartResolver til vores forårskonfiguration:

@Bean offentlig StandardServletMultipartResolver multipartResolver () {returner ny StandardServletMultipartResolver (); }

4. Uploade en fil

For at uploade vores fil kan vi oprette en simpel form, hvor vi bruger en HTML input tag med type = 'fil'.

Uanset konfiguration af uploadhåndtering har vi valgt, at vi skal indstille kodningsattributten for formularen til multipart / form-data. Dette lader browseren vide, hvordan man koder formularen:

Vælg en fil, der skal uploades

For at gemme den uploadede fil kan vi bruge en MultipartFile variabel. Vi kan hente denne variabel fra anmodningsparameteren inde i vores controller's metode:

@RequestMapping (værdi = "/ uploadFile", metode = RequestMethod.POST) offentlig streng indsende (@RequestParam ("fil") MultipartFile-fil, ModelMap modelMap) {modelMap.addAttribute ("fil", fil); returner "fileUploadView"; } 

Det MultipartFile klasse giver adgang til detaljer om den uploadede fil, inklusive filnavn, filtype og så videre. Vi kan bruge en simpel HTML-side til at vise disse oplysninger:

Indsendt fil

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

5. Uploader Flere filer

For at uploade flere filer i en enkelt anmodning lægger vi blot flere inputfilfelter inde i formularen:

Vælg en fil, der skal uploades
Vælg en fil, der skal uploades
Vælg en fil, der skal uploades

Vi er nødt til at passe på, at hvert inputfelt har samme navn, så det er tilgængeligt som en række af MultipartFile:

@RequestMapping (værdi = "/ uploadMultiFile", metode = RequestMethod.POST) offentlig String indsende (@RequestParam ("filer") MultipartFile [] filer, ModelMap modelMap) {modelMap.addAttribute ("filer", filer); returner "fileUploadView"; } 

Nu kan vi simpelthen gentage det matrix for at vise filoplysninger:

   Spring MVC File Upload 

Indsendte filer

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

6. Uploade filer med yderligere formulardata

Vi kan også sende yderligere oplysninger til serveren sammen med den fil, der uploades. Vi skal bare medtage de krævede felter i formularen:

Navn
E-mail
Vælg en fil, der skal uploades

I controlleren kan vi få alle formulardata ved hjælp af @RequestParam kommentar:

@PostMapping ("/ uploadFileWithAddtionalData") offentlig streng indsend (@RequestParam MultipartFile fil, @RequestParam String navn, @RequestParam String email, ModelMap modelMap) {modelMap.addAttribute ("navn", navn); modelMap.addAttribute ("e-mail", e-mail); modelMap.addAttribute ("fil", fil); returner "fileUploadView"; }

I lighed med tidligere sektioner kan vi bruge HTML-siden med JSTL tags for at få vist oplysningerne.

Vi kan også indkapsle alle formularfelterne i en modelklasse og bruge dem @ModelAttribute kommentar i controlleren. Dette ville være nyttigt, når der er mange yderligere felter sammen med filen. Lad os se på koden:

offentlig klasse FormDataWithFile {privat strengnavn; privat streng e-mail; privat MultipartFile-fil; // standard getters og setter}
@PostMapping ("/ uploadFileModelAttribute") offentlig streng indsende (@ModelAttribute FormDataWithFile formDataWithFile, ModelMap modelMap) {modelMap.addAttribute ("formDataWithFile", formDataWithFile); returner "fileUploadView"; }

7. Upload af Spring Boot-fil

Hvis vi bruger Spring Boot, gælder alt, hvad vi hidtil har set.

Spring Boot gør det dog endnu nemmere at konfigurere og starte alt med lidt besvær.

I særdeleshed, det er ikke nødvendigt at konfigurere nogen servlet, som Boot vil registrere og konfigurere det for os, forudsat at vi inkluderer webmodulet i vores afhængigheder:

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

Vi kan finde den nyeste version af spring-boot-starter-web på Maven Central.

Hvis vi vil kontrollere den maksimale filoverførselsstørrelse, kan vi redigere vores application.properties:

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

Vi kan også kontrollere, om filupload er aktiveret, og placeringen af ​​filupload:

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

Bemærk, at vi har brugt $ {java.io.tmpdir} for at definere uploadplaceringen, så vi kan bruge den midlertidige placering til forskellige operativsystemer.

8. Konklusion

I denne artikel så vi på forskellige måder at konfigurere understøttelse af flere dele om foråret. Ved hjælp af disse kan vi understøtte filuploads i vores webapplikationer.

Implementeringen af ​​denne vejledning kan findes i et GitHub-projekt. Når projektet kører lokalt, kan du få adgang til formulareksemplet på // localhost: 8080 / spring-mvc-java / fileUpload