高效的JSON转换工具

       在网上搜索了一番发现用json-lib进行json格式转换的还真不少，但是经过测试性能不太令人满意，同类工具中还有个后起

之秀那就是jackson，单从性能上说要比json-lib好很多，于是在项目中就决定用jackson了。
     但是关于jackson的资料在网上相比不是很多，于是到了官方网站看了看，把源码下载下来。帮助文档做的不太好，也没有

个现成的例子供参考。不过还好，最后在官方网（http://jackson.codehaus.org/）站的某个角落里找到了一些例子， 我在原来例子的基础上稍加改动封装了一个工具，供网友们参考，有不当之处还望拍砖指正。

      为性能考虑尽量少的向客户端发送数据，所以在Bean到JSON转换的时候把不需要的字段过滤掉，要完成这个功能我们必须自定义一个实现StdSerializerProvider接口的序列化器BzStdSerializerProvider，然后把这个序列化器赋给ObjectMapper即可，下面就把整个具体实现贴出来：

package com.bzlccn.oa.common.json.jackson;import java.io.IOException;import java.util.HashMap;import java.util.List;import java.util.Vector;import org.codehaus.jackson.JsonGenerator;import org.codehaus.jackson.JsonParseException;import org.codehaus.jackson.map.JsonMappingException;import org.codehaus.jackson.map.ObjectMapper;import org.codehaus.jackson.map.SerializationConfig;import org.codehaus.jackson.map.SerializerFactory;import org.codehaus.jackson.map.SerializerProvider;import org.codehaus.jackson.map.introspect.BasicBeanDescription;import org.codehaus.jackson.map.ser.BeanPropertyWriter;import org.codehaus.jackson.map.ser.BeanSerializer;import org.codehaus.jackson.map.ser.CustomSerializerFactory;import org.codehaus.jackson.map.ser.StdSerializerProvider;/** * json处理工具集 * * @author rain * */public class CustomSerialization {private static final ObjectMapper mapper = new ObjectMapper();static class FilteredWriter extends BeanPropertyWriter {public FilteredWriter(BeanPropertyWriter w) {super(w);}public void serializeAsField(Object bean, JsonGenerator jgen,SerializerProvider prov) throws Exception {BzStdSerializerProvider myprov = (BzStdSerializerProvider) prov;HashMap<?, ?> filter = myprov.getCurrentFilter();if (filter == null) {super.serializeAsField(bean, jgen, prov);} else if (filter.containsKey(this._name)) {Object subfilter = filter.get(this._name);myprov.pushFilter(HashMap.class.isAssignableFrom(subfilter.getClass()) ? (HashMap<?, ?>) subfilter : null);super.serializeAsField(bean, jgen, prov);myprov.popFilter();}}}static class CustomBeanFactory extends CustomSerializerFactory{@Overrideprotected BeanSerializer processViews(SerializationConfig config,BasicBeanDescription beanDesc, BeanSerializer ser,List<BeanPropertyWriter> props) {ser = super.processViews(config, beanDesc, ser, props);BeanPropertyWriter[] writers = props.toArray(new BeanPropertyWriter[props.size()]);for (int i = 0; i < writers.length; ++i) {writers[i] = new FilteredWriter(writers[i]);}ser = ser.withFiltered(writers);return ser;}}static class BzStdSerializerProvider extends StdSerializerProvider {private HashMap<?, ?> _filter;private Vector<HashMap<?, ?>> _stack = new Vector<HashMap<?, ?>>();public BzStdSerializerProvider() {super();}public BzStdSerializerProvider(HashMap<?, ?> filter) {super();_filter = filter;}protected BzStdSerializerProvider(SerializationConfig config,StdSerializerProvider src, SerializerFactory f) {super(config, src, f);}protected BzStdSerializerProvider(SerializationConfig config,StdSerializerProvider src, SerializerFactory f,HashMap<?, ?> filter) {super(config, src, f);_filter = filter;}protected StdSerializerProvider createInstance(SerializationConfig config, SerializerFactory jsf) {return new BzStdSerializerProvider(config, this, jsf, _filter);}public HashMap<?, ?> getCurrentFilter() {if (_stack.isEmpty())return _filter;return _stack.lastElement();}public void pushFilter(HashMap<?, ?> filter) {_stack.add(filter);}public void popFilter() {if (!_stack.isEmpty()) {_stack.removeElement(_stack.lastElement());}}}/** * 把对应的bean转换成json串,并可以对多余的字段进行过滤 * @param bean 要转换的bean * @param filter 过滤字符串 * @return */public static String writeBean(ObjectMapper mapper,Object bean, String filter) {try {if (bean != null && filter != null) {HashMap<?, ?> filterMap = mapper.readValue(filter,HashMap.class);mapper.setSerializerProvider(new BzStdSerializerProvider(filterMap));mapper.setSerializerFactory(new CustomBeanFactory());return mapper.viewWriter(String.class).writeValueAsString(bean);}} catch (JsonParseException e) {e.printStackTrace();} catch (JsonMappingException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return null;}/** * 把对应的bean转换成json串,并可以对多余的字段进行过滤 * @param bean 要转换的bean * @param filter 过滤字符串 * @return */public static String writeBean(Object bean, String filter) {try {if (bean != null && filter != null) {HashMap<?, ?> filterMap = mapper.readValue(filter,HashMap.class);mapper.setSerializerProvider(new BzStdSerializerProvider(filterMap));mapper.setSerializerFactory(new CustomBeanFactory());return mapper.viewWriter(String.class).writeValueAsString(bean);}} catch (JsonParseException e) {e.printStackTrace();} catch (JsonMappingException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return null;}/** * 把javabean转换成json串 * @param bean * @return */public static String writeBean(Object bean) {try {if (bean != null) {return mapper.writeValueAsString(bean);}} catch (JsonParseException e) {e.printStackTrace();} catch (JsonMappingException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return null;}}

上述类只是一个实现过滤功能的Bean to Json的工具类，当然你也可以继续扩展。下面我们继续完善，提供一个综合的，支持过滤的，能JSON互转的，转换内容以及方法能自定义的一个综合JSON转换工具，当然要有上边的类做支持了。这是一个基于接口的动态代理的实现，

具体代码如下。

package com.bzlccn.oa.common.json.jackson;import java.io.*;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.Type;import java.net.URL;import java.util.LinkedHashMap;import java.util.Map;import org.codehaus.jackson.JsonEncoding;import org.codehaus.jackson.JsonGenerator;import org.codehaus.jackson.JsonParser;import org.codehaus.jackson.map.JsonMappingException;import org.codehaus.jackson.map.ObjectMapper;import org.codehaus.jackson.map.RuntimeJsonMappingException;import org.codehaus.jackson.map.SerializationConfig;import org.codehaus.jackson.map.type.TypeFactory;import org.codehaus.jackson.type.JavaType;public class JacksonProxy { private JacksonProxy() {} public static <T> T newProxyInstance(Class<T> type, Class<?>... additionalTypes) { ObjectMapper objectMapper = new ObjectMapper(); return newProxyInstance(objectMapper, type, additionalTypes); } public static <T> T newProxyInstance(ObjectMapper objectMapper, Class<T> type, Class<?>... additionalTypes) { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); if (classLoader == null) classLoader = type.getClassLoader(); Class<?>[] interfaces = new Class<?>[additionalTypes.length + 1]; interfaces[0] = type; System.arraycopy(additionalTypes, 0, interfaces, 1, additionalTypes.length); InvocationHandler invocationHandler = new JsonInvocationHandler(objectMapper, interfaces); Object proxy = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler); return type.cast(proxy); } public static ObjectMapper getObjectMapper(Object proxy) { InvocationHandler invocationHandler = Proxy.getInvocationHandler(proxy); if (invocationHandler instanceof JsonInvocationHandler) { JsonInvocationHandler jsonInvocationHandler = (JsonInvocationHandler) invocationHandler; return jsonInvocationHandler.getObjectMapper(); } throw new IllegalArgumentException("Proxy is not a JacksonProxy"); } public static class JsonInvocationHandler implements InvocationHandler { private final ObjectMapper objectMapper; private final Map<Method, Handler> handlers = new LinkedHashMap<Method, Handler>(); public JsonInvocationHandler(ObjectMapper objectMapper, Class<?>[] interfaces) { if (objectMapper == null) throw new NullPointerException("mapper is null"); if (interfaces == null) throw new NullPointerException("type is null"); this.objectMapper = objectMapper; for (Class<?> type : interfaces) { for (Method method : type.getMethods()) { String name = method.getName(); Class<?>[] parameterTypes = method.getParameterTypes(); Class<?> returnType = method.getReturnType(); if (name.startsWith("read")) { if (parameterTypes.length == 1 && !returnType.equals(Void.TYPE)) { ReadHandler handler = new ReadHandler(objectMapper, method.getGenericReturnType(), canThrowIOException(method)); handlers.put(method, handler); } } else if (name.startsWith("write")) { if (Void.TYPE.equals(returnType)) { WriteHandler handler = new WriteHandler(objectMapper, null, canThrowIOException(method)); handlers.put(method, handler); }else{ WriteHandler handler = new WriteHandler(objectMapper, returnType, canThrowIOException(method)); handlers.put(method, handler); } } } } } public ObjectMapper getObjectMapper() { return objectMapper; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Handler handler = handlers.get(method); if (handler == null) { throw new UnsupportedOperationException(method.toString()); } return handler.invoke(args); } private static boolean canThrowIOException(Method method) { for (Class<?> exceptionType : method.getExceptionTypes()) { if (IOException.class.isAssignableFrom(exceptionType)) { return true; } } return false; } } private static interface Handler { Object invoke(Object[] args) throws Throwable; } private static class ReadHandler implements Handler { private final ObjectMapper mapper; private final JavaType javaType; private final boolean canThrowIoException; public ReadHandler(ObjectMapper mapper, Type type, boolean canThrowIoException) { this.mapper = mapper; javaType = TypeFactory.fromType(type); this.canThrowIoException = canThrowIoException; } @Override public Object invoke(Object[] args) throws Throwable { try { Object source = args[0]; return read(source); } catch (IOException e) { if (canThrowIoException) { throw e; } else { throw new RuntimeJsonMappingException((JsonMappingException) e); } } } public Object read(Object source) throws IOException { if (source == null) { throw new NullPointerException("source is null"); } JsonParser parser; if (source instanceof String) { String string = (String) source; parser = mapper.getJsonFactory().createJsonParser(string); } else if (source instanceof byte[]) { byte[] bytes = (byte[]) source; parser = mapper.getJsonFactory().createJsonParser(bytes); } else if (source instanceof Reader) { Reader reader = (Reader) source; parser = mapper.getJsonFactory().createJsonParser(reader); parser.disableFeature(JsonParser.Feature.AUTO_CLOSE_SOURCE); } else if (source instanceof InputStream) { InputStream inputStream = (InputStream) source; parser = mapper.getJsonFactory().createJsonParser(inputStream); parser.disableFeature(JsonParser.Feature.AUTO_CLOSE_SOURCE); } else if (source instanceof File) { File file = (File) source; parser = mapper.getJsonFactory().createJsonParser(file); } else if (source instanceof URL) { URL url = (URL) source; parser = mapper.getJsonFactory().createJsonParser(url); } else { throw new UnsupportedOperationException("Unsupported source type " + source.getClass() + " for JSON read method"); } try { return mapper.readValue(parser, javaType); } finally { parser.close(); } } } private static class WriteHandler implements Handler { private final ObjectMapper mapper; private final Class<?> returnType; private final boolean canThrowIoException; public WriteHandler(ObjectMapper mapper, Class<?> returnType, boolean canThrowIoException) { this.mapper = mapper; this.returnType = returnType; this.canThrowIoException = canThrowIoException; } @Override public Object invoke(Object[] args) throws Throwable { try { Object value = args[0]; if (returnType == null) { Object target = args[1]; write(value, target); return null; } else if (String.class.equals(returnType)) { if (args.length>=2&&args[1]!=null) {//如果返回类型是String且有第二个参数，那么就默认第二个参数为过滤参数return CustomSerialization.writeBean(value, args[1].toString());} else { StringWriter stringWriter = new StringWriter(); write(value, stringWriter); return stringWriter.toString();} } else if (byte[].class.equals(returnType)) { ByteArrayOutputStream out = new ByteArrayOutputStream(); write(value, out); return out.toByteArray(); } else { throw new UnsupportedOperationException("Unsupported target type " + returnType + " for JSON write method"); } } catch (IOException e) { if (canThrowIoException) { throw e; } else { throw new RuntimeJsonMappingException((JsonMappingException) e); } } } public void write(Object value, Object target) throws IOException { if (target == null) { throw new NullPointerException("target is null"); } JsonGenerator generator; if (target instanceof Writer) { Writer writer = (Writer) target; generator = mapper.getJsonFactory().createJsonGenerator(writer); generator.disableFeature(JsonGenerator.Feature.AUTO_CLOSE_TARGET); } else if (target instanceof OutputStream) { OutputStream outputStream = (OutputStream) target; generator = mapper.getJsonFactory().createJsonGenerator(outputStream, JsonEncoding.UTF8); generator.disableFeature(JsonGenerator.Feature.AUTO_CLOSE_TARGET); } else if (target instanceof File) { File file = (File) target; generator = mapper.getJsonFactory().createJsonGenerator(file, JsonEncoding.UTF8); } else { throw new UnsupportedOperationException("Unsupported target type " + target.getClass() + " for JSON write method"); } if (mapper.getSerializationConfig().isEnabled(SerializationConfig.Feature.INDENT_OUTPUT)) { generator.useDefaultPrettyPrinter(); } try { mapper.writeValue(generator, value); } finally { generator.close(); } } }}

接口代码：

 

 package com.bzlccn.oa.common.json.jackson;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.Reader;import java.io.Writer;import java.util.List;import java.util.Map;public interface JsonInterface { String readString(String value) throws IOException; int readInt(String value); Integer readInteger(String value); Object readBean(String value); List<String> readStringList(String value) throws IOException; int[] readIntArray(String value); List<Integer> readIntegerList(String value); List<Short> readShortList(String value); List<Object> readBeanList(String value); List<Map<String,Object>> readBeanByMap(String value); List<Object> readBeanList(byte[] value); List<Object> readBeanList(Reader value); List<Object> readBeanList(InputStream value); String writeString(String value) throws IOException; String writeInt(int value); String writeInteger(Integer value); String writeBean(Object value); String writeBean(Object value,String filter); String writeStringList(List<String> value) throws IOException; String writeIntArray(int[] value); String writeIntegerList(List<Integer> value); String writeBeanList(List<?> value); String writeBeanList(List<?> value,String filter); void writeBeanList(List<?> value, Writer writer); void writeBeanList(List<?> value, OutputStream writer); byte[] writeBeanListToByteArray(List<?> value);}

最终供调用的工具代码：

package com.bzlccn.oa.common.json;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.Reader;import java.io.Writer;import java.util.ArrayList;import java.util.List;import org.codehaus.jackson.map.ObjectMapper;import org.codehaus.jackson.map.SerializationConfig.Feature;import com.bzlccn.oa.common.json.jackson.JacksonProxy;import com.bzlccn.oa.common.json.jackson.JsonInterface;/** * json处理工具集 * * @author rain * */public class JsonUtil{private static JsonInterface json;static{ ObjectMapper mapper = new ObjectMapper(); mapper.configure(Feature.INDENT_OUTPUT, true); json = JacksonProxy.newProxyInstance(mapper, JsonInterface.class);}public static JsonInterface getTool(){return json;}//********************************************************************************** static class ViewBean { public String name; public String value; public String secret; public ViewBean sibling; public ViewBeanChild child; public ViewBean(String name, String value, String secret) { this.name = name; this.value = value; this.secret = secret; child = new ViewBeanChild(); } } static class ViewBeanChild { public long id = 123; public String name = "child"; public String address = "123 Street"; }public static void main(String[] args) throws Exception { ViewBean bean = new ViewBean("mr bean", null, "secret!"); bean.sibling = new ViewBean("sibling", "lala", "boooo");String filter = "{/"name/":0,/"value/":0,/"sibling/":{/"name/":0}, /"child/":{/"id/":0,/"address/":0}}";System.out.println(json.writeBean(bean,filter));}}

这样实现的一个好处就是方法可以自定义，向把json串转换成什么类型的bean只要在JsonInterface接口中申明就可以了。这个是基于

jackson1.5版本实现的。