com.tomtom.speedtools.json.SimpleJsonSerializer Maven / Gradle / Ivy
/*
* Copyright (C) 2012-2016. TomTom International BV (http://tomtom.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.tomtom.speedtools.json;
import com.google.common.collect.ImmutableMap;
import com.thoughtworks.paranamer.BytecodeReadingParanamer;
import com.thoughtworks.paranamer.ParameterNamesNotFoundException;
import com.tomtom.speedtools.domain.Uid;
import com.tomtom.speedtools.objects.Immutables;
import com.tomtom.speedtools.time.UTCTime;
import com.tomtom.speedtools.utils.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
/**
* Simple POJO (Plain Old Java Object, or 'regular Java object') to JSON object mapper. It is lenient, invalid values
* may be discarded or an exception can be thrown (customizable).
*
* For non JSON-type fields, the serializer returns a Java Map object that contains the JSON representation of the
* supplied POJO. However, This mapper may be overridden to generate other forms of JSON map objects, such as a MongoDB
* DBObject (which effectively is also a JSON map object). To do so, override the {@link #createJsonMappedObject()}
* method.
*/
@SuppressWarnings("UnnecessarilyQualifiedInnerClassAccess")
public class SimpleJsonSerializer {
private static final Logger LOG = LoggerFactory.getLogger(SimpleJsonSerializer.class);
/**
* Fields used by serializer to denote class name and nameless values.
*/
private static final String CLASS_NAME_FIELD = "@class";
private static final String WRAPPER_VALUE_FIELD = "_value";
/**
* Indentation for pretty printing.
*/
private static final String INDENT = " "; // Indent is 4 spaces.
/**
* Prefixes for getters and setters.
*/
private static final List GETTER_PREFIXES = Immutables.listOf("get", "is", "has");
private static final String SETTER_PREFIX = "set";
/**
* Look-up cache for mappers.
*/
private final Map mappers = new ConcurrentHashMap<>();
/**
* Singleton instance of this class.
*/
private static final SimpleJsonSerializer INSTANCE = new SimpleJsonSerializer();
/**
* Constructor should only be used by singleton instance and derived classes.
*/
protected SimpleJsonSerializer() {
super();
}
/**
* Get singleton instance of this class.
*
* @return Singleton instance.
*/
@Nonnull
public static SimpleJsonSerializer getInstance() {
return INSTANCE;
}
/**
* Serialize a POJO into a JSON value object.
*
* @param pojo POJO to serialize.
* @return JSON mapped object, or null if serialization failed.
*/
@Nullable
public Object serialize(@Nullable final Object pojo) {
if (pojo == null) {
return null;
}
Object serialized;
try {
final Class cls = pojo.getClass();
final Mapper mapper = getOrCreateMapper(cls);
final IdentityHashMap seen = new IdentityHashMap<>();
serialized = mapper.toJson(pojo, cls, seen);
} catch (final RuntimeException e) {
LOG.warn("serialize: failure, value='{}'. Runtime exception:", Json.toStringJson(pojo), e);
serialized = null;
}
return serialized;
}
/**
* Given a JSON value object, deserialize it into a POJO.
*
* @param jsonValue JSON mapped object to deserialize.
* @return POJO object. If deserialization failed, the return value is null. If the serialized object was null,
* however, the deserialized object is also null.
*/
@Nullable
public Object deserialize(@Nullable final Object jsonValue) {
Object deserialized;
try {
final Mapper mapper = getOrCreateMapper(Object.class);
deserialized = mapper.fromJson(jsonValue);
} catch (final RuntimeException e) {
LOG.warn("deserialize: failure, value='{}'. Runtime exception:", Json.toStringJson(jsonValue), e);
deserialized = null;
}
return deserialized;
}
/**
* Convert a POJO to JSON string object. Note that there is no method to read the JSON string representation and
* deserialize it. It is primarily used for logging.
*
* Also note that the string representation includes additional tags for class/type names, unnamed values and such.
* As such, it is not compatible with other JSON frameworks, such as Jackson, and is not suitable for use in JSON
* web responses, for example.
*
* @param pojo POJO to convert.
* @param pretty True for pretty printing (indented).
* @return JSON string representation of POJO.
*/
@Nonnull
public String toStringPretty(@Nullable final Object pojo, final boolean pretty) {
return toStringInternal(pojo, "\n", pretty);
}
/**
* Same as {@link #toStringPretty(Object, boolean)}, without pretty printing.
*
* @param pojo POJO to convert.
* @return JSON string representation of POJO.
*/
@Nonnull
public String toString(@Nullable final Object pojo) {
return toStringPretty(pojo, false);
}
/**
* Create a new JSON mapped object. Note that this object can be overridden by derived implementations to, for
* example, create a MongoDB JSON object.
*
* @return New, empty JSON mapped object.
*/
@Nonnull
protected Map createJsonMappedObject() {
return new LinkedHashMap<>();
}
// ------------------------------------------------------------------------
// Private methods and classes.
// ------------------------------------------------------------------------
/**
* Find the mapper for a specific object type. Uses a lookup cache to speed things up.
*
* @param type Object type.
* @return Object mapper.
*/
@Nonnull
private Mapper getOrCreateMapper(@Nonnull final Type type) {
assert type != null;
// Lookup mapper in cache.
Mapper mapper = mappers.get(type.toString());
if (mapper == null) {
// Might be calculated multiple times, but result will always be the same.
mapper = determineMapper(type);
mappers.put(type.toString(), mapper);
}
return mapper;
}
/**
* Determine the mapper for a given raw type. You can override this method to add additional mappers. You don't need
* to call super.determineMapperFromRawType() in that case.
*
* @param rawType Object type.
* @return Always null (needs to be overridden in order to be useful).
*/
@Nullable
protected Mapper determineMapperFromRawType(@Nonnull final Class rawType) {
assert rawType != null;
return null;
}
/**
* Determine object mapper for a specific object type.
*
* @param type Object type.
* @return Object mapper.
*/
@SuppressWarnings("ConstantConditions")
@Nonnull
private Mapper determineMapper(@Nonnull final Type type) {
assert type != null;
// Get the object type.
final Class rawType = getRawType(type);
/**
* Now, for every known type, return its object mapper.
*/
final Mapper mapper = determineMapperFromRawType(rawType);
if (mapper != null) {
return mapper;
}
if (List.class.isAssignableFrom(rawType)) {
return new CollectionMapper(type);
}
if (Set.class.isAssignableFrom(rawType)) {
return new WrappedCollectionMapper(type);
}
if (rawType.isArray()) {
return new ArrayMapper(type);
}
if (DateTime.class.isAssignableFrom(rawType)) {
return dateTimeMapper;
}
if (Integer.class.isAssignableFrom(rawType) || Integer.TYPE.isAssignableFrom(rawType)) {
return intMapper;
}
if (Long.class.isAssignableFrom(rawType) || Long.TYPE.isAssignableFrom(rawType)) {
return longMapper;
}
if (Byte.class.isAssignableFrom(rawType) || Byte.TYPE.isAssignableFrom(rawType)) {
return byteMapper;
}
if (Short.class.isAssignableFrom(rawType) || Short.TYPE.isAssignableFrom(rawType)) {
return shortMapper;
}
if (Float.class.isAssignableFrom(rawType) || Float.TYPE.isAssignableFrom(rawType)) {
return floatMapper;
}
if (Double.class.isAssignableFrom(rawType) || Double.TYPE.isAssignableFrom(rawType)) {
return doubleMapper;
}
if (Character.class.isAssignableFrom(rawType) || Character.TYPE.isAssignableFrom(rawType)) {
return charMapper;
}
if (CharSequence.class.isAssignableFrom(rawType)) {
return stringMapper;
}
if (Boolean.class.isAssignableFrom(rawType) || Boolean.TYPE.isAssignableFrom(rawType)) {
return booleanMapper;
}
if (Currency.class.isAssignableFrom(rawType)) {
return currencyMapper;
}
if (Uid.class.isAssignableFrom(rawType)) {
return uidMapper;
}
if (Class.class.isAssignableFrom(rawType)) {
return classMapper;
}
if (rawType.isEnum()) {
//noinspection unchecked
return new EnumMapper(rawType);
}
@Nonnull final Map propertyMap = new HashMap<>();
findBeanProperties(rawType, propertyMap);
// Find suitable constructor.
PropertyInfo[] mostConstructorProperties = null;
final List ctors = new ArrayList<>();
final Constructor[] declaredConstructors = rawType.getDeclaredConstructors();
for (final Constructor constructor : declaredConstructors) {
final PropertyInfo[] constructorProperties = getCompatibleConstructor(constructor, propertyMap);
// Add the constructor to the list of constructors and force it to be accessible.
if (constructorProperties != null) {
// Set the nullable flag for the constructor parameters according to the annotations.
for (int i = 0; i < constructorProperties.length; ++i) {
final Annotation[] annotations = constructor.getParameterAnnotations()[i];
if (annotations.length > 0) {
LOG.debug("determineMapper: Parameter {} has annotations: {}",
constructorProperties[i].name, Json.toStringJson(annotations));
}
final boolean nullable = !hasAnnotationNonnull(annotations);
constructorProperties[i] = new PropertyInfo(constructorProperties[i], nullable);
}
constructor.setAccessible(true);
ctors.add(new BeanInfo.Ctor(constructor, constructorProperties));
if ((mostConstructorProperties == null) ||
(mostConstructorProperties.length < constructorProperties.length)) {
mostConstructorProperties = constructorProperties;
}
}
}
// Add all constructor parameters to the BeanInfo mapper object.
final Set properties = new LinkedHashSet<>();
if (mostConstructorProperties != null) {
properties.addAll(Immutables.listOf(mostConstructorProperties));
}
// And add the properties with setters.
for (final PropertyInfo property : propertyMap.values()) {
//noinspection VariableNotUsedInsideIf
if (property.setter != null) {
properties.add(property);
}
}
return new BeanInfoMapper(new BeanInfo(rawType, ctors, properties));
}
/**
* Figure out if one of the annotations (of a parameter) is NotNull or Nonnull.
*
* @param annotations List of annotations.
* @return True if the annotations contains Nonnull.
*/
private static boolean hasAnnotationNonnull(@Nonnull final Annotation[] annotations) {
assert annotations != null;
for (final Annotation annotation : annotations) {
/**
* Now, unfortunately, some or all of these annotations may not be available runtime
* if their retention policy is not set to RUNTIME...
*/
if (annotation instanceof Nonnull) { // This one is not available runtime.
/**
* The annotation javax.annotation.Nonnull does not seem to exists
* anymore...
*/
return true;
}
}
return false;
}
private void findBeanProperties(
@Nonnull final Class objClass,
@Nonnull final Map properties) {
assert objClass != null;
assert properties != null;
final Class superclass = objClass.getSuperclass();
if (superclass != null) {
findBeanProperties(superclass, properties);
}
if (objClass.equals(Object.class)) {
return;
}
for (final Method getter : objClass.getDeclaredMethods()) {
final String getterPrefix = getterPrefixOrNull(getter.getName());
if ((getter.getParameterTypes().length == 0) && (getterPrefix != null)) {
final int getterPrefixLength = getterPrefix.length();
final Character propertyNameFirstCharacter = getter.getName().charAt(getterPrefixLength);
final String propertyNameWithoutFirstCharacter = getter.getName().substring(getterPrefixLength + 1);
final String propertyName = Character.toLowerCase(propertyNameFirstCharacter) +
propertyNameWithoutFirstCharacter;
// Find corresponding setter.
@Nullable Method setter = null;
final String setterName = SETTER_PREFIX + Character.toUpperCase(propertyNameFirstCharacter) +
propertyNameWithoutFirstCharacter;
for (final Method s : objClass.getDeclaredMethods()) {
if ((s.getParameterTypes().length == 1) && s.getName().equals(setterName)) {
setter = s;
break;
}
}
properties.put(propertyName, new PropertyInfo(propertyName, getter, setter));
}
}
}
@Nullable
private static String getterPrefixOrNull(@Nonnull final String methodName) {
assert methodName != null;
for (final String getterPrefix : GETTER_PREFIXES) {
if (methodName.startsWith(getterPrefix) &&
(methodName.length() > getterPrefix.length()) &&
Character.isUpperCase(methodName.charAt(getterPrefix.length()))) {
return getterPrefix;
}
}
return null;
}
@Nullable
private PropertyInfo[] getCompatibleConstructor(@Nonnull final Constructor constructor,
@Nonnull final Map properties) {
assert constructor != null;
assert properties != null;
// Get all parameter names reflectively (if possible).
final String[] parameterNames;
try {
parameterNames = new BytecodeReadingParanamer().lookupParameterNames(constructor);
} catch (final ParameterNamesNotFoundException ignored) {
// Some libraries don't provide names, so return null (no ctor found).
return null;
}
// Create a list of constructor parameter properties.
final PropertyInfo[] constructorProperties = new PropertyInfo[parameterNames.length];
for (int i = 0; i < parameterNames.length; ++i) {
final PropertyInfo property = properties.get(parameterNames[i]);
if (property == null) {
// The parameter name was not found in our list, no ctor found.
return null;
}
constructorProperties[i] = property;
}
return constructorProperties;
}
@Nullable
private Map createWrappedValue(@Nonnull final Class type, @Nullable final Object value) {
assert type != null;
if (value == null) {
return null;
}
final Map jsonObject = createJsonMappedObject();
jsonObject.put(CLASS_NAME_FIELD, type.getName());
final String actualValue;
if (type.isEnum()) {
actualValue = ((Enum) value).name();
} else {
actualValue = value.toString();
}
jsonObject.put(WRAPPER_VALUE_FIELD, actualValue);
return jsonObject;
}
@Nonnull
private static Class getRawType(final @Nonnull Type type) {
assert type != null;
if (type instanceof ParameterizedType) {
return (Class) ((ParameterizedType) type).getRawType();
}
if (type instanceof Class) {
return (Class) type;
}
return Object.class;
}
@Nonnull
private static Class getBoxedType(@Nonnull final Type type) {
assert type != null;
if (type instanceof Class) {
final Class cls = (Class) type;
if (cls.isPrimitive()) {
if (cls.equals(Integer.TYPE)) {
return Integer.class;
}
if (cls.equals(Long.TYPE)) {
return Long.class;
}
if (cls.equals(Byte.TYPE)) {
return Byte.class;
}
if (cls.equals(Boolean.TYPE)) {
return Boolean.class;
}
if (cls.equals(Short.TYPE)) {
return Short.class;
}
if (cls.equals(Character.TYPE)) {
return Character.class;
}
if (cls.equals(Float.TYPE)) {
return Float.class;
}
if (cls.equals(Double.TYPE)) {
return Double.class;
}
}
return cls;
}
return Object.class;
}
@Nonnull
private String toStringInternal(
@Nullable final Object value,
@Nonnull final String prefix,
final boolean pretty) {
assert prefix != null;
final StringBuilder sb = new StringBuilder();
if (value == null) {
sb.append("null");
} else if (value instanceof String) {
final String escapedValue = StringUtils.encodeToJsonString((String) value);
sb.append(escapedValue);
} else if (value instanceof Character) {
final String escapedValue = StringUtils.encodeToJsonString(String.valueOf(value));
sb.append(escapedValue);
} else if (value instanceof Number) {
sb.append(value);
} else if (value instanceof Boolean) {
sb.append(value);
} else if (value instanceof Date) {
sb.append('"').append(UTCTime.from((Date) value)).append('"');
} else if (value instanceof List) {
if (pretty) {
sb.append(prefix);
}
sb.append('[');
final String nestedPrefix = prefix + INDENT;
String sep = "";
for (final Object elem : (List) value) {
sb.append(sep);
sep = ", ";
sb.append(toStringInternal(elem, nestedPrefix, pretty));
}
if (pretty) {
sb.append(prefix);
}
sb.append(']');
} else if (value instanceof Map) {
if (pretty) {
sb.append(prefix);
}
sb.append('{');
final String nestedPrefix = prefix + INDENT;
String sep = "";
//noinspection unchecked
for (final Entry elem : ((Map) value).entrySet()) {
sb.append(sep);
sep = ", ";
if (pretty) {
sb.append(prefix).append(INDENT);
}
sb.append(StringUtils.encodeToJsonString(elem.getKey())).append(": ");
sb.append(toStringInternal(elem.getValue(), nestedPrefix, pretty));
}
if (pretty) {
sb.append(prefix);
}
sb.append('}');
} else {
sb.append(toStringInternal(serialize(value), prefix, pretty));
}
return sb.toString();
}
// ------------------------------------------------------------------------
// BeanInfo class.
// ------------------------------------------------------------------------
private static class BeanInfo {
@Nonnull
private final Class beanClass;
@Nonnull
private final List ctors; // Sorted most args to least.
@Nonnull
private final Set properties; // Properties.
private BeanInfo(
@Nonnull final Class beanClass,
@Nonnull final List ctors,
@Nonnull final Set properties) {
assert beanClass != null;
assert properties != null;
this.beanClass = beanClass;
final List copy = new ArrayList<>(ctors.size());
copy.addAll(ctors);
Collections.sort(copy);
this.ctors = copy;
this.properties = properties;
}
@SuppressWarnings("ComparableImplementedButEqualsNotOverridden")
private static class Ctor implements Comparable {
@Nonnull
private final Constructor constructor;
@Nonnull
private final PropertyInfo[] constructorProperties;
private Ctor(
@Nonnull final Constructor constructor,
@Nonnull final PropertyInfo[] constructorProperties) {
this.constructor = constructor;
this.constructorProperties = constructorProperties;
}
@Override
public int compareTo(@Nullable final Ctor o) {
if ((o == null) || (constructorProperties.length > o.constructorProperties.length)) {
return -1;
} else if (constructorProperties.length < o.constructorProperties.length) {
return 1;
} else {
return 0;
}
}
}
}
// ------------------------------------------------------------------------
// PropertyInfo class.
// ------------------------------------------------------------------------
private class PropertyInfo {
@Nonnull
private final String name;
@Nonnull
private final Method getter;
@Nullable
private final Method setter;
private final boolean nullable;
private PropertyInfo(
@Nonnull final String name,
@Nonnull final Method getter,
@Nullable final Method setter) {
assert name != null;
assert getter != null;
this.name = name;
this.getter = getter;
this.setter = setter;
this.nullable = true;
}
private PropertyInfo(
@Nonnull final PropertyInfo propertyInfo,
final boolean nullable) {
assert propertyInfo != null;
this.name = propertyInfo.name;
this.getter = propertyInfo.getter;
this.setter = propertyInfo.setter;
this.nullable = nullable;
}
@Nonnull
public Mapper getMapper() {
return getOrCreateMapper(getter.getGenericReturnType());
}
}
// ------------------------------------------------------------------------
// Mapper interface.
// ------------------------------------------------------------------------
protected interface Mapper {
/**
* Convert a POJO to JSON value object.
*
* @param object POJO to convert.
* @param elementType Type of POJO.
* @param seen Identity map, needed to detect recursive data structures.
* @return JSON mapped object, or null if the mapping was not possible for some reason.
*/
@Nullable
Object toJson(
@Nullable Object object,
@Nonnull final Type elementType,
@Nonnull IdentityHashMap seen);
/**
* Convert a JSON value object back to a POJO.
*
* @param jsonValue JSON value object.
* @return (Newly instantiated) POJO, or null if the JSON object could not be mapped back to a POJO.
*/
@Nullable
Object fromJson(@Nullable Object jsonValue);
/**
* Return mapper name (for debugging).
*
* @return Mapper name.
*/
@Nonnull
String getName();
}
private abstract static class NamedMapper implements Mapper {
@Nonnull
private final String name;
private NamedMapper(@Nonnull final String name) {
assert name != null;
this.name = name;
}
@Override
@Nullable
public abstract Object toJson(
@Nullable Object object,
@Nonnull final Type elementType,
@Nonnull IdentityHashMap seen);
@Override
@Nullable
public abstract Object fromJson(
@Nullable Object jsonValue);
@Override
@Nonnull
public String getName() {
return name;
}
}
// ------------------------------------------------------------------------
// Identity mapper (used to map BSON (e.g. MongoDB) object IDs).
// ------------------------------------------------------------------------
protected static class IdentityMapper extends NamedMapper {
@Nonnull
private final Class rawType;
public IdentityMapper(@Nonnull final Class rawType) {
super("IdentityMapper");
assert rawType != null;
this.rawType = rawType;
}
@Override
@Nullable
public Object fromJson(@Nullable final Object jsonValue) {
// Shortcut.
if (jsonValue == null) {
return null;
}
if (rawType.isInstance(jsonValue)) {
return jsonValue;
}
return null;
}
@Override
@Nullable
public Object toJson(
@Nullable final Object object,
@Nonnull final Type elementType,
@Nonnull final IdentityHashMap seen) {
assert elementType != null;
assert seen != null;
if (seen.put(object, object) != null) {
return null;
}
if (rawType.isInstance(object)) {
return object;
}
return null;
}
}
// ------------------------------------------------------------------------
// Bean info mapper (mapper for POJOs, which maps JSON types to JSON
// objects and wraps non-JSON types to mapped objects (type/value pairs).
// ------------------------------------------------------------------------
@SuppressWarnings("UnnecessarilyQualifiedInnerClassAccess")
private class BeanInfoMapper extends NamedMapper {
@Nonnull
private final BeanInfo beanInfo;
private BeanInfoMapper(@Nonnull final BeanInfo beanInfo) {
super("BeanInfoMapper");
assert beanInfo != null;
this.beanInfo = beanInfo;
}
@SuppressWarnings("ConstantConditions")
@Override
@Nullable
public Object fromJson(@Nullable final Object jsonValue) {
// Shortcut.
if (jsonValue == null) {
return null;
}
// List?
if (jsonValue instanceof List) {
final List