springboot mime类型处理

朱雀 2022-01-23 08:51 270阅读 0赞

## 一、关于MIME ##

**MIME**的全称是Multipurpose Internet Mail Extensions，即多用途互联网邮件扩展，尽管读起来有些拗口，但大多数人可能都知道，  
这是HTTP协议中用来定义文档性质及格式的标准。[IETF RFC 6838][]，对HTTP传输内容类型进行了全面定义。  
而**IANA**(互联网号码分配机构)是负责管理所有标准MIME类型的官方机构。可以[在这里][Link 1])找到所有的标准MIME

服务器通过MIME告知响应内容类型，而浏览器则通过MIME类型来确定如何处理文档；  
因此为传输内容(文档、图片等)设置正确的MIME非常重要。

通常Server会在HTTP响应中设置**Content-Type**，如下面的响应：

1.  `HTTP/1.1 200 OK`
2.  `Server: Golfe2`
3.  `Content-Length: 233`
4.  `Content-Type: application/html`
5.  `Date: Sun, 28 Dec 2018 02:55:19 GMT`

这表示服务端将返回html格式的文档，而同样客户端也可以在HTTP请求中设置**Content-Type**以告知服务器当前所发送内容的格式。  
如下面的请求体：

1.  `POST / HTTP/1.1`
2.  `Host: localhost:8000`
3.  `User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:50.0) Gecko/20100101 Firefox/50.0`
4.  `Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
5.  `Connection: keep-alive`
6.  `Content-Type: application/json`
7.  `Content-Length: 465`

这表示客户端会发送application/json格式的数据到服务端，同时应该注意到**Accept**请求头，这个选项用于告知服务器应该返回什么样的数据格式(由客户端接收并完成解析)。

**MIME的格式**

type/subtype

这是一个两级的分类，比较容易理解，第一级分类通常包含：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>text</td> 
   <td>普通文本</td> 
  </tr> 
  <tr> 
   <td>image</td> 
   <td>某种图像</td> 
  </tr> 
  <tr> 
   <td>audio</td> 
   <td>某种音频文件</td> 
  </tr> 
  <tr> 
   <td>video</td> 
   <td>某种视频文件</td> 
  </tr> 
  <tr> 
   <td>application</td> 
   <td>应用数据</td> 
  </tr> 
  <tr> 
   <td>multi-part</td> 
   <td>复合内容</td> 
  </tr> 
 </tbody> 
</table>

而二级类型则非常多，以下是一些常用的MIME：

<table> 
 <thead> 
  <tr> 
   <th>MIME</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>audio/wav</td> 
   <td>wave音频流媒体文件</td> 
  </tr> 
  <tr> 
   <td>audio/webm</td> 
   <td>webm 音频文件格式</td> 
  </tr> 
  <tr> 
   <td>audio/ogg</td> 
   <td>ogg多媒体文件格式的音频文件</td> 
  </tr> 
  <tr> 
   <td>audio/mpeg</td> 
   <td>mpeg多媒体文件格式的音频文件</td> 
  </tr> 
  <tr> 
   <td>image/gif</td> 
   <td>gif图片</td> 
  </tr> 
  <tr> 
   <td>image/jpeg</td> 
   <td>jpeg图片</td> 
  </tr> 
  <tr> 
   <td>image/png</td> 
   <td>png图片</td> 
  </tr> 
  <tr> 
   <td>image/svg+xml</td> 
   <td>svg矢量图片</td> 
  </tr> 
  <tr> 
   <td>application/json</td> 
   <td>json格式</td> 
  </tr> 
  <tr> 
   <td>application/xml</td> 
   <td>xml格式</td> 
  </tr> 
  <tr> 
   <td>application/xhtml+xml</td> 
   <td>扩展html格式</td> 
  </tr> 
  <tr> 
   <td>application/x-www-form-urlencoded</td> 
   <td>表单url内容编码</td> 
  </tr> 
  <tr> 
   <td>application/octet-stream</td> 
   <td>二进制格式</td> 
  </tr> 
  <tr> 
   <td>application/pdf</td> 
   <td>pdf文档</td> 
  </tr> 
  <tr> 
   <td>application/atom+xml</td> 
   <td>atom订阅feed流</td> 
  </tr> 
  <tr> 
   <td>multipart/form-data</td> 
   <td>多文档格式</td> 
  </tr> 
  <tr> 
   <td>text/plain</td> 
   <td>普通文本</td> 
  </tr> 
  <tr> 
   <td>text/html</td> 
   <td>html文档</td> 
  </tr> 
  <tr> 
   <td>text/css</td> 
   <td>css文件</td> 
  </tr> 
  <tr> 
   <td>text/javascript</td> 
   <td>javascript文件</td> 
  </tr> 
  <tr> 
   <td>text/markdown</td> 
   <td>markdown文档</td> 
  </tr> 
  <tr> 
   <td>video/mpeg</td> 
   <td>mpeg多媒体视频文件</td> 
  </tr> 
  <tr> 
   <td>video/quicktime</td> 
   <td>mov多媒体视频文件</td> 
  </tr> 
 </tbody> 
</table>

接下来，看看springboot如何实现几个常见类型格式的处理。

## 二、springboot-json处理 ##

先看看这样一段代码：

1.  `@ResponseBody`
2.  `@PostMapping(value = "/json", consumes= { MediaType.APPLICATION_JSON_UTF8_VALUE }, produces="application/json;charset=UTF-8")`
3.  `public Map<String, Object> jsonIO(@RequestBody Map<String, Object> jsonData) {`
4.  `Map<String, Object> resultData = new HashMap<>(jsonData);`
5.  `resultData.put("resultCode", UUID.randomUUID().toString());`
6.  `return resultData;`
7.  `}`

这是一个Controller层的方法定义，其中@PostMapping将该方法映射到***/json***路径的POST方法。

1.  consumes = \{ MediaType.APPLICATION\_JSON\_UTF8\_VALUE \} 指定了该方法仅处理application/json的内容格式
2.  produces="application/json;charset=UTF-8" 则表示会在响应头中指定**Content-Type=application/json;charset=UTF-8**
3.  @RequestBody 指定了将请求的输入通过Json转换为DTO
4.  @ResponseBody 指定将响应对象转换为Json格式输出

通过观察请求响应，我们会得到以下的结果：

1.  `====> Request:`
2.  `Content-Type=application/json;`
3.  `{`
4.  `"key": "value"`
5.  `}`
6.  `====> Response:`
7.  `Content-Type=application/json;charset=UTF-8`
8.  `{`
9.  `"resultCode": "1ec407e1-d753-4439-b31c-bb7e888aa6a2",`
10. `"key": "value"`
11. `}`

使用Postman工具进行调试，可以非常直观的获得想要的信息，[点击这里][Link 2]可以下载

**异常情况**  
如果，请求的内容格式不是json，而是其他的如***application/x-www-form-urlencoded***呢？  
放心，框架会返回如下面的错误：

1.  `{`
2.  `"timestamp": 1530626924715,`
3.  `"status": 415,`
4.  `"error": "Unsupported Media Type",`
5.  `"exception": "org.springframework.web.HttpMediaTypeNotSupportedException",`
6.  `"message": "Content type 'application/x-www-form-urlencoded' not supported",`
7.  `"path": "/content/json"`
8.  `}`

## 三、springboot-xml处理 ##

如上，通过springboot框架，我们快速实现了Json格式的输入输出。  
那么，如何实现xml格式的处理呢？xml格式主要用于soap、rpc等领域，为了实现xml数据的序列化，我们需要添加jackson-xml依赖包

1.  ``
2.  `<dependency>`
3.  `<groupId>com.fasterxml.jackson.dataformat</groupId>`
4.  `<artifactId>jackson-dataformat-xml</artifactId>`
5.  `<version>2.8.6</version>`
6.  `</dependency>`

接下来，声明一个Controller方法

1.  `@PostMapping(value = "/xml", consumes = {`
2.  `MediaType.APPLICATION_XML_VALUE }, produces = MediaType.APPLICATION_XML_VALUE)`
3.  `@ResponseBody`
4.  `public ParamData xmlIO(@RequestBody ParamData data) {`
5.  `data.setAge(data.getAge() + 1);`
6.  `return data;`
7.  `}`

这次，我们指定了consumes、produces都是**application/xml**，通过@RequestBody、@ResponseBody注解之后，  
springboot框架会自动根据需求的内容格式进行转换。

这里的ParamData是一个简单的Pojo类：

1.  `public static class ParamData {`
2.   
3.  `private String name;`
4.  `private int age;`
5.   
6.  `public String getName() {`
7.  `return name;`
8.  `}`
9.   
10. `public void setName(String name) {`
11. `this.name = name;`
12. `}`
13.  
14. `public int getAge() {`
15. `return age;`
16. `}`
17.  
18. `public void setAge(int age) {`
19. `this.age = age;`
20. `}`
21.  
22. `}`

通过真实的请求-响应观测，我们得到如下的结果：

1.  `====> Request:`
2.  `Content-Type=application/xml;`
3.  `<ParamData>`
4.  `<name>Jim</name>`
5.  `<age>1</age>`
6.  `</ParamData>`
7.  `====> Response:`
8.  `Content-Type=application/xml;charset=UTF-8`
9.  `<ParamData>`
10. `<name>Jim</name>`
11. `<age>2</age>`
12. `</ParamData>`

BTW，springboot 完成自动类型转换是通过**内容协商**实现的，相关的接口为**ContentNegotiationManager**。  
默认情况下，对于声明了consumes及produce属性的方法，会按照声明的值进行处理，否则格式的转换会根据请求中的Content-Type、Accept头部来进行判断。  
此外，实现请求/响应内容到DTO转换功能的是**HttpMessageConverter**接口。

> 准确说，内容转换是由springmvc框架提供，而springboot是一个整合模块的脚手架

## 四、http参数处理 ##

对于普通的表单请求参数处理，我们通常有两种方式：

*  通过方法参数映射

1.  `@PostMapping(value = "/form", consumes = {`
2.  `MediaType.APPLICATION_FORM_URLENCODED_VALUE }, produces = MediaType.TEXT_PLAIN_VALUE)`
3.  `@ResponseBody`
4.  `public String form(@RequestParam("name") String name, @RequestParam("age") int age) {`
5.  `return String.format("Welcome %s, you are %d years old", name, age);`
6.  `}`

*  通过参数绑定

1.  `@PostMapping(value = "/form1", consumes = {`
2.  `MediaType.APPLICATION_FORM_URLENCODED_VALUE }, produces = MediaType.TEXT_PLAIN_VALUE)`
3.  `@ResponseBody`
4.  `public String form1(ParamData data) {`
5.  `return String.format("Welcome %s, you are %d years old. Bye", data.getName(), data.getAge());`
6.  `}`

form表单的请求内容格式为**application/x-www-form-urlencoded**,  
一个请求的样例如下：

1.  `====>Request:`
2.  `Content-Length →40`
3.  `Content-Type →text/plain;charset=UTF-8`
4.  `Date →Mon, 16 Jul 2018 13:50:14 GMT`
5.   
6.  `name=Lilei`
7.  `age=11`
8.   
9.  `====>Response:`
10. `Content-Length →40`
11. `Content-Type →text/plain;charset=UTF-8`
12. `Date →Mon, 16 Jul 2018 13:50:14 GMT`
13.  
14. `Welcome Lilei, you are 11 years old. Bye`

## 五、文件上传下载 ##

对于文件上传，我们需要将请求声明为**multipart/form-data**格式，一个文件上传的请求样例如下：

1.  `POST / HTTP/1.1`
2.  `Host: localhost:8000`
3.  `User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36`
4.  `Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
5.  `Accept-Language: en-US,en;q=0.5`
6.  `Accept-Encoding: gzip, deflate`
7.  `Connection: keep-alive`
8.  `Upgrade-Insecure-Requests: 1`
9.  `Content-Type: multipart/form-data; boundary=---------------------------8721656041911415653955004498`
10. `Content-Length: 465`
11.  
12. `-----------------------------8721656041911415653955004498`
13. `Content-Disposition: form-data; name="name"`
14.  
15. `Test`
16. `-----------------------------8721656041911415653955004498`
17. `Content-Disposition: form-data; name="file"; filename="flower.jpg"`
18. `Content-Type: image/jpeg`
19.  
20. `....`
21. `-----------------------------8721656041911415653955004498--`

