• Homepage
  • Articoli
  • Generale
  • Come caricare più file in una posizione specifica utilizzando Spring MVC? Tutorial completo con codice Java

Come caricare più file in una posizione specifica utilizzando Spring MVC? Tutorial completo con codice Java

Pubblicato: 2013-06-22

Questo è un altro tutorial completo di Spring MVC che accetta il file sul modulo di caricamento e lo copia in una cartella specifica sull'evento "Invia". Come al solito abbiamo una dependency da Hello World Spring MVC Example.

Quindi, queste sono le aggiunte/modifiche che dobbiamo eseguire in questo esempio:

  • Nuovo file: CrunchifyFileUploadController.java
  • Nuovo file: CrunchifyFileUpload.java
  • Nuovo file: uploadfile.jsp
  • Nuovo file: uploadfilesuccess.jsp
  • File modificato: crunchify-servlet.xml
  • 2 nuovi file jar: commons-io-2.4.jar e commons-fileupload-1.3.jar

Hai una delle seguenti domande? Allora sei nel posto giusto.

  • Esempio di caricamento di più file Java
  • Carica più file o cartelle

Ecco una struttura finale del progetto in modo da avere un'idea su dove aggiungere file.

Esercitazione sul caricamento di file MVC primaverili di Crunchify

Ora iniziamo:

Passaggio 1) Prerequisito:

https://crunchify.com/hello-world-example-spring-mvc-3-2-1/ (distribuisci questo progetto con successo su Tomcat)

Dipendenze Maven:

Aggiungi di seguito nuove dipendenze al file pom.xml del tuo progetto.

Add belwo to pom.xml file
1
2
3
4
5
6
7
8
9
10
< dependency >
< groupId > commons - fileupload < / groupId >
< artifactId > commons - fileupload < / artifactId >
< version > 1.2 < / version >
< / dependency >
< dependency >
< groupId > commons - io < / groupId >
< artifactId > commons - io < / artifactId >
< version > 1.4 < / version >
< / dependency >

Passaggio 2) SpringController

Crea un controller basato su MVC Spring 3 che gestisce il caricamento dei file. Ci sono due metodi in questo controller:

  1. crunchifyDisplayForm : inoltra semplicemente la richiesta a pageuploadfile.jsp
  2. crunchifySave : recupera il modulo utilizzando l'annotazione @ModelAttribute e ne ricava il contenuto del file. Crea un elenco di nomi di file caricati e passa questo elenco alla pagina di successo.

CrunchifyFileUploadController.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com . crunchify . controller ;
 
import com . crunchify . form . CrunchifyFileUpload ;
 
import java . io . File ;
import java . io . IOException ;
import java . util . ArrayList ;
import java . util . List ;
 
import org . springframework . stereotype . Controller ;
import org . springframework . ui . Model ;
import org . springframework . web . bind . annotation . ModelAttribute ;
import org . springframework . web . bind . annotation . RequestMapping ;
import org . springframework . web . bind . annotation . RequestMethod ;
import org . springframework . web . multipart . MultipartFile ;
 
@Controller
public class CrunchifyFileUploadController {
 
     @RequestMapping ( value = "/upload" , method = RequestMethod . GET )
     public String crunchifyDisplayForm ( ) {
         return "uploadfile" ;
     }
 
     @RequestMapping ( value = "/savefiles" , method = RequestMethod . POST )
     public String crunchifySave (
             @ModelAttribute ( "uploadForm" ) CrunchifyFileUpload uploadForm ,
             Model map ) throws IllegalStateException , IOException {
         String saveDirectory = "c:/crunchify/" ;
 
         List <MultipartFile> crunchifyFiles = uploadForm . getFiles ( ) ;
 
         List <String> fileNames = new ArrayList <String> ( ) ;
 
         if ( null ! = crunchifyFiles && crunchifyFiles.size() > 0) {
            for (MultipartFile multipartFile : crunchifyFiles) {
 
                String fileName = multipartFile.getOriginalFilename();
                 if ( ! "" . equalsIgnoreCase ( fileName ) ) {
                     // Handle file content - multipartFile.getInputStream()
                     multipartFile
                             . transferTo ( new File ( saveDirectory + fileName ) ) ;
                     fileNames . add ( fileName ) ;
                 }
             }
         }
 
         map . addAttribute ( "files" , fileNames ) ;
         return "uploadfilesuccess" ;
     }
}

Passaggio 3) Modello – Oggetto modulo

Crea un bean Java che funge da oggetto Model/Form per la nostra applicazione Spring. Questo bean contiene un List di oggetti org.springframework.web.multipart.MultipartFile . Il framework Spring fornisce un'utile classe MultipartFile che può essere utilizzata per recuperare il contenuto del file caricato. Oltre al suo contenuto, l'oggetto MultipartFile fornisce anche altre informazioni utili come il nome del file, la dimensione del file ecc.

CrunchifyFileUpload.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com . crunchify . form ;
 
import java . util . List ;
import org . springframework . web . multipart . MultipartFile ;
 
public class CrunchifyFileUpload {
 
