feat(java): support meta shared serialization for xlang in java

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

@@ -326,8 +326,7 @@ public MemoryBuffer serialize(MemoryBuffer buffer, Object obj, BufferCallback ca
       if (language == Language.JAVA) {
         write(buffer, obj);
       } else {
-        buffer.writeByte((byte) Language.JAVA.ordinal());
-        xwriteRef(buffer, obj);
+        xwrite(buffer, obj);
       }
       return buffer;
     } catch (StackOverflowError t) {
@@ -412,6 +411,21 @@ private void write(MemoryBuffer buffer, Object obj) {
     }
   }
 
+  private void xwrite(MemoryBuffer buffer, Object obj) {
+    buffer.writeByte((byte) Language.JAVA.ordinal());
+    int startOffset = buffer.writerIndex();
+    boolean shareMeta = config.isMetaShareEnabled();
+    if (shareMeta) {
+      buffer.writeInt32(-1); // preserve 4-byte for meta start offsets.
+    }
+    xwriteRef(buffer, obj);
+    MetaContext metaContext = serializationContext.getMetaContext();
+    if (shareMeta && metaContext != null && !metaContext.writingClassDefs.isEmpty()) {
+      buffer.putInt32(startOffset, buffer.writerIndex() - startOffset - 4);
+      classResolver.writeClassDefs(buffer);
+    }
+  }
+
   /** Serialize a nullable referencable object to <code>buffer</code>. */
   public void writeRef(MemoryBuffer buffer, Object obj) {
     if (!refResolver.writeRefOrNull(buffer, obj)) {
@@ -861,13 +875,13 @@ public Object deserialize(MemoryBuffer buffer, Iterable<MemoryBuffer> outOfBandB
             "outOfBandBuffers should be null when the serialized stream is "
                 + "produced with bufferCallback null.");
       }
+      if (shareMeta) {
+        readClassDefs(buffer);
+      }
       Object obj;
       if (isTargetXLang) {
         obj = xreadRef(buffer);
       } else {
-        if (shareMeta) {
-          readClassDefs(buffer);
-        }
         obj = readRef(buffer);
       }
       return obj;

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

@@ -76,7 +76,11 @@ public MetaSharedCodecBuilder(TypeRef<?> beanType, Fory fory, ClassDef classDef)
     this.classDef = classDef;
     Collection<Descriptor> descriptors =
         fory(
-            f -> MetaSharedSerializer.consolidateFields(f.getClassResolver(), beanClass, classDef));
+            f ->
+                MetaSharedSerializer.consolidateFields(
+                    f.isCrossLanguage() ? f.getXtypeResolver() : f.getClassResolver(),
+                    beanClass,
+                    classDef));
     DescriptorGrouper grouper = fory.getClassResolver().createDescriptorGrouper(descriptors, false);
     objectCodecOptimizer =
         new ObjectCodecOptimizer(beanClass, grouper, !fory.isBasicTypesRefIgnored(), ctx);

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

@@ -88,13 +88,15 @@ public ObjectCodecBuilder(Class<?> beanClass, Fory fory) {
     super(TypeRef.of(beanClass), fory, Generated.GeneratedObjectSerializer.class);
     Collection<Descriptor> descriptors;
     boolean shareMeta = fory.getConfig().isMetaShareEnabled();
+    boolean xlang = fory.isCrossLanguage();
     if (shareMeta) {
       descriptors =
           fory(
               f ->
                   f.getClassResolver()
                       .getClassDef(beanClass, true)
-                      .getDescriptors(f.getClassResolver(), beanClass));
+                      .getDescriptors(
+                          xlang ? f.getXtypeResolver() : f.getClassResolver(), beanClass));
     } else {
       descriptors = fory.getClassResolver().getFieldDescriptors(beanClass, true);
     }

java/fory-core/src/main/java/org/apache/fory/config/ForyBuilder.java

@@ -95,6 +95,9 @@ public ForyBuilder() {}
    */
   public ForyBuilder withLanguage(Language language) {
     this.language = language;
+    if (language != Language.JAVA) {
+      codeGenEnabled = false;
+    }
     return this;
   }
 

java/fory-core/src/main/java/org/apache/fory/meta/ClassDef.java

@@ -239,9 +239,10 @@ public static ClassDef readClassDef(Fory fory, MemoryBuffer buffer, long header)
    *
    * @param cls class load in current process.
    */