参照以下的代码可以实现简单的文件上传处理：

1.  `@PostMapping(value = "file", consumes = {`
2.  `MediaType.MULTIPART_FORM_DATA_VALUE }, produces = MediaType.TEXT_PLAIN_VALUE)`
3.  `@ResponseBody`
4.  `public String file(@RequestParam("name") String name, @RequestParam("file") MultipartFile file) {`
5.   
6.  `logger.info("file receive {}", name);`
7.   
8.  `if (file.isEmpty()) {`
9.  `return "No File";`
10. `}`
11. `String fileName = file.getOriginalFilename();`
12.  
13. `File root = new File("D:/temp");`
14. `if (!root.isDirectory()) {`
15. `root.mkdirs();`
16. `}`
17. `try {`
18. `file.transferTo(new File(root, name));`
19. `return String.format("Upload to %s", fileName);`
20. `} catch (IllegalStateException e) {`
21. `e.printStackTrace();`
22. `} catch (IOException e) {`
23. `e.printStackTrace();`
24. `}`
25. `return "Upload Failed";`
26. `}`

这个例子非常简单，通过声明***@RequestParam***注解获得***MultipartFile*** 对象，在获得上传文件后存储到服务器本地目录。  
当然，在真实的项目应用中你需要做的更多，比如文件的大小、类型校验，将文件进行压缩或将文件存放到大容量、高稳定性的分布式文件存储系统等等。

