Spring Boot 之遇见JSON

MVC框架中，Spring Boot内置了jackson来完成JSON的序列化和反序列化操作，并且，在与其他技术集成的时候，如Redis、MongoDB、Elasticsearch等对象序列化，都可使用jackson来完成。

Spring Boot 之遇见JSON

• Spring Boot中使用Jackson
• 自定义ObjectMapper
• Jackson的三种使用方式
• Jackson树遍历
• 对象绑定
• 流式操作
• Jackson注解
• 集合的反序列化

Spring Boot中使用Jackson

在Controller中，方法注解为@ResponseBody，则自动将方法返回的对象序列化成JSON。

@Controller
@RequestMapping("/json")
public class JsonController(){
	@Autowired UserService userService;
	@GetMapping("/user/{id}.json")
	public @ResponseBody User showUserInfo(@PathVariable Long id){
		User user = userService.getUserById(id);
		return user;
	}
}

自定义ObjectMapper

使用Java Config来自定义一个ObjectMapper，使用@Bean来配置，如：

@Configuration
public class JacksonConf{
	@Bean
	public ObjectMapper getObjectMapper() {
		ObjectMapper objectMapper = new ObjectMapper();
		objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
		return objectMapper;
	}
}

获取当前时间：

@GetMapping("/now.json")
public @ResopnseBody Map datetime() {
	Map map = new HashMap ();
	map.put("time", new Date());
	return map;
}

当访问now.json时，输出：

{"time": "2019-03-17 11:11:11"}

Jackson的三种使用方式

• 采用JsonParser来解析JSON，解析结果是一串Tokens，采用JsonGenerator来生成JSON，这是最底层的方式。
• 采用树遍历（Tree Traversing）方式，JSON被读入到JsonNode对象中，可以像操作XML DOM那样读取JSON。
• 采用DataBind方式，将POJO序列化成JSON，或者反序列化到POJO。

Jackson树遍历

树遍历通常适合没有POJO对应的JSON，如：

@Autowired ObjectMapper mapper;

@GetMapping("/readtree.json")
public @ResponseBody String readtree() throws JsonProcessingException,IOException{
	String json = "{"name":"aaa","id":10}";
	JsonNode node = mapper.readTree(json);
	String name = node.get("name").asText();
	int id = node.get("id").asInt();
	return "name:"+name+",id"+id;
}

readTree方法可以接受一个字符串或者字节数组、文件、InputStream等，返回JsonNode作为根节点。

JsonNode支持以下方法来读取JSON数据：

• asXXX，如asText、asBoolean、asInt等，读取JsonNode对应的值。
• isArray，用于判断JsonNode是否是数组，如果是数组，可以用get(i)来进行遍历，通过size()来获取长度。
• get(String)，获取当前节点的子节点，返回JsonNode。

JSON规范要求Key是字符串，且用双引号

对象绑定

应用程序更多的是使用Java对象与JSON数据互相绑定，仅仅调用ObjectMapper的readValue来实现，如：

{"name":"aaa",age:10}

可以创建一个POJO对象来与JSON相对应：

public class User {
	Long id;
	String name;
	// setter getter
}

然后使用readValue来反序列化上面的JSON字符串：

@GetMapping("/databind.json")
public @ResponseBody String databind() throws JsonProcessingException,IOException{
	String json = "{"name":"aaa","id":10}";
	User user = mapper.readValue(json,User.class);
	return "name:"+user.getName()+",id:"+user.getId();
}

将POJO序列化成JSON，使用mapper的writeValueAsString方法：

@GetMapping("/serialization.json")
public @ResponseBody String custom() throws JsonProcessingException {
	User user = new User();
	user.setId(11);
	user.setName("hello");
	String str = mapper.writeValueAsString(user);
	return str;
}

mapper.writeValueAsString将对象序列化成JSON字符串，可以使用Jackson注解来对序列化的字段进行定制。

流式操作

树模型和数据绑定都是基于流式操作完成的，即通过JsonParser来解析JSON，形成JsonToken流，下面的代码是解析JSON：

