Add GsonHttpMessageConverter

This commit adds support to read and write JSON using the Google Gson
library. GsonHttpMessageConverter offers default Gson configuration, but
can be customized by using GsonFactoryBean. GsonFactoryBean includes
several convenience properties for configuring the internal GsonBuilder
and the resulting Gson object.

By default Gson converts byte arrays to JSON arrays instead of a Base64
encoded string. GsonBase64ByteArrayJsonTypeAdapter provides support to
read and write Base64 encoded byte arrays, and can be enabled in
GsonFactoryBean.

RestTemplate will enable GsonHttpMessageConverter only if Jackson 2 is
not found on the class path, because by default GsonHttpMessageConverter
supports the same media types as Jackson.

Issue: SPR-9488
This commit is contained in:
Roy Clarkson
2014-05-14 16:07:08 -05:00
committed by Rossen Stoyanchev
parent 9952973e01
commit 811330f5c8
7 changed files with 1033 additions and 0 deletions

View File

@@ -0,0 +1,239 @@
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.http.converter.json;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.junit.Before;
import org.junit.Test;
import com.google.gson.Gson;
import static org.junit.Assert.*;
/**
* {@link GsonFactoryBean} tests
*
* @author Roy Clarkson
*/
public class GsonFactoryBeanTests {
private static final String NEWLINE_SYSTEM_PROPERTY = System.getProperty("line.separator");
private static final String DATE_FORMAT = "yyyy-MM-dd";
private GsonFactoryBean factory;
@Before
public void setUp() {
factory = new GsonFactoryBean();
}
@Test
public void prettyPrint() throws Exception {
this.factory.setPrettyPrint(true);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
bean.setName("Jason");
String result = gson.toJson(bean);
assertEquals("{" + NEWLINE_SYSTEM_PROPERTY + " \"name\": \"Jason\"" + NEWLINE_SYSTEM_PROPERTY + "}", result);
}
@Test
public void prettyPrintFalse() throws Exception {
this.factory.setPrettyPrint(false);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
bean.setName("Jason");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Jason\"}", result);
}
@Test
public void serializeNulls() throws Exception {
this.factory.setSerializeNulls(true);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
String result = gson.toJson(bean);
assertEquals("{\"name\":null}", result);
}
@Test
public void serializeNullsFalse() throws Exception {
this.factory.setSerializeNulls(false);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
String result = gson.toJson(bean);
assertEquals("{}", result);
}
@Test
public void disableHtmlEscaping() throws Exception {
this.factory.setDisableHtmlEscaping(true);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
bean.setName("Bob=Bob");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Bob=Bob\"}", result);
}
@Test
public void disableHtmlEscapingFalse() throws Exception {
this.factory.setDisableHtmlEscaping(false);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
bean.setName("Bob=Bob");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Bob\\u003dBob\"}", result);
}
@Test
public void customizeDateFormat() throws Exception {
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
this.factory.setSimpleDateFormat(dateFormat);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
DateBean bean = new DateBean();
Calendar cal = Calendar.getInstance();
cal.clear();
cal.set(Calendar.YEAR, 2014);
cal.set(Calendar.MONTH, Calendar.JANUARY);
cal.set(Calendar.DATE, 1);
Date date = cal.getTime();
bean.setDate(date);
String result = gson.toJson(bean);
assertEquals("{\"date\":\"2014-01-01\"}", result);
}
@Test
public void customizeDateFormatString() throws Exception {
this.factory.setSimpleDateFormat(DATE_FORMAT);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
DateBean bean = new DateBean();
Calendar cal = Calendar.getInstance();
cal.clear();
cal.set(Calendar.YEAR, 2014);
cal.set(Calendar.MONTH, Calendar.JANUARY);
cal.set(Calendar.DATE, 1);
Date date = cal.getTime();
bean.setDate(date);
String result = gson.toJson(bean);
assertEquals("{\"date\":\"2014-01-01\"}", result);
}
@Test
public void customizeDateFormatNone() throws Exception {
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
DateBean bean = new DateBean();
Calendar cal = Calendar.getInstance();
cal.clear();
cal.set(Calendar.YEAR, 2014);
cal.set(Calendar.MONTH, Calendar.JANUARY);
cal.set(Calendar.DATE, 1);
Date date = cal.getTime();
bean.setDate(date);
String result = gson.toJson(bean);
assertEquals("{\"date\":\"Jan 1, 2014 12:00:00 AM\"}", result);
}
@Test
public void base64EncodeByteArrays() throws Exception {
this.factory.setBase64EncodeByteArrays(true);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] { 0x1, 0x2 });
String result = gson.toJson(bean);
assertEquals("{\"bytes\":\"AQI\\u003d\"}", result);
}
@Test
public void base64EncodeByteArraysDisableHtmlEscaping() throws Exception {
this.factory.setBase64EncodeByteArrays(true);
this.factory.setDisableHtmlEscaping(true);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] { 0x1, 0x2 });
String result = gson.toJson(bean);
assertEquals("{\"bytes\":\"AQI=\"}", result);
}
@Test
public void base64EncodeByteArraysFalse() throws Exception {
this.factory.setBase64EncodeByteArrays(false);
this.factory.afterPropertiesSet();
Gson gson = this.factory.getObject();
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] { 0x1, 0x2 });
String result = gson.toJson(bean);
assertEquals("{\"bytes\":[1,2]}", result);
}
private static class StringBean {
private String name;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
private static class DateBean {
private Date date;
public Date getDate() {
return this.date;
}
public void setDate(Date date) {
this.date = date;
}
}
public static class ByteArrayBean {
private byte[] bytes;
public byte[] getBytes() {
return this.bytes;
}
public void setBytes(byte[] bytes) {
this.bytes = bytes;
}
}
}