     private List <MultipartFile> crunchifyFiles ;
 
     public List <MultipartFile> getFiles ( ) {
         return crunchifyFiles ;
     }
 
     public void setFiles ( List <MultipartFile> files ) {
         this . crunchifyFiles = files ;
     }
}

Passaggio 4) Viste JSP

Ora crea le pagine di visualizzazione per questa applicazione. Avremo bisogno di due JSP, uno per visualizzare il modulo di caricamento dei file e un altro per mostrare il risultato in caso di caricamento riuscito.

Il uploadfile.jsp mostra un modulo con l'input del file. Oltre a questo abbiamo aggiunto un piccolo frammento di jquery facendo clic sul pulsante Aggiungi. Questo aggiungerà un nuovo componente di input del file alla fine del modulo. Ciò consente all'utente di caricare tutti i file che desidera.

Nota che abbiamo impostato enctype=”multipart/form-data” del nostro tag <form> .

uploadfile.jsp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<% @ taglib uri = "http://www.springframework.org/tags/form" prefix = "form" %>
< html >
< head >
< title > Crunchify - Spring MVC Upload Multiple Files Example < / title >
<script
     src = "http://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js" > </script>
<script>
     $ ( document )
             . ready (
                     function ( ) {
                         //add more file components if Add is clicked
                         $ ( '#addFile' )
                                 . click (
                                         function ( ) {
                                             var fileIndex = $ ( '#fileTable tr' )
                                                     . children ( ) . length - 1 ;
                                             $ ( '#fileTable' )
                                                     . append (
                                                             '<tr><td>'
                                                                    + '   <input type="file" name="files[' + fileIndex + ']" />'
                                                                    + '</td></tr>' ) ;
                                         } ) ;
 
                     } ) ;
</script>
<style type ="text/css">
body {
     background-image :
         url ( 'https://cdn.crunchify.com/wp-content/uploads/2013/03/Crunchify.bg_.300.png' ) ;
}
</style>
< / head >
< body >
     < br >
     < br >
     < div align = "center" >
         < h1 > Crunchify - Spring MVC Upload Multiple Files Example < / h1 >
 
         < form : form method = "post" action = "savefiles.html"
             modelAttribute = "uploadForm" enctype = "multipart/form-data" >
 
             < p > Select files to upload . Press Add button to add more file
                 inputs . < / p >
 
             < table id = "fileTable" >
                 < tr >
                     < td > < input name = "files[0]" type = "file" / > < / td >
                 < / tr >
                 < tr >
                     < td > < input name = "files[1]" type = "file" / > < / td >
                 < / tr >
             < / table >
             < br / >
             < input type = "submit" value = "Upload" / >
             < input id = "addFile" type = "button" value = "Add File" / >
         < / form : form >
 
         < br / >
     < / div >
< / body >
< / html >

uploadfilesuccess.jsp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<% @ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c" %>
< html >
< head >
< title > Crunchify - Upload Multiple Files Example < / title >
<style type ="text/css">
body {
     background-image :
         url ( 'https://cdn.crunchify.com/wp-content/uploads/2013/03/Crunchify.bg_.300.png' ) ;
}
</style>
< / head >
< body >
     < br >
     < br >
     < div align = "center" >
 
         < h1 > Crunchify - Spring MVC Upload Multiple Files Example < / h1 >
         < p > Awesome . . Following files are uploaded successfully . < / p >
         < ol >
             < c : forEach items = "${files}" var = "file" >
           - $ { file } < br >
             < / c : forEach >
         < / ol >
         < a href = "http://localhost:8080/CrunchifySpringMVC3.2.1/upload.html" > < input
             type = "button" value = "Go Back" / > < / a > < br / >
         < br / >
         < br / >
         < div
             style = "font-family: verdana; line-height: 25px; padding: 5px 10px; border-radius: 10px; border: 1px dotted #A4A4A4; width: 50%; font-size: 12px;" >
 
             Spring MVC Upload Multiple Files Example by < a
                 href = 'https://crunchify.com' > Crunchify < / a > . Click < a
                 href = 'https://crunchify.com/category/java-tutorials/' > here < / a >
             for all Java , Spring MVC , Web Development examples . < br >
         < / div >
     < / div >
< / body >
< / html >

Passaggio 5) Aggiorna la configurazione di primavera

Aggiungi il bean sottostante al file crunchify-servlet.xml , appena sopra la riga <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"> .

1
2
< bean id = "multipartResolver"
         class = "org.springframework.web.multipart.commons.CommonsMultipartResolver" / >

Passaggio 6) Risultato del pagamento

Avvia Tomcat e punta il tuo browser a questo URL: http://localhost:8080/CrunchifySpringMVC3.2.1/upload.html e dovresti vedere una schermata simile a questa.

Crunchify Spring MVC - Esempio di caricamento di file multipli

Dopo il caricamento del file vedrai un messaggio di successo come questo. Puoi sempre abbellire il tuo file .jsp nel modo che preferisci.

Crunchify Spring MVC - Risultato di esempio di caricamento di file multipli

Elenco di tutti gli esempi Spring MVC, esempi Java.