¿Cómo cargar varios archivos en una ubicación específica usando Spring MVC? Tutorial completo con código Java

Publicado: 2013-06-22

Este es otro tutorial completo de Spring MVC que acepta el archivo en el formulario de carga y lo copia en una carpeta específica en el evento "Enviar". Como de costumbre, tenemos una dependency en Hello World Spring MVC Example.

Entonces, estas son las adiciones/cambios que necesitamos realizar en este ejemplo:

  • Nuevo archivo: CrunchifyFileUploadController.java
  • Nuevo archivo: CrunchifyFileUpload.java
  • Nuevo archivo: uploadfile.jsp
  • Nuevo archivo: uploadfilesuccess.jsp
  • Archivo modificado: crunchify-servlet.xml
  • 2 nuevos archivos jar: commons-io-2.4.jar y commons-fileupload-1.3.jar

¿Tiene alguna de las siguientes preguntas? Entonces estás en el lugar correcto.

  • Ejemplo de carga de archivos múltiples de Java
  • Subir varios archivos o carpetas

Aquí hay una estructura de proyecto final para que tenga una idea de dónde agregar archivos.

Tutorial de carga de archivos Spring MVC por Crunchify

Ahora comencemos:

Paso-1) Requisito previo:

https://crunchify.com/hello-world-example-spring-mvc-3-2-1/ (Implemente este proyecto con éxito en Tomcat)

Dependencias Maven:

Agregue a continuación nuevas dependencias al archivo pom.xml de su proyecto.

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 >

Paso-2) SpringController

Cree un controlador basado en Spring 3 MVC que maneje la carga de archivos. Hay dos métodos en este controlador:

  1. crunchifyDisplayForm : simplemente reenvía la solicitud a pageuploadfile.jsp
  2. crunchifySave : obtiene el formulario usando la anotación @ModelAttribute y obtiene el contenido del archivo. Crea una lista de nombres de archivo de los archivos que se cargan y pasa esta lista a la página de éxito.

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

Paso-3) Modelo - Objeto de formulario

Cree un bean de Java que actúe como objeto de modelo/formulario para nuestra aplicación Spring. Este bean contiene una List de objetos org.springframework.web.multipart.MultipartFile . Spring framework proporciona una clase útil MultipartFile que se puede usar para obtener el contenido del archivo cargado. Además de su contenido, el objeto MultipartFile también le brinda otra información útil, como el nombre del archivo, el tamaño del archivo, etc.

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

Paso 4) Vistas JSP

Ahora cree las páginas de vista para esta aplicación. Necesitaremos dos JSP, uno para mostrar el formulario de carga de archivos y otro para mostrar el resultado de una carga exitosa.

uploadfile.jsp muestra un formulario con entrada de archivo. Aparte de esto, hemos agregado un pequeño fragmento de jquery al hacer clic en el botón Agregar. Esto agregará un nuevo componente de entrada de archivo al final del formulario. Esto permite al usuario cargar tantos archivos como desee.

Tenga en cuenta que hemos establecido enctype=”multipart/form-data” de nuestra etiqueta <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 >

Paso 5) Actualizar la configuración de Spring

Agregue debajo del bean al archivo crunchify-servlet.xml , justo encima de la línea <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"> .

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

Paso 6) Resultado de pago

Inicie Tomcat y apunte su navegador a esta URL: http://localhost:8080/CrunchifySpringMVC3.2.1/upload.html y debería ver una pantalla similar a esta.

Crunchify Spring MVC - Ejemplo de carga de archivos múltiples

Después de cargar el archivo, verá un mensaje de éxito como este. Siempre puede embellecer su archivo .jsp de la forma que desee.

Crunchify Spring MVC - Ejemplo de resultado de carga de archivos múltiples

Lista de todos los ejemplos de Spring MVC, ejemplos de Java.