View File

@@ -0,0 +1,288 @@
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.http.converter.json;
import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import com.google.gson.reflect.TypeToken;
import static org.junit.Assert.*;
/**
* Gson 2.x converter tests.
*
* @author Roy Clarkson
*/
public class GsonHttpMessageConverterTests {
private static final Charset UTF8 = Charset.forName("UTF-8");
private GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
@Test
public void canRead() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "json")));
assertTrue(converter.canRead(Map.class, new MediaType("application", "json")));
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "json")));
assertTrue(converter.canWrite(Map.class, new MediaType("application", "json")));
}
@Test
public void canReadAndWriteMicroformats() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
}
@Test
public void readTyped() throws IOException {
String body =
"{\"bytes\":[1,2],\"array\":[\"Foo\",\"Bar\"],\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
MyBean result = (MyBean) converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[]{"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[]{0x1, 0x2}, result.getBytes());
}
@Test
@SuppressWarnings("unchecked")
public void readUntyped() throws IOException {
String body =
"{\"bytes\":[1,2],\"array\":[\"Foo\",\"Bar\"],\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
HashMap<String, Object> result = (HashMap<String, Object>) converter.read(HashMap.class, inputMessage);
assertEquals("Foo", result.get("string"));
Number n = (Number) result.get("number");
assertEquals(42, n.longValue());
n = (Number) result.get("fraction");
assertEquals(42D, n.doubleValue(), 0D);
List<String> array = new ArrayList<String>();
array.add("Foo");
array.add("Bar");
assertEquals(array, result.get("array"));
assertEquals(Boolean.TRUE, result.get("bool"));
byte[] bytes = new byte[2];
List<Number> resultBytes = (ArrayList<Number>)result.get("bytes");
for (int i = 0; i < 2; i++) {
bytes[i] = resultBytes.get(i).byteValue();
}
assertArrayEquals(new byte[]{0x1, 0x2}, bytes);
}
@Test
public void write() throws IOException {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MyBean body = new MyBean();
body.setString("Foo");
body.setNumber(42);
body.setFraction(42F);
body.setArray(new String[]{"Foo", "Bar"});
body.setBool(true);
body.setBytes(new byte[]{0x1, 0x2});
converter.write(body, null, outputMessage);
Charset utf8 = Charset.forName("UTF-8");
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":[1,2]"));
assertEquals("Invalid content-type", new MediaType("application", "json", utf8),
outputMessage.getHeaders().getContentType());
}
@Test
public void writeUTF16() throws IOException {
Charset utf16 = Charset.forName("UTF-16BE");
MediaType contentType = new MediaType("application", "json", utf16);
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
converter.write(body, contentType, outputMessage);
assertEquals("Invalid result", "\"" + body + "\"", outputMessage.getBodyAsString(utf16));
assertEquals("Invalid content-type", contentType, outputMessage.getHeaders().getContentType());
}
@Test(expected = HttpMessageNotReadableException.class)
public void readInvalidJson() throws IOException {
String body = "FooBar";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
converter.read(MyBean.class, inputMessage);
}
@Test
@SuppressWarnings("unchecked")
public void readGenerics() throws IOException {
GsonHttpMessageConverter converter = new GsonHttpMessageConverter() {
@Override
protected TypeToken<?> getTypeToken(Type type) {
if (type instanceof Class && List.class.isAssignableFrom((Class<?>) type)) {
return new TypeToken<ArrayList<MyBean>>() {
};
}
else {
return super.getTypeToken(type);
}
}
};
String body = "[{\"bytes\":[1,2],\"array\":[\"Foo\",\"Bar\"],\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}]";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(
body.getBytes(UTF8));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(List.class, inputMessage);
assertEquals(1, results.size());
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] { "Foo", "Bar" }, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] { 0x1, 0x2 }, result.getBytes());
}
@Test
@SuppressWarnings("unchecked")
public void readParameterizedType() throws IOException {
ParameterizedTypeReference<List<MyBean>> beansList = new ParameterizedTypeReference<List<MyBean>>() {
};
String body = "[{\"bytes\":[1,2],\"array\":[\"Foo\",\"Bar\"],\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}]";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(
body.getBytes(UTF8));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] { "Foo", "Bar" }, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] { 0x1, 0x2 }, result.getBytes());
}
@Test
public void prefixJson() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setPrefixJson(true);
this.converter.writeInternal("foo", outputMessage);
assertEquals("{} && \"foo\"", outputMessage.getBodyAsString(UTF8));
}
@Test
public void prefixJsonCustom() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setJsonPrefix(")]}',");
this.converter.writeInternal("foo", outputMessage);
assertEquals(")]}',\"foo\"", outputMessage.getBodyAsString(UTF8));
}
public static class MyBean {
private String string;
private int number;
private float fraction;
private String[] array;
private boolean bool;
private byte[] bytes;
public byte[] getBytes() {
return bytes;
}
public void setBytes(byte[] bytes) {
this.bytes = bytes;
}
public boolean isBool() {
return bool;
}
public void setBool(boolean bool) {
this.bool = bool;
}
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public float getFraction() {
return fraction;
}
public void setFraction(float fraction) {
this.fraction = fraction;
}
public String[] getArray() {
return array;
}
public void setArray(String[] array) {
this.array = array;
}
}
}