Package org.springframework.web.multipart.support

# Class StandardServletMultipartResolver

java.lang.Object
org.springframework.web.multipart.support.StandardServletMultipartResolver

All Implemented Interfaces:
  `MultipartResolver`

public class StandardServletMultipartResolver extends Object implements MultipartResolver
Standard implementation of the `MultipartResolver` interface, based on the Servlet `Part` API. To be added as "multipartResolver" bean to a Spring DispatcherServlet context, without any extra configuration at the bean level (see below).

This resolver variant uses your Servlet container's multipart parser as-is, potentially exposing the application to container implementation differences. Also, see this resolver's configuration option for strict Servlet compliance, narrowing the applicability of Spring's `MultipartHttpServletRequest` to form data only.

Note: In order to use Servlet container based multipart parsing, you need to mark the affected servlet with a "multipart-config" section in `web.xml`, or with a `MultipartConfigElement` in programmatic servlet registration, or (in case of a custom servlet class) possibly with a `MultipartConfig` annotation on your servlet class. Configuration settings such as maximum sizes or storage locations need to be applied at that servlet registration level; a Servlet container does not allow for them to be set at the MultipartResolver level.

     public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
       // ...
       @Override
       protected void customizeRegistration(ServletRegistration.Dynamic registration) {
         // Optionally also set maxFileSize, maxRequestSize, fileSizeThreshold
         registration.setMultipartConfig(new MultipartConfigElement("/tmp"));
       }
     }

Since:
  3.1
Author:
  Juergen Hoeller
See Also:
  - `setResolveLazily(boolean)`
  - `setStrictServletCompliance(boolean)`
  - `HttpServletRequest.getParts()`

## Constructor Summary

Constructors
Constructor
Description
`StandardServletMultipartResolver()`

## Method Summary

Modifier and Type
Method
Description
`void`
`cleanupMultipart(MultipartHttpServletRequest request)`
Clean up any resources used for the multipart handling, like a storage for the uploaded files.
`boolean`
`isMultipart(HttpServletRequest request)`
Determine if the given request contains multipart content.
`MultipartHttpServletRequest`
`resolveMultipart(HttpServletRequest request)`
Parse the given HTTP request into multipart files and parameters, and wrap the request inside a `MultipartHttpServletRequest` object that provides access to file descriptors and makes contained parameters accessible via the standard ServletRequest methods.
`void`
`setResolveLazily(boolean resolveLazily)`
Set whether to resolve the multipart request lazily at the time of file or parameter access.
`void`
`setStrictServletCompliance(boolean strictServletCompliance)`
Specify whether this resolver should strictly comply with the Servlet specification, only kicking in for "multipart/form-data" requests.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### StandardServletMultipartResolver

public StandardServletMultipartResolver()

## Method Details

### setResolveLazily

public void setResolveLazily(boolean resolveLazily)
Set whether to resolve the multipart request lazily at the time of file or parameter access.

Default is "false", resolving the multipart elements immediately, throwing corresponding exceptions at the time of the `resolveMultipart(jakarta.servlet.http.HttpServletRequest)` call. Switch this to "true" for lazy multipart parsing, throwing parse exceptions once the application attempts to obtain multipart files or parameters.

Since:
  3.2.9

### setStrictServletCompliance

public void setStrictServletCompliance(boolean strictServletCompliance)
Specify whether this resolver should strictly comply with the Servlet specification, only kicking in for "multipart/form-data" requests.

Default is "false", trying to process any request with a "multipart/" content type as far as the underlying Servlet container supports it (which works on, for example, Tomcat but not on Jetty). For consistent portability and in particular for consistent custom handling of non-form multipart request types outside of Spring's `MultipartResolver` mechanism, switch this flag to "true": Only "multipart/form-data" requests will be wrapped with a `MultipartHttpServletRequest` then; other kinds of requests will be left as-is, allowing for custom processing in user code.

Since:
  5.3.9

### isMultipart

public boolean isMultipart(HttpServletRequest request)
Description copied from interface: `MultipartResolver`
Determine if the given request contains multipart content.

Will typically check for content type "multipart/form-data", but the actually accepted requests might depend on the capabilities of the resolver implementation.

Specified by:
  `isMultipart` in interface `MultipartResolver`
Parameters:
  `request` - the servlet request to be evaluated
Returns:
  whether the request contains multipart content

### resolveMultipart

public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException
Description copied from interface: `MultipartResolver`
Parse the given HTTP request into multipart files and parameters, and wrap the request inside a `MultipartHttpServletRequest` object that provides access to file descriptors and makes contained parameters accessible via the standard ServletRequest methods.

Specified by:
  `resolveMultipart` in interface `MultipartResolver`
Parameters:
  `request` - the servlet request to wrap (must be of a multipart content type)
Returns:
  the wrapped servlet request
Throws:
  `MultipartException` - if the servlet request is not multipart, or if implementation-specific problems are encountered (such as exceeding file size limits)
See Also:
  - `MultipartRequest.getFile(java.lang.String)`
  - `MultipartRequest.getFileNames()`
  - `MultipartRequest.getFileMap()`
  - `ServletRequest.getParameter(java.lang.String)`
  - `ServletRequest.getParameterNames()`
  - `ServletRequest.getParameterMap()`

### cleanupMultipart

public void cleanupMultipart(MultipartHttpServletRequest request)
Description copied from interface: `MultipartResolver`
Clean up any resources used for the multipart handling, like a storage for the uploaded files.

Specified by:
  `cleanupMultipart` in interface `MultipartResolver`
Parameters:
  `request` - the request to clean up resources for