这里不多啰嗦了，关于**文件下载**，可以通过以下的方法实现：

1.  `@GetMapping(path = "/download")`
2.  `public ResponseEntity<Resource> download(@RequestParam("name") String name) throws IOException {`
3.   
4.  `File file = new File("D:/temp", name);`
5.  `Path path = Paths.get(file.getAbsolutePath());`
6.  `ByteArrayResource resource = new ByteArrayResource(Files.readAllBytes(path));`
7.  `return ResponseEntity.ok().header("Content-Disposition", "attachment;fileName=" + name)`
8.  `.contentLength(file.length()).contentType(MediaType.APPLICATION_OCTET_STREAM).body(resource);`
9.  `}`

聪明的读者一定会发现，除了将文件内容作为输出之外，我们还为响应添加两个header：

1.  **Content-Type:application/octet-stream**，这表示响应的文档是未知的二进制数据，大多数情况下浏览器会直接下载；
2.  **Content-Disposition →attachment;fileName=test.jpg**，表示文档应该作为附件保存，并名称为test.jpg。

## 六、获得原始字节流 ##

在某些情况下，你可能需要获得原始的请求字节流，比如实现内容的过滤，或者为了完成制作自己的RPC接口。  
在springboot中获得字节流非常简单，从Servlet API的定义中可以发现，直接通过HttpServletRequest对象便可以获取一个InputStream。