@Autowired
ObjectMapper mapper;

@RequestMapping("/parser.html")
public @ResponseBody String parser() throws JsonParseException,IOException{
	String json = "{"name":"aaa","id":10}";
	JsonFactory f = mapper.getFactory();
	String key = null,value=null;
	JsonParser parser = f.createParser(json);
	JsonToken token = parser.nextToken();
	if(token == JsonToken.FIELD_NAME){
		key = parser.getCurrentName();
	}
	token = parser.nextToken();
	value = parser.getValueAsString();
	parser.close();
	return key+","+value;
}

JsonParser的解析结果包含了一系列JsonToken，JsonToken是一个枚举类型，常用的START_OBJECT代表符号“{”;START_ARRAY和END_ARRAY代表"[“和”]"，FIELD_NAME表示一个JSON Key；VALUE_STRING代表一个JSON Value,字符串类型；VALUE_NUMBER则表示一个整数类型。

判断Token的类型后，通过调用getValueAsXXX来获取其值，XXX是其值的类型。

@RequestMapping("/generator.html")
public @ResponseBody String generator() throws JsonParseException,IOException{
	JsonFactory f = mapper.getFactory();
	StringWriter sw = new StringWriter();
	JsonGenerator g = f.createGenerator(sw);
	g.writeStartObject();
	g.writeStringField("name","aaa");
	g.writeEndObject();
	g.close();
	return sw.toString();
}

Jackson注解

Jackson包含了很多注解，用来个性化序列化和反序列化，如：

@JsonProperty，作用在属性上，用来为JSON Key指定一个别名。

@JsonProperty("userName")
private String name

@JsonIgnore，作用在属性上，用来忽略此属性。

@JsonIgnore
private String pwd

@JsonIgnoreProperties，忽略一组属性，作用在类上；

@JsonIgnoreProperties
public static class SamplePojo{
}

@JsonAnySetter，标记在某个方法上，此方法接受Key、Value两个参数，用于JackSon在反序列化过程中，未找到的对应属性都调用此方法，通常用一个map来实现：

@JsonAnySetter
private void other( String property, Object value ) {
	map.put(property,value);
}

@JsonAnyGetter，此注解标注在一个返回Map的方法上，JackSon会取出Map中的每一个值进行序列化。

Class Department {
	Map map = new HashMap();
	int id;
	public Department(int id){
		this.id = id;
		map.put("newAttr",1);
	}
	@JsonAnyGetter
	public Map<String,Object> getOtherProperties() {
		return map;
	}
}

Department，对象序列化的时候，其JSON类似：

{“id”:1,“newAttr”:1}

@JsonFormat，用于日期格式，

@JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss")
private Date createDate;

@JsonNaming，用于指定一个命名策略，作用于类或者属性上。
@JsonSerialize，指定一个实现类来自定义序列化。类必须实现JsonSerializer接口。
@JsonDeserialize，用户自定义反序列化。

@JsonView，作用在类或者属性上，用来自定义一个序列化组。比如对于User对象，某些情况下只返回id，而某些情况下需要返回id和name；

public class User {
	public interface IdView {};
	public interface IdNameView extends IdView {};

	@JsonView(IdView.class)
	private Interger id;
	@JsonView(IdNameView.class)
	private String name;
}

集合的反序列化

在Spring MVC的Controller方法中，可以使用@RequestBody将提交的JSON自动映射到方法参数上，如：

@RequestMapping("/updateUsers.json")
public @ResponseBody String say(@RequestBody List<User> list){
	StringBuilder sb = new StringBuilder();
	for(User user:list){
		sb.append(user.getName()).append(" ");
	}
	return sb.toString();
}

接受如下一个JSON请求，并自动映射到User对象上。

[
	{
		"name":"aaa",
		"id":1
	}
	{
		"name":"bbb",
		"id":2
	}
]

Spring Boot能自动识别出List对象包含的是User类，因为在方法中定义的泛型的类型会被保留在字节码中，所以Spring Boot能识别List包含的泛型类型从而能正确反序列化。