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