package org.onap.policy.common.gson;
import com.google.gson.Gson;
-
+import com.google.gson.GsonBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;
-
import lombok.Getter;
-
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Gson gson;
/**
- * Constructs the object, using a plain Gson object.
+ * Constructs the object, using a Gson object that translates Doubles inside of Maps
+ * into Integer/Long, where possible.
*/
public GsonMessageBodyHandler() {
- this(new Gson());
+ this(new GsonBuilder().registerTypeAdapterFactory(new MapDoubleAdapterFactory()).create());
logger.info("Using GSON for REST calls");
}
@Override
public void writeTo(Object object, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
- MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream)
- throws IOException {
+ MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
try (OutputStreamWriter writer = new OutputStreamWriter(entityStream, StandardCharsets.UTF_8)) {
Type jsonType = (type.equals(genericType) ? type : genericType);
@Override
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType,
- MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
- throws IOException {
+ MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException {
try (InputStreamReader streamReader = new InputStreamReader(entityStream, StandardCharsets.UTF_8)) {
Type jsonType = (type.equals(genericType) ? type : genericType);
*/
public JacksonHandler() {
this(new GsonBuilder());
-
+
logger.info("Using GSON with Jackson behaviors for REST calls");
}
super(builder
.registerTypeAdapterFactory(new JacksonFieldAdapterFactory())
.registerTypeAdapterFactory(new JacksonMethodAdapterFactory())
+ .registerTypeAdapterFactory(new MapDoubleAdapterFactory())
.setExclusionStrategies(new JacksonExclusionStrategy())
.create());
}
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.common.gson;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+/**
+ * Adapter factory for Map<String,Object>. By default, GSON treats all Objects, that
+ * are numbers, as Double. This walks the map and converts Doubles to Integer or Long, if
+ * possible.
+ */
+public class MapDoubleAdapterFactory implements TypeAdapterFactory {
+
+ @Override
+ public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+ if (type.getRawType() != Map.class) {
+ return null;
+ }
+
+ Type[] actualParams = ((ParameterizedType) type.getType()).getActualTypeArguments();
+
+ // only supports Map<String,Object>
+ if (actualParams[0] != String.class || actualParams[1] != Object.class) {
+ return null;
+ }
+
+ TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+ return new MapAdapter<T>(delegate);
+ }
+
+ /**
+ * Type adapter that performs conversion from Double to Integer/Long.
+ *
+ * @param <T> type of object on which this works (always Map.class)
+ */
+ private static class MapAdapter<T> extends TypeAdapter<T> {
+
+ /**
+ * Used to perform conversion between JSON and Map<String,Object>.
+ */
+ private final TypeAdapter<T> delegate;
+
+ /**
+ * Constructs the object.
+ *
+ * @param delegate JSON/Map converter
+ */
+ public MapAdapter(TypeAdapter<T> delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void write(JsonWriter out, T value) throws IOException {
+ delegate.write(out, value);
+ }
+
+ @Override
+ public T read(JsonReader in) throws IOException {
+ T value = delegate.read(in);
+
+ @SuppressWarnings("rawtypes")
+ Map map = (Map) value;
+
+ convertFromDouble(map);
+
+ return value;
+ }
+
+ /**
+ * Performs conversion of all values in a map.
+ *
+ * @param map the map whose values are to be converted
+ */
+ @SuppressWarnings("rawtypes")
+ private void convertFromDouble(Map map) {
+
+ @SuppressWarnings("unchecked")
+ Set<Entry> set = map.entrySet();
+
+ for (Entry entry : set) {
+ convertFromDouble(entry);
+ }
+ }
+
+ /**
+ * Converts an entry's value. If the value is a Map, then it recursively converts
+ * the entries of the map.
+ *
+ * @param entry entry whose value is to be converted
+ */
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ private void convertFromDouble(Entry entry) {
+ Object obj = entry.getValue();
+
+ if (obj instanceof Map) {
+ convertFromDouble((Map) obj);
+ return;
+ }
+
+ if (!(obj instanceof Double)) {
+ return;
+ }
+
+ Double num = (Double) obj;
+ long longval = num.longValue();
+
+ if (num.doubleValue() == longval) {
+ // it's integral - determine if it's an integer or a long
+ int intval = (int) longval;
+
+ if (intval == longval) {
+ // it fits in an integer
+ entry.setValue(intval);
+
+ } else {
+ // doesn't fit in an integer - must be a long
+ entry.setValue(longval);
+ }
+ }
+ }
+ }
+}
* Constructs the object.
*
* @param gson Gson object providing type adapters
- * @param propName property name associated with the lifted field
* @param unliftedProps property names that should not be lifted
* @param getter method used to get the item from within an object
*/
*
* @param gson Gson object providing type adapters
* @param unliftedProps property names that should not be lifted
- * @param getter method used to get the item from within an object
+ * @param setter method used to set the item within an object
*/
public AnySetterDeserializer(Gson gson, Set<String> unliftedProps, Method setter) {
super(gson, unliftedProps, setter, setter.getGenericParameterTypes()[1]);
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
+import java.util.HashMap;
+import java.util.Map;
import javax.ws.rs.core.MediaType;
import org.junit.Before;
import org.junit.Test;
-import org.onap.policy.common.gson.GsonMessageBodyHandler;
public class GsonMessageBodyHandlerTest {
private static final String GEN_TYPE = "some-type";
assertEquals(obj1.toString(), obj2.toString());
}
+ @Test
+ public void testMapDouble() throws Exception {
+ MyMap map = new MyMap();
+ map.props = new HashMap<>();
+ map.props.put("plainString", "def");
+ map.props.put("negInt", -10);
+ map.props.put("doubleVal", 12.5);
+ map.props.put("posLong", 100000000000L);
+
+ ByteArrayOutputStream outstr = new ByteArrayOutputStream();
+ hdlr.writeTo(map, map.getClass(), map.getClass(), null, null, null, outstr);
+
+ Object obj2 = hdlr.readFrom(Object.class, map.getClass(), null, null, null,
+ new ByteArrayInputStream(outstr.toByteArray()));
+ assertEquals(map.toString(), obj2.toString());
+
+ map = (MyMap) obj2;
+
+ assertEquals(-10, map.props.get("negInt"));
+ assertEquals(100000000000L, map.props.get("posLong"));
+ assertEquals(12.5, map.props.get("doubleVal"));
+ }
+
+
public static class MyObject {
private int id;
}
}
+ private static class MyMap {
+ private Map<String, Object> props;
+
+ @Override
+ public String toString() {
+ return props.toString();
+ }
+ }
}
import java.util.TreeMap;
import javax.ws.rs.core.MediaType;
import org.junit.Test;
-import org.onap.policy.common.gson.JacksonHandler;
import org.onap.policy.common.gson.annotation.GsonJsonAnyGetter;
import org.onap.policy.common.gson.annotation.GsonJsonAnySetter;
assertEquals(data.toString(), data2.toString());
}
+ @Test
+ public void testMapDouble() throws Exception {
+ MyMap map = new MyMap();
+ map.props = new HashMap<>();
+ map.props.put("plainString", "def");
+ map.props.put("negInt", -10);
+ map.props.put("doubleVal", 12.5);
+ map.props.put("posLong", 100000000000L);
+
+ JacksonHandler hdlr = new JacksonHandler();
+ ByteArrayOutputStream outstr = new ByteArrayOutputStream();
+ hdlr.writeTo(map, map.getClass(), map.getClass(), null, null, null, outstr);
+
+ Object obj2 = hdlr.readFrom(Object.class, map.getClass(), null, null, null,
+ new ByteArrayInputStream(outstr.toByteArray()));
+ assertEquals(map.toString(), obj2.toString());
+
+ map = (MyMap) obj2;
+
+ assertEquals(-10, map.props.get("negInt"));
+ assertEquals(100000000000L, map.props.get("posLong"));
+ assertEquals(12.5, map.props.get("doubleVal"));
+ }
+
/**
* This class includes all policy-specific gson annotations.
*/
/**
* Sets a property.
+ *
* @param name property name
* @param value new value
*/
return "Data [id=" + id + ", value=" + value + ", props=" + props + "]";
}
}
+
+ private static class MyMap {
+ private Map<String, Object> props;
+
+ @Override
+ public String toString() {
+ return props.toString();
+ }
+
+ @SuppressWarnings("unused")
+ public Map<String, Object> getProps() {
+ return props;
+ }
+
+ @SuppressWarnings("unused")
+ public void setProps(Map<String, Object> props) {
+ this.props = props;
+ }
+ }
}
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.common.gson;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.Test;
+
+public class MapDoubleAdapterFactoryTest {
+ private static Gson gson = new GsonBuilder().registerTypeAdapterFactory(new MapDoubleAdapterFactory()).create();
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void test() {
+ MyMap map = new MyMap();
+ map.props = new HashMap<>();
+ map.props.put("plainString", "def");
+ map.props.put("posInt", 10);
+ map.props.put("negInt", -10);
+ map.props.put("doubleVal", 12.5);
+ map.props.put("posLong", 100000000000L);
+ map.props.put("negLong", -100000000000L);
+
+ Map<String, Object> nested = new LinkedHashMap<>();
+ map.props.put("nestedMap", nested);
+ nested.put("nestedString", "world");
+ nested.put("nestedInt", 50);
+
+ String json = gson.toJson(map);
+
+ map.props.clear();
+ map = gson.fromJson(json, MyMap.class);
+
+ assertEquals(json, gson.toJson(map));
+
+ assertEquals(10, map.props.get("posInt"));
+ assertEquals(-10, map.props.get("negInt"));
+ assertEquals(100000000000L, map.props.get("posLong"));
+ assertEquals(-100000000000L, map.props.get("negLong"));
+ assertEquals(12.5, map.props.get("doubleVal"));
+ assertEquals(nested, map.props.get("nestedMap"));
+
+ nested = (Map<String, Object>) map.props.get("nestedMap");
+ assertEquals(50, nested.get("nestedInt"));
+ }
+
+ @Test
+ public void test_ValueIsNotObject() {
+ MyDoubleMap map = new MyDoubleMap();
+ map.props = new LinkedHashMap<>();
+ map.props.put("plainDouble", 13.5);
+ map.props.put("doubleAsInt", 100.0);
+
+ String json = gson.toJson(map);
+
+ map.props.clear();
+ map = gson.fromJson(json, MyDoubleMap.class);
+
+ // everything should still be Double - check by simply accessing
+ map.props.get("plainDouble");
+ map.props.get("doubleAsInt");
+ }
+
+ @Test
+ public void test_KeyIsNotString() {
+ MyObjectMap map = new MyObjectMap();
+
+ map.props = new LinkedHashMap<>();
+ map.props.put("plainDouble2", 14.5);
+ map.props.put("doubleAsInt2", 200.0);
+
+ String json = gson.toJson(map);
+
+ map.props.clear();
+ map = gson.fromJson(json, MyObjectMap.class);
+
+ // everything should still be Double
+ assertEquals(14.5, map.props.get("plainDouble2"));
+ assertEquals(200.0, map.props.get("doubleAsInt2"));
+ }
+
+ private static class MyMap {
+ private Map<String, Object> props;
+ }
+
+ private static class MyDoubleMap {
+ private Map<String, Double> props;
+ }
+
+ private static class MyObjectMap {
+ private Map<Object, Object> props;
+ }
+
+}
return data;
}
}
+
/**
* Adapter for "DerivedData".
*/
<artifactId>capabilities</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.onap.policy.common</groupId>
+ <artifactId>gson</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
+import org.onap.policy.common.gson.MapDoubleAdapterFactory;
/**
* JSON encoder and decoder using the "standard" mechanism, which is currently gson.
/**
* Gson object used to encode and decode messages.
*/
- private static final Gson GSON = new GsonBuilder()
- .registerTypeAdapter(StandardCoderObject.class, new StandardTypeAdapter()).create();
+ private static final Gson GSON =
+ new GsonBuilder().registerTypeAdapter(StandardCoderObject.class, new StandardTypeAdapter())
+ .registerTypeAdapterFactory(new MapDoubleAdapterFactory()).create();
/**
* Constructs the object.
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
assertThatThrownBy(() -> coder.fromJson(new StringReader("["), StandardCoderObject.class));
}
+ @Test
+ public void testMapDouble() throws Exception {
+ MyMap map = new MyMap();
+ map.props = new HashMap<>();
+ map.props.put("plainString", "def");
+ map.props.put("negInt", -10);
+ map.props.put("doubleVal", 12.5);
+ map.props.put("posLong", 100000000000L);
+
+ String json = coder.encode(map);
+
+ map.props.clear();
+ map = coder.decode(json, MyMap.class);
+
+ assertEquals("def", map.props.get("plainString"));
+ assertEquals(-10, map.props.get("negInt"));
+ assertEquals(100000000000L, map.props.get("posLong"));
+ assertEquals(12.5, map.props.get("doubleVal"));
+ }
+
private static class MyObject {
private String abc;
return "MyObject [abc=" + abc + "]";
}
}
+
+ private static class MyMap {
+ private Map<String, Object> props;
+ }
}
Code Review / policy / common.git / commitdiff