Spring supports pluggable MultipartResolver objects for file uploads. There are currently two implementations;

• Prior to Servlet 2.5 and earlier versions, file uploads were implemented with the commons-Fileupload component.
• Since the Servlet 3.0 specification, native support for file uploads has been provided, further simplifying application implementation.

See MultipartAutoConfiguration. Java classes, the default configuration StandardServletMultipartResolver automatically, we don’t need to do anything

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Servlet.class, StandardServletMultipartResolver.class, MultipartConfigElement.class })
@ConditionalOnProperty(prefix = "spring.servlet.multipart", name = "enabled", matchIfMissing = true)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(MultipartProperties.class)
public class MultipartAutoConfiguration {

	private final MultipartProperties multipartProperties;

	public MultipartAutoConfiguration(MultipartProperties multipartProperties) {
		this.multipartProperties = multipartProperties;
	}

	@Bean
	@ConditionalOnMissingBean({ MultipartConfigElement.class, CommonsMultipartResolver.class })
	public MultipartConfigElement multipartConfigElement(a) {
		return this.multipartProperties.createMultipartConfig();
	}

	@Bean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
	@ConditionalOnMissingBean(MultipartResolver.class)
	public StandardServletMultipartResolver multipartResolver(a) {
		StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
		multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily());
		returnmultipartResolver; }}Copy the code

Common file uploading requirements are summarized as follows:

Front-end core code

<form method="POST" action="/upload-files" enctype="multipart/form-data">
    <table>
        <tr>
            <td>Select a file to upload</td>
            <td><input type="file" name="files" /></td>
        </tr>
        <tr>
            <td>Select a file to upload</td>
            <td><input type="file" name="files" /></td>
        </tr>
        <tr>
            <td>Select a file to upload</td>
            <td><input type="file" name="files" /></td>
        </tr>
        <tr>
            <td><input type="submit" value="Submit" /></td>
        </tr>
    </table>
</form>
Copy the code

Back-end core code

We need to note that each input field has the same name so that it can be accessed as a MultipartFile array:

    @RequestMapping(value = "/upload-files", method = RequestMethod.POST)
    public String submit(@RequestParam("files") MultipartFile[] files) {
        return "ok";
    }
Copy the code

We can also wrap all the form fields in classes, which is handy when there are many other fields in the file.

public class FormDataWithFile {
    private String name;
    private String email;
    private MultipartFile file;
}
@PostMapping("/upload-files-with-data")
public String submit(FormDataWithFile formDataWithFile) {
    return "ok";
}
Copy the code

Convert the file to a Base64 string, but the converted string is three times the size of the original image. (carefully)

[{"name": "a"."emainl": ""."fileBase64":"xxxxx"
    },
    {
        "name": "b"."emainl": ""."fileBase64":"xxxxx"}]Copy the code

The format of a file upload request is as follows:

POST /upload HTTP/1.1 
Host:xxx.org 
Content-type: multipart/form-data, boundary="boundaryStr"

--boundaryStr
content-disposition: form-data; name="name"

Name Of Picture
--boundaryStr
Content-disposition: attachment; name="picfile"; filename="picfile.gif"Content-type: image/gif Content-Transfer-Encoding: binary ... contentsof picfile.gif...
Copy the code

Where boundary specifies the boundary string of content segmentation;

Content-dispostion specifies that this is an attachment (file), including parameter names, file names;

Content-type specifies the file type.

Content-transfer-encoding Specifies the Content Transfer Encoding.

TomcatImplemented the Servlet3.0 specification, throughApplicationPartEncapsulate the file up-stream, where,DiskFileItemDiskFileItem represents an upload file entity that is generated when the request is resolved. Note that DiskFileItem declares oneThe temporary file, which is used to temporarily store the content of uploaded files. SpringMVC encapsulates the request entity of the upper layer again, and finally constructs asMultipartFilePass to the application.

The following is an example:

The generated temporary files are as follows:

This is the directory for temporary files, which can be configured

The temporary file is opened and its contents are as follows:

• Parameters: the name
  
  
• Parameters: the file
  
  
  
  After uploading, temporary files will be deleted

As you can see, parameters that are not file types are also written to temporary files.

Packet capture using Fiddler:

POST http://localhost:8080/upload-files-with-data HTTP / 1.1
cache-control: no-cache
Accept: * / *Host: localhost:8080
accept-encoding: gzip, deflate
content-type: multipart/form-data; boundary=--------------------------895818005136536360125479
content-length: 268707
Connection: keep-alive

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 895818005136536360125479
Content-Disposition: form-data; name="name"

123
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 895818005136536360125479
Content-Disposition: form-data; name="file"; filename="test.txt"
Content-Type: text/plain

abc123
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 895818005136536360125479
Content-Disposition: form-data; name="file"; filename="1114289-20190110120111312-1475461850.png"
Content-Type: image/png

...contents of png...
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 895818005136536360125479
Copy the code

At this point, we have a rough idea of how HTTP upload files work. HTTP stores all data from the form to be uploaded in a certain format in the request body, as well as files.

• Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryqj67FUBQUHXZj78GTo upload an attachment,
• Among themboundaryRepresents a delimiter, used if there are multiple entries in the formboundaryEach form item is separated by------FormBoundaryBegan to------FormBoundaryAt the end. For example:

------FormBoundary
Content-Disposition: form-data; name="param1"

value1
------FormBoundary
Copy the code

The value of boundary is generated by the browser to ensure that it does not duplicate the uploaded content.

• In each separator, we need to focusContent-DispositionMessage header, where the first parameter is always fixedform-data, name represents the form element attribute name, and the content after the carriage return newline character is the element value. There areContent-TypeRepresents the MIME type of the file that we are uploading, and we need to differentiate files on the server side based on this.
• The last oneboundaryThere will be two more at the end--

HTTP encapsulates the data in a form into a request and sends it to the server. The server parses the received request according to this rule to complete the file upload function.

The following is an example of background parsing found on the Internet. DEBUG traces the code to analyze.

@WebServlet(urlPatterns = "/lakerfile")
public class FileUploadDemo extends HttpServlet {
    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        DiskFileItemFactory fac = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(fac);
        upload.setFileSizeMax(10 * 1024 * 1024);
        upload.setSizeMax(20 * 1024 * 1024);
        if (ServletFileUpload.isMultipartContent(request)) { // Only Multipart requests are processed
                List<FileItem> list = upload.parseRequest(new ServletRequestContext(request));// Parse the packet
                for (FileItem item : list) {
                    if (item.isFormField()) {
                        String fileName = item.getFieldName();
                        String value = item.getString("UTF-8");
                    } else {
                        File file = newFile(realPath, name); item.write(file); . }}}Copy the code

spring:
  servlet:
    multipart:
      # Maximum file size (single)
      max-file-size: 10MB
      If the file is larger than this threshold, it will be written to disk. The unit of B/KB/MB is supported
      file-size-threshold: 0B
      # // Maximum request size (total)
      max-request-size: 100MB
Copy the code

These parameters are controlled by SpringMVC and are used to inject the file upload configuration of Servlet3.0 with the following associated classes:

public class MultipartConfigElement {
    private final String location;/ / = "";
    private final long maxFileSize;// = -1;
    private final long maxRequestSize;// = -1;
    private final int fileSizeThreshold;/ / = 0;
Copy the code

Custom temporary file generation directory

server:
  tomcat:
    basedir: /laker/tmp
Copy the code

🍎QQ group [837324215] 🍎 pay attention to my public number [Java Factory interview officer], learn together 🍎🍎🍎