文件上传原理

于 2022-01-17 21:56:49 发布
阅读量533 收藏 1
点赞数
分类专栏： SpringBoot2 文章标签： 文件上传解析器 MultipartFile
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzw752890913/article/details/122483863
版权

文章目录

MultipartAutoConfiguration自动配置文件上传解析器

类MultipartAutoConfiguration中自动配置了文件上传解析器StandardServletMultipartResolver ，如下：

@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() {
		return this.multipartProperties.createMultipartConfig();
	}

	@Bean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
	@ConditionalOnMissingBean(MultipartResolver.class)
	public StandardServletMultipartResolver multipartResolver() {
		StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
		multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily());
		return multipartResolver;
	}
}

如果容器中没有MultipartResolver类实例（MultipartResolver.class），则调用方法multipartResolver，该方法会返回一个StandardServletMultipartResolver类实例，且实例名为multipartResolver，（@Bean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)），并将该实例放入容器，即得到了文件上传解析器。
如果容器中有MultipartResolver类实例，则不会调用方法multipartResolver。
SpringBoot通过底层的这种自动配置保证了容器中一定会有一个MultipartResolver类实例（文件上传解析器），从而支持文件上传功能。

文件上传解析器的自定义配置

文件上传解析器的自定义配置，通过以下方式实现，如spring.servlet.multipart.enabled、spring.servlet.multipart.max-file-size、spring.servlet.multipart.max-request-size等。

  1. 以spring.servlet.multipart为前缀。
@ConditionalOnProperty(prefix = "spring.servlet.multipart",)
  1. 与类MultipartProperties的属性绑定。
public class MultipartProperties {
	private boolean enabled = true;
	private String location;
	private DataSize maxFileSize = DataSize.ofMegabytes(1);
	private DataSize maxRequestSize = DataSize.ofMegabytes(10);
	private DataSize fileSizeThreshold = DataSize.ofBytes(0);
	private boolean resolveLazily = false;
	//...
}

MultipartFile参数解析过程

DispatcherServlet#doDispatch
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
	HttpServletRequest processedRequest = request;
	boolean multipartRequestParsed = false;
	try {
		try {
			processedRequest = checkMultipart(request);
			multipartRequestParsed = (processedRequest != request);

			// Determine handler for the current request.
			mappedHandler = getHandler(processedRequest);

			// Determine handler adapter for the current request.
			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
				return;
			}

			// Actually invoke the handler.
			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

			mappedHandler.applyPostHandle(processedRequest, response, mv);
		}
		catch (Exception ex) {
		}
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	}
	catch (Exception ex) {
	}
	finally {
		if (asyncManager.isConcurrentHandlingStarted()) {
		}
		else {
			// Clean up any resources used by a multipart request.
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
	}
}
DispatcherServlet#checkMultipart

文件上传解析器对请求进行判断，如果请求是文件上传请求（如Content-Type为multipart/form-data），则封装该请求为StandardMultipartHttpServletRequest类请求，且请求中的内容封装为MultipartFile类。

protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
	if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
		return this.multipartResolver.resolveMultipart(request);
	}
}
StandardServletMultipartResolver#isMultipart

判断请求是不是文件上传请求，如果请求的Content-Type以multipart/开头，则确定该请求为文件上传请求。（这也是为什么上传文件的表单，一定要加enctype="multipart/form-data"。）

public boolean isMultipart(HttpServletRequest request) {
	return StringUtils.startsWithIgnoreCase(request.getContentType(),
			(this.strictServletCompliance ? MediaType.MULTIPART_FORM_DATA_VALUE : "multipart/"));
}
StandardServletMultipartResolver#resolveMultipart

如果请求是文件上传请求，则解析该请求，将请求封装为StandardMultipartHttpServletRequest类请求，且将请求中的内容封装为MultipartFile类。

public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
	return new StandardMultipartHttpServletRequest(request, this.resolveLazily);
}

//StandardMultipartHttpServletRequest#StandardMultipartHttpServletRequest(javax.servlet.http.HttpServletRequest, boolean)
public StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing)
		throws MultipartException {

	super(request);
	if (!lazyParsing) {
		parseRequest(request);
	}
}
//StandardMultipartHttpServletRequest#parseRequest
private void parseRequest(HttpServletRequest request) {
	try {
		Collection<Part> parts = request.getParts();
		this.multipartParameterNames = new LinkedHashSet<>(parts.size());
		MultiValueMap<String, MultipartFile> files = new LinkedMultiValueMap<>(parts.size());
		for (Part part : parts) {
			String headerValue = part.getHeader(HttpHeaders.CONTENT_DISPOSITION);
			ContentDisposition disposition = ContentDisposition.parse(headerValue);
			String filename = disposition.getFilename();
			if (filename != null) {
				if (filename.startsWith("=?") && filename.endsWith("?=")) {
					filename = MimeDelegate.decode(filename);
				}
				files.add(part.getName(), new StandardMultipartFile(part, filename));
			}
			else {
				this.multipartParameterNames.add(part.getName());
			}
		}
		setMultipartFiles(files);
	}
	catch (Throwable ex) {
		handleParseFailure(ex);
	}
}
AbstractHandlerMethodAdapter#handle
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
		throws Exception {

	return handleInternal(request, response, (HandlerMethod) handler);
}

//RequestMappingHandlerAdapter#handleInternal
protected ModelAndView handleInternal(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
	ModelAndView mav;
	checkRequest(request);
	mav = invokeHandlerMethod(request, response, handlerMethod);
	return mav;
}

//RequestMappingHandlerAdapter#invokeHandlerMethod
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
	invocableMethod.invokeAndHandle(webRequest, mavContainer);
	return getModelAndView(mavContainer, modelFactory, webRequest);
}

//ServletInvocableHandlerMethod#invokeAndHandle
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {
	Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
	this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
}

//InvocableHandlerMethod#invokeForRequest
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {

	Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
	return doInvoke(args);
}

//InvocableHandlerMethod#getMethodArgumentValues
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {
	MethodParameter[] parameters = getMethodParameters();
	Object[] args = new Object[parameters.length];
	for (int i = 0; i < parameters.length; i++) {
		MethodParameter parameter = parameters[i];
		args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
	}
	return args;
}

//HandlerMethodArgumentResolverComposite#resolveArgument
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
		NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

	HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
	return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}

//RequestPartMethodArgumentResolver#resolveArgument
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
		NativeWebRequest request, @Nullable WebDataBinderFactory binderFactory) throws Exception {
		RequestPart requestPart = parameter.getParameterAnnotation(RequestPart.class);
		String name = getPartName(parameter, requestPart);
		parameter = parameter.nestedIfOptional();
		Object arg = null;
		Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
		if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
			arg = mpArg;
		}
		return adaptArgumentIfNecessary(arg, parameter);
}

//MultipartResolutionDelegate#resolveMultipartArgument
public static Object resolveMultipartArgument(String name, MethodParameter parameter, HttpServletRequest request)
		throws Exception {
		MultipartHttpServletRequest multipartRequest =
				WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
		boolean isMultipart = (multipartRequest != null || isMultipartContent(request));
		if (MultipartFile.class == parameter.getNestedParameterType()) {
			return multipartRequest.getFile(name);
		}
		else if (isMultipartFileArray(parameter)) {
			List<MultipartFile> files = multipartRequest.getFiles(name);
			return (!files.isEmpty() ? files.toArray(new MultipartFile[0]) : null);
		}
		
}

MultipartFile是一个接口类，其定义如下，

public interface MultipartFile extends InputStreamSource {
	String getName();
	
	@Nullable
	String getOriginalFilename();
	
	@Nullable
	String getContentType();
	
	boolean isEmpty();
	long getSize();
	byte[] getBytes() throws IOException;
	
	@Override
	InputStream getInputStream() throws IOException;
	
	default Resource getResource() {
		return new MultipartFileResource(this);
	}
	void transferTo(File dest) throws IOException, IllegalStateException;
	default void transferTo(Path dest) throws IOException, IllegalStateException {
		FileCopyUtils.copy(getInputStream(), Files.newOutputStream(dest));
	}

}

MultipartFile类数由参数解析器RequestPartMethodArgumentResolver解析。
在这里插入图片描述

richest_qi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
文件上传的原理
学而不思
07-27 1722
1.    文件上传的原理： 表单元素的enctype属性指定的是表单数据的编码方式，该属性有3个值： 1)      application/x-www-form-urlencoded：这是默认编码方式，它只处理表单域里的value属性值，采用这种编码方式的表单会将表单域的值处理成URL编码方式。 2)      multipart/form-data：这种编码方式的表单会以二进制
java文件上传原理
keepeye的专栏
05-20 7598
  网页表单是一个web基础设施,提供了交互接口,作为使用web技术的开发人员,了解其工作原理,是必须的功课,本文描述表单域和二进制数据一同传输并被处理.   有关表单资料,若需要可参考http://www.htmlhelp.com/reference/html40/forms/form.html.   在表单元素中 enctype 属性指定了传递给服务器的表单数据集编码的内容类型,它的默认值是“
Spring Boot 文件上传原理解析
08-27
Spring Boot 文件上传原理主要涉及到Spring MVC的处理机制。Spring Boot本身并不直接处理文件上传，而是依赖于Spring MVC的组件来完成这项任务。Spring MVC通过一个名为`MultipartResolver`的接口来处理文件上传请求...
Struts2.0文件上传原理
03-17
以下是对Struts2.0文件上传原理的详细解释： 1. **HTTP协议与表单提交** 在HTML表单中，如果需要上传文件，`<form>`标签必须包含`enctype="multipart/form-data"`属性。这是因为普通POST请求无法处理二进制数据，...
通过Servlet文件上传理解Struts2文件上传原理(附源码)
04-06
在本文中，我们将深入探讨如何使用Servlet来理解Struts2中的文件上传原理。Servlet是Java Web应用程序中的一个组件，用于处理HTTP请求和响应。而Struts2是一个基于MVC（模型-视图-控制器）设计模式的开源Web应用框架...
php文件上传原理与实现方法详解
10-15
以下是对PHP文件上传原理与实现方法的详细解析： 首先，了解文件上传的原理。当用户通过HTML表单选择文件并提交时，浏览器会将文件作为二进制数据封装在HTTP请求中，以`multipart/form-data`的格式发送。PHP服务器...
文件上传原理学习
08-04
NULL 博文链接：https://username2.iteye.com/blog/2004665
web文件上传原理讲解与代码
06-24
web文件上传原理讲解与代码
Spring Multipart工作原理(文件上传到服务器)
04-26
NULL 博文链接：https://huangyongxing310.iteye.com/blog/2321943
Java文件上传详解：原理与代码分析
"本文将深入探讨Java文件上传的过程，包括文件上传的定义、原因、为何需要使用上传组件，以及如何在实际开发中处理文件上传的细节。" 在Java Web开发中，文件上传是一项重要的功能，允许用户将文件从本地计算机传输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值