Spring MVC file upload – single and Multiple files upload

In Spring MVC application, it is very much common that we need to upload the file.

So it provides a simple way for doing it.

We need to follow below 4 steps to make the file upload successfully in Spring MVC

1)Add the file upload field in the form using input type as file

  1. <input type=”file” name=”uploadFile”/>
<input type=”file” name=”uploadFile”/>

2)The form must be configured to submit the file in the request by providing encype as multipart/form-data as below

  1. <form method="POST" action="uploadFile" enctype="multipart/form-data">
<form method="POST" action="uploadFile" enctype="multipart/form-data">

3)Handler Method needs to be configured to handle the uploaded file, so handler method must have a parameter of type MultipartFile as below

  1. public @ResponseBody String uploadFileHandler(@RequestParam("name") String name, @RequestParam("file") MultipartFile file)
public @ResponseBody String uploadFileHandler(@RequestParam("name") String name, @RequestParam("file") MultipartFile file)

4)Define the bean of type MultipartResolver and it has 2 implementations
CommonsMultipartResolver and StandardServletMultipartResolver

Since Dsipatcher servlet has declared a field called multipartResolver, we need to define a bean with the same name so that it will be injected to DispatcherServlet.

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

Lets develop an application

User uploads the file from the form and same file will be saved in the server by the handler.

Project structure

Create the pom.xml with required dependencies

We will add apache file upload and file io dependencies as below

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.   <groupId>Spring</groupId>
  5.   <artifactId>FileUpload</artifactId>
  6.   <packaging>war</packaging>
  7.   <version>0.0.1-SNAPSHOT</version>
  8.   <name>FileUpload Maven Webapp</name>
  9.   <url>http://maven.apache.org</url>
  10.    <properties>
  11.         <org.springframework.version>4.2.0.RELEASE</org.springframework.version>
  12.     </properties>
  13.   <dependencies>
  14.     <dependency>
  15.       <groupId>junit</groupId>
  16.       <artifactId>junit</artifactId>
  17.       <version>3.8.1</version>
  18.       <scope>test</scope>
  19.     </dependency>
  20.     <dependency>
  21.             <groupId>org.springframework</groupId>
  22.             <artifactId>spring-web</artifactId>
  23.             <version>${org.springframework.version}</version>
  24.         </dependency>
  25.  
  26.         <dependency>
  27.             <groupId>org.springframework</groupId>
  28.             <artifactId>spring-webmvc</artifactId>
  29.             <version>${org.springframework.version}</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>javax.servlet</groupId>
  33.             <artifactId>servlet-api</artifactId>
  34.             <version>2.5</version>
  35.             <scope>provided</scope>
  36.         </dependency>
  37.         <dependency>
  38.     <groupId>javax.servlet.jsp.jstl</groupId>
  39.     <artifactId>javax.servlet.jsp.jstl-api</artifactId>
  40.     <version>1.2.1</version>
  41. </dependency>
  42.  
  43. <!-- Apache Commons FileUpload -->
  44. <dependency>
  45.     <groupId>commons-fileupload</groupId>
  46.     <artifactId>commons-fileupload</artifactId>
  47.     <version>1.3.1</version>
  48. </dependency>
  49.  
  50. <!-- Apache Commons IO -->
  51. <dependency>
  52.     <groupId>commons-io</groupId>
  53.     <artifactId>commons-io</artifactId>
  54.     <version>2.4</version>
  55. </dependency>
  56. <dependency>
  57.     <groupId>taglibs</groupId>
  58.     <artifactId>standard</artifactId>
  59.     <version>1.1.2</version>
  60. </dependency>
  61.   </dependencies>
  62.   <build>
  63.     <finalName>SpringFileUpload</finalName>
  64.     <plugins>
  65.             <plugin>
  66.                 <groupId>org.apache.maven.plugins</groupId>
  67.                 <artifactId>maven-compiler-plugin</artifactId>
  68.                 <version>2.5.1</version>
  69.                 <configuration>
  70.                     <source>1.8</source>
  71.                     <target>1.8</target>
  72.                 </configuration>
  73.             </plugin>
  74.         </plugins>
  75.   </build>
  76. </project>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>Spring</groupId>
  <artifactId>FileUpload</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>FileUpload Maven Webapp</name>
  <url>http://maven.apache.org</url>
   <properties>
		<org.springframework.version>4.2.0.RELEASE</org.springframework.version>
	</properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
	<groupId>javax.servlet.jsp.jstl</groupId>
	<artifactId>javax.servlet.jsp.jstl-api</artifactId>
	<version>1.2.1</version>
