可以将其中的main方法删掉。测试用的。我测试的结果是，jackson比fastjson快。
fastjson是1.1.36
jackson是2.2.3
jdk是1.7.40，client
cpu是intel i3
内存4g
package org.springframework.web.servlet.view.json;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.servlet.view.AbstractView;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.test.User;
public class MappingFastJsonView extends AbstractView {
/**
* Default content type: "application/json".
* Overridable through {@link #setContentType}.
*/
public static final String DEFAULT_CONTENT_TYPE = "application/json";
private String encoding = "UTF-8";
private String jsonPrefix;
private Boolean prettyPrint;
private Set<String> modelKeys;
private boolean extractValueFromSingleKeyModel = false;
private boolean disableCaching = true;
private boolean updateContentLength = false;
/**
* Construct a new {@code MappingFastJsonView}, setting the content type to {@code application/json}.
*/
public MappingFastJsonView() {
setContentType(DEFAULT_CONTENT_TYPE);
setExposePathVariables(false);
}
public String getEncoding() {
return encoding;
}
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* Specify a custom prefix to use for this view's JSON output.
* Default is none.
* @see #setPrefixJson
*/
public void setJsonPrefix(String jsonPrefix) {
this.jsonPrefix = jsonPrefix;
}
/**
* Indicates whether the JSON output by this view should be prefixed with <tt>"{} && "</tt>.
* Default is {@code false}.
* <p>Prefixing the JSON string in this manner is used to help prevent JSON Hijacking.
* The prefix renders the string syntactically invalid as a script so that it cannot be hijacked.
* This prefix does not affect the evaluation of JSON, but if JSON validation is performed
* on the string, the prefix would need to be ignored.
* @see #setJsonPrefix
*/
public void setPrefixJson(boolean prefixJson) {
// if (prefixJson) {
// if (jsonPrefix == null) {
// jsonPrefix = "{} && ";
// }
// }
this.jsonPrefix = (prefixJson ? "{} && " : null);
}
/**
* Whether to use the default pretty printer when writing JSON.
* This is a shortcut for setting up an {@code JSON}
* <p>The default value is {@code false}.
*/
public void setPrettyPrint(boolean prettyPrint) {
this.prettyPrint = prettyPrint;
}
/**
* Set the attribute in the model that should be rendered by this view.
* When set, all other model attributes will be ignored.
*/
public void setModelKey(String modelKey) {
this.modelKeys = Collections.singleton(modelKey);
}
/**
* Set the attributes in the model that should be rendered by this view.
* When set, all other model attributes will be ignored.
*/
public void setModelKeys(Set<String> modelKeys) {
this.modelKeys = modelKeys;
}
/**
* Return the attributes in the model that should be rendered by this view.
*/
public final Set<String> getModelKeys() {
return this.modelKeys;
}
/**
* Set whether to serialize models containing a single attribute as a map or whether to
* extract the single value from the model and serialize it directly.
* <p>The effect of setting this flag is similar to using {@code MappingJacksonHttpMessageConverter}
* with an {@code @ResponseBody} request-handling method.
* <p>Default is {@code false}.
*/
public void setExtractValueFromSingleKeyModel(boolean extractValueFromSingleKeyModel) {
this.extractValueFromSingleKeyModel = extractValueFromSingleKeyModel;
}
/**
* Disables caching of the generated JSON.
* <p>Default is {@code true}, which will prevent the client from caching the generated JSON.
*/
public void setDisableCaching(boolean disableCaching) {
this.disableCaching = disableCaching;
}
/**
* Whether to update the 'Content-Length' header of the response. When set to
* {@code true}, the response is buffered in order to determine the content
* length and set the 'Content-Length' header of the response.
* <p>The default setting is {@code false}.
*/
public void setUpdateContentLength(boolean updateContentLength) {
this.updateContentLength = updateContentLength;
}
@Override
protected void prepareResponse(HttpServletRequest request, HttpServletResponse response) {
setResponseContentType(request, response);
response.setCharacterEncoding(encoding);
if (this.disableCaching) {
response.addHeader("Pragma", "no-cache");
response.addHeader("Cache-Control", "no-cache, no-store, max-age=0");
response.addDateHeader("Expires", 1L);
}
}
@Override
protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response)
throws Exception {
OutputStream stream = (this.updateContentLength ? createTemporaryOutputStream() : response.getOutputStream());
Object value = filterModel(model);
writeContent(stream, value, this.jsonPrefix);
if (this.updateContentLength) {
writeToResponse(response, (ByteArrayOutputStream) stream);
}
}
/**
* Filter out undesired attributes from the given model.
* The return value can be either another {@link Map} or a single value object.
* <p>The default implementation removes {@link BindingResult} instances and entries
* not included in the {@link #setRenderedAttributes renderedAttributes} property.
* @param model the model, as passed on to {@link #renderMergedOutputModel}
* @return the value to be rendered
*/
protected Object filterModel(Map<String, Object> model) {
Map<String, Object> result = new HashMap<String, Object>(model.size());
Set<String> renderedAttributes = (!CollectionUtils.isEmpty(this.modelKeys) ? this.modelKeys : model.keySet());
for (Map.Entry<String, Object> entry : model.entrySet()) {
if (!(entry.getValue() instanceof BindingResult) && renderedAttributes.contains(entry.getKey())) {
result.put(entry.getKey(), entry.getValue());
}
}
return (this.extractValueFromSingleKeyModel && result.size() == 1 ? result.values().iterator().next() : result);
}
/**
* Write the actual JSON content to the stream.
* @param stream the output stream to use
* @param value the value to be rendered, as returned from {@link #filterModel}
* @param jsonPrefix the prefix for this view's JSON output
* (as indicated through {@link #setJsonPrefix}/{@link #setPrefixJson})
* @throws IOException if writing failed
*/
protected void writeContent(OutputStream stream, Object value, String jsonPrefix) throws IOException {
List<SerializerFeature> list = new ArrayList<SerializerFeature>();
if (prettyPrint != null && prettyPrint) {
list.add(SerializerFeature.PrettyFormat);
}
SerializerFeature[] features = new SerializerFeature[list.size()];
list.toArray(features);
byte[] jsonBytes = JSON.toJSONBytes(value, features);
if (jsonPrefix != null) {//此处亦可字符串相加，然后转成字节数组
byte[] prefixBytes = jsonPrefix.getBytes(Charset.forName("UTF-8"));
int prefixLength = prefixBytes.length;
int jsonLength = jsonBytes.length;
byte[] finalJsonBytes = new byte[prefixLength + jsonLength];
System.arraycopy(prefixBytes, 0, finalJsonBytes, 0, prefixLength);
System.arraycopy(jsonBytes, 0, finalJsonBytes, prefixLength, jsonLength);
stream.write(finalJsonBytes);
} else {
stream.write(jsonBytes);
}
stream.flush();
}
public static void main(String[] args) {
List<User> users = Lists.newArrayList();
for (int j = 0; j < 10; j++) {
User value = new User();
value.setAddress("asdfjklasdjf");
value.setAge(22);
value.setGender(1);
value.setPassword("jkljklj");
value.setUserName("");
List<String> strList = Lists.newArrayList();
Map<String, String> strMap = Maps.newHashMap();
Set<Integer> setInt = Sets.newHashSet();
for (int i = 0; i < 10; i++) {
strList.add("a" + i);
strMap.put("a" + i, "a" + i);
setInt.add(i);
}
value.setSetInt(setInt);
value.setStrList(strList);
value.setStrMap(strMap);
users.add(value);
}
int times = 1;
// long d = System.currentTimeMillis();
// String jsonPrefix = "aaa{}";
//
// for (int i = 0; i < times; i++) {
// byte[] jsonBytes = JSON.toJSONBytes(value);
// byte[] prefixBytes = jsonPrefix.getBytes(Charset.forName("UTF-8"));
// int prefixLength = prefixBytes.length;
// int jsonLength = jsonBytes.length;
// byte[] finalJsonBytes = new byte[prefixLength + jsonLength];
//
// System.arraycopy(prefixBytes, 0, finalJsonBytes, 0, prefixLength);
// System.arraycopy(jsonBytes, 0, finalJsonBytes, prefixLength, jsonLength);
// }
// System.out.println(System.currentTimeMillis() - d);
String json = "";
String json2 = "";
long d2 = System.currentTimeMillis();
//String jsonPrefix2 = "aaa{}";
for (int i = 0; i < times; i++) {
json = JSON.toJSONString(users);
// jsonBytes = jsonPrefix2 + jsonBytes;
//
// byte[] prefixBytes = jsonBytes.getBytes(Charset.forName("UTF-8"));
}
System.out.println("fastjson parser :" + (System.currentTimeMillis() - d2));
ObjectMapper mapper = new ObjectMapper();
//org.codehaus.jackson.map.ObjectMapper mapper = new org.codehaus.jackson.map.ObjectMapper();
long d3 = System.currentTimeMillis();
//String jsonPrefix3 = "aaa{}";
for (int i = 0; i < times; i++) {
//String jsonBytes = null;
try {
//StringWriter writer = new StringWriter();
//JsonGenerator generator = new JsonFactory().createGenerator(writer);
//mapper.writeValue(writer, value);
//jsonBytes = writer.toString();
json2 = mapper.writeValueAsString(users);
//mapper.readValue(new StringReader(""), class1);
} catch (Exception e) {
e.printStackTrace();
}
// jsonBytes = jsonPrefix3 + jsonBytes;
//
// byte[] prefixBytes = jsonBytes.getBytes(Charset.forName("UTF-8"));
}
System.out.println("jackson parser :" + (System.currentTimeMillis() - d3));
long d5 = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
JSON.parseArray(json, User.class);
}
System.out.println("fastjson deserializer :" + (System.currentTimeMillis() - d5));
long d4 = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
try {
//List<User> userList = Lists.newArrayList();
mapper.readValue(json2, new TypeReference<List<User>>() {});
// List<User> userList = Lists.newArrayList();
// for (;iterator.hasNext();) {
// userList.add(iterator.nextValue());
// }
//System.out.println(userList);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("jackson deserializer :" + (System.currentTimeMillis() - d4));
}
}
package com.test;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class User {
private String userName;
private String address;
private int age;
private int gender;
private String password;
private List<String> strList;
private Map<String, String> strMap;
private Set<Integer> setInt;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public List<String> getStrList() {
return strList;
}
public void setStrList(List<String> strList) {
this.strList = strList;
}
public Map<String, String> getStrMap() {
return strMap;
}
public void setStrMap(Map<String, String> strMap) {
this.strMap = strMap;
}
public Set<Integer> getSetInt() {
return setInt;
}
public void setSetInt(Set<Integer> setInt) {
this.setInt = setInt;
}
}