deserializers are now reused

Signed-off-by: David Kral <[email protected]>

common/common/src/main/java/io/helidon/common/GenericType.java

@@ -243,7 +243,7 @@ public Builder<T> baseType(Class<? extends T> baseType) {
         }
 
         public Builder<T> addGenericParameter(GenericType<?> genericParameter) {
-            this.genericParameters.add(genericParameter);
+            this.genericParameters.add(genericParameter.type());
             return this;
         }
 

common/common/src/main/java/io/helidon/common/HelidonParameterizedType.java

@@ -32,32 +32,36 @@ public Type getOwnerType() {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
+        if (o instanceof ParameterizedType) {
+            // Check that information is equivalent
+            ParameterizedType that = (ParameterizedType) o;
+
+            if (this == that)
+                return true;
+
+            Type thatRawType = that.getRawType();
+
+            return Objects.equals(type, thatRawType) &&
+                    Arrays.equals(typeArgs,
+                                  that.getActualTypeArguments());
+        } else {
             return false;
         }
-        HelidonParameterizedType that = (HelidonParameterizedType) o;
-        return Objects.equals(type, that.type)
-                && Arrays.equals(typeArgs, that.typeArgs);
     }
 
     @Override
     public int hashCode() {
-        int result = Objects.hash(type);
-        result = 31 * result + Arrays.hashCode(typeArgs);
-        return result;
+        return Arrays.hashCode(typeArgs) ^ Objects.hashCode(type);
     }
 
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
-        sb.append(type.toString());
+        sb.append(type.getName());
         if (typeArgs.length > 0) {
             sb.append("<");
             for (Type typeArg : typeArgs) {
-                sb.append(typeArg);
+                sb.append(typeArg.getTypeName());
             }
             sb.append(">");
         }

json/binding/src/main/java/io/helidon/json/binding/BindingFactoryConverter.java

@@ -0,0 +1,4 @@
+package io.helidon.json.binding;
+
+public interface BindingFactoryConverter<T> extends BindingFactorySerializer<T>, BindingFactoryDeserializer<T> {
+}

json/binding/src/main/java/io/helidon/json/binding/BindingFactoryDeserializer.java

@@ -0,0 +1,9 @@
+package io.helidon.json.binding;
+
+import java.lang.reflect.Type;
+
+public interface BindingFactoryDeserializer<T> extends JsonDeserializer<T> {
+
+    void configure(JsonBindingConfigurer jsonBindingConfigurer, Type type);
+
+}

json/binding/src/main/java/io/helidon/json/binding/BindingFactorySerializer.java

@@ -0,0 +1,9 @@
+package io.helidon.json.binding;
+
+import java.lang.reflect.Type;
+
+public interface BindingFactorySerializer<T> extends JsonSerializer<T> {
+
+    void configure(JsonBindingConfigurer jsonBindingConfigurer, Type type);
+
+}

json/binding/src/main/java/io/helidon/json/binding/JsonBindingFactory.java

@@ -1,13 +1,8 @@
 package io.helidon.json.binding;
 
-import java.lang.reflect.Type;
-
 public interface JsonBindingFactory<T> {
 
-//    ConfigurableJsonDeserializer<T>  createDeserializer(JsonBinding jsonBinding, Type type);
-//    ConfigurableJsonSerializer<T>  createSerializer(JsonBinding jsonBinding, Type type);
-
-    JsonDeserializer<T>  createDeserializer(JsonBindingConfigurer jsonBindingConfigurer, Type type);
-    JsonSerializer<T>  createSerializer(JsonBindingConfigurer jsonBindingConfigurer, Type type);
+    BindingFactoryDeserializer<T>  createDeserializer();
+    BindingFactorySerializer<T>  createSerializer();
 
 }

json/binding/src/main/java/io/helidon/json/binding/JsonBindingImpl.java

@@ -1,12 +1,11 @@
 package io.helidon.json.binding;
 
 import java.io.ByteArrayOutputStream;
-import java.lang.reflect.Parameter;
-import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
 
 import io.helidon.common.GenericType;
 import io.helidon.json.processor.Generator;
@@ -17,13 +16,16 @@ final class JsonBindingImpl implements JsonBinding, JsonBindingConfigurer {
     static final JsonBinding DEFAULT_INSTANCE = JsonBinding.builder().build();
 
     private final JsonBindingConfig config;
-    private final Map<Class<?>, JsonSerializer<?>> identitySerializers = new HashMap<>();
-    private final Map<Class<?>, JsonDeserializer<?>> identityDeserializers = new HashMap<>();
-    private final Map<Class<?>, JsonBindingFactory<?>> bindingFactories = new HashMap<>();
+    private final Map<Class<?>, JsonSerializer<?>> identitySerializers = new IdentityHashMap<>();
+    private final Map<Class<?>, JsonDeserializer<?>> identityDeserializers = new IdentityHashMap<>();
+    private final Map<Class<?>, JsonBindingFactory<?>> bindingFactories = new IdentityHashMap<>();
     private final Map<Type, JsonSerializer<?>> serializers = new HashMap<>();
     private final Map<Type, JsonDeserializer<?>> deserializers = new HashMap<>();
+
     private final Map<Type, JsonSerializer<?>> serializersNotConfigured = new HashMap<>();
     private final Map<Type, JsonDeserializer<?>> deserializersNotConfigured = new HashMap<>();
+    private final ReentrantLock serNotConfiguredLock = new ReentrantLock();
+    private final ReentrantLock desNotConfiguredLock = new ReentrantLock();
 
     JsonBindingImpl(JsonBindingConfig config) {
         this.config = config;
@@ -79,7 +81,7 @@ public <T> String toJson(T obj, Class<T> type) {
         }
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         try (Generator generator = Generator.create(outputStream)) {
-            JsonSerializer<T> converter = getSerializer(type);
+            JsonSerializer<T> converter = getFinishedSerializer(type);
             converter.toJson(generator, obj);
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -94,7 +96,7 @@ public <T> String toJson(T obj, GenericType<T> type) {
         }
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         try (Generator generator = Generator.create(outputStream)) {
-            JsonSerializer<T> converter = getSerializer(type);
+            JsonSerializer<T> converter = getFinishedSerializer(type);
             converter.toJson(generator, obj);
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -104,35 +106,22 @@ public <T> String toJson(T obj, GenericType<T> type) {
 
     @Override
     public <T> T fromJson(String jsonStr, Class<T> type) {
-        JsonDeserializer<T> deserializer = getDeserializer(type);
+        JsonDeserializer<T> deserializer = getFinishedDeserializer(type);
         JsonParser parser = JsonParser.createParser(jsonStr);
         parser.nextToken();
         return deserializer.fromJson(parser);
     }
 
     @Override
     public <T> T fromJson(String jsonStr, GenericType<T> type) {
-        JsonDeserializer<T> deserializer = getDeserializer(type);
+        JsonDeserializer<T> deserializer = getFinishedDeserializer(type);
         JsonParser parser = JsonParser.createParser(jsonStr);
         parser.nextToken();
         return deserializer.fromJson(parser);
     }
 
-    @Override
-    @SuppressWarnings("unchecked")
-    public <T> JsonDeserializer<T> getDeserializer(Type type) {
-        if (type instanceof Class<?> clazz) {
-            return (JsonDeserializer<T>) getDeserializer(clazz);
-        } else if (type instanceof GenericType<?> genericType) {
-            return getDeserializer(genericType);
-        } else {
-            return getDeserializer(GenericType.create(type));
-        }
-    }
-
-    @Override
     @SuppressWarnings("unchecked")
-    public <T> JsonDeserializer<T> getDeserializer(Class<T> type) {
+    private <T> JsonDeserializer<T> getFinishedDeserializer(Class<T> type) {
         JsonDeserializer<T> deserializer = (JsonDeserializer<T>) identityDeserializers.get(type);
         if (deserializer != null) {
             return deserializer;
@@ -142,78 +131,144 @@ public <T> JsonDeserializer<T> getDeserializer(Class<T> type) {
             throw new IllegalStateException("Deserializer/Converter/BindingFactory for type "
                                                     + type + " is not registered.");
         }
-        deserializer = factory.createDeserializer(this, type);
-        deserializers.putIfAbsent(type, deserializer);
-        identityDeserializers.putIfAbsent(type, deserializer);
-        return deserializer;
+        BindingFactoryDeserializer<T> factoryDeserializer = factory.createDeserializer();
+
+        deserializersNotConfigured.putIfAbsent(type, factoryDeserializer);
+        factoryDeserializer.configure(this, type);
+        deserializersNotConfigured.remove(type);
+
+        deserializers.putIfAbsent(type, factoryDeserializer);
+        identityDeserializers.putIfAbsent(type, factoryDeserializer);
+        return factoryDeserializer;
     }
 
-    @Override
     @SuppressWarnings("unchecked")
-    public <T> JsonDeserializer<T> getDeserializer(GenericType<?> type) {
+    private <T> JsonDeserializer<T> getFinishedDeserializer(GenericType<?> type) {
         JsonDeserializer<T> deserializer = (JsonDeserializer<T>) deserializers.get(type);
         if (deserializer == null) {
             JsonBindingFactory<T> factory = (JsonBindingFactory<T>) bindingFactories.get(type.rawType());
             if (factory == null) {
                 throw new IllegalStateException("Deserializer/Converter/BindingFactory for type "
                                                         + type + " is not registered.");
             }
-            deserializer = factory.createDeserializer(this, type.type());
-            deserializers.putIfAbsent(type, deserializer);
-            deserializers.putIfAbsent(type.type(), deserializer);
+            BindingFactoryDeserializer<T> factoryDeserializer = factory.createDeserializer();
+
+            deserializersNotConfigured.putIfAbsent(type, factoryDeserializer);
+            factoryDeserializer.configure(this, type.type());
+            deserializersNotConfigured.remove(type);
+
+            deserializers.putIfAbsent(type, factoryDeserializer);
+            deserializers.putIfAbsent(type.type(), factoryDeserializer);
             if (type.isClass()) {
-                identityDeserializers.putIfAbsent(type.rawType(), deserializer);
+                identityDeserializers.putIfAbsent(type.rawType(), factoryDeserializer);
             }
+            return factoryDeserializer;
         }
         return deserializer;
     }
 
-    @Override
     @SuppressWarnings("unchecked")
-    public <T> JsonSerializer<T> getSerializer(Type type) {
-        if (type instanceof Class<?> clazz) {
-            return (JsonSerializer<T>) getSerializer(clazz);
-        } else if (type instanceof GenericType<?> genericType) {
-            return getSerializer(genericType);
-        } else {
-            return getSerializer(GenericType.create(type));
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <T> JsonSerializer<T> getSerializer(Class<T> type) {
+    private <T> JsonSerializer<T> getFinishedSerializer(Class<T> type) {
         JsonSerializer<T> serializer = (JsonSerializer<T>) identitySerializers.get(type);
         if (serializer == null) {
             JsonBindingFactory<T> factory = (JsonBindingFactory<T>) bindingFactories.get(type);
             if (factory == null) {
                 throw new IllegalStateException("Serializer/Converter/BindingFactory for type "
                                                         + type + " is not registered.");
             }
-            serializer = factory.createSerializer(this, type);
-            serializers.putIfAbsent(type, serializer);
-            identitySerializers.putIfAbsent(type, serializer);
+            BindingFactorySerializer<T> factorySerializer = factory.createSerializer();
+            serializersNotConfigured.putIfAbsent(type, factorySerializer);
+            factorySerializer.configure(this, type);
+            serializersNotConfigured.remove(type);
+
+            serializers.putIfAbsent(type, factorySerializer);
+            identitySerializers.putIfAbsent(type, factorySerializer);
+            return factorySerializer;
         }
         return serializer;
     }
 
-    @Override
     @SuppressWarnings("unchecked")
-    public <T> JsonSerializer<T> getSerializer(GenericType<?> type) {
+    private <T> JsonSerializer<T> getFinishedSerializer(GenericType<?> type) {
         JsonSerializer<T> serializer = (JsonSerializer<T>) serializers.get(type);
         if (serializer == null) {
             JsonBindingFactory<T> factory = (JsonBindingFactory<T>) bindingFactories.get(type.rawType());
             if (factory == null) {
                 throw new IllegalStateException("Serializer/Converter/BindingFactory for type "
                                                         + type + " is not registered.");
             }
-            serializer = factory.createSerializer(this, type.type());
-            serializers.putIfAbsent(type, serializer);
-            serializers.putIfAbsent(type.type(), serializer);
+            BindingFactorySerializer<T> factorySerializer = factory.createSerializer();
+            serializersNotConfigured.putIfAbsent(type.type(), factorySerializer);
+            factorySerializer.configure(this, type.type());
+            serializersNotConfigured.remove(type.type());
+
+            serializers.putIfAbsent(type, factorySerializer);
+            serializers.putIfAbsent(type.type(), factorySerializer);
             if (type.isClass()) {
-                identitySerializers.putIfAbsent(type.rawType(), serializer);
+                identitySerializers.putIfAbsent(type.rawType(), factorySerializer);
             }
+            return factorySerializer;
         }
         return serializer;
     }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonDeserializer<T> getDeserializer(Type type) {
+        return switch (type) {
+            case Class<?> clazz -> (JsonDeserializer<T>) getDeserializer(clazz);
+            case GenericType<?> genericType -> getDeserializer(genericType);
+            case null, default -> getDeserializer(GenericType.create(type));
+        };
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonDeserializer<T> getDeserializer(Class<T> type) {
+        JsonDeserializer<T> deserializer = (JsonDeserializer<T>) deserializersNotConfigured.get(type);
+        if (deserializer != null) {
+            return deserializer;
+        }
+        return getFinishedDeserializer(type);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonDeserializer<T> getDeserializer(GenericType<?> type) {
+        JsonDeserializer<T> deserializer = (JsonDeserializer<T>) deserializersNotConfigured.get(type);
+        if (deserializer != null) {
+            return deserializer;
+        }
+        return getFinishedDeserializer(type);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonSerializer<T> getSerializer(Type type) {
+        return switch (type) {
+            case Class<?> clazz -> (JsonSerializer<T>) getSerializer(clazz);
+            case GenericType<?> genericType -> getSerializer(genericType);
+            case null, default -> getSerializer(GenericType.create(type));
+        };
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonSerializer<T> getSerializer(Class<T> type) {
+        JsonSerializer<T> serializer = (JsonSerializer<T>) serializersNotConfigured.get(type);
+        if (serializer != null) {
+            return serializer;
+        }
+        return getFinishedSerializer(type);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> JsonSerializer<T> getSerializer(GenericType<?> type) {
+        JsonSerializer<T> serializer = (JsonSerializer<T>) serializersNotConfigured.get(type.type());
+        if (serializer != null) {
+            return serializer;
+        }
+        return getFinishedSerializer(type);
+    }
 }

json/binding/src/main/java/io/helidon/json/binding/JsonSerializer.java

@@ -1,6 +1,5 @@
 package io.helidon.json.binding;
 
-import io.helidon.common.GenericType;
 import io.helidon.json.processor.Generator;
 
 public interface JsonSerializer<T> {