server/runtime/org.argeo.server.json/src/main/java/org/argeo/server/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.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                                                 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 }