</dependency>

<!-- Apache Commons FileUpload -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>
 
<!-- Apache Commons IO -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
<dependency>
	<groupId>taglibs</groupId>
	<artifactId>standard</artifactId>
	<version>1.1.2</version>
</dependency>
  </dependencies>
  <build>
    <finalName>SpringFileUpload</finalName>
    <plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.5.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
  </build>
</project>

Create the web.xml

  1. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  3.     version="3.1">
  4.  
  5.     <display-name>FileUpload</display-name>
  6.  
  7.     <!-- Spring MVC dispatcher servlet -->
  8.     <servlet>
  9.         <servlet-name>mvc-dispatcher</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <init-param>
  12.             <param-name>contextConfigLocation</param-name>
  13.             <param-value>
  14.             /WEB-INF/spring-mvc.xml,
  15.         </param-value>
  16.         </init-param>
  17.         <load-on-startup>1</load-on-startup>
  18.     </servlet>
  19.     <servlet-mapping>
  20.         <servlet-name>mvc-dispatcher</servlet-name>
  21.         <url-pattern>/</url-pattern>
  22.     </servlet-mapping>
  23.  
  24.     <listener>
  25.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  26.     </listener>
  27. </web-app>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
	version="3.1">

	<display-name>FileUpload</display-name>

	<!-- Spring MVC dispatcher servlet -->
	<servlet>
		<servlet-name>mvc-dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>
			/WEB-INF/spring-mvc.xml,
		</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>mvc-dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
</web-app>

Create the spring configuration file

Now add the multipartResolver bean in the configuration file so that spring can handle multippart requests like file upload.

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  8.        http://www.springframework.org/schema/context
  9.        http://www.springframework.org/schema/context/spring-context-3.2.xsd
  10.        http://www.springframework.org/schema/mvc
  11.        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
  12.  
  13.     <context:component-scan base-package="com.kb.*" />
  14.     <mvc:annotation-driven />
  15.  
  16.     <bean id="viewResolver"
  17.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  18.         <property name="prefix" value="/WEB-INF/pages/" />
  19.         <property name="suffix" value=".jsp" />
  20.     </bean>
  21.    
  22.      <bean id="multipartResolver"
  23.         class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  24.  
  25.          <!-- setting maximum upload size in KB -->
  26.         <property name="maxUploadSize" value="100000" />
  27.  
  28.     </bean>
  29.    
  30. </beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

	<context:component-scan base-package="com.kb.*" />
	<mvc:annotation-driven />

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/pages/" />
		<property name="suffix" value=".jsp" />
	</bean>
	
	 <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 
         <!-- setting maximum upload size in KB -->
        <property name="maxUploadSize" value="100000" />
 
    </bean>
    
</beans>

Create the view page

One for single file and other for multiple files upload

uploadSingleFile.jsp

  1. <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
  2.     pageEncoding="ISO-8859-1"%>
  3. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
  4. <%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
  5. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  6. <html>
  7. <head>
  8. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  9. <title>Hello</title>
  10. </head>
  11. <body>
  12.  <form method="POST" action="uploadSingleFile" enctype="multipart/form-data">
  13.         File to Upload: <input type="file" name="file"><br />
  14.         Name: <input type="text" name="name"><br /> <br />
  15.         <input type="submit" value="Upload">
  16.  </form>
  17. </body>
  18. </html>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Hello</title>
</head>
<body>
 <form method="POST" action="uploadSingleFile" enctype="multipart/form-data">
        File to Upload: <input type="file" name="file"><br /> 
        Name: <input type="text" name="name"><br /> <br /> 
        <input type="submit" value="Upload">
 </form>
</body>
</html>

