log4j.logger.org.springframework=WARN
#log4j.logger.org.springframework.web=DEBUG
#log4j.logger.org.springframework.jms=WARN
-log4j.logger.org.springframework.security=DEBUG
+log4j.logger.org.springframework.security=WARN
log4j.org.apache.directory=ERROR
org.argeo.security.manager.ldap,
org.argeo.security.webapp,
org.argeo.security.ria,
+ org.argeo.security.core,
org.argeo.server.ads.server
</slc.osgi.start>
<slc.osgi.bundles>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+ <classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
+ <classpathentry kind="output" path="target/classes"/>
+</classpath>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.argeo.security.modules</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.maven.ide.eclipse.maven2Builder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.maven.ide.eclipse.maven2Nature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
--- /dev/null
+#Fri Sep 18 15:22:32 CEST 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
--- /dev/null
+#Fri Sep 18 15:22:23 CEST 2009
+activeProfiles=
+eclipse.preferences.version=1
+fullBuildGoals=process-test-resources
+includeModules=false
+resolveWorkspaceProjects=true
+resourceFilterGoals=process-resources resources\:testResources
+skipCompilerPlugin=true
+version=1
Import-Package: javax.servlet,
javax.servlet.http,
javax.servlet.resources,
+ org.argeo.security,
org.argeo.security.dao,
org.argeo.security.mvc,
org.argeo.server.json,
<reference id="userDao" interface="org.argeo.security.dao.UserDao" />\r
<reference id="roleDao" interface="org.argeo.security.dao.RoleDao" />\r
\r
+ <list id="objectFactories" interface="org.argeo.server.json.JsonObjectFactory"\r
+ cardinality="0..N" />\r
</beans:beans>
\ No newline at end of file
<bean id="controller" class="org.argeo.security.mvc.UsersRolesController">
<property name="userDao" ref="userDao" />
<property name="roleDao" ref="roleDao" />
+ <property name="userDeserializer">
+ <bean class="org.argeo.server.json.JsonServerMapper">
+ <property name="targetClass" value="org.argeo.security.BasicArgeoUser" />
+ <property name="deserializers">
+ <map>
+ <entry key="org.argeo.security.UserNature">
+ <bean class="org.argeo.server.json.GenericJsonDeserializer">
+ <property name="objectFactories" ref="objectFactories" />
+ </bean>
+ </entry>
+ </map>
+ </property>
+ </bean>
+ </property>
</bean>
<bean id="viewResolver" class="org.argeo.server.mvc.SerializingViewResolver">
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.argeo.commons</groupId>
</plugin>
</plugins>
</build>
+ <dependencies>
+ <!-- Argeo -->
+ <dependency>
+ <groupId>org.argeo.commons.security</groupId>
+ <artifactId>org.argeo.security.mvc</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.argeo.commons.security</groupId>
+ <artifactId>org.argeo.security.ria</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.argeo.commons.server</groupId>
+ <artifactId>org.argeo.server.json</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ </dependency>
+
+ <!-- OSGi -->
+ <dependency>
+ <groupId>org.argeo.commons.osgi</groupId>
+ <artifactId>org.argeo.osgi.boot</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ </dependency>
+
+ <!-- Commons Dep -->
+ <dependency>
+ <groupId>org.argeo.commons.server</groupId>
+ <artifactId>org.argeo.server.dep.tomcat</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ <type>pom</type>
+ </dependency>
+ <dependency>
+ <groupId>org.argeo.commons.server</groupId>
+ <artifactId>org.argeo.server.dep.ads</artifactId>
+ <version>0.1.1-SNAPSHOT</version>
+ <type>pom</type>
+ </dependency>
+
+ <!-- Spring -->
+ <dependency>
+ <groupId>org.springframework.osgi</groupId>
+ <artifactId>org.springframework.osgi.extender</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.osgi</groupId>
+ <artifactId>org.springframework.osgi.web.extender</artifactId>
+ </dependency>
+ </dependencies>
</project>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src/main/java"/>
- <classpathentry kind="src" path="src/test/java"/>
+ <classpathentry kind="src" output="target/classes" path="src/main/resources"/>
+ <classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
<classpathentry kind="output" path="target/classes"/>
<Export-Package>
org.argeo.security.*
</Export-Package>
+ <Import-Package>*,
+ org.argeo.server.json;resolution:=optional
+ </Import-Package>
</instructions>
</configuration>
</plugin>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
+
+ <bean id="jsonObjectFactory" class="org.argeo.server.json.JsonObjectFactoryImpl">
+ </bean>
+</beans>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<beans:beans xmlns="http://www.springframework.org/schema/osgi"\r
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"\r
+ xsi:schemaLocation="http://www.springframework.org/schema/osgi \r
+ http://www.springframework.org/schema/osgi/spring-osgi-1.1.xsd\r
+ http://www.springframework.org/schema/beans \r
+ http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">\r
+\r
+ <service ref="jsonObjectFactory" interface="org.argeo.server.json.JsonObjectFactory" />\r
+\r
+</beans:beans>
\ No newline at end of file
package org.argeo.security.mvc;
+import java.io.Reader;
+import java.io.StringReader;
import java.util.List;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import org.argeo.security.ArgeoUser;
+import org.argeo.security.BasicArgeoUser;
import org.argeo.security.core.ArgeoUserDetails;
import org.argeo.security.dao.RoleDao;
import org.argeo.security.dao.UserDao;
import org.argeo.server.BooleanAnswer;
+import org.argeo.server.DeserializingEditor;
import org.argeo.server.ServerAnswer;
+import org.argeo.server.ServerDeserializer;
import org.argeo.server.mvc.MvcConstants;
import org.springframework.security.Authentication;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class UsersRolesController implements MvcConstants {
+ private final static Log log = LogFactory
+ .getLog(UsersRolesController.class);
+
private UserDao userDao;
private RoleDao roleDao;
+ private ServerDeserializer userDeserializer = null;
+
+ @InitBinder
+ public void initBinder(WebDataBinder binder) {
+ binder.registerCustomEditor(BasicArgeoUser.class,
+ new DeserializingEditor(userDeserializer));
+ }
+
/* USER */
@RequestMapping("/getCredentials.security")
return new BooleanAnswer(userDao.userExists(username));
}
+ @RequestMapping("/createUser.security")
+ @ModelAttribute(ANSWER_MODEL_KEY)
+ public ServerAnswer createUser(Reader reader) {
+ ArgeoUser user = (ArgeoUser) userDeserializer.deserialize(reader);
+ userDao.create(user);
+ return ServerAnswer.ok("User " + user.getUsername() + " created");
+ }
+
+ @RequestMapping("/updateUser.security")
+ @ModelAttribute(ANSWER_MODEL_KEY)
+ public ServerAnswer updateUser(Reader reader) {
+ ArgeoUser user = (ArgeoUser) userDeserializer.deserialize(reader);
+ userDao.update(user);
+ return ServerAnswer.ok("User " + user.getUsername() + " updated");
+ }
+
+ @RequestMapping("/createUser2.security")
+ @ModelAttribute(ANSWER_MODEL_KEY)
+ public ServerAnswer createUser(@RequestParam("body") String body) {
+ if (log.isDebugEnabled())
+ log.debug("body:\n" + body);
+ StringReader reader = new StringReader(body);
+ ArgeoUser user = null;
+ try {
+ user = (ArgeoUser) userDeserializer.deserialize(reader);
+ } finally {
+ IOUtils.closeQuietly(reader);
+ }
+ userDao.create(user);
+ return ServerAnswer.ok("User " + user.getUsername() + " created");
+ }
+
@RequestMapping("/deleteUser.security")
@ModelAttribute(ANSWER_MODEL_KEY)
public ServerAnswer deleteUser(@RequestParam("username") String username) {
this.roleDao = roleDao;
}
+ public void setUserDeserializer(ServerDeserializer userDeserializer) {
+ this.userDeserializer = userDeserializer;
+ }
+
}
<artifactId>com.springsource.javax.servlet</artifactId>
</dependency>
+ <!-- Logging -->
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>com.springsource.slf4j.org.apache.commons.logging</artifactId>
+ </dependency>
+
</dependencies>
</project>
--- /dev/null
+package org.argeo.server;
+
+import java.beans.PropertyEditorSupport;
+import java.io.StringReader;
+
+import org.apache.commons.io.IOUtils;
+
+public class DeserializingEditor extends PropertyEditorSupport {
+ private ServerDeserializer deserializer;
+
+ public DeserializingEditor(ServerDeserializer deserializer) {
+ super();
+ this.deserializer = deserializer;
+ }
+
+ @Override
+ public void setAsText(String text) throws IllegalArgumentException {
+ StringReader reader = new StringReader(text);
+ try {
+ setValue(deserializer.deserialize(reader));
+ } finally {
+ IOUtils.closeQuietly(reader);
+ }
+ }
+
+}
return new ServerAnswer(OK, message);
}
+ @Override
+ public String toString() {
+ return "ServerAnswer{status:"+status+", message:"+message+"}";
+ }
+
}
package org.argeo.server;
-import javax.servlet.http.HttpServletRequest;
+import java.io.Reader;
+
public interface ServerDeserializer {
- public Object deserialize(Object obj, HttpServletRequest request);
+ public Object deserialize(Reader str);
}
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import org.argeo.server.ServerAnswer;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
public class DefaultHandlerExceptionResolver implements
HandlerExceptionResolver {
+ private final static Log log = LogFactory
+ .getLog(DefaultHandlerExceptionResolver.class);
public ModelAndView resolveException(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex) {
ModelAndView mv = new ModelAndView();
- mv.addObject(ServerAnswer.error(ex));
+ ServerAnswer serverAnswer = ServerAnswer.error(ex);
+ mv.addObject(serverAnswer);
+
+ if (log.isDebugEnabled())
+ log.error(serverAnswer);
+
+ mv.setViewName("500");
+ // response.setStatus(500);
return mv;
}
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src/main/java"/>
+ <classpathentry kind="src" path="src/test/java" output="target/test-classes"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
<classpathentry kind="con" path="org.maven.ide.eclipse.MAVEN2_CLASSPATH_CONTAINER"/>
<classpathentry kind="output" path="target/classes"/>
<groupId>org.springframework</groupId>
<artifactId>org.springframework.web.servlet</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.springframework.osgi</groupId>
+ <artifactId>org.springframework.osgi.core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.osgi</groupId>
+ <artifactId>org.eclipse.osgi</artifactId>
+ </dependency>
<!-- J2EE -->
<dependency>
<artifactId>com.springsource.javax.servlet</artifactId>
</dependency>
+ <!-- Logging -->
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>com.springsource.slf4j.org.apache.commons.logging</artifactId>
+ </dependency>
+
+ <!-- TEST -->
+ <dependency>
+ <groupId>org.junit</groupId>
+ <artifactId>com.springsource.junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+
</dependencies>
</project>
--- /dev/null
+package org.argeo.server.json;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.server.ArgeoServerException;
+import org.codehaus.jackson.JsonFactory;
+import org.codehaus.jackson.JsonGenerator;
+import org.codehaus.jackson.JsonNode;
+import org.codehaus.jackson.JsonParser;
+import org.codehaus.jackson.JsonProcessingException;
+import org.codehaus.jackson.ObjectCodec;
+import org.codehaus.jackson.map.DeserializationContext;
+import org.codehaus.jackson.map.JsonDeserializer;
+import org.codehaus.jackson.map.ObjectMapper;
+
+public class GenericJsonDeserializer<T> extends JsonDeserializer<T> {
+ private final static Log log = LogFactory
+ .getLog(GenericJsonDeserializer.class);
+
+ private JsonFactory jsonFactory = new JsonFactory();
+ private ObjectCodec objectCodec = new ObjectMapper();
+
+ private String typeField = "type";
+
+ private List<JsonObjectFactory> objectFactories = new ArrayList<JsonObjectFactory>();
+
+ @Override
+ public T deserialize(JsonParser parser, DeserializationContext ctxt)
+ throws IOException, JsonProcessingException {
+ // first read as Json DOM in order to extract the type
+ // TODO: optimize with streaming API
+ JsonNode root = parser.readValueAsTree();
+ String type = root.get(typeField).getTextValue();
+
+ // Write it back as a string
+ StringWriter writer = new StringWriter();
+ JsonGenerator generator = jsonFactory.createJsonGenerator(writer);
+ generator.setCodec(objectCodec);
+ generator.writeTree(root);
+ String str = writer.toString();
+
+ if (log.isDebugEnabled())
+ log.debug("Deserialize object of type=" + type + ", str=" + str);
+
+ JsonObjectFactory objectFactory = null;
+ jofs: for (JsonObjectFactory jof : objectFactories) {
+ if (jof.supports(type)) {
+ objectFactory = jof;
+ break jofs;
+ }
+ }
+
+ if (objectFactory == null)
+ throw new ArgeoServerException(
+ "Cannot find JSON object factory for type " + type);
+
+ return (T) objectFactory.readValue(type, str);
+ }
+
+ public void setTypeField(String typeField) {
+ this.typeField = typeField;
+ }
+
+ public void setObjectFactories(List<JsonObjectFactory> objectFactories) {
+ this.objectFactories = objectFactories;
+ }
+
+}
--- /dev/null
+package org.argeo.server.json;
+
+
+public interface JsonObjectFactory {
+ public Boolean supports(String type);
+
+ public <T> T readValue(String type, String str);
+}
--- /dev/null
+package org.argeo.server.json;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.server.ArgeoServerException;
+import org.codehaus.jackson.map.ObjectMapper;
+import org.osgi.framework.BundleContext;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.osgi.context.BundleContextAware;
+import org.springframework.osgi.util.BundleDelegatingClassLoader;
+
+public class JsonObjectFactoryImpl implements JsonObjectFactory,
+ BundleContextAware, InitializingBean {
+ private final static Log log = LogFactory
+ .getLog(JsonObjectFactoryImpl.class);
+
+ private BundleContext bundleContext;
+ private BundleDelegatingClassLoader classLoader;
+
+ private ObjectMapper objectMapper = new ObjectMapper();
+ private Map<String, Class> supportedTypes = new HashMap<String, Class>();
+
+ public Boolean supports(String type) {
+ if (supportedTypes.containsKey(type))
+ return true;
+
+ return loadClass(type) != null ? true : false;
+ // try {
+ // // Class.forName(type);
+ // Thread.currentThread().getContextClassLoader().loadClass(type);
+ // return true;
+ // } catch (ClassNotFoundException e) {
+ // return false;
+ // }
+ }
+
+ public <T> T readValue(String type, String str) {
+ final Class clss;
+ if (supportedTypes.containsKey(type))
+ clss = supportedTypes.get(type);
+ else {
+ clss = loadClass(type);
+ if (clss == null)
+ throw new ArgeoServerException("Cannot find type " + type);
+ // try {
+ // // clss = Class.forName(type);
+ // clss = Thread.currentThread().getContextClassLoader()
+ // .loadClass(type);
+ // } catch (ClassNotFoundException e) {
+ // throw new ArgeoServerException("Cannot find type " + type, e);
+ // }
+ }
+
+ try {
+ return (T) objectMapper.readValue(str, clss);
+ } catch (Exception e) {
+ throw new ArgeoServerException("Cannot deserialize " + str
+ + " (type=" + type + ")", e);
+ }
+ }
+
+ public void setSupportedTypes(Map<String, Class> supportedTypes) {
+ this.supportedTypes = supportedTypes;
+ }
+
+ protected Class loadClass(String type) {
+ Class clss;
+// try {
+// return Class.forName(type);
+// } catch (ClassNotFoundException e) {
+// if (log.isDebugEnabled())
+// log.debug("Class.forName failed: " + e);
+// }
+//
+// try {
+// return Thread.currentThread().getContextClassLoader().loadClass(
+// type);
+// } catch (ClassNotFoundException e) {
+// if (log.isDebugEnabled())
+// log
+// .debug("Thread.currentThread().getContextClassLoader().loadClass failed: "
+// + e);
+// }
+//
+// try {
+// return getClass().getClassLoader().loadClass(type);
+// } catch (ClassNotFoundException e) {
+// if (log.isDebugEnabled())
+// log.debug("getClass().getClassLoader().loadClass failed: " + e);
+// }
+//
+ try {
+ return classLoader.loadClass(type);
+ } catch (ClassNotFoundException e) {
+ if (log.isDebugEnabled())
+ log.debug("BundleDelegatingClassLoader.loadClass failed: " + e);
+ }
+
+ return null;
+ }
+
+ public void setBundleContext(BundleContext bundleContext) {
+ this.bundleContext = bundleContext;
+ }
+
+ public void afterPropertiesSet() throws Exception {
+ classLoader = BundleDelegatingClassLoader
+ .createBundleClassLoaderFor(bundleContext.getBundle());
+ }
+}
package org.argeo.server.json;
-import java.io.BufferedReader;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import org.argeo.server.ArgeoServerException;
import org.argeo.server.ServerDeserializer;
-import org.argeo.server.ServerSerializer;
-import org.codehaus.jackson.JsonFactory;
-import org.codehaus.jackson.JsonGenerator;
-import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.JsonProcessingException;
+import org.codehaus.jackson.map.DeserializationContext;
+import org.codehaus.jackson.map.DeserializationProblemHandler;
+import org.codehaus.jackson.map.JsonDeserializer;
+import org.codehaus.jackson.map.deser.CustomDeserializerFactory;
+import org.codehaus.jackson.map.deser.StdDeserializerProvider;
+import org.springframework.beans.factory.InitializingBean;
-public class JsonServerMapper implements ServerSerializer, ServerDeserializer {
- private JsonFactory jsonFactory = new JsonFactory();
- private ObjectMapper objectMapper = new ObjectMapper();
+public class JsonServerMapper extends JsonServerSerializer implements
+ ServerDeserializer, InitializingBean {
+ private final static Log log = LogFactory.getLog(JsonServerMapper.class);
- public void serialize(Object obj, HttpServletRequest request,
- HttpServletResponse response) {
- try {
- response.setContentType("application/json");
+ private Class targetClass;
- JsonGenerator jsonGenerator = jsonFactory
- .createJsonGenerator(response.getWriter());
- jsonGenerator.useDefaultPrettyPrinter();
+ private Map<Class, JsonDeserializer> deserializers = new HashMap<Class, JsonDeserializer>();
- objectMapper.writeValue(jsonGenerator, obj);
- } catch (Exception e) {
- throw new ArgeoServerException("Cannot serialize " + obj, e);
+ public void afterPropertiesSet() throws Exception {
+ CustomDeserializerFactory dsf = new CustomDeserializerFactory();
+ for (Class clss : deserializers.keySet()) {
+ dsf.addSpecificMapping(clss, deserializers.get(clss));
}
+ StdDeserializerProvider sdp = new StdDeserializerProvider(dsf);
+ getObjectMapper().setDeserializerProvider(sdp);
+ // ignore unkown properties
+ getObjectMapper().getDeserializationConfig().addHandler(
+ new DeserializationProblemHandler() {
+ public boolean handleUnknownProperty(
+ DeserializationContext ctxt,
+ JsonDeserializer<?> deserializer, Object bean,
+ String propertyName) throws IOException,
+ JsonProcessingException {
+ if (log.isDebugEnabled())
+ log.debug("Ignore property " + propertyName);
+ return true;
+ }
+ });
}
- public Object deserialize(Object obj, HttpServletRequest request) {
+ public Object deserialize(Reader reader) {
try {
- String body = request.getParameter("body");
- if (body == null) {
- // lets read the message body instead
- BufferedReader reader = request.getReader();
- StringBuffer buffer = new StringBuffer();
- String line = null;
- while (((line = reader.readLine()) != null)) {
- buffer.append(line);
- }
- body = buffer.toString();
- }
- return objectMapper.readValue(body, Object.class);
+ // String body = request.getParameter("body");
+ // if (body == null) {
+ // // lets read the message body instead
+ // BufferedReader reader = request.getReader();
+ // StringBuffer buffer = new StringBuffer();
+ // String line = null;
+ // while (((line = reader.readLine()) != null)) {
+ // buffer.append(line);
+ // }
+ // body = buffer.toString();
+ // }
+ return getObjectMapper().readValue(reader, targetClass);
} catch (Exception e) {
- throw new ArgeoServerException("Cannot deserialize " + request, e);
+ throw new ArgeoServerException("Cannot deserialize " + reader, e);
}
+
+ }
+
+ public void setTargetClass(Class targetClass) {
+ this.targetClass = targetClass;
+ }
+
+ public void setDeserializers(Map<Class, JsonDeserializer> deserializers) {
+ this.deserializers = deserializers;
}
}
--- /dev/null
+package org.argeo.server.json;
+
+import java.io.IOException;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.server.ArgeoServerException;
+import org.argeo.server.ServerSerializer;
+import org.codehaus.jackson.JsonFactory;
+import org.codehaus.jackson.JsonGenerator;
+import org.codehaus.jackson.map.ObjectMapper;
+
+public class JsonServerSerializer implements ServerSerializer {
+ private final static Log log = LogFactory
+ .getLog(JsonServerSerializer.class);
+
+ private JsonFactory jsonFactory = new JsonFactory();
+ private ObjectMapper objectMapper = new ObjectMapper();
+
+ private Boolean prettyPrint = true;
+
+ public void serialize(Object obj, HttpServletRequest request,
+ HttpServletResponse response) {
+ JsonGenerator jsonGenerator = null;
+ try {
+ response.setContentType("application/json");
+
+ jsonGenerator = jsonFactory.createJsonGenerator(response
+ .getWriter());
+ if (prettyPrint)
+ jsonGenerator.useDefaultPrettyPrinter();
+
+ objectMapper.writeValue(jsonGenerator, obj);
+
+ jsonGenerator.close();
+ } catch (Exception e) {
+ throw new ArgeoServerException("Cannot serialize " + obj, e);
+ } finally {
+ if (jsonGenerator != null)
+ try {
+ jsonGenerator.close();
+ } catch (IOException e) {
+ if (log.isTraceEnabled())
+ log.error("Cannot close JSON generator", e);
+ }
+ }
+ }
+
+ public void setPrettyPrint(Boolean prettyPrint) {
+ this.prettyPrint = prettyPrint;
+ }
+
+ protected ObjectMapper getObjectMapper() {
+ return objectMapper;
+ }
+}
--- /dev/null
+package org.argeo.server.json;
+
+public class JsonServerMapperTest {
+ public void testDeserialize() {
+ JsonServerMapper mapper = new JsonServerMapper();
+ //mapper.setTargetClass(targetClass)
+ }
+}
projects / lgpl / argeo-commons.git / commitdiff