json/JsonServerMapper.java

   1 package org.argeo.server.json;
   2
   3 import java.io.IOException;
   4 import java.io.Reader;
   5 import java.io.StringReader;
   6 import java.util.HashMap;
   7 import java.util.Map;
   8
   9 import org.apache.commons.io.IOUtils;
  10 import org.apache.commons.logging.Log;
  11 import org.apache.commons.logging.LogFactory;
  12 import org.argeo.ArgeoException;
  13 import org.argeo.server.Deserializer;
  14 import org.codehaus.jackson.JsonProcessingException;
  15 import org.codehaus.jackson.map.DeserializationContext;
  16 import org.codehaus.jackson.map.DeserializationProblemHandler;
  17 import org.codehaus.jackson.map.JsonDeserializer;
  18 import org.codehaus.jackson.map.deser.CustomDeserializerFactory;
  19 import org.codehaus.jackson.map.deser.StdDeserializerProvider;
  20 import org.springframework.beans.factory.InitializingBean;
  21
  22 public class JsonServerMapper extends JsonServerSerializer implements
  23                 Deserializer, InitializingBean {
  24         private final static Log log = LogFactory.getLog(JsonServerMapper.class);
  25
  26         private Class<?> targetClass;
  27
  28         private Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<Class<?>, JsonDeserializer<?>>();
  29
  30         @SuppressWarnings("unchecked")
  31         public void afterPropertiesSet() throws Exception {
  32                 CustomDeserializerFactory dsf = new CustomDeserializerFactory();
  33                 for (Class clss : deserializers.keySet()) {
  34                         dsf.addSpecificMapping(clss, deserializers.get(clss));
  35                         if (log.isDebugEnabled())
  36                                 log.debug("Add JSON mapping for " + clss);
  37                 }
  38                 StdDeserializerProvider sdp = new StdDeserializerProvider(dsf);
  39                 getObjectMapper().setDeserializerProvider(sdp);
  40                 // ignore unkown properties
  41                 getObjectMapper().getDeserializationConfig().addHandler(
  42                                 new DeserializationProblemHandler() {
  43                                         public boolean handleUnknownProperty(
  44                                                         DeserializationContext ctxt,
  45                                                         JsonDeserializer<?> deserializer, Object bean,
  46                                                         String propertyName) throws IOException,
  47                                                         JsonProcessingException {
  48                                                 if (log.isTraceEnabled())
  49                                                         log.debug("Ignore property " + propertyName
  50                                                                         + " in bean " + bean);
  51                                                 ctxt.getParser().skipChildren();
  52                                                 return true;
  53                                         }
  54                                 });
  55         }
  56
  57         public Object deserialize(Reader reader) {
  58                 try {
  59                         if (log.isTraceEnabled()) {
  60                                 String str = IOUtils.toString(reader);
  61                                 log.debug(str);
  62                                 reader = new StringReader(str);
  63                         }
  64
  65                         return getObjectMapper().readValue(reader, targetClass);
  66                 } catch (Exception e) {
  67                         throw new ArgeoException("Cannot deserialize " + reader, e);
  68                 }
  69
  70         }
  71
  72         public <T> T deserialize(Reader reader, Class<T> clss) {
  73                 try {
  74                         if (log.isTraceEnabled()) {
  75                                 String str = IOUtils.toString(reader);
  76                                 log.debug(str);
  77                                 reader = new StringReader(str);
  78                         }
  79
  80                         return getObjectMapper().readValue(reader, clss);
  81                 } catch (Exception e) {
  82                         throw new ArgeoException("Cannot deserialize " + reader, e);
  83                 }
  84
  85         }
  86
  87         public Object deserialize(String content) {
  88                 StringReader reader = new StringReader(content);
  89                 try {
  90                         return deserialize(reader);
  91                 } finally {
  92                         IOUtils.closeQuietly(reader);
  93                 }
  94         }
  95
  96         public void setTargetClass(Class<?> targetClass) {
  97                 this.targetClass = targetClass;
  98         }
  99
 100         public void setDeserializers(
 101                         Map<Class<?>, JsonDeserializer<?>> deserializers) {
 102                 this.deserializers = deserializers;
 103         }
 104
 105         public Class<?> getTargetClass() {
 106                 return targetClass;
 107         }
 108
 109         public Map<Class<?>, JsonDeserializer<?>> getDeserializers() {
 110                 return deserializers;
 111         }
 112
 113 }