uploadMultipleFile.jsp

  1. <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
  2.     pageEncoding="ISO-8859-1"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  7. <title>Insert title here</title>
  8. </head>
  9. <body>
  10. <form method="POST" action="uploadMultipleFiles" enctype="multipart/form-data">
  11.         File1 to upload: <input type="file" name="file"><br />
  12.         Name: <input type="text" name="name"><br /> <br />
  13.         File2 to upload: <input type="file" name="file"><br />
  14.         Name: <input type="text" name="name"><br /> <br />
  15.         <input type="submit" value="Upload">
  16.     </form>
  17. </body>
  18. </html>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form method="POST" action="uploadMultipleFiles" enctype="multipart/form-data">
        File1 to upload: <input type="file" name="file"><br /> 
        Name: <input type="text" name="name"><br /> <br /> 
        File2 to upload: <input type="file" name="file"><br /> 
        Name: <input type="text" name="name"><br /> <br />
        <input type="submit" value="Upload">
    </form>
</body>
</html>

Create the controller

  1. package com.kb.controllers;
  2.  
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6.  
  7. import javax.servlet.ServletContext;
  8.  
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestMethod;
  12. import org.springframework.web.bind.annotation.RequestParam;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  14. import org.springframework.web.context.ServletContextAware;
  15. import org.springframework.web.multipart.MultipartFile;
  16. import org.springframework.web.servlet.ModelAndView;
  17.  
  18. @Controller
  19. public class FileUploadController implements ServletContextAware {
  20.  
  21.     private ServletContext servletContext;
  22.    
  23.    
  24.     @RequestMapping(value = "/uploadSingleFile", method = RequestMethod.GET)
  25.     public ModelAndView uploadSingleFileFormDisplay() {
  26.    
  27.         return new ModelAndView("uploadSingleFile");
  28.        
  29.     }
  30.    
  31.     @RequestMapping(value = "/uploadMultipleFiles", method = RequestMethod.GET)
  32.     public ModelAndView uploadMultipleFilesFormDisplay() {
  33.    
  34.         return new ModelAndView("uploadMultipleFiles");
  35.        
  36.     }
  37.    
  38.    
  39.     //Handle the single file upload
  40.    
  41.     @RequestMapping(value = "/uploadSingleFile", method = RequestMethod.POST)
  42.     public @ResponseBody String uploadSingleFileHandler(@RequestParam("name") String filename,
  43.             @RequestParam("file") MultipartFile file) {
  44.        
  45.         //file handling to upload it in the server path
  46.        
  47.         if (!file.isEmpty()) {
  48.             try {
  49.                 byte[] bytes = file.getBytes();
  50.                 BufferedOutputStream stream =
  51.                         new BufferedOutputStream(new FileOutputStream(new File(servletContext.getRealPath("/")+"/"+filename)));
  52.                 stream.write(bytes);
  53.                 stream.close();
  54.                 return "You successfully uploaded " + filename + "!";
  55.             } catch (Exception e) {
  56.                 return "You failed to upload " + filename + " => " + e.getMessage();
  57.             }
  58.         } else {
  59.             return "You failed to upload " + filename + " because the file was empty.";
  60.         }
  61.        
  62.     }
  63.    
  64.    
  65.     //Handle the multiple  files upload
  66.    
  67.     @RequestMapping(value = "/uploadMultipleFiles", method = RequestMethod.POST)
  68.     public @ResponseBody String uploadMultipleFilesHandler(@RequestParam("name") String[] filenames,
  69.             @RequestParam("file") MultipartFile[] files) {
  70.        
  71.         //file handling to upload it in the server path
  72.        
  73.         if (files.length != filenames.length)
  74.             return "Required information missing";
  75.         String message = "";
  76.         for (int i = 0; i < files.length; i++) {
  77.             MultipartFile file = files[i];
  78.             String filename = filenames[i];
  79.             try {
  80.  
  81.                 byte[] bytes = file.getBytes();
  82.                 BufferedOutputStream stream =
  83.                         new BufferedOutputStream(new FileOutputStream(new File(servletContext.getRealPath("/")+"/"+filename)));
  84.                 stream.write(bytes);
  85.                 stream.close();
  86.  
  87.                 message = message + "You successfully uploaded file=" + filename
  88.                         + "<br />";
  89.             } catch (Exception e) {
  90.                 return "You failed to upload " + filename + " => " + e.getMessage();
  91.             }
  92.         }
  93.         return message;
  94.        
  95.     }
  96.  
  97.  
  98.     public void setServletContext(ServletContext servletContext) {
  99.         this.servletContext=servletContext;
  100.        
  101.     }
  102.  
  103. }
