feat(java): Add ForyFeature for GraalVM Native Image

integration_tests/graalvm_tests/pom.xml

@@ -59,6 +59,11 @@
       <artifactId>fory-core</artifactId>
       <version>${project.version}</version>
     </dependency>
+    <dependency>
+      <groupId>org.apache.fory</groupId>
+      <artifactId>fory-graalvm-feature</artifactId>
+      <version>${project.version}</version>
+    </dependency>
   </dependencies>
 
   <build>

integration_tests/graalvm_tests/src/main/java/org/apache/fory/graalvm/FeatureTestExample.java

@@ -0,0 +1,125 @@
+/*
+ * 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.graalvm;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import org.apache.fory.Fory;
+import org.apache.fory.config.Language;
+
+public class FeatureTestExample {
+
+  // Test class with private constructor (problematic for creation)
+  public static class ProblematicClass {
+    private String value;
+
+    private ProblematicClass() {
+      // Private constructor
+    }
+
+    public ProblematicClass(String value) {
+      this.value = value;
+    }
+
+    public String getValue() {
+      return value;
+    }
+
+    public void setValue(String value) {
+      this.value = value;
+    }
+  }
+
+  // Test interface for proxy
+  public interface TestInterface {
+    String getValue();
+
+    void setValue(String value);
+  }
+
+  // Simple invocation handler
+  public static class TestInvocationHandler implements InvocationHandler {
+    private String value;
+
+    public TestInvocationHandler(String value) {
+      this.value = value;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      if ("getValue".equals(method.getName())) {
+        return value;
+      } else if ("setValue".equals(method.getName())) {
+        value = (String) args[0];
+        return null;
+      }
+      return null;
+    }
+  }
+
+  public static void main(String[] args) {
+    System.out.println("Testing Fory GraalVM Feature...");
+
+    Fory fory =
+        Fory.builder().withLanguage(Language.JAVA).withRefTracking(true).withCodegen(false).build();
+
+    fory.register(ProblematicClass.class);
+    fory.register(TestInvocationHandler.class);
+
+    // Register proxy interface
+    Fory.addProxyInterface(TestInterface.class);
+
+    try {
+      // Test 1: Serialize/deserialize problematic class
+      ProblematicClass original = new ProblematicClass("test-value");
+      byte[] serialized = fory.serialize(original);
+      ProblematicClass deserialized = (ProblematicClass) fory.deserialize(serialized);
+
+      if (!"test-value".equals(deserialized.getValue())) {
+        throw new RuntimeException("Problematic class test failed");
+      }
+      System.out.println("✓ Problematic class serialization test passed");
+
+      // Test 2: Serialize/deserialize proxy object
+      TestInterface proxy =
+          (TestInterface)
+              Proxy.newProxyInstance(
+                  TestInterface.class.getClassLoader(),
+                  new Class[] {TestInterface.class},
+                  new TestInvocationHandler("proxy-value"));
+
+      byte[] proxySerialised = fory.serialize(proxy);
+      TestInterface deserializedProxy = (TestInterface) fory.deserialize(proxySerialised);
+
+      if (!"proxy-value".equals(deserializedProxy.getValue())) {
+        throw new RuntimeException("Proxy test failed");
+      }
+      System.out.println("✓ Proxy serialization test passed");
+
+      System.out.println("All GraalVM Feature tests passed!");
+
+    } catch (Exception e) {
+      System.err.println("GraalVM Feature test failed: " + e.getMessage());
+      e.printStackTrace();
+      System.exit(1);
+    }
+  }
+}

integration_tests/graalvm_tests/src/main/java/org/apache/fory/graalvm/Main.java

@@ -40,5 +40,6 @@ public static void main(String[] args) throws Throwable {
     Benchmark.main(args);
     CollectionExample.main(args);
     ArrayExample.main(args);
+    FeatureTestExample.main(args);
   }
 }

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

@@ -27,6 +27,7 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import javax.annotation.concurrent.NotThreadSafe;
@@ -177,11 +178,13 @@ public Fory(ForyBuilder builder, ClassLoader classLoader) {
   @Override
   public void register(Class<?> cls) {
     _getTypeResolver().register(cls);
+    TypeResolver.registerClassForGraalvm(cls, config.getConfigHash());
   }
 
   @Override
   public void register(Class<?> cls, int id) {
     _getTypeResolver().register(cls, id);
+    TypeResolver.registerClassForGraalvm(cls, config.getConfigHash());
   }
 
   @Deprecated
@@ -213,6 +216,7 @@ public void register(Class<?> cls, String typeName) {
 
   public void register(Class<?> cls, String namespace, String typeName) {
     _getTypeResolver().register(cls, namespace, typeName);
+    TypeResolver.registerClassForGraalvm(cls, config.getConfigHash());
   }
 
   @Override
@@ -1764,4 +1768,47 @@ public MetaCompressor getMetaCompressor() {
   public static ForyBuilder builder() {
     return new ForyBuilder();
   }
+
+  /**
+   * Get all registered classes for GraalVM native image compilation. This is a convenience method
+   * that delegates to {@link TypeResolver#getAllRegisteredClasses()}.
+   *
+   * @return unmodifiable set of all registered classes
+   */
+  public static Set<Class<?>> getRegisteredClasses() {
+    return TypeResolver.getAllRegisteredClasses();
+  }
+
+  /**
+   * Get all registered proxy interfaces for GraalVM native image compilation. This is a convenience
+   * method that delegates to {@link TypeResolver#getAllProxyInterfaces()}.
+   *
+   * @return unmodifiable set of all registered proxy interfaces
+   */
+  public static Set<Class<?>> getProxyInterfaces() {
+    return TypeResolver.getAllProxyInterfaces();
+  }
+
+  /**
+   * Register a proxy interface for GraalVM native image compilation. This is a convenience method
+   * that delegates to {@link TypeResolver#registerProxyInterfaceForGraalvm}.
+   *
+   * <p>Note: This registers the proxy interface globally across all Fory configurations. If you
+   * need per-configuration registration, use the TypeResolver methods directly.
+   *
+   * @param proxyInterface the proxy interface to register
+   * @throws NullPointerException if proxyInterface is null
+   * @throws IllegalArgumentException if proxyInterface is not an interface
+   */
+  public static void addProxyInterface(Class<?> proxyInterface) {
+    TypeResolver.registerProxyInterfaceForGraalvm(proxyInterface, 0);
+  }
+
+  /**
+   * Clear all GraalVM registrations. This is primarily for testing purposes. This is a convenience
+   * method that delegates to {@link TypeResolver#clearGraalvmRegistrations()}.
+   */
+  public static void clearRegistrations() {
+    TypeResolver.clearGraalvmRegistrations();
+  }
 }

java/fory-core/src/main/java/org/apache/fory/reflect/ObjectCreators.java

@@ -77,16 +77,47 @@ public static <T> ObjectCreator<T> getObjectCreator(Class<T> type) {
     return (ObjectCreator<T>) cache.get(type, () -> creategetObjectCreator(type));
   }
 
+  /**
+   * Checks if a class is problematic for object creation and requires special handling in GraalVM.
+   *
+   * <p>A class is considered problematic if it lacks a public no-arg constructor and would
+   * typically require ReflectionFactory or unsafe allocation for instantiation.
+   *
+   * @param type the class to check
+   * @return true if the class is problematic for creation, false otherwise
+   */
+  public static boolean isProblematicForCreation(Class<?> type) {
+    if (type.isInterface()
+        || java.lang.reflect.Modifier.isAbstract(type.getModifiers())
+        || type.isArray()
+        || type.isEnum()
+        || type.isAnonymousClass()
+        || type.isLocalClass()
+        || RecordUtils.isRecord(type)) {
+      return false;
+    }
+    Constructor<?>[] constructors = type.getDeclaredConstructors();
+    if (constructors.length == 0) {
+      return true;
+    }
+    for (Constructor<?> constructor : constructors) {
+      if (constructor.getParameterCount() == 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   private static <T> ObjectCreator<T> creategetObjectCreator(Class<T> type) {
     if (RecordUtils.isRecord(type)) {
       return new RecordObjectCreator<>(type);
     }
     Constructor<T> noArgConstructor = ReflectionUtils.getNoArgConstructor(type);
-    if (GraalvmSupport.IN_GRAALVM_NATIVE_IMAGE && Platform.JAVA_VERSION >= 25) {
+    if (GraalvmSupport.IN_GRAALVM_NATIVE_IMAGE) {
       if (noArgConstructor != null) {
         return new DeclaredNoArgCtrObjectCreator<>(type);
       } else {
-        return new ParentNoArgCtrObjectCreator<>(type);
+        return new UnsafeObjectCreator<>(type);
       }
     }
     if (noArgConstructor == null) {

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

@@ -589,11 +589,15 @@ static class GraalvmClassRegistry {
     final List<ClassResolver> resolvers;
     final Map<Class<?>, Class<? extends Serializer>> serializerClassMap;
     final Map<Long, Class<? extends Serializer>> deserializerClassMap;
+    final Set<Class<?>> registeredClasses;
+    final Set<Class<?>> proxyInterfaces;
 
     private GraalvmClassRegistry() {
       resolvers = Collections.synchronizedList(new ArrayList<>());
       serializerClassMap = new ConcurrentHashMap<>();
       deserializerClassMap = new ConcurrentHashMap<>();
+      registeredClasses = ConcurrentHashMap.newKeySet();
+      proxyInterfaces = ConcurrentHashMap.newKeySet();
     }
   }
 
@@ -670,6 +674,72 @@ public final MetaStringResolver getMetaStringResolver() {
     return metaStringResolver;
   }
 
+  /**
+   * Get all registered classes across all GraalVM registries for native image compilation.
+   *
+   * @return unmodifiable set of all registered classes
+   */
+  public static Set<Class<?>> getAllRegisteredClasses() {
+    Set<Class<?>> allClasses = ConcurrentHashMap.newKeySet();
+    for (GraalvmClassRegistry registry : GRAALVM_REGISTRY.values()) {
+      allClasses.addAll(registry.registeredClasses);
+    }
+    return Collections.unmodifiableSet(allClasses);
+  }
+
+  /**
+   * Get all registered proxy interfaces across all GraalVM registries for native image compilation.
+   *
+   * @return unmodifiable set of all registered proxy interfaces
+   */
+  public static Set<Class<?>> getAllProxyInterfaces() {
+    Set<Class<?>> allInterfaces = ConcurrentHashMap.newKeySet();
+    for (GraalvmClassRegistry registry : GRAALVM_REGISTRY.values()) {
+      allInterfaces.addAll(registry.proxyInterfaces);
+    }
+    return Collections.unmodifiableSet(allInterfaces);
+  }
+
+  /**
+   * Register a class in the GraalVM registry for native image compilation. This should be called
+   * from {@link org.apache.fory.Fory#register} methods.
+   *
+   * @param cls the class to register
+   * @param configHash the configuration hash for the Fory instance
+   */
+  public static void registerClassForGraalvm(Class<?> cls, int configHash) {
+    GraalvmClassRegistry registry =
+        GRAALVM_REGISTRY.computeIfAbsent(configHash, k -> new GraalvmClassRegistry());
+    registry.registeredClasses.add(cls);
+  }
+
+  /**
+   * Register a proxy interface in the GraalVM registry for native image compilation.
+   *
+   * @param proxyInterface the proxy interface to register
+   * @param configHash the configuration hash for the Fory instance
+   */
+  public static void registerProxyInterfaceForGraalvm(Class<?> proxyInterface, int configHash) {
+    if (proxyInterface == null) {
+      throw new NullPointerException("Proxy interface must not be null");
+    }
+    if (!proxyInterface.isInterface()) {
+      throw new IllegalArgumentException(
+          "Proxy type must be an interface: " + proxyInterface.getName());
+    }
+    GraalvmClassRegistry registry =
+        GRAALVM_REGISTRY.computeIfAbsent(configHash, k -> new GraalvmClassRegistry());
+    registry.proxyInterfaces.add(proxyInterface);
+  }
+
+  /** Clear all GraalVM registrations. This is primarily for testing purposes. */
+  public static void clearGraalvmRegistrations() {
+    for (GraalvmClassRegistry registry : GRAALVM_REGISTRY.values()) {
+      registry.registeredClasses.clear();
+      registry.proxyInterfaces.clear();
+    }
+  }
+
   static class ExtRegistry {
     // Here we set it to 1 because `NO_CLASS_ID` is 0 to avoid calculating it again in
     // `register(Class<?> cls)`.