-  public List<Descriptor> getDescriptors(ClassResolver resolver, Class<?> cls) {
+  public List<Descriptor> getDescriptors(TypeResolver resolver, Class<?> cls) {
     if (descriptors == null) {
-      SortedMap<Member, Descriptor> allDescriptorsMap = resolver.getAllDescriptorsMap(cls, true);
+      SortedMap<Member, Descriptor> allDescriptorsMap =
+          resolver.getFory().getClassResolver().getAllDescriptorsMap(cls, true);
       Map<String, Descriptor> descriptorsMap = new HashMap<>();
       for (Map.Entry<Member, Descriptor> e : allDescriptorsMap.entrySet()) {
         if (descriptorsMap.put(
@@ -333,9 +334,16 @@ public FieldType getFieldType() {
      * null. Don't invoke this method if class does have <code>fieldName</code> field. In such case,
      * reflection should be used to get the descriptor.
      */
-    Descriptor toDescriptor(ClassResolver classResolver, Descriptor descriptor) {
+    Descriptor toDescriptor(TypeResolver resolver, Descriptor descriptor) {
       TypeRef<?> declared = descriptor != null ? descriptor.getTypeRef() : null;
-      TypeRef<?> typeRef = fieldType.toTypeToken(classResolver, declared);
+      TypeRef<?> typeRef = fieldType.toTypeToken(resolver, declared);
+      if (descriptor != null) {
+        if (typeRef.equals(declared)) {
+          return descriptor;
+        } else {
+          descriptor.copyWithTypeName(typeRef.getType().getTypeName());
+        }
+      }
       // This field doesn't exist in peer class, so any legal modifier will be OK.
       int stubModifiers = ReflectionUtils.getField(getClass(), "fieldName").getModifiers();
       return new Descriptor(typeRef, fieldName, stubModifiers, definedClass);
@@ -407,7 +415,7 @@ public boolean nullable() {
      *
      * @see FinalObjectTypeStub
      */
-    public abstract TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared);
+    public abstract TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared);
 
     @Override
     public boolean equals(Object o) {
@@ -555,10 +563,6 @@ public static FieldType xread(
               ClassInfo classInfo = resolver.getXtypeInfo(xtypeId);
               Preconditions.checkNotNull(classInfo);
               Class<?> cls = classInfo.getCls();
-              if (Types.isPrimitiveArray(xtypeId)) {
-                FieldType type = buildFieldType(resolver, resolver.buildGenericType(cls));
-                return new ArrayFieldType(xtypeId, true, nullable, trackingRef, type, 1);
-              }
               return new RegisteredFieldType(
                   resolver.isMonomorphic(cls), nullable, trackingRef, xtypeId);
             } else {
@@ -584,8 +588,21 @@ public short getClassId() {
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
-      Class<?> cls = classResolver.getRegisteredClass(classId);
+    public TypeRef<?> toTypeToken(TypeResolver resolver, TypeRef<?> declared) {
+      Class<?> cls;
+      if (resolver instanceof XtypeResolver) {
+        cls = ((XtypeResolver) resolver).getXtypeInfo(classId).getCls();
+        if (Types.isPrimitiveType(classId)) {
+          if (declared.isPrimitive() && !nullable) {
+            cls = TypeUtils.unwrap(cls);
+          }
+          if (nullable && !declared.isPrimitive()) {
+            cls = TypeUtils.wrap(cls);
+          }
+        }
+      } else {
+        cls = ((ClassResolver) resolver).getRegisteredClass(classId);
+      }
       if (cls == null) {
         LOG.warn("Class {} not registered, take it as Struct type for deserialization.", classId);
         cls = NonexistentClass.NonexistentMetaShared.class;
@@ -652,7 +669,7 @@ public FieldType getElementType() {
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
+    public TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared) {
       // TODO support preserve element TypeExtMeta
       TypeRef<? extends Collection<?>> collectionTypeRef =
           collectionOf(
@@ -749,7 +766,7 @@ public FieldType getValueType() {
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
+    public TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared) {
       // TODO support preserve element TypeExtMeta, it will be lost when building other TypeRef
       return mapOf(
           keyType.toTypeToken(classResolver, declared),
@@ -798,7 +815,7 @@ private EnumFieldType(boolean nullable, int xtypeId) {
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
+    public TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared) {
       return TypeRef.of(NonexistentClass.NonexistentEnum.class);
     }
   }
@@ -825,7 +842,7 @@ public ArrayFieldType(
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
+    public TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared) {
       TypeRef<?> componentTypeRef = componentType.toTypeToken(classResolver, declared);
       Class<?> componentRawType = componentTypeRef.getRawType();
       if (NonexistentClass.class.isAssignableFrom(componentRawType)) {
@@ -893,7 +910,7 @@ public ObjectFieldType(int xtypeId, boolean isFinal, boolean nullable, boolean t
     }
 
     @Override
-    public TypeRef<?> toTypeToken(ClassResolver classResolver, TypeRef<?> declared) {
+    public TypeRef<?> toTypeToken(TypeResolver classResolver, TypeRef<?> declared) {
       return isMonomorphic()
           ? TypeRef.of(FinalObjectTypeStub.class, new TypeExtMeta(nullable, trackingRef))
           : TypeRef.of(Object.class, new TypeExtMeta(nullable, trackingRef));

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

@@ -36,6 +36,7 @@
 import org.apache.fory.resolver.ClassInfoHolder;
 import org.apache.fory.resolver.ClassResolver;
 import org.apache.fory.resolver.RefResolver;
+import org.apache.fory.resolver.TypeResolver;
 import org.apache.fory.type.Descriptor;
 import org.apache.fory.type.DescriptorGrouper;
 import org.apache.fory.type.Generics;
@@ -84,7 +85,10 @@ public MetaSharedSerializer(Fory fory, Class<T> type, ClassDef classDef) {
         "Class version check should be disabled when compatible mode is enabled.");
     Preconditions.checkArgument(
         fory.getConfig().isMetaShareEnabled(), "Meta share must be enabled.");
-    Collection<Descriptor> descriptors = consolidateFields(this.classResolver, type, classDef);
+    boolean xlang = fory.isCrossLanguage();
+    Collection<Descriptor> descriptors =
+        consolidateFields(
+            xlang ? fory.getXtypeResolver() : fory.getClassResolver(), type, classDef);
     DescriptorGrouper descriptorGrouper = classResolver.createDescriptorGrouper(descriptors, false);
     // d.getField() may be null if not exists in this class when meta share enabled.
     Tuple3<
@@ -118,6 +122,11 @@ public void write(MemoryBuffer buffer, T value) {
     serializer.write(buffer, value);
   }
 
+  @Override
+  public void xwrite(MemoryBuffer buffer, T value) {
+    write(buffer, value);
+  }
+
   @Override
   public T read(MemoryBuffer buffer) {
     if (isRecord) {
@@ -192,6 +201,11 @@ public T read(MemoryBuffer buffer) {
     return obj;
   }
 
+  @Override
+  public T xread(MemoryBuffer buffer) {
+    return read(buffer);
+  }
+
   private void readFields(MemoryBuffer buffer, Object[] fields) {
     int counter = 0;
     Fory fory = this.fory;
@@ -280,7 +294,7 @@ static boolean skipPrimitiveFieldValueFailed(Fory fory, short classId, MemoryBuf
   }
 
   public static Collection<Descriptor> consolidateFields(
-      ClassResolver classResolver, Class<?> cls, ClassDef classDef) {
-    return classDef.getDescriptors(classResolver, cls);
+      TypeResolver resolver, Class<?> cls, ClassDef classDef) {
+    return classDef.getDescriptors(resolver, cls);
   }
 }

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

@@ -19,6 +19,8 @@
 
 package org.apache.fory.serializer;
 
+import static org.apache.fory.serializer.SerializationUtils.getTypeResolver;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -36,6 +38,7 @@
 import org.apache.fory.resolver.MetaContext;
 import org.apache.fory.resolver.MetaStringResolver;
 import org.apache.fory.resolver.RefResolver;
+import org.apache.fory.resolver.TypeResolver;
 import org.apache.fory.serializer.NonexistentClass.NonexistentEnum;
 import org.apache.fory.type.Descriptor;
 import org.apache.fory.type.DescriptorGrouper;
@@ -155,11 +158,12 @@ public void write(MemoryBuffer buffer, Object v) {
 
     private ClassFieldsInfo getClassFieldsInfo(ClassDef classDef) {
       ClassFieldsInfo fieldsInfo = fieldsInfoMap.get(classDef.getId());
+      TypeResolver resolver = getTypeResolver(fory);
       if (fieldsInfo == null) {
         // Use `NonexistentSkipClass` since it doesn't have any field.
         Collection<Descriptor> descriptors =
             MetaSharedSerializer.consolidateFields(
-                fory.getClassResolver(), NonexistentClass.NonexistentSkip.class, classDef);
+                resolver, NonexistentClass.NonexistentSkip.class, classDef);
         DescriptorGrouper descriptorGrouper =
             fory.getClassResolver().createDescriptorGrouper(descriptors, false);
         Tuple3<

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

@@ -96,7 +96,7 @@ public ObjectSerializer(Fory fory, Class<T> cls, boolean resolveParent) {
     boolean shareMeta = fory.getConfig().isMetaShareEnabled();
     if (shareMeta) {
       ClassDef classDef = classResolver.getClassDef(cls, resolveParent);
-      descriptors = classDef.getDescriptors(classResolver, cls);
+      descriptors = classDef.getDescriptors(typeResolver, cls);
     } else {
       descriptors = fory.getClassResolver().getFieldDescriptors(cls, resolveParent);
     }

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

@@ -26,7 +26,7 @@
 
 @Internal
 class SerializationUtils {
-  static TypeResolver getTypeResolver(Fory fory) {
+  public static TypeResolver getTypeResolver(Fory fory) {
     return fory.isCrossLanguage() ? fory.getXtypeResolver() : fory.getClassResolver();
   }
 

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

@@ -67,7 +67,8 @@ public void xwrite(MemoryBuffer buffer, T value) {
   }
 
   public T xread(MemoryBuffer buffer) {
-    throw new UnsupportedOperationException();
+    throw new UnsupportedOperationException(
+        getClass() + " doesn't support xlang serialization for " + type);
   }
 
   public Serializer(Fory fory, Class<T> type) {