package com.kb.controllers;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;

import javax.servlet.ServletContext;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.ServletContextAware;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FileUploadController implements ServletContextAware {

	private ServletContext servletContext;
	
	
	@RequestMapping(value = "/uploadSingleFile", method = RequestMethod.GET)
	public ModelAndView uploadSingleFileFormDisplay() {
	
		return new ModelAndView("uploadSingleFile");
		
	}
	
	@RequestMapping(value = "/uploadMultipleFiles", method = RequestMethod.GET)
	public ModelAndView uploadMultipleFilesFormDisplay() {
	
		return new ModelAndView("uploadMultipleFiles");
		
	}
	
	
	//Handle the single file upload
	
	@RequestMapping(value = "/uploadSingleFile", method = RequestMethod.POST)
	public @ResponseBody String uploadSingleFileHandler(@RequestParam("name") String filename,
			@RequestParam("file") MultipartFile file) {
		
		//file handling to upload it in the server path
		
		if (!file.isEmpty()) {
            try {
                byte[] bytes = file.getBytes();
                BufferedOutputStream stream =
                        new BufferedOutputStream(new FileOutputStream(new File(servletContext.getRealPath("/")+"/"+filename)));
                stream.write(bytes);
                stream.close();
                return "You successfully uploaded " + filename + "!";
            } catch (Exception e) {
                return "You failed to upload " + filename + " => " + e.getMessage();
            }
        } else {
            return "You failed to upload " + filename + " because the file was empty.";
        }
		
	}
	
	
	//Handle the multiple  files upload
	
	@RequestMapping(value = "/uploadMultipleFiles", method = RequestMethod.POST)
	public @ResponseBody String uploadMultipleFilesHandler(@RequestParam("name") String[] filenames,
			@RequestParam("file") MultipartFile[] files) {
		
		//file handling to upload it in the server path
		
		if (files.length != filenames.length)
            return "Required information missing";
		String message = "";
        for (int i = 0; i < files.length; i++) {
            MultipartFile file = files[i];
            String filename = filenames[i];
            try {

                byte[] bytes = file.getBytes();
                BufferedOutputStream stream =
                        new BufferedOutputStream(new FileOutputStream(new File(servletContext.getRealPath("/")+"/"+filename)));
                stream.write(bytes);
                stream.close();
 
                message = message + "You successfully uploaded file=" + filename
                        + "<br />";
            } catch (Exception e) {
                return "You failed to upload " + filename + " => " + e.getMessage();
            }
        }
        return message;
		
	}


	public void setServletContext(ServletContext servletContext) {
		this.servletContext=servletContext;
		
	}

}

Added first 2 methods to display the view page.
Then next 2 methods to handle the file upload.

Deploy the application

Access the below url

http://localhost:8080/SpringFileUpload/uploadSingleFile

Now Choose any file in your system and try to upload it

I am uploading example.pdf file

Give the name as you want in the Name box.

Click on Upload

Now access the below url to upload multiple files

http://localhost:8080/SpringFileUpload/uploadMultipleFiles

Choose 2 files and upload them

Click on upload

Now check the server path whether files are upload in that path

All the uploaded files are present in the server path where our application is deployed as shown below

And that path is E:\java\apache-tomcat-8.0.5-windows-x64\apache-tomcat-8.0.5\webapps\SpringFileUpload

Download this project SpringFileUpload.zip

About the Author

Raj
Founder of javainsimpleway.com
I love Java and open source technologies and very much passionate about software development.
I like to share my knowledge with others especially on technology 🙂
I have given all the examples as simple as possible to understand for the beginners.
All the code posted on my blog is developed,compiled and tested in my development environment.
If you find any mistakes or bugs, Please drop an email to kb.knowledge.sharing@gmail.com

Connect with me on Facebook for more updates

Share this article on