feat(java): implement FinalFieldReplaceResolveSerializer for final fields with writeReplace/readResolve methods (#2917)

<!--
**Thanks for contributing to Apache Fory™.**

**If this is your first time opening a PR on fory, you can refer to
[CONTRIBUTING.md](https://github.com/apache/fory/blob/main/CONTRIBUTING.md).**

Contribution Checklist

- The **Apache Fory™** community has requirements on the naming of pr
titles. You can also find instructions in
[CONTRIBUTING.md](https://github.com/apache/fory/blob/main/CONTRIBUTING.md).

- Apache Fory™ has a strong focus on performance. If the PR you submit
will have an impact on performance, please benchmark it first and
provide the benchmark result here.
-->

## Why?

Based on the discussion #2786.
We can optimize the payload in cases where we have final fields in some
Object.

re-created, closed PR #2904 

## What does this PR do?

Introduce `FinalFieldReplaceResolver` which does not write the classname
into the payload.

## Related issues

<!--
Is there any related issue? If this PR closes them you say say
fix/closes:

- #xxxx0
- #xxxx1
- Fixes #xxxx2
-->

## Does this PR introduce any user-facing change?

<!--
If any user-facing interface changes, please [open an
issue](https://github.com/apache/fory/issues/new/choose) describing the
need to do so and update the document if necessary.

Delete section if not applicable.
-->

- [x] Does this PR introduce any public API change?
- [x] Does this PR introduce any binary protocol compatibility change?

## Benchmark

<!--
When the PR has an impact on performance (if you don't know whether the
PR will have an impact on performance, you can submit the PR first, and
if it will have impact on performance, the code reviewer will explain
it), be sure to attach a benchmark data here.

Delete section if not applicable.
-->

---------

Co-authored-by: Shawn Yang <[email protected]>

Author: mchernyakov

java/fory-core/src/main/java/org/apache/fory/Fory.java

@@ -1712,6 +1712,10 @@ public boolean isCompatible() {
     return config.getCompatibleMode() == CompatibleMode.COMPATIBLE;
   }
 
+  public boolean isShareMeta() {
+    return shareMeta;
+  }
+
   public boolean trackingRef() {
     return refTracking;
   }

java/fory-core/src/main/java/org/apache/fory/builder/BaseObjectCodecBuilder.java

@@ -207,9 +207,7 @@ private Expression serializeGroup(
             // `bean` will be replaced by `Reference` to cut-off expr dependency.
             Expression fieldValue = getFieldValue(bean, d);
             walkPath.add(d.getDeclaringClass() + d.getName());
-            boolean nullable = d.isNullable();
-            Expression fieldExpr =
-                serializeForNullable(fieldValue, buffer, d.getTypeRef(), nullable);
+            Expression fieldExpr = serializeField(fieldValue, buffer, d);
             walkPath.removeLast();
             groupExpressions.add(fieldExpr);
           }
@@ -555,17 +553,15 @@ protected Expression deserializeGroup(
           for (Descriptor d : group) {
             ExpressionVisitor.ExprHolder exprHolder = ExpressionVisitor.ExprHolder.of("bean", bean);
             walkPath.add(d.getDeclaringClass() + d.getName());
-            boolean nullable = d.isNullable();
             Expression action =
-                deserializeForNullable(
+                deserializeField(
                     buffer,
-                    d.getTypeRef(),
+                    d,
                     // `bean` will be replaced by `Reference` to cut-off expr
                     // dependency.
                     expr ->
                         setFieldValue(
-                            exprHolder.get("bean"), d, tryInlineCast(expr, d.getTypeRef())),
-                    nullable);
+                            exprHolder.get("bean"), d, tryInlineCast(expr, d.getTypeRef())));
             walkPath.removeLast();
             groupExpressions.add(action);
           }

java/fory-core/src/main/java/org/apache/fory/builder/ObjectCodecBuilder.java

@@ -110,6 +110,7 @@
 import org.apache.fory.serializer.CompatibleSerializer;
 import org.apache.fory.serializer.EnumSerializer;
 import org.apache.fory.serializer.ExternalizableSerializer;
+import org.apache.fory.serializer.FinalFieldReplaceResolveSerializer;
 import org.apache.fory.serializer.ForyCopyableSerializer;
 import org.apache.fory.serializer.JavaSerializer;
 import org.apache.fory.serializer.JdkProxySerializer;
@@ -789,8 +790,8 @@ public void clearSerializer(Class<?> cls) {
     }
   }
 
-  /** Ass serializer for specified class. */
-  private void addSerializer(Class<?> type, Serializer<?> serializer) {
+  /** Add serializer for specified class. */
+  public void addSerializer(Class<?> type, Serializer<?> serializer) {
     Preconditions.checkNotNull(serializer);
     // 1. Try to get ClassInfo from `registeredId2ClassInfo` and
     // `classInfoMap` or create a new `ClassInfo`.
@@ -801,7 +802,8 @@ private void addSerializer(Class<?> type, Serializer<?> serializer) {
     if (registered) {
       classInfo = registeredId2ClassInfo[classId];
     } else {
-      if (serializer instanceof ReplaceResolveSerializer) {
+      if (serializer instanceof ReplaceResolveSerializer
+          && !(serializer instanceof FinalFieldReplaceResolveSerializer)) {
         classId = REPLACE_STUB_ID;
       } else {
         classId = NO_CLASS_ID;

java/fory-core/src/main/java/org/apache/fory/resolver/ClassResolver.java

@@ -706,6 +706,7 @@ public <T> Serializer<T> getSerializer(Class<T> cls) {
     return (Serializer) getClassInfo(cls).serializer;
   }
 
+  @Override
   public Serializer<?> getRawSerializer(Class<?> cls) {
     return getClassInfo(cls).serializer;
   }

java/fory-core/src/main/java/org/apache/fory/resolver/XtypeResolver.java

@@ -1035,6 +1035,12 @@ private FinalTypeField(Fory fory, Descriptor d) {
         classInfo = null;
       } else {
         classInfo = SerializationUtils.getClassInfo(fory, typeRef.getRawType());
+        if (!fory.isShareMeta()
+            && !fory.isCompatible()
+            && classInfo.getSerializer() instanceof ReplaceResolveSerializer) {
+          // overwrite replace resolve serializer for final field
+          classInfo.setSerializer(new FinalFieldReplaceResolveSerializer(fory, classInfo.getCls()));
+        }
       }
     }
   }

java/fory-core/src/main/java/org/apache/fory/serializer/AbstractObjectSerializer.java

@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.fory.serializer;
+
+import org.apache.fory.Fory;
+import org.apache.fory.config.CompatibleMode;
+import org.apache.fory.memory.MemoryBuffer;
+
+/**
+ * Serializer for class which: - has jdk `writeReplace`/`readResolve` method defined, - is a final
+ * class. Main advantage of this serializer is that it does not write class name to the payload.
+ * NOTE: this serializer is used only with {@link CompatibleMode#SCHEMA_CONSISTENT} mode.
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+public class FinalFieldReplaceResolveSerializer extends ReplaceResolveSerializer {
+
+  public FinalFieldReplaceResolveSerializer(Fory fory, Class type) {
+    // the serializer does not write class info
+    // and does not set itself for the provided class
+    // see checks in ReplaceResolveSerializer constructor
+    super(fory, type, true, false);
+  }
+
+  @Override
+  protected void writeObject(
+      MemoryBuffer buffer, Object value, MethodInfoCache jdkMethodInfoCache) {
+    jdkMethodInfoCache.objectSerializer.write(buffer, value);
+  }
+
+  @Override
+  protected Object readObject(MemoryBuffer buffer) {
+    MethodInfoCache jdkMethodInfoCache = getMethodInfoCache(type);
+    Object o = jdkMethodInfoCache.objectSerializer.read(buffer);
+    ReplaceResolveInfo replaceResolveInfo = jdkMethodInfoCache.info;
+    if (replaceResolveInfo.readResolveMethod == null) {
+      return o;
+    }
+    return replaceResolveInfo.readResolve(o);
+  }
+}

java/fory-core/src/main/java/org/apache/fory/serializer/FinalFieldReplaceResolveSerializer.java

@@ -53,15 +53,15 @@ public class ReplaceResolveSerializer extends Serializer {
    */
   public static class ReplaceStub {}
 
-  private static final byte ORIGINAL = 0;
-  private static final byte REPLACED_NEW_TYPE = 1;
-  private static final byte REPLACED_SAME_TYPE = 2;
+  protected static final byte ORIGINAL = 0;
+  protected static final byte REPLACED_NEW_TYPE = 1;
+  protected static final byte REPLACED_SAME_TYPE = 2;
 
   // Extract Method Info to cache for graalvm build time lambda generation and avoid
   // generate function repeatedly too.
-  private static class ReplaceResolveInfo {
-    private final Method writeReplaceMethod;
-    private final Method readResolveMethod;
+  protected static class ReplaceResolveInfo {
+    protected final Method writeReplaceMethod;
+    protected final Method readResolveMethod;
     private final Function writeReplaceFunc;
     private final Function readResolveFunc;
 
@@ -162,10 +162,10 @@ protected ReplaceResolveInfo computeValue(Class<?> type) {
         }
       };
 
-  private static class MethodInfoCache {
-    private final ReplaceResolveInfo info;
+  protected static class MethodInfoCache {
+    protected final ReplaceResolveInfo info;
 
-    private Serializer objectSerializer;
+    protected Serializer objectSerializer;
 
     public MethodInfoCache(ReplaceResolveInfo info) {
       this.info = info;
@@ -210,26 +210,38 @@ private static Serializer createDataSerializer(
     return serializer;
   }
 
-  private final RefResolver refResolver;
-  private final ClassResolver classResolver;
-  private final MethodInfoCache jdkMethodInfoWriteCache;
-  private final ClassInfo writeClassInfo;
-  private final Map<Class<?>, MethodInfoCache> classClassInfoHolderMap = new HashMap<>();
+  protected final RefResolver refResolver;
+  protected final ClassResolver classResolver;
+  protected final MethodInfoCache jdkMethodInfoWriteCache;
+  protected final ClassInfo writeClassInfo;
+  protected final Map<Class<?>, MethodInfoCache> classClassInfoHolderMap = new HashMap<>();
 
   public ReplaceResolveSerializer(Fory fory, Class type) {
+    this(fory, type, false, true);
+  }
+
+  public ReplaceResolveSerializer(
+      Fory fory, Class type, boolean isFinalField, boolean setSerializer) {
     super(fory, type);
     refResolver = fory.getRefResolver();
     classResolver = fory.getClassResolver();
-    // `setSerializer` before `newJDKMethodInfoCache` since it query classinfo from `classResolver`,
-    // which create serializer in turn.
-    // ReplaceResolveSerializer is used as data serializer for ImmutableList/Map,
-    // which serializer is already set.
-    classResolver.setSerializerIfAbsent(type, this);
+    if (setSerializer) {
+      // `setSerializer` before `newJDKMethodInfoCache` since it query classinfo from
+      // `classResolver`,
+      // which create serializer in turn.
+      // ReplaceResolveSerializer is used as data serializer for ImmutableList/Map,
+      // which serializer is already set.
+      classResolver.setSerializerIfAbsent(type, this);
+    }
     if (type != ReplaceStub.class) {
       jdkMethodInfoWriteCache = newJDKMethodInfoCache(type, fory);
       classClassInfoHolderMap.put(type, jdkMethodInfoWriteCache);
-      // FIXME new classinfo may miss serializer update in async compilation mode.
-      writeClassInfo = classResolver.newClassInfo(type, this, ClassResolver.NO_CLASS_ID);
+      if (isFinalField) {
+        writeClassInfo = null;
+      } else {
+        // FIXME new classinfo may miss serializer update in async compilation mode.
+        writeClassInfo = classResolver.newClassInfo(type, this, ClassResolver.NO_CLASS_ID);
+      }
     } else {
       jdkMethodInfoWriteCache = null;
       writeClassInfo = null;
@@ -280,7 +292,8 @@ public void write(MemoryBuffer buffer, Object value) {
     }
   }
 
-  private void writeObject(MemoryBuffer buffer, Object value, MethodInfoCache jdkMethodInfoCache) {
+  protected void writeObject(
+      MemoryBuffer buffer, Object value, MethodInfoCache jdkMethodInfoCache) {
     classResolver.writeClassInternal(buffer, writeClassInfo);
     jdkMethodInfoCache.objectSerializer.write(buffer, value);
   }
@@ -319,7 +332,7 @@ public Object read(MemoryBuffer buffer) {
     }
   }
 
-  private Object readObject(MemoryBuffer buffer) {
+  protected Object readObject(MemoryBuffer buffer) {
     Class cls = classResolver.readClassInternal(buffer);
     MethodInfoCache jdkMethodInfoCache = getMethodInfoCache(cls);
     Object o = jdkMethodInfoCache.objectSerializer.read(buffer);
@@ -350,7 +363,7 @@ public Object copy(Object originObj) {
     return newObj;
   }
 
-  private MethodInfoCache getMethodInfoCache(Class<?> cls) {
+  protected MethodInfoCache getMethodInfoCache(Class<?> cls) {
     MethodInfoCache jdkMethodInfoCache = classClassInfoHolderMap.get(cls);
     if (jdkMethodInfoCache == null) {
       jdkMethodInfoCache = newJDKMethodInfoCache(cls, fory);