Jak przesłać wiele plików do określonej lokalizacji za pomocą Spring MVC? Kompletny samouczek z kodem Java

Opublikowany: 2013-06-22

To kolejny kompletny samouczek Spring MVC, który akceptuje plik w formularzu przesyłania i kopiuje go do określonego folderu w zdarzeniu „Prześlij”. Jak zwykle mamy dependency od Hello World Spring MVC Przykład.

Oto dodatki / zmiany, które musimy wykonać w tym przykładzie:

  • Nowy plik: CrunchifyFileUploadController.java
  • Nowy plik: CrunchifyFileUpload.java
  • Nowy plik: uploadfile.jsp
  • Nowy plik: uploadfilesuccess.jsp
  • Zmodyfikowany plik: crunchify-servlet.xml
  • 2 nowe pliki jar: commons-io-2.4.jar i commons-fileupload-1.3.jar

Masz któreś z poniższych pytań? Jesteś we właściwym miejscu.

  • Przykład przesyłania wielu plików Java
  • Prześlij wiele plików lub folderów

Oto ostateczna struktura projektu, dzięki czemu dowiesz się, gdzie dodać pliki.

Samouczek przesyłania plików Spring MVC autorstwa Crunchify

Teraz zacznijmy:

Krok-1) Warunek wstępny:

https://crunchify.com/hello-world-example-spring-mvc-3-2-1/ (Wdróż ten projekt pomyślnie na Tomcat)

Zależności Mavena:

Dodaj poniżej nowe zależności do pliku pom.xml projektu.

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 >

Krok-2) SpringController

Utwórz kontroler oparty na Spring 3 MVC, który obsługuje przesyłanie plików. W tym kontrolerze są dwie metody:

  1. crunchifyDisplayForm – po prostu przekazuje żądanie do pageuploadfile.jsp
  2. crunchifySave — pobiera formularz za pomocą adnotacji @ModelAttribute i pobiera z niego zawartość pliku. Tworzy listę nazw plików przesyłanych plików i przekazuje tę listę do strony sukcesu.

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" ;
     }
}

Krok-3) Model – Obiekt formularza

Utwórz ziarno Java, które działa jako obiekt Model/Form dla naszej aplikacji Spring. Ten ziarno zawiera List obiektów org.springframework.web.multipart.MultipartFile . Framework Spring zapewnia użyteczną klasę MultipartFile, która może być użyta do pobrania zawartości przesłanego pliku. Oprócz swojej zawartości obiekt MultipartFile dostarcza również inne przydatne informacje, takie jak nazwa pliku, rozmiar pliku itp.

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 ;
     }
}

Krok-4) Widoki JSP

Teraz utwórz strony widoku dla tej aplikacji. Będziemy potrzebować dwóch stron JSP, jednego do wyświetlania formularza przesyłania plików, a drugiego do wyświetlania wyników pomyślnego przesyłania.

uploadfile.jsp wyświetla formularz z danymi wejściowymi do pliku. Oprócz tego dodaliśmy mały fragment jquery po kliknięciu przycisku Dodaj. Spowoduje to dodanie nowego komponentu wejściowego pliku na końcu formularza. Dzięki temu użytkownik może przesłać tyle plików, ile chce.

Zauważ, że ustawiliśmy enctype=”multipart/form-data” naszego tagu <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 >

Krok-5) Zaktualizuj konfigurację wiosenną

Dodaj poniżej fasolę do pliku crunchify-servlet.xml , tuż nad <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"> .

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

Krok 6) Wynik kasy

Uruchom tomcat i skieruj przeglądarkę na ten adres URL: http://localhost:8080/CrunchifySpringMVC3.2.1/upload.html i powinieneś zobaczyć ekran podobny do tego.

Crunchify Spring MVC — przykład przesyłania wielu plików

Po przesłaniu pliku zobaczysz taki komunikat o sukcesie. Zawsze możesz upiększyć swój plik .jsp tak, jak chcesz.

Crunchify Spring MVC - Przesyłanie wielu plików Przykładowy wynik

Lista wszystkich przykładów Spring MVC, przykładów Java.