在我们定义的Controller方法中，还可以***直接声明流类型的参数***以获取数据。

1.  `@PostMapping(value = "/data", produces = MediaType.TEXT_PLAIN_VALUE)`
2.  `@ResponseBody`
3.  `public String rawIO(InputStream dataStream) throws Exception {`
4.  `return IOUtils.toString(dataStream, "UTF-8");`
5.  `}`

然而，如果这么做了，你可能会遇到一些麻烦：  
当请求头中**Content-Type=application/x-www-form-urlencoded** 时，你会获得一个空的InputStream！

笔者曾经在制作代理服务器的时候遇到了这个问题，经过一番查阅，发现问题的原因在于：

按照Servlet规范，如果同时满足下列条件，则请求体(Entity)中的表单数据，将被填充到request的parameter集合中(导致inputstream为空)。  
1 这是一个HTTP/HTTPS请求  
2 请求方法是POST  
3 请求的类型Content-Type=application/x-www-form-urlencoded  
4 Servlet调用了getParameter系列方法

springboot框架内置了**HiddenHttpMethodFilter**，用于支持浏览器form表单无法支持put/delete等请求方法的问题。

在Filter的实现中发现存在如下代码：

1.  `if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {`
2.  `String paramValue = request.getParameter(this.methodParam);`
3.  `if (StringUtils.hasLength(paramValue)) {`
4.  `requestToUse = new HttpMethodRequestWrapper(request, paramValue);`
5.  `}`
6.  `}`

1.  `以下代码与本文无关，请自行跳过`
2.  `<P><A href="http://xzmobile.zztj120.com/"><FONT color=#ffffff>郑州正规妇科医院</FONT>`
3.  `<P><A href="http://byby.zztjyy.com/"><FONT color=#ffffff>郑州哪家医院能做三代试管婴儿</FONT>`
4.  `<P><A href="http://www.zzfkyy120.com/"><FONT color=#ffffff>郑州看不孕不育</FONT>`
5.  `<P><A href="http://www.zztjfk.com/"><FONT color=#ffffff>郑州治疗妇科疾病医院</FONT>`

由于getParameter被提前调用，导致后续获取InputStream为空。  
该问题的**解决方法**是实现HttpServletRequest的代理，事先将InputStream保存起来供多次使用，通过**高优先级的过滤器提前将Request对象置换**可达到目的。

## 小结 ##

HTTP协议中定义了MIME标准，以实现传输内容格式的识别及转换。  
本文介绍了常见的MIME类型，并结合springboot框架的代码样例，讲述如何完成Json/xml/字节流等常见类型的内容处理。  
对于Http参数、文件的上传下载提供了简单代码示例，读者在充分了解用法之后可以进一步完善，并应用到实际的项目中去。

原址 [https://blog.csdn.net/qq\_42606051/article/details/81080253][https_blog.csdn.net_qq_42606051_article_details_81080253]

[IETF RFC 6838]: https://tools.ietf.org/html/rfc6838
[Link 1]: https://www.iana.org/assignments/media-types/media-types.xhtml
[Link 2]: https://www.getpostman.com/apps
[https_blog.csdn.net_qq_42606051_article_details_81080253]: https://blog.csdn.net/qq_42606051/article/details/81080253