First half of actual #2800 (java.lang.Record) impl: find Record fields for serialization

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/introspect/BasicClassIntrospector.java

@@ -178,8 +178,9 @@ protected POJOPropertiesCollector collectProperties(MapperConfig<?> config,
             JavaType type, MixInResolver r, boolean forSerialization)
     {
         final AnnotatedClass classDef = _resolveAnnotatedClass(config, type, r);
-        final AccessorNamingStrategy accNaming = config.getAccessorNaming()
-                .forPOJO(config, classDef);
+        final AccessorNamingStrategy accNaming = type.isRecordType()
+                ? config.getAccessorNaming().forRecord(config, classDef)
+                : config.getAccessorNaming().forPOJO(config, classDef);
         return constructPropertyCollector(config, classDef, type, forSerialization, accNaming);
     }
 

src/main/java/com/fasterxml/jackson/databind/introspect/DefaultAccessorNamingStrategy.java

@@ -1,10 +1,14 @@
 package com.fasterxml.jackson.databind.introspect;
 
+import java.util.HashSet;
+import java.util.Set;
+
 import com.fasterxml.jackson.databind.AnnotationIntrospector;
 import com.fasterxml.jackson.databind.BeanDescription;
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
 import com.fasterxml.jackson.databind.cfg.MapperConfig;
+import com.fasterxml.jackson.databind.jdk14.JDK14Util;
 
 /**
  * Default {@link AccessorNamingStrategy} used by Jackson: to be used either as-is,
@@ -20,19 +24,23 @@ public class DefaultAccessorNamingStrategy
 
     protected final boolean _stdBeanNaming;
 
+    protected final String _getterPrefix;
+
     /**
      * Prefix used by auto-detected mutators ("setters"): usually "set",
      * but differs for builder objects ("with" by default).
      */
     protected final String _mutatorPrefix;
 
     protected DefaultAccessorNamingStrategy(MapperConfig<?> config, AnnotatedClass forClass,
-            String mutatorPrefix) {
+            String mutatorPrefix, String getterPrefix)
+    {
         _config = config;
         _forClass = forClass;
 
         _stdBeanNaming = config.isEnabled(MapperFeature.USE_STD_BEAN_NAMING);
         _mutatorPrefix = mutatorPrefix;
+        _getterPrefix = getterPrefix;
     }
 
     @Override
@@ -52,7 +60,7 @@ public String findNameForIsGetter(AnnotatedMethod am, String name)
     @Override
     public String findNameForRegularGetter(AnnotatedMethod am, String name)
     {
-        if (name.startsWith("get")) {
+        if ((_getterPrefix != null) && name.startsWith(_getterPrefix)) {
             // 16-Feb-2009, tatu: To handle [JACKSON-53], need to block CGLib-provided
             // method "getCallbacks". Not sure of exact safe criteria to get decent
             // coverage without false matches; but for now let's assume there is
@@ -68,16 +76,16 @@ public String findNameForRegularGetter(AnnotatedMethod am, String name)
                 }
             }
             return _stdBeanNaming
-                    ? stdManglePropertyName(name, 3)
-                    : legacyManglePropertyName(name, 3);
+                    ? stdManglePropertyName(name, _getterPrefix.length())
+                    : legacyManglePropertyName(name, _getterPrefix.length());
         }
         return null;
     }
 
     @Override
     public String findNameForMutator(AnnotatedMethod am, String name)
     {
-        if (name.startsWith(_mutatorPrefix)) {
+        if ((_mutatorPrefix != null) && name.startsWith(_mutatorPrefix)) {
             return _stdBeanNaming
                     ? stdManglePropertyName(name, _mutatorPrefix.length())
                     : legacyManglePropertyName(name, _mutatorPrefix.length());
@@ -210,7 +218,8 @@ public final static class Provider
         @Override
         public AccessorNamingStrategy forPOJO(MapperConfig<?> config, AnnotatedClass targetClass)
         {
-            return new DefaultAccessorNamingStrategy(config, targetClass, "set");
+            return new DefaultAccessorNamingStrategy(config, targetClass,
+                    "set", "get");
         }
 
         @Override
@@ -220,13 +229,49 @@ public AccessorNamingStrategy forBuilder(MapperConfig<?> config,
             AnnotationIntrospector ai = config.isAnnotationProcessingEnabled() ? config.getAnnotationIntrospector() : null;
             JsonPOJOBuilder.Value builderConfig = (ai == null) ? null : ai.findPOJOBuilderConfig(builderClass);
             String mutatorPrefix = (builderConfig == null) ? JsonPOJOBuilder.DEFAULT_WITH_PREFIX : builderConfig.withPrefix;
-            return new DefaultAccessorNamingStrategy(config, builderClass, mutatorPrefix);
+            return new DefaultAccessorNamingStrategy(config, builderClass,
+                    mutatorPrefix, "get");
         }
 
         @Override
         public AccessorNamingStrategy forRecord(MapperConfig<?> config, AnnotatedClass recordClass)
         {
-            return new DefaultAccessorNamingStrategy(config, recordClass, "set");
+            return new RecordNaming(config, recordClass);
+        }
+    }
+
+    public static class RecordNaming
+        extends DefaultAccessorNamingStrategy
+    {
+        /**
+         * Names of actual Record fields from definition; auto-detected.
+         */
+        protected final Set<String> _fieldNames;
+
+        public RecordNaming(MapperConfig<?> config, AnnotatedClass forClass) {
+            super(config, forClass,
+                    // no setters for (immutable) Records:
+                    null,
+                    // trickier: regular fields are ok (handled differently), but should
+                    // we also allow getter discovery? For now let's do so
+                    "get");
+            _fieldNames = new HashSet<>();
+            for (String name : JDK14Util.getRecordFieldNames(forClass.getRawType())) {
+                _fieldNames.add(name);
+            }
+        }
+
+        @Override
+        public String findNameForRegularGetter(AnnotatedMethod am, String name)
+        {
+            // By default, field names are un-prefixed, but verify so that we will not
+            // include "toString()" or additional custom methods (unless latter are
+            // annotated for inclusion)
+            if (_fieldNames.contains(name)) {
+                return name;
+            }
+            // but also allow auto-detecting additional getters, if any?
+            return super.findNameForRegularGetter(am, name);
         }
     }
 }

src/main/java/com/fasterxml/jackson/databind/jdk14/JDK14Util.java

@@ -0,0 +1,87 @@
+package com.fasterxml.jackson.databind.jdk14;
+
+import java.lang.reflect.Method;
+
+import com.fasterxml.jackson.databind.util.ClassUtil;
+
+/**
+ * Helper class to support some of JDK 14 (and later) features
+ * without Jackson itself being run on (or even built with) Java 14.
+ * In particular allows better support of {@code java.lang.Record}
+ * types (see <a href="https://openjdk.java.net/jeps/359">JEP 359</a>).
+ *
+ * @since 2.12
+ */
+public class JDK14Util
+{
+    public static String[] getRecordFieldNames(Class<?> recordType) {
+        return RecordAccessor.instance().getRecordFieldNames(recordType);
+    }
+
+    static class RecordAccessor {
+        private final Method RECORD_GET_RECORD_COMPONENTS;
+        private final Method RECORD_COMPONENT_GET_NAME;
+        private final Method RECORD_COMPONENT_GET_TYPE;
+
+        private final static RecordAccessor INSTANCE;
+        private final static RuntimeException PROBLEM;
+
+        static {
+            RuntimeException prob = null;
+            RecordAccessor inst = null;
+            try {
+                inst = new RecordAccessor();
+            } catch (RuntimeException e) {
+                prob = e;
+            }
+            INSTANCE = inst;
+            PROBLEM = prob;
+        }
+
+        private RecordAccessor() throws RuntimeException {
+            try {
+                RECORD_GET_RECORD_COMPONENTS = Class.class.getMethod("getRecordComponents");
+                Class<?> c = Class.forName("java.lang.reflect.RecordComponent");
+                RECORD_COMPONENT_GET_NAME = c.getMethod("getName");
+                RECORD_COMPONENT_GET_TYPE = c.getMethod("getType");
+            } catch (Exception e) {
+                throw new RuntimeException(String.format(
+"Failed to access Methods needed to support `java.lang.Record`: (%s) %s",
+e.getClass().getName(), e.getMessage()), e);
+            }
+        }
+
+        public static RecordAccessor instance() {
+            if (PROBLEM != null) {
+                throw PROBLEM;
+            }
+            return INSTANCE;
+        }
+
+        public String[] getRecordFieldNames(Class<?> recordType) throws IllegalArgumentException
+        {
+            final Object[] components = recordComponents(recordType);
+            final String[] names = new String[components.length];
+            for (int i = 0; i < components.length; i++) {
+                try {
+                    names[i] = (String) RECORD_COMPONENT_GET_NAME.invoke(components[i]);
+                } catch (Exception e) {
+                    throw new IllegalArgumentException(String.format(
+"Failed to access name of field #%d (of %d) of Record type %s",
+i, components.length, ClassUtil.nameOf(recordType)), e);
+                }
+            }
+            return names;
+        }
+
+        protected Object[] recordComponents(Class<?> recordType) throws IllegalArgumentException
+        {
+            try {
+                return (Object[]) RECORD_GET_RECORD_COMPONENTS.invoke(recordType);
+            } catch (Exception e) {
+                throw new IllegalArgumentException("Failed to access RecordComponents of type "
+                        +ClassUtil.nameOf(recordType));
+            }
+        }
+    }
+}

src/main/java/com/fasterxml/jackson/databind/jdk14/package-info.java

@@ -0,0 +1,6 @@
+/**
+Contains helper class(es) needed to support some of JDK14+
+features without requiring running or building using JDK 14.
+*/
+
+package com.fasterxml.jackson.databind.jdk14;