Http Message Converters with the Spring Framework--转载
原文:http://www.baeldung.com/spring-httpmessageconverter-rest
1. Overview
This article describes how to Configure HttpMessageConverter in Spring.
Simply put, message converters are used to marshall and unmarshall Java Objects to and from JSON, XML, etc – over HTTP.
2. The Basics
2.1. Enable Web MVC
The Web Application needs to be configured with Spring MVC support – one convenient and very customizable way to do this is to use the @EnableWebMvc annotation:
1
2
3
4
5
6
|
@EnableWebMvc @Configuration @ComponentScan ({ "org.baeldung.web" }) public class WebConfig extends WebMvcConfigurerAdapter { ... } |
Note that this class extends WebMvcConfigurerAdapter – which will allow us to change the default list of Http Converters with our own.
2.2. The Default Message Converters
By default, the following HttpMessageConverters instances are pre-enabled:
- ByteArrayHttpMessageConverter – converts byte arrays
- StringHttpMessageConverter – converts Strings
- ResourceHttpMessageConverter – converts org.springframework.core.io.Resource for any type of octet stream
- SourceHttpMessageConverter – converts javax.xml.transform.Source
- FormHttpMessageConverter – converts form data to/from a MultiValueMap<String, String>.
- Jaxb2RootElementHttpMessageConverter – converts Java objects to/from XML (added only if JAXB2 is present on the classpath)
- MappingJackson2HttpMessageConverter – converts JSON (added only if Jackson 2 is present on the classpath)
- MappingJacksonHttpMessageConverter – converts JSON (added only if Jackson is present on the classpath)
- AtomFeedHttpMessageConverter – converts Atom feeds (added only if Rome is present on the classpath)
- RssChannelHttpMessageConverter – converts RSS feeds (added only if Rome is present on the classpath)
3. Client-Server Communication – JSON only
3.1. High Level Content Negotiation
Each HttpMessageConverter implementation has one or several associated MIME Types.
When receiving a new request, Spring will use of the “Accept” header to determine the media type that it needs to respond with.
It will then try to find a registered converter that is capable of handling that specific media type – and it will use it to convert the entity and send back the response.
The process is similar for receiving a request which contains JSON information – the framework will use the “Content-Type” header to determine the media type of the request body.
It will then search for a HttpMessageConverter that can convert the body sent by the client to a Java Object.
Let’s clarify this with a quick example:
- the Client sends a GET request to /foos with the Accept header set to application/json – to get all Foo resources as Json
- the Foo Spring Controller is hit and returns the corresponding Foo Java entities
- Spring then uses one of the Jackson message converters to marshall the entities to json
Let’s now look at the specifics of how this works – and how we should leverage the@ResponseBody and @RequestBody annotations.
3.2. @ResponseBody
@ResponseBody on a Controller method indicates to Spring that the return value of the method is serialized directly to the body of the HTTP Response. As discussed above, the “Accept” header specified by the Client will be used to choose the appropriate Http Converter to marshall the entity.
Let’s look at a simple example:
1
2
3
4
|
@RequestMapping (method=RequestMethod.GET, value= "/foos/{id}" ) public @ResponseBody Foo findById( @PathVariable long id) { return fooService.get(id); } |
Now, the client will specify the “Accept” header to application/json in the request – example curl command:
curl --header "Accept: application/json" http: //localhost :8080 /spring-rest/foos/1 |
The Foo class:
1
2
3
4
|
public class Foo { private long id; private String name; } |
And the Http Response Body:
1
2
3
4
|
{ "id" : 1, "name" : "Paul" , } |
3.3. @RequestBody
@RequestBodyis used on the argument of a Controller method – it indicates to Spring that the body of the HTTP Request is deserialized to that particular Java entity. As discussed previously, the “Content-Type” header specified by the Client will be used to determine the appropriate converter for this.
Let’s look at an example:
1
2
3
4
|
@RequestMapping (method=RequestMethod.PUT, value= "/foos/{id}" ) public @ResponseBody void updateFoo( @RequestBody Foo foo, @PathVariable String id) { fooService.update(foo); } |
Now, let’s consume this with a JSON object – we’re specifying “Content-Type” to beapplication/json:
curl -i -X PUT -H "Content-Type: application/json" -d '{"id":"83","name":"klik"}' http: //localhost :8080 /spring-rest/foos/1 |
We get back a 200 OK – a successful response:
1
2
3
4
|
HTTP /1 .1 200 OK Server: Apache-Coyote /1 .1 Content-Length: 0 Date: Fri, 10 Jan 2014 11:18:54 GMT |
4. Custom Converters Configuration – adding XML Support
We can customize the message converters by extending the WebMvcConfigurerAdapter class and overriding the configureMessageConvertersmethod:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@EnableWebMvc @Configuration @ComponentScan ({ "org.baeldung.web" }) public class WebConfig extends WebMvcConfigurerAdapter { @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { messageConverters.add(createXmlHttpMessageConverter()); messageConverters.add( new MappingJackson2HttpMessageConverter()); super .configureMessageConverters(converters); } private HttpMessageConverter<Object> createXmlHttpMessageConverter() { MarshallingHttpMessageConverter xmlConverter = new MarshallingHttpMessageConverter(); XStreamMarshaller xstreamMarshaller = new XStreamMarshaller(); xmlConverter.setMarshaller(xstreamMarshaller); xmlConverter.setUnmarshaller(xstreamMarshaller); return xmlConverter; } } |
Note that the XStream library now needs to be present on the classpath.
Also be aware that by extending this support class, we are losing the default message converters which were previously pre-registered – we only have what we define.
Let’s go over this example – we are creating a new converter – theMarshallingHttpMessageConverter – and we’re using the Spring XStream support to configure it. This allows a great deal of flexibility since we’re working with the low level APIs of the underlying marshalling framework – in this case XStream – and we can configure that however we want.
We can of course now do the same for Jackson – by defining our ownMappingJackson2HttpMessageConverter we can now set a custom ObjectMapper on this converter and have it configured as we need to.
In this case XStream was the selected marshaller/unmarshaller implementation, but others like CastorMarshaller can be used to – refer to Spring api documentation for full list of available marshallers.
At this point – with XML enabled on the back end – we can consume the API with XML Representations:
1
|
curl --header "Accept: application/xml" http: //localhost :8080 /spring-rest/foos/1 |
5. Using Spring’s RestTemplate with Http Message Converters
As well as with the server side, Http Message Conversion can be configured in the client side on the Spring RestTemplate.
We’re going to configure the template with the “Accept” and “Content-Type” headers when appropriate and we’re going to try to consume the REST API with full marshalling and unmarshalling of the Foo Resource – both with JSON and with XML.
5.1. Retrieving the Resource with no Accept Header
1
2
3
4
5
6
7
|
@Test public void testGetFoo() { String URI = “http: //localhost:8080/spring-rest/foos/{id}"; RestTemplate restTemplate = new RestTemplate(); Foo foo = restTemplate.getForObject(URI, Foo. class , "1" ); Assert.assertEquals( new Integer( 1 ), foo.getId()); } |
5.2. Retrieving a Resource with application/xml Accept header
Let’s now explicitly retrieve the Resource as an XML Representation – we’re going to define a set of Converters – same way we did previously – and we’re going to set these on the RestTemplate.
Because we’re consuming XML, we’re going to use the same XStream marshaller as before:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
@Test public void givenConsumingXml_whenReadingTheFoo_thenCorrect() { String URI = BASE_URI + "foos/{id}" ; RestTemplate restTemplate = new RestTemplate(); restTemplate.setMessageConverters(getMessageConverters()); HttpHeaders headers = new HttpHeaders(); headers.setAccept(Arrays.asList(MediaType.APPLICATION_XML)); HttpEntity<String> entity = new HttpEntity<String>(headers); ResponseEntity<Foo> response = restTemplate.exchange(URI, HttpMethod.GET, entity, Foo. class , "1" ); Foo resource = response.getBody(); assertThat(resource, notNullValue()); } private List<HttpMessageConverter<?>> getMessageConverters() { XStreamMarshaller marshaller = new XStreamMarshaller(); MarshallingHttpMessageConverter marshallingConverter = new MarshallingHttpMessageConverter(marshaller); converters.add(marshallingConverter); |
1
2
3
|
List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(); return converters; } |
5.3. Retrieving a Resource with application/json Accept header
Similarly, let’s now consume the REST API by asking for JSON:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@Test public void givenConsumingJson_whenReadingTheFoo_thenCorrect() { String URI = BASE_URI + "foos/{id}" ; RestTemplate restTemplate = new RestTemplate(); restTemplate.setMessageConverters(getMessageConverters()); HttpHeaders headers = new HttpHeaders(); headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON)); HttpEntity<String> entity = new HttpEntity<String>(headers); ResponseEntity<Foo> response = restTemplate.exchange(URI, HttpMethod.GET, entity, Foo. class , "1" ); Foo resource = response.getBody(); assertThat(resource, notNullValue()); } private List<HttpMessageConverter<?>> getMessageConverters() { List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(); converters.add( new MappingJackson2HttpMessageConverter()); return converters; } |
5.4. Update a Resource with XML Content-Type
Finally, let’s also send JSON data to the REST API and specify the media type of that data via the Content-Type header:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@Test public void givenConsumingXml_whenWritingTheFoo_thenCorrect() { String URI = BASE_URI + "foos/{id}" ; RestTemplate restTemplate = new RestTemplate(); restTemplate.setMessageConverters(getMessageConverters()); Foo resource = new Foo( 4 , "jason" ); HttpHeaders headers = new HttpHeaders(); headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON)); headers.setContentType((MediaType.APPLICATION_XML)); HttpEntity<Foo> entity = new HttpEntity<Foo>(resource, headers); ResponseEntity<Foo> response = restTemplate.exchange(URI, HttpMethod.PUT, entity, Foo. class , resource.getId()); Foo fooResponse = response.getBody(); Assert.assertEquals(resource.getId(), fooResponse.getId()); } |
What’s interesting here is that we’re able to mix the media types – we are sending XML data but we’re waiting for JSON data back from the server. This shows just how powerful the Spring conversion mechanism really is.
6. Conclusion
In this tutorial, we looked at how Spring MVC allows us to specify and fully customize Http Message Converters to automatically marshall/unmarshall Java Entities to and from XML or JSON. This is of course a simplistic definition, and there is so much more that the message conversion mechanism can do – as we can see from the last test example.
We have also looked at how to leverage the same powerful mechanism with theRestTemplate client – leading to a fully type-safe way of consuming the API.
Http Message Converters with the Spring Framework--转载的更多相关文章
- Spring Framework(框架)整体架构 变迁
Spring Framework(框架)整体架构 2018年04月24日 11:16:41 阅读数:1444 标签: Spring框架架构 更多 个人分类: Spring框架 版权声明:本文为博主 ...
- Spring Framework------>version4.3.5.RELAESE----->Reference Documentation学习心得----->Spring Framework中的spring web MVC模块
spring framework中的spring web MVC模块 1.概述 spring web mvc是spring框架中的一个模块 spring web mvc实现了web的MVC架构模式,可 ...
- Spring Framework 5.0.0.M3中文文档 翻译记录 Part I. Spring框架概览1-2.2
Part I. Spring框架概览 The Spring Framework is a lightweight solution and a potential one-stop-shop for ...
- Spring系列(零) Spring Framework 文档中文翻译
Spring 框架文档(核心篇1和2) Version 5.1.3.RELEASE 最新的, 更新的笔记, 支持的版本和其他主题,独立的发布版本等, 是在Github Wiki 项目维护的. 总览 历 ...
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion(一)
题外话:本篇是对之前那篇的重排版.并拆分成两篇,免得没了看的兴趣. 前言 在Spring Framework官方文档中,这三者是放到一起讲的,但没有解释为什么放到一起.大概是默认了读者都是有相关经验的 ...
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion(二)
接前一篇 Spring Framework 官方文档学习(四)之Validation.Data Binding.Type Conversion(一) 本篇主要内容:Spring Type Conver ...
- Spring Framework 官方文档学习(四)之Validation、Data Binding、Type Conversion
本篇太乱,请移步: Spring Framework 官方文档学习(四)之Validation.Data Binding.Type Conversion(一) 写了删删了写,反复几次,对自己的描述很不 ...
- Spring Framework 官方文档学习(一)介绍
http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#overview-maven-bom ...
- Dive into Spring framework -- 了解基本原理(一)
在继续我们的分析之前,推荐各位静心来读一下<<Expert_OneOne_J2EE_Design_and_Development>> 第四章, 正如spring BeanFac ...
随机推荐
- C++的笔记学习第一篇,认识C++
在一个类中包含两种成员: 数据和函数,分别称为C++数据成员和成员函数. 关于类: 类是C++新增加的重要数据类型,有了类,就就可以实现面向对象程序设计方法中的封装.信息隐蔽.继承.派生.多态等功能. ...
- thread.join函数,java多线程中的join函数解析
join函数的作用,是让当前线程等待,直到调用join()的 线程结束或者等到一段时间,我们来看以下代码 package mian; public class simpleplela { static ...
- stl+模拟 CCF2016 4 路径解析
// stl+模拟 CCF2016 4 路径解析 // 一开始题意理解错了.... #include <iostream> #include <string> #include ...
- c++ 概念及学习/c++ concept&learning(一)
学习过计算机组成原理就会知道,处理器会从主存中取得指令,然后进行解释执行.而他们的交流方式是以二进制方式进行的,也就是他们只能识别1和0 :其实计算机是不知道1和0的,现在的实现方式是以高电压与低电压 ...
- windwos iis 7.5 使用html 报405错误
今天遇到了这个问题,网上搜一下基本上都是下面的答案: <form> 没有指定action的话就是文件自身了. .html本身是不可执行的,如果要修改的话,在IIS中站点属性- 主目录 - ...
- 【转】新建maven工程为什么jdk会是默认版本 而不是自己设置的版本?
原文链接:为什么我eclipse新建项目的时候默认的是JRE1.5? 修改Maven中conf目录里的setting.xml文件内容,加上如下内容: <profiles> <!-- ...
- [转]MyEclipse for Spring2014破解
转至:http://blog.my-eclipse.cn/myeclipse-2014-crack.html 一.安装完成MyEclipse2014(适用于2013等版本)后,不要打开软件,下载破解附 ...
- Linux实战教学笔记08:Linux 文件的属性(下半部分)
第八节 Linux 文件的属性(下半部分) 标签(空格分隔): Linux教学笔记 ---更多相关资料请点我查看 第1章 链接的概念 在linux系统中,链接可分为两种:一种为硬链接(Hard Lin ...
- JAVA事务的概念
From:http://www.cnblogs.com/kristain/articles/2038397.html 一.什么是事务 事务是访问数据库的一个操作序列,数据库应用系统通过事务集来完成对数 ...
- 利用AssetsManager实现在线更新脚本文件lua、js、图片等资源(免去平台审核周期)
转自:http://www.himigame.com/iphone-cocos2dx/1354.html 首先说明一个问题: 为什么要在线更新资源和脚本文件!? 对于此问题,那要说的太多了,简单概括, ...