createBiFunction

Author: wenshao

core-jdk11/src/main/java/com/alibaba/fastjson2/introspect/PropertyAccessorFactoryMethodHandle.java

@@ -140,6 +140,24 @@ public DoubleFunction createDoubleFunction(Constructor constructor) {
         }
     }
 
+    @Override
+    public BiFunction createBiFunction(Constructor constructor) {
+        try {
+            MethodHandles.Lookup lookup = lookup(constructor.getDeclaringClass());
+            MethodHandle methodHandle = lookup.unreflectConstructor(constructor);
+            return (arg1, arg2) -> {
+                try {
+                    return methodHandle.invoke(arg1, arg2);
+                } catch (Throwable e) {
+                    throw new RuntimeException(e);
+                }
+            };
+        } catch (Throwable ignored) {
+            // ignore
+            return super.createBiFunction(constructor);
+        }
+    }
+
     /**
      * Creates a property accessor for the given field using MethodHandle-based implementation.
      * Different accessor implementations are created based on the field type to provide

core-jdk11/src/test/java/com/alibaba/fastjson2/introspect/PropertyAccessorFactoryVarHandleTest.java

@@ -9,6 +9,7 @@
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.function.BiFunction;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -58,6 +59,11 @@ public TestClass(double doubleField) {
         public TestClass(Byte byteObjField) {
             this.byteObjField = byteObjField;
         }
+
+        public TestClass(Character charObjField, Short shortObjField) {
+            this.charObjField = charObjField;
+            this.shortObjField = shortObjField;
+        }
     }
 
     public static java.util.Map<Class<?>, Field> fieldMap = new java.util.HashMap<>();
@@ -123,6 +129,12 @@ public void allocate(PropertyAccessorFactory factory) throws Exception {
         assertEquals(1001, ((TestClass) factory.createIntFunction(TestClass.class.getDeclaredConstructor(int.class)).apply(1001)).intField);
         assertEquals(1002L, ((TestClass) factory.createLongFunction(TestClass.class.getDeclaredConstructor(long.class)).apply(1002L)).longField);
         assertEquals(123.45D, ((TestClass) factory.createDoubleFunction(TestClass.class.getDeclaredConstructor(double.class)).apply(123.45D)).doubleField);
+        {
+            BiFunction biFunction = factory.createBiFunction(TestClass.class.getDeclaredConstructor(Character.class, Short.class));
+            TestClass x = (TestClass) biFunction.apply('X', (short) 100);
+            assertEquals('X', x.charObjField);
+            assertEquals((short) 100, x.shortObjField);
+        }
     }
 
     @ParameterizedTest

core/src/main/java/com/alibaba/fastjson2/introspect/PropertyAccessorFactory.java

@@ -80,6 +80,15 @@ public DoubleFunction createDoubleFunction(Constructor constructor) {
         return new ConstructorDoubleFunction(constructor);
     }
 
+    /**
+     * Creates a BiFunction that can instantiate objects using the given constructor.
+     * @param constructor the constructor to use for object instantiation
+     * @return a BiFunction that creates new instances using the provided constructor
+     */
+    public BiFunction createBiFunction(Constructor constructor) {
+        return new ConstructorBiFunction(constructor);
+    }
+
     /**
      * Base class for Constructor-based Function implementations.
      * Handles constructor accessibility and instantiation errors.
@@ -244,6 +253,32 @@ public Object apply(double arg) {
         }
     }
 
+    /**
+     * A Supplier implementation that uses reflection to create new instances
+     * of a class via its constructor. This class handles constructor accessibility
+     * and instantiation errors appropriately.
+     */
+    static final class ConstructorBiFunction extends ConstructorFunctionBase implements BiFunction {
+        /**
+         * Creates a ConstructorBiFunction for the given constructor.
+         * Automatically makes the constructor accessible.
+         *
+         * @param constructor the constructor to use for instantiation
+         */
+        public ConstructorBiFunction(Constructor constructor) {
+            super(constructor);
+        }
+
+        @Override
+        public Object apply(Object t, Object u) {
+            try {
+                return constructor.newInstance(t, u);
+            } catch (Exception e) {
+                throw errorOnNewInstance(e);
+            }
+        }
+    }
+
     /**
      * Creates a property accessor for the specified field.
      * This method analyzes the field type and returns an appropriate

core/src/main/java/com/alibaba/fastjson2/introspect/PropertyAccessorFactoryLambda.java

@@ -159,6 +159,32 @@ public DoubleFunction createDoubleFunction(Constructor constructor) {
         }
     }
 
+    @Override
+    public BiFunction createBiFunction(Constructor constructor) {
+        try {
+            Class<?> declaringClass = constructor.getDeclaringClass();
+            MethodHandles.Lookup lookup = JDKUtils.trustedLookup(declaringClass);
+            Class<?>[] parameterTypes = constructor.getParameterTypes();
+            Class<?> param0 = parameterTypes[0];
+            Class<?> param1 = parameterTypes[1];
+            MethodHandle methodHandle = lookup.findConstructor(
+                    declaringClass,
+                    MethodType.methodType(void.class, param0, param1)
+            );
+            CallSite callSite = LambdaMetafactory.metafactory(
+                    lookup,
+                    "apply",
+                    METHOD_TYPE_BI_FUNCTION,
+                    METHOD_TYPE_OBJECT_OBJECT_OBJECT,
+                    methodHandle,
+                    MethodType.methodType(declaringClass, box(param0), box(param1))
+            );
+            return (BiFunction) callSite.getTarget().invokeExact();
+        } catch (Throwable ignored) {
+            return super.createBiFunction(constructor);
+        }
+    }
+
     static Class<?> box(Class cls) {
         if (cls == int.class) {
             return Integer.class;