38-Web开发(中)
1. 数据响应与内容协商
1.1 返回值处理流程
（1）执行目标方法，获取方法返回值 returnValue。
（2）returnValueHandlers 调用 handleReturnValue() 进行处理 → 循环遍历〈返回值处理器集合〉，找到 support 处理返回值标了@ResponseBody 注解的 → RequestResponseBodyMethodProcessor。
返回值处理器集合如下：
【补充】除了 RequestResponseBodyMethodProcessor，ServletModelAttributeMethodProcessor、ModelMethodProcessor 同样既存在于 argumentResolvers[] 中，也存在于 returnValueHandlers[] 中 ~
@Override
public boolean supportsParameter(MethodParameter parameter) {
return parameter.hasParameterAnnotation(RequestBody.class);
}
@Override
public boolean supportsReturnType(MethodParameter returnType) {
return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass()
, ResponseBody.class) || returnType.hasMethodAnnotation(ResponseBody.class));
}
（3）RequestResponseBodyMethodProcessor 内部是利用 MessageConverters 进行处理（writeWithMessageConverters 方法）→ 该方法实现在父类中（如下）
- 内容协商（双重 for 循环）
- 浏览器默认会以请求头的方式（Accept）告诉服务器他能接受什么样的内容类型，封装成 acceptableTypes；
- 服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，封装成 producibleTypes；
- 协商出最终返回类型后，RequestResponseBodyMethodProcessor 会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理（把 returnValue 转换成协商结果类型）？
（4）最终利用 MappingJackson2HttpMessageConverter.write() 把对象转为 JSON（利用底层 ObjectMapper 转换的）写入 outputBuffer 中。
上述 messageConverter 可读写的类型（按照索引顺序）：
0 - 只支持Byte类型的
1 - String
2 - String
3 - Resource
4 - ResourceRegion
5 - DOMSource.class \ SAXSource.class) \ StAXSource.class \StreamSource.class \Source.class
6 - MultiValueMap
7 - true【如下所示】
8 - true
9 - 支持注解方式 xml 处理的
MappingJackson2HttpMessageConverter 支持任何类型。
public abstract class AbstractJackson2HttpMessageConverter
extends AbstractGenericHttpMessageConverter<Object> {
// ...
}
public abstract class AbstractGenericHttpMessageConverter<T> extends ...{
@Override
protected boolean supports(Class<?> clazz) {
return true;
}
}
1.2 Request/ResponseBody
测试代码：
@ResponseBody
@PostMapping("echo")
public Person echo(@RequestBody Person person) {
return person;
}
涉及到的参数解析器、返回值处理器为同一个类 —— RequestResponseBodyMethodProcessor，其父类是 AbstractMessageConverterMethodProcessor：
class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {...}
abstract class AbstractMessageConverterMethodProcessor
extends AbstractMessageConverterMethodArgumentResolver
implements HandlerMethodReturnValueHandler {...}
下面涉及到的方法均是这两个类中的方法~
1.2.1 @RequestBody
调用过程都是一样的，就是具体到某个解析器，其各自处理方式不同（就看栈顶 3 个 方法）：
RequestResponseBodyMethodProcessor：
@Override
public Object resolveArgument(
MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) {
parameter = parameter.nestedIfOptional();
// ===== ↓↓↓↓↓ Step Into ↓↓↓↓↓ =====
Object arg = readWithMessageConverters(
webRequest, parameter, parameter.getNestedGenericParameterType());
String name = Conventions.getVariableNameForParameter(parameter);
if (binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
if (arg != null) {
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
}
}
if (mavContainer != null) {
mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
}
}
return adaptArgumentIfNecessary(arg, parameter);
}
@Override
protected <T> Object readWithMessageConverters(
NativeWebRequest webRequest, MethodParameter parameter, Type paramType) {
HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
Assert.state(servletRequest != null, "No HttpServletRequest");
ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
// ===== ↓↓↓↓↓ Step Into ↓↓↓↓↓ =====
Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
if (arg == null && checkRequired(parameter)) {
throw new HttpMessageNotReadableException("Required request body is missing: " +
parameter.getExecutable().toGenericString(), inputMessage);
}
return arg;
}
AbstractMessageConverterMethodArgumentResolver：
1.2.2 @ResponseBody
上文 #1.1 小节差不多都提到了，其中（3）的配图就是 AbstractMessageConverterMethodArgumentResolver 中的 writeWithMessageConverters 方法，就顺着那张截图的最后一句代码 Step Into：
【小结】当处理方法上标 @ResponseBody，则会选用 RequestResponseBodyMethodProcessor 返回值处理器，其处理流程是：先进行内容协商，确定合适的返回类型；然后循环遍历 messageConverters 集合选择能够将 returnValue 转换成协商结果类型的 HttpMessageConverter，若找到了就调用 write 写给客户端，响应成功；若找不到可用的 HttpMessageConverter 则报错。
1.3 内容协商
根据客户端接收能力不同，返回不同媒体类型的数据。
1.3.1 PostMan 展示效果
引入 XML 依赖：
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
再查看 messageConverters 集合：
只需要改变请求头中 Accept 字段。Http 协议中规定的，告诉服务器本客户端可以接收的数据类型。
1.3.2 内容协商原理
RequestResponseBodyMethodProcessor
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) {
mavContainer.setRequestHandled(true);
ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
// Try even with null return value. ResponseBodyAdvice could get involved.
// =========== 使用消息转换器进行写出操作 ===========
writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}
AbstractMessageConverterMethodProcessor
// ===> 第 1 次循环是来统计支持处理返回值类型的 converter 能将其转成哪些 MediaType
protected List<MediaType> getProducibleMediaTypes(
HttpServletRequest request, Class<?> valueClass, @Nullable Type targetType) {
Set<MediaType> mediaTypes = (Set<MediaType>)
request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
if (!CollectionUtils.isEmpty(mediaTypes)) {
return new ArrayList<>(mediaTypes);
} else if (!this.allSupportedMediaTypes.isEmpty()) {
// - 统计支持处理的 converter 们所支持的 MediaType -
List<MediaType> result = new ArrayList<>();
for (HttpMessageConverter<?> converter : this.messageConverters) {
if (converter instanceof GenericHttpMessageConverter && targetType != null) {
if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) {
result.addAll(converter.getSupportedMediaTypes());
}
} else if (converter.canWrite(valueClass, null)) {
result.addAll(converter.getSupportedMediaTypes());
}
}
return result; // 服务端能处理的 MediaType 集合（见下图）
} else {
return Collections.singletonList(MediaType.ALL);
}
}
protected <T> void writeWithMessageConverters(
@Nullable T value, MethodParameter returnType,
ServletServerHttpRequest inputMessage,
ServletServerHttpResponse outputMessage) {
// ...
MediaType selectedMediaType = null;
MediaType contentType = outputMessage.getHeaders().getContentType();
boolean isContentTypePreset = contentType != null && contentType.isConcrete();
if (isContentTypePreset) {
if (logger.isDebugEnabled()) {
logger.debug("Found 'Content-Type:" + contentType + "' in response");
}
selectedMediaType = contentType;
} else {
// ===== else Start ======
HttpServletRequest request = inputMessage.getServletRequest();
// 客户端可接受的类型 → 见下个方法(内容协商管理器默认基于请求头的内容协商策略)
List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
// 服务端可处理的类型 → 见上个方法
List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
if (body != null && producibleTypes.isEmpty()) {
throw new HttpMessageNotWritableException(
"No converter found for return value of type: " + valueType);
}
// 内容协商！
List<MediaType> mediaTypesToUse = new ArrayList<>();
for (MediaType requestedType : acceptableTypes) {
for (MediaType producibleType : producibleTypes) {
if (requestedType.isCompatibleWith(producibleType)) {
mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
}
}
}
if (mediaTypesToUse.isEmpty()) {
if (body != null) throw new HttpMediaTypeNotAcceptableException(producibleTypes);
return;
}
MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
// 第 1 个就是内容协商の最佳匹配 ~
for (MediaType mediaType : mediaTypesToUse) {
if (mediaType.isConcrete()) {
selectedMediaType = mediaType;
break;
} else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
break;
}
}
// ===== else End ======
}
// ===> 第 2 次循环来找能将返回类型转成指定 selectedMediaType 类型的 converter
if (selectedMediaType != null) {
selectedMediaType = selectedMediaType.removeQualityValue();
for (HttpMessageConverter<?> converter : this.messageConverters) {
GenericHttpMessageConverter genericConverter =
(converter instanceof GenericHttpMessageConverter
? (GenericHttpMessageConverter<?>) converter : null);
// - 判断 -
if (genericConverter != null ? ((GenericHttpMessageConverter) converter)
.canWrite(targetType, valueType, selectedMediaType)
: converter.canWrite(valueType, selectedMediaType)) {
body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
(Class<? extends HttpMessageConverter<?>>)
converter.getClass(), inputMessage, outputMessage);
if (body != null) {
Object theBody = body;
addContentDispositionHeader(inputMessage, outputMessage);
if (genericConverter != null) {
// ======== ObjectWriter.ToXmlGenerator ========
genericConverter.write(body, targetType, selectedMediaType, outputMessage);
} else {
((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
}
} else {
if (logger.isDebugEnabled()) {
logger.debug("Nothing to write: null body");
}
}
return;
}
}
}
// ...
}
private List<MediaType> getAcceptableMediaTypes(HttpServletRequest request)
throws HttpMediaTypeNotAcceptableException {
return this.contentNegotiationManager.resolveMediaTypes(new ServletWebRequest(request));
}
（1）判断当前响应头中是否已经有确定的媒体类型（MediaType）；
（2）获取客户端（PostMan、Browser）支持接收的内容类型（底层通过「内容协商管理器」）；
（3）遍历循环所有 MessageConverter，看谁支持操作 handle-ret 类型，将所有支持的 converters 所能处理成的 MediaType 打包返回；
（4）acceptableTypes、producibleTypes 双重 for 进行内容协商，选中最佳匹配类型；
（5）循环遍历 converters，用「支持将对象转为最佳匹配类型的 converter」进行转换。
1.3.3 基于请求参数的内容协商
通过 #1.2.2 某图可以看出，内容协商处理器 contentNegotiationManager 默认只有一种策略 —— HeaderContentNegotiationStrategy，即通过 HttpHeaders.ACCEPT 来获取 acceptableTypes，但如果不想用这种方式呢，在 PostMan 测试，请求头可以随便改，但如果用 Browser 测试呢？
查看 ContentNegotiationStrategy 的实现类：
所以，针对这种情况，为方便内容协商，开启「基于请求参数」的内容协商功能 —— ParameterContentNegotiationStrategy。
spring:
mvc:
contentnegotiation:
favor-parameter: true # 开启请求参数内容协商模式
WebMvcProperties：
/**
* Whether a request parameter ("format" by default) should be used to determine
* the requested media type.
*/
private boolean favorParameter = false;
测试：
http://localhost:8080/test/person?format=json
http://localhost:8080/test/person?format=xml
底层：
1.3.4 自定义 MessageConverter
Quiz：通过自定义 Accept 方式（走请求头策略），要求 Server 返回的 Person 对象是以属性间
;隔开的形式。
（1）先来看下 messageConverters 封装原理
（2）问题切入口
public interface WebMvcConfigurer {
// 覆盖
default void configureMessageConverters(List<HttpMessageConverter<?>> converters) {}
// 扩展
default void extendMessageConverters(List<HttpMessageConverter<?>> converters) {}
// ...
}
（3）MyMessageConverter
public class MyMessageConverter implements HttpMessageConverter<Person> {
@Override
public boolean canRead(Class<?> clazz, MediaType mediaType) {
return false;
}
@Override
public boolean canWrite(Class<?> clazz, MediaType mediaType) {
return clazz.isAssignableFrom(Person.class);
}
@Override
public List<MediaType> getSupportedMediaTypes() {
return MediaType.parseMediaTypes("application/x-1101");
}
@Override
public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage)
throws IOException, HttpMessageNotReadableException {
return null;
}
@Override
public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage)
throws IOException, HttpMessageNotWritableException {
// 自定义协议数据的写出
String data = person.getName() + ";" + person.getAge();
OutputStream outputStream = outputMessage.getBody();
outputStream.write(data.getBytes());
}
}
（4）将 MyMessageConverter 添加到 messageConverters 中
@Bean
public WebMvcConfigurer webMvcConfigurer() {
return new WebMvcConfigurer() {
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
converters.add(new MyMessageConverter());
}
// ...
}
}
（5）流程概览
1.3.5 以参数方式内容协商扩展
上文可以看到，ParameterContentNegotiationStrategy 要求请求参数 format 只能写 json 和 xml，无法满足现在的要求，How？
（1）自定义 ParameterContentNegotiationStrategy
@Bean
public WebMvcConfigurer webMvcConfigurer() {
return new WebMvcConfigurer() {
/**
* 自定义内容协商策略
* @param configurer
*/
@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
Map<String, MediaType> mediaTypes = new HashMap<>(16);
mediaTypes.put("json", MediaType.APPLICATION_JSON);
mediaTypes.put("xml", MediaType.APPLICATION_XML);
mediaTypes.put("tree", MediaType.parseMediaType("application/x-1101"));
ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(mediaTypes);
configurer.strategies(Arrays.asList(strategy));
}
// ...
}
}
注意！上述这种写法就没有默认的请求头策略咯~ 如此以来，你就是在 Accept 里写出花，Server 还是会给你返 Json 格式。
ParameterContentNegotiationStrategy paramStrategy = new ParameterContentNegotiationStrategy(mediaTypes);
HeaderContentNegotiationStrategy headerStrategy = new HeaderContentNegotiationStrategy();
configurer.strategies(Arrays.asList(paramStrategy, headerStrategy));
所以说，有时候我们添加的自定义功能会覆盖默认配置，导致一些默认的功能失效，这点要注意下。
（2）走一遍源码
2. 模板引擎 Thymeleaf
2.1 引入 Starter
（1）导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
（2）查看自动配置类
@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {
private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";
}
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ThymeleafProperties.class)
@ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })
@AutoConfigureAfter({ WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })
public class ThymeleafAutoConfiguration {
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = "defaultTemplateResolver")
static class DefaultTemplateResolverConfiguration {...}
@Configuration(proxyBeanMethods = false)
protected static class ThymeleafDefaultConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnProperty(name = "spring.thymeleaf.enabled", matchIfMissing = true)
static class ThymeleafWebMvcConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.REACTIVE)
@ConditionalOnProperty(name = "spring.thymeleaf.enabled", matchIfMissing = true)
static class ThymeleafReactiveConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.REACTIVE)
@ConditionalOnProperty(name = "spring.thymeleaf.enabled", matchIfMissing = true)
static class ThymeleafWebFluxConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(LayoutDialect.class)
static class ThymeleafWebLayoutConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(DataAttributeDialect.class)
static class DataAttributeDialectConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ SpringSecurityDialect.class })
static class ThymeleafSecurityDialectConfiguration {...}
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Java8TimeDialect.class)
static class ThymeleafJava8TimeDialect {...}
}
（3）简单测试
@Controller
public class ThymeleafController {
@GetMapping("test")
public String test1(HttpServletRequest request) {
request.setAttribute("msg", "Future is coming.");
request.setAttribute("link", "www.gotoFuture.com");
return "success";
}
}
2.2 初步结合 AdminEX
https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html
2.2.1 Controller
IndexController
@GetMapping(value={"", "login"})
public String loginPage() {
System.out.println("重定向到登录页");
return "login";
}
@PostMapping("login")
public String login(HttpSession session, User user, Model model) {
if (StringUtils.hasLength(user.getUsername()) && StringUtils.hasLength(user.getPassword())) {
session.setAttribute("loginUser", user);
} else {
model.addAttribute("msg", "账号/密码错误！");
return "login";
}
System.out.println("防止表单重复提交(step1): 采用重定向到主页，一旦登录成功就和/login撇开关系");
return "redirect:main.html";
}
@GetMapping("main.html")
public String mainPage(HttpSession session, Model model) {
if (session.getAttribute("loginUser") == null) {
System.out.println("转发到登录页");
model.addAttribute("msg", "请先登录！");
return "login";
}
System.out.println("防止表单重复提交(step2): 刷新主页抵达该处理方法，再转发回主页~");
return "main";
}
TableController
@GetMapping("/basic_table")
public String basicTable() {
return "table/basic_table";
}
@GetMapping("/dynamic_table")
public String dynamicTable(Model model) {
List<User> list = Arrays.asList(
new User("zhangsan", "123"),
new User("lisi", "123"),
new User("wangwu", "123"),
new User("zhaoliu", "123")
);
model.addAttribute("users", list);
return "table/dynamic_table";
}
@GetMapping("/responsive_table")
public String responsiveTable() {
return "table/responsive_table";
}
@GetMapping("/editable_table")
public String editableTable() {
return "table/editable_table";
}
@GetMapping("/pricing_table")
public String pricingTable() {
return "table/pricing_table";
}
2.2.2 HTML
main.html、table/*.html 具有共同的左侧菜单和顶部导航栏，故抽取成 common.html：
<div class="left-side sticky-left-side" id="common-left-menu"></div>
<div class="header-section" th:fragment="common-header">...</div>
在其他页面中引入：
<div th:replace="common::#common-left-menu"></div>
<link th:replace="common::common-header"/>
table/dynamic_table 有个数据列表的展示：
<thead>
<tr>
<th>#</th>
<th>username</th>
<th>password</th>
</tr>
</thead>
<tbody>
<tr class="gradeX" th:each="user, status:${users}">
<td th:text="${status.count}">Trident</td>
<td th:text="${user.username}">Win 95+</td>
<td th:text="${user.password}">Win 95+</td>
</tr>
</tbody>
2.3 视图渲染过程
ViewNameMethodReturnValueHandler
ContentNegotiatingViewResolver 处理“请求重定向”和“请求转发”
请求重定向
请求转发
3. 拦截器
3.1 自定义拦截器
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
System.out.println("LoginInterceptor#preHandle");
HttpSession session = request.getSession();
if (session.getAttribute("loginUser") == null) {
response.sendRedirect("/admin/login");
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("LoginInterceptor#postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.out.println("LoginInterceptor#afterCompletion");
}
}
3.2 注册拦截器
@Configuration
public class AdminWebConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry
.addInterceptor(new LoginInterceptor())
.addPathPatterns("/**")
.excludePathPatterns("/", "/login", "/css/**", "/fonts/**", "/images/**", "/js/**");
// '/**' 把所有请求(包括静态)都被拦截，两种方式解决：
// (1) 如上所示，静态资源挨个列出来
// (2) 配置静态资源的访问前缀，记得改每个超链接
// spring:
// mvc:
// static-path-pattern: xxx
}
}
3.3 Debug 源码
boolean applyPreHandle(HttpServletRequest request,
HttpServletResponse response) throws Exception {
for (int i = 0; i < this.interceptorList.size(); i++) {
HandlerInterceptor interceptor = this.interceptorList.get(i);
if (!interceptor.preHandle(request, response, this.handler)) {
triggerAfterCompletion(request, response, null);
return false;
}
this.interceptorIndex = i;
}
return true;
}
void applyPostHandle(HttpServletRequest request, HttpServletResponse response,
@Nullable ModelAndView mv) throws Exception {
for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
HandlerInterceptor interceptor = this.interceptorList.get(i);
interceptor.postHandle(request, response, this.handler, mv);
}
}
void triggerAfterCompletion(HttpServletRequest request,
HttpServletResponse response, @Nullable Exception ex) {
for (int i = this.interceptorIndex; i >= 0; i--) {
HandlerInterceptor interceptor = this.interceptorList.get(i);
try {
interceptor.afterCompletion(request, response, this.handler, ex);
} catch (Throwable ex2) {
logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
}
}
}
4. 文件上传
4.1 测试
表单
<form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">
<div class="form-group">
<label for="exampleInputEmail1">Email address</label>
<input type="email" name="email" class="form-control"
id="exampleInputEmail1" placeholder="Enter email">
</div>
<div class="form-group">
<label for="exampleInputPassword1">Password</label>
<input type="password" name="password" class="form-control"
id="exampleInputPassword1" placeholder="Password">
</div>
<div class="form-group">
<label for="exampleInputFile">File input</label>
<input type="file" name="headerImg" id="exampleInputFile">
<p class="help-block">Example block-level help text here.</p>
</div>
<div class="form-group">
<label for="exampleInputFile">File input</label>
<input type="file" name="photos" id="exampleInputFiles" multiple>
<p class="help-block">Example block-level help text here.</p>
</div>
<div class="checkbox">
<label>
<input type="checkbox"> Check me out
</label>
</div>
<button type="submit" class="btn btn-primary">Submit</button>
</form>
控制器
@Slf4j
@Controller
public class FormController {
@GetMapping("/form_layouts")
public String layoutForm() {
return "form/form_layouts";
}
@PostMapping("/upload")
public String upload(
@RequestParam("email") String email,
@RequestParam("password") String password,
@RequestPart("headerImg") MultipartFile headerImg,
@RequestPart("photos") MultipartFile[] photos) {
log.info("上传的文件：email={}, password={}, headerImg={}, photos.length={}",
email, password, headerImg.getSize(), photos.length);
return "main";
}
}
4.2 源码
（1）checkMultipart(request)
（2）mav = invokeHandlerMethod(...) → ... → Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs) 进入循环解析参数流程
