JsonServerSerializer.java

   1 package org.argeo.server.json;
   2
   3 import java.io.IOException;
   4 import java.io.StringWriter;
   5 import java.io.Writer;
   6
   7 import javax.servlet.http.HttpServletRequest;
   8 import javax.servlet.http.HttpServletResponse;
   9
  10 import org.apache.commons.logging.Log;
  11 import org.apache.commons.logging.LogFactory;
  12 import org.argeo.ArgeoException;
  13 import org.argeo.server.Serializer;
  14 import org.argeo.server.ServerSerializer;
  15 import org.codehaus.jackson.JsonFactory;
  16 import org.codehaus.jackson.JsonGenerator;
  17 import org.codehaus.jackson.map.JsonMappingException;
  18 import org.codehaus.jackson.map.JsonSerializer;
  19 import org.codehaus.jackson.map.ObjectMapper;
  20 import org.codehaus.jackson.map.SerializationConfig;
  21 import org.codehaus.jackson.map.SerializerFactory;
  22 import org.codehaus.jackson.map.SerializerProvider;
  23 import org.codehaus.jackson.map.ser.StdSerializerProvider;
  24
  25 public class JsonServerSerializer implements ServerSerializer, Serializer {
  26         private final static Log log = LogFactory
  27                         .getLog(JsonServerSerializer.class);
  28
  29         private JsonFactory jsonFactory = new JsonFactory();
  30         private ObjectMapper objectMapper = new ObjectMapper();
  31         private SerializerProvider serializerProvider = new CustomSerializerProvider();
  32
  33         private Boolean prettyPrint = false;
  34
  35         private Boolean asHtml = false;
  36
  37         private String contentTypeCharset = "UTF-8";
  38
  39         // private Map<Class<?>,String> ignoredFields = new HashMap<Class<?>,
  40         // String>();
  41
  42         public JsonServerSerializer() {
  43                 objectMapper.setSerializerProvider(serializerProvider);
  44         }
  45
  46         public void serialize(Object obj, HttpServletRequest request,
  47                         HttpServletResponse response) {
  48                 if (asHtml)
  49                         response.setContentType("text/html;charset=" + contentTypeCharset);
  50                 else
  51                         response.setContentType("application/json;charset="
  52                                         + contentTypeCharset);
  53
  54                 try {
  55                         if (asHtml)
  56                                 response.getWriter().append("<pre>");
  57
  58                         serialize(response.getWriter(), obj);
  59
  60                         if (asHtml)
  61                                 response.getWriter().append("</pre>");
  62
  63                 } catch (IOException e) {
  64                         throw new ArgeoException("Cannot open response stream.", e);
  65                 }
  66         }
  67
  68         public void serialize(Writer writer, Object obj) {
  69                 serializeAndLog(obj);
  70
  71                 JsonGenerator jsonGenerator = null;
  72                 try {
  73                         jsonGenerator = jsonFactory.createJsonGenerator(writer);
  74
  75                         if (prettyPrint)
  76                                 jsonGenerator.useDefaultPrettyPrinter();
  77
  78                         objectMapper.writeValue(jsonGenerator, obj);
  79                         jsonGenerator.flush();
  80                 } catch (Exception e) {
  81                         throw new ArgeoException("Cannot serialize " + obj, e);
  82                 } finally {
  83                         if (jsonGenerator != null)
  84                                 try {
  85                                         jsonGenerator.close();
  86                                 } catch (IOException e) {
  87                                         if (log.isTraceEnabled())
  88                                                 log.error("Cannot close JSON generator", e);
  89                                 }
  90                 }
  91         }
  92
  93         protected void serializeAndLog(Object obj) {
  94                 if (!log.isTraceEnabled())
  95                         return;
  96
  97                 JsonGenerator jsonGenerator = null;
  98                 try {
  99                         StringWriter stringWriter = new StringWriter();
 100                         jsonGenerator = jsonFactory.createJsonGenerator(stringWriter);
 101                         jsonGenerator.useDefaultPrettyPrinter();
 102                         objectMapper.writeValue(jsonGenerator, obj);
 103                         jsonGenerator.close();
 104                         log.debug(stringWriter.toString());
 105                 } catch (Exception e) {
 106                         throw new ArgeoException("Cannot log JSON", e);
 107                 } finally {
 108                         if (jsonGenerator != null)
 109                                 try {
 110                                         jsonGenerator.close();
 111                                 } catch (IOException e) {
 112                                         if (log.isTraceEnabled())
 113                                                 log.error("Cannot close JSON generator", e);
 114                                 }
 115
 116                 }
 117         }
 118
 119         public void setPrettyPrint(Boolean prettyPrint) {
 120                 this.prettyPrint = prettyPrint;
 121         }
 122
 123         protected ObjectMapper getObjectMapper() {
 124                 return objectMapper;
 125         }
 126
 127         public void setContentTypeCharset(String contentTypeCharset) {
 128                 this.contentTypeCharset = contentTypeCharset;
 129         }
 130
 131         static class CustomSerializerProvider extends StdSerializerProvider {
 132
 133                 public CustomSerializerProvider() {
 134                         super();
 135                 }
 136
 137                 public CustomSerializerProvider(SerializationConfig config,
 138                                 StdSerializerProvider src, SerializerFactory f) {
 139                         super(config, src, f);
 140                 }
 141
 142                 protected StdSerializerProvider createInstance(
 143                                 SerializationConfig config, SerializerFactory jsf) {
 144                         return new CustomSerializerProvider(config, this, jsf);
 145                 }
 146
 147                 @Override
 148                 public JsonSerializer<Object> getUnknownTypeSerializer(
 149                                 Class<?> unknownType) {
 150                         JsonSerializer<Object> res = new JsonSerializer<Object>() {
 151                                 public void serialize(Object value, JsonGenerator jgen,
 152                                                 SerializerProvider provider)
 153                                                 throws JsonMappingException {
 154                                         if (log.isDebugEnabled())
 155                                                 log.warn("Unknown serializer for "
 156                                                                 + value.getClass().getName());
 157                                         try {
 158                                                 jgen.writeNull();
 159                                         } catch (Exception e) {
 160                                                 throw new ArgeoException("Cannot write null", e);
 161                                         }
 162                                 }
 163
 164                         };
 165
 166                         return res;
 167                 }
 168
 169         }
 170 }