and some more refactoring of java.sql type handlers

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/ext/OptionalHandlerFactory.java

@@ -6,6 +6,9 @@
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.deser.Deserializers;
 import com.fasterxml.jackson.databind.ser.Serializers;
+import com.fasterxml.jackson.databind.ser.std.DateSerializer;
+import com.fasterxml.jackson.databind.ser.std.SqlDateSerializer;
+import com.fasterxml.jackson.databind.ser.std.SqlTimeSerializer;
 import com.fasterxml.jackson.databind.util.ClassUtil;
 
 /**
@@ -79,16 +82,28 @@ public class OptionalHandlerFactory implements java.io.Serializable
     public final static OptionalHandlerFactory instance = new OptionalHandlerFactory();
 
     // classes from java.sql module, this module may not be present at runtime
-    private final Map<String, String> _sqlClasses;
+    private final Map<String, String> _sqlDeserializers;
+    private final Map<String, Object> _sqlSerializers;
+
+    private final static String CLS_NAME_JAVA_SQL_TIMESTAMP = "java.sql.Timestamp";
+    private final static String CLS_NAME_JAVA_SQL_DATE = "java.sql.Date";
+    private final static String CLS_NAME_JAVA_SQL_TIME = "java.sql.Time";
 
     protected OptionalHandlerFactory() {
-        _sqlClasses = new HashMap<>();
-        try {
-            _sqlClasses.put("java.sql.Date",
-                    "com.fasterxml.jackson.databind.deser.std.DateDeserializers$SqlDateDeserializer");
-            _sqlClasses.put("java.sql.Timestamp",
-                    "com.fasterxml.jackson.databind.deser.std.DateDeserializers$TimestampDeserializer");
-        } catch (Throwable t) { }
+        _sqlDeserializers = new HashMap<>();
+        _sqlDeserializers.put(CLS_NAME_JAVA_SQL_DATE,
+                "com.fasterxml.jackson.databind.deser.std.DateDeserializers$SqlDateDeserializer");
+        _sqlDeserializers.put(CLS_NAME_JAVA_SQL_TIMESTAMP,
+                "com.fasterxml.jackson.databind.deser.std.DateDeserializers$TimestampDeserializer");
+
+        _sqlSerializers = new HashMap<>();
+        // 09-Jan-2015, tatu: As per [databind#1073], let's try to guard against possibility
+        //   of some environments missing `java.sql.` types
+
+        // note: timestamps are very similar to java.util.Date, thus serialized as such
+        _sqlSerializers.put(CLS_NAME_JAVA_SQL_TIMESTAMP, DateSerializer.instance);
+        _sqlSerializers.put(CLS_NAME_JAVA_SQL_DATE, "com.fasterxml.jackson.databind.ser.std.SqlDateSerializer");
+        _sqlSerializers.put(CLS_NAME_JAVA_SQL_TIME, "com.fasterxml.jackson.databind.ser.std.SqlTimeSerializer");
     }
 
     /*
@@ -114,6 +129,16 @@ public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType typ
         }
 
         String className = rawType.getName();
+        Object sqlHandler = _sqlSerializers.get(className);
+
+        if (sqlHandler != null) {
+            if (sqlHandler instanceof JsonSerializer<?>) {
+                return (JsonSerializer<?>) sqlHandler;
+            }
+            // must be class name otherwise
+            return (JsonSerializer<?>) instantiate((String) sqlHandler, type);
+        }
+
         String factoryName;
         if (className.startsWith(PACKAGE_PREFIX_JAVAX_XML) || hasSuperClassStartingWith(rawType, PACKAGE_PREFIX_JAVAX_XML)) {
             factoryName = SERIALIZERS_FOR_JAVAX_XML;
@@ -147,7 +172,7 @@ public JsonDeserializer<?> findDeserializer(JavaType type, DeserializationConfig
             return (JsonDeserializer<?>) instantiate(DESERIALIZER_FOR_DOM_DOCUMENT, type);
         }
         String className = rawType.getName();
-        final String deserName = _sqlClasses.get(className);
+        final String deserName = _sqlDeserializers.get(className);
         if (deserName != null) {
             return (JsonDeserializer<?>) instantiate(deserName, type);
         }
@@ -178,7 +203,7 @@ public boolean hasDeserializerFor(Class<?> valueType) {
             return true;
         }
         // 06-Nov-2020, tatu: One of "java.sql" types?
-        return _sqlClasses.containsKey(className);
+        return _sqlDeserializers.containsKey(className);
     }
 
     /*
@@ -190,14 +215,25 @@ public boolean hasDeserializerFor(Class<?> valueType) {
     private Object instantiate(String className, JavaType valueType)
     {
         try {
-            return ClassUtil.createInstance(Class.forName(className), false);
+            return instantiate(Class.forName(className), valueType);
         } catch (Throwable e) {
-            throw new IllegalStateException("Failed to create instance of `"
+            throw new IllegalStateException("Failed to find class `"
 +className+"` for handling values of type "+ClassUtil.getTypeDescription(valueType)
 +", problem: ("+e.getClass().getName()+") "+e.getMessage());
         }
     }
 
+    private Object instantiate(Class<?> handlerClass, JavaType valueType)
+    {
+        try {
+            return ClassUtil.createInstance(handlerClass, false);
+        } catch (Throwable e) {
+            throw new IllegalStateException("Failed to create instance of `"
++handlerClass.getName()+"` for handling values of type "+ClassUtil.getTypeDescription(valueType)
++", problem: ("+e.getClass().getName()+") "+e.getMessage());
+        }
+    }
+
     /**
      * Since 2.7 we only need to check for class extension, as all implemented
      * types are classes, not interfaces. This has performance implications for

src/main/java/com/fasterxml/jackson/databind/ser/std/StdJdkSerializers.java

@@ -48,19 +48,6 @@ public static Collection<Map.Entry<Class<?>, Object>> all()
         sers.put(Void.class, NullSerializer.instance);
         sers.put(Void.TYPE, NullSerializer.instance);
 
-        // 09-Jan-2015, tatu: As per [databind#1073], let's try to guard against possibility
-        //   of some environments missing `java.sql.` types
-        try {
-            // note: timestamps are very similar to java.util.Date, thus serialized as such
-            sers.put(java.sql.Timestamp.class, DateSerializer.instance);
-    
-            // leave some of less commonly used ones as lazy, no point in proactive construction
-            sers.put(java.sql.Date.class, SqlDateSerializer.class);
-            sers.put(java.sql.Time.class, SqlTimeSerializer.class);
-        } catch (NoClassDefFoundError e) {
-            // nothing much we can do here; could log, but probably not useful for now.
-        }
-
         return sers.entrySet();
     }