perf(java): optimize java json serde performace

java/fory-core/src/main/java/org/apache/fory/codegen/Expression.java

@@ -1597,7 +1597,7 @@ public String toString() {
     }
   }
 
-  class NewArray extends AbstractExpression {
+  class NewArray extends Inlineable {
     private TypeRef<?> type;
     private Expression[] elements;
 
@@ -1662,59 +1662,35 @@ public ExprCode doGenCode(CodegenContext ctx) {
       Class<?> rawType = getRawType(type);
       String arrayType = getArrayType(rawType);
       String value = ctx.newName("arr");
+      String arrayValue;
       if (dims != null) {
         // multi-dimension array
         ExprCode dimsExprCode = dims.genCode(ctx);
         if (StringUtils.isNotBlank(dimsExprCode.code())) {
           codeBuilder.append(dimsExprCode.code()).append('\n');
         }
-        // "${arrType} ${value} = new ${elementType}[$?][$?]...
-        codeBuilder
-            .append(arrayType)
-            .append(' ')
-            .append(value)
-            .append(" = new ")
-            .append(ctx.type(elemType));
+        // "new ${elementType}[$?][$?]..."
+        StringBuilder arrayValueBuilder = new StringBuilder("new ").append(ctx.type(elemType));
         for (int i = 0; i < numDimensions; i++) {
           // dims is dimensions array, which store size of per dim.
           String idim = StringUtils.format("${dims}[${i}]", "dims", dimsExprCode.value(), "i", i);
-          codeBuilder.append('[').append(idim).append("]");
+          arrayValueBuilder.append('[').append(idim).append("]");
         }
-        codeBuilder.append(';');
+        arrayValue = arrayValueBuilder.toString();
       } else if (dim != null) {
         ExprCode dimExprCode = dim.genCode(ctx);
         if (StringUtils.isNotBlank(dimExprCode.code())) {
           codeBuilder.append(dimExprCode.code()).append('\n');
         }
+        StringBuilder arrayValueBuilder = new StringBuilder("new ").append(ctx.type(elemType));
+        arrayValueBuilder.append('[').append(dimExprCode.value()).append(']');
         if (numDimensions > 1) {
           // multi-dimension array
-          // "${arrType} ${value} = new ${elementType}[$?][][][]...
-          codeBuilder
-              .append(arrayType)
-              .append(' ')
-              .append(value)
-              .append(" = new ")
-              .append(ctx.type(elemType));
-          codeBuilder.append('[').append(dimExprCode.value()).append(']');
           for (int i = 1; i < numDimensions; i++) {
-            codeBuilder.append('[').append("]");
+            arrayValueBuilder.append('[').append("]");
           }
-          codeBuilder.append(';');
-        } else {
-          // one-dimension array
-          String code =
-              StringUtils.format(
-                  "${type} ${value} = new ${elemType}[${dim}];",
-                  "type",
-                  arrayType,
-                  "elemType",
-                  ctx.type(elemType),
-                  "value",
-                  value,
-                  "dim",
-                  dimExprCode.value());
-          codeBuilder.append(code);
         }
+        arrayValue = arrayValueBuilder.toString();
       } else {
         // create array with init value
         int len = elements.length;
@@ -1733,18 +1709,22 @@ public ExprCode doGenCode(CodegenContext ctx) {
           }
         }
 
-        String code =
+        arrayValue =
             StringUtils.format(
-                "${type} ${value} = new ${type} {${args}};",
-                "type",
-                arrayType,
-                "value",
-                value,
-                "args",
-                argsBuilder.toString());
-        codeBuilder.append(code);
+                "new ${type} {${args}}", "type", arrayType, "args", argsBuilder.toString());
       }
 
+      if (inlineCall) {
+        String code = StringUtils.isBlank(codeBuilder) ? null : codeBuilder.toString();
+        return new ExprCode(code, null, Code.variable(rawType, arrayValue));
+      }
+      codeBuilder
+          .append(arrayType)
+          .append(' ')
+          .append(value)
+          .append(" = ")
+          .append(arrayValue)
+          .append(';');
       return new ExprCode(codeBuilder.toString(), null, Code.variable(rawType, value));
     }
   }

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

@@ -442,6 +442,38 @@ public static byte[] getStringBytes(String value) {
     return (byte[]) getStringValue(value);
   }
 
+  @Internal
+  public static void copyStringCharsToBytes(String value, byte[] target) {
+    int length = value.length();
+    if (length > (Integer.MAX_VALUE >>> 1)) {
+      throw new IllegalArgumentException("String is too large");
+    }
+    int numBytes = length << 1;
+    if (target.length < numBytes) {
+      throw new IllegalArgumentException("Target byte array is too small");
+    }
+    if (STRING_VALUE_FIELD_IS_CHARS) {
+      char[] chars = (char[]) getStringValue(value);
+      int offset = STRING_HAS_COUNT_OFFSET ? getStringOffset(value) : 0;
+      PlatformStringUtils.copyCharsToBytes(chars, offset, target, 0, numBytes);
+      return;
+    }
+    int byteIndex = 0;
+    if (NativeByteOrder.IS_LITTLE_ENDIAN) {
+      for (int i = 0; i < length; i++) {
+        char c = value.charAt(i);
+        target[byteIndex++] = (byte) c;
+        target[byteIndex++] = (byte) (c >>> 8);
+      }
+    } else {
+      for (int i = 0; i < length; i++) {
+        char c = value.charAt(i);
+        target[byteIndex++] = (byte) (c >>> 8);
+        target[byteIndex++] = (byte) c;
+      }
+    }
+  }
+
   @Internal
   public static byte getStringCoder(String value) {
     return PlatformStringUtils.getStringCoder(value);
@@ -969,6 +1001,11 @@ public static String newLatin1StringZeroCopy(byte[] data) {
     return newBytesStringZeroCopy(LATIN1, data);
   }
 
+  @Internal
+  public static String newUtf16StringZeroCopy(byte[] data) {
+    return newBytesStringZeroCopy(UTF16, data);
+  }
+
   private static String newBytesStringSlow(byte coder, byte[] data) {
     if (coder == LATIN1) {
       return new String(data, StandardCharsets.ISO_8859_1);

java/fory-json/src/main/java/org/apache/fory/json/ForyJson.java

@@ -19,14 +19,15 @@
 
 package org.apache.fory.json;
 
+import java.io.OutputStream;
 import java.lang.reflect.Type;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.atomic.AtomicReferenceArray;
 import org.apache.fory.json.codec.GeneratedObjectCodec;
 import org.apache.fory.json.reader.Latin1JsonReader;
 import org.apache.fory.json.reader.Utf16JsonReader;
 import org.apache.fory.json.reader.Utf8JsonReader;
-import org.apache.fory.json.resolver.CodecRegistry;
 import org.apache.fory.json.resolver.JsonSharedRegistry;
 import org.apache.fory.json.resolver.JsonTypeInfo;
 import org.apache.fory.json.resolver.JsonTypeResolver;
@@ -39,8 +40,10 @@
 public final class ForyJson {
   private static final int PREFERRED_SLOT_RETRIES = 2;
   private static final int INITIAL_BUFFER_SIZE = 8192;
+  private static final int RETAINED_UTF16_BYTES = 64 * 1024;
   private static final int PRIMARY_SLOT = -1;
   private static final int TEMPORARY_SLOT = -2;
+  private static final byte[] EMPTY_BYTES = new byte[0];
   private static final int DEFAULT_POOL_SIZE =
       Math.max(1, Runtime.getRuntime().availableProcessors() * 4);
 
@@ -54,11 +57,10 @@ public final class ForyJson {
   private final AtomicReference<PooledState> primarySlot;
   private final AtomicReferenceArray<PooledState> slots;
 
-  ForyJson(
-      boolean writeNullFields, boolean codegenEnabled, int maxDepth, CodecRegistry codecRegistry) {
-    this.writeNullFields = writeNullFields;
-    this.maxDepth = maxDepth;
-    sharedRegistry = new JsonSharedRegistry(codegenEnabled, writeNullFields, codecRegistry);
+  ForyJson(JsonConfig config) {
+    this.writeNullFields = config.writeNullFields();
+    this.maxDepth = config.maxDepth();
+    sharedRegistry = new JsonSharedRegistry(config);
     poolSize = DEFAULT_POOL_SIZE;
     primarySlot =
         new AtomicReference<>(
@@ -111,13 +113,34 @@ public byte[] toJsonBytes(Object value) {
     }
   }
 
+  /** Serializes {@code value} as UTF-8 JSON to {@code output}. */
+  public void writeJsonTo(Object value, OutputStream output) {
+    Objects.requireNonNull(output, "output");
+    PooledState entry = acquire();
+    JsonState state = entry.state;
+    Utf8JsonWriter writer = state.utf8Writer;
+    try {
+      if (value == null) {
+        writer.writeNull();
+      } else {
+        JsonTypeResolver resolver = state.typeResolver;
+        JsonTypeInfo typeInfo = state.rootTypeInfo(value.getClass());
+        typeInfo.codec().writeUtf8(writer, value, resolver);
+      }
+      writer.writeTo(output);
+    } finally {
+      writer.reset();
+      release(entry);
+    }
+  }
+
   public <T> T fromJson(String json, Class<T> type) {
     PooledState entry = acquire();
     JsonState state = entry.state;
     try {
       return castValue(readJavaStringValue(json, type, type, state), type);
     } finally {
-      state.clearReaders();
+      state.clearStringReaders();
       release(entry);
     }
   }
@@ -130,7 +153,7 @@ public <T> T fromJson(String json, TypeRef<T> typeRef) {
       Object value = readJavaStringValue(json, typeRef.getType(), typeRef.getRawType(), state);
       return castValue(value, typeRef);
     } finally {
-      state.clearReaders();
+      state.clearStringReaders();
       release(entry);
     }
   }
@@ -141,7 +164,7 @@ public <T> T fromJson(byte[] bytes, Class<T> type) {
     try {
       return castValue(readUtf8Value(state.utf8Reader(bytes, maxDepth), type, type, state), type);
     } finally {
-      state.clearReaders();
+      state.clearUtf8Reader();
       release(entry);
     }
   }
@@ -156,7 +179,7 @@ public <T> T fromJson(byte[] bytes, TypeRef<T> typeRef) {
               state.utf8Reader(bytes, maxDepth), typeRef.getType(), typeRef.getRawType(), state);
       return castValue(value, typeRef);
     } finally {
-      state.clearReaders();
+      state.clearUtf8Reader();
       release(entry);
     }
   }
@@ -235,13 +258,15 @@ private Object readJavaStringValue(String json, Type type, Class<?> fallback, Js
     if (StringSerializer.isBytesBackedString()) {
       byte coder = StringSerializer.getStringCoder(json);
       if (StringSerializer.isLatin1Coder(coder)) {
+        // Keep String input on its reader owner even when ASCII Latin1 bytes match UTF-8;
+        // custom JsonCodec implementations can observe readLatin1/readUtf8 dispatch.
         return readLatin1Value(state.latin1Reader(json, maxDepth), type, fallback, state);
       }
       if (StringSerializer.isUtf16Coder(coder)) {
         return readUtf16Value(state.utf16Reader(json, maxDepth), type, fallback, state);
       }
     }
-    return readUtf16Value(state.utf16Reader(json, maxDepth), type, fallback, state);
+    return readUtf16Value(state.legacyUtf16Reader(json, maxDepth), type, fallback, state);
   }
 
   private Object readLatin1Value(
@@ -299,6 +324,7 @@ private static final class JsonState {
     private final Latin1JsonReader latin1Reader;
     private final Utf16JsonReader utf16Reader;
     private final JsonTypeResolver typeResolver;
+    private byte[] legacyUtf16Bytes;
     private Type lastRootType;
     private Class<?> lastRootFallback;
     private JsonTypeInfo lastRootInfo;
@@ -310,6 +336,7 @@ private JsonState(boolean writeNullFields, JsonSharedRegistry sharedRegistry) {
       latin1Reader = new Latin1JsonReader();
       utf16Reader = new Utf16JsonReader();
       typeResolver = new JsonTypeResolver(sharedRegistry);
+      legacyUtf16Bytes = EMPTY_BYTES;
     }
 
     private Latin1JsonReader latin1Reader(String input, int maxDepth) {
@@ -324,18 +351,46 @@ private Utf16JsonReader utf16Reader(String input, int maxDepth) {
       return utf16Reader;
     }
 
+    private Utf16JsonReader legacyUtf16Reader(String input, int maxDepth) {
+      int length = input.length();
+      if (length > (Integer.MAX_VALUE >>> 1)) {
+        throw new IllegalArgumentException("String is too large");
+      }
+      int numBytes = length << 1;
+      byte[] bytes;
+      if (numBytes <= RETAINED_UTF16_BYTES) {
+        bytes = legacyUtf16Bytes;
+        if (bytes.length < numBytes) {
+          bytes = new byte[Math.max(numBytes, INITIAL_BUFFER_SIZE)];
+          legacyUtf16Bytes = bytes;
+        }
+      } else {
+        bytes = new byte[numBytes];
+      }
+      // Legacy char[]-backed Strings are converted once so parsing still uses UTF16 byte loads.
+      StringSerializer.copyStringCharsToBytes(input, bytes);
+      utf16Reader.resetUtf16Bytes(input, bytes);
+      utf16Reader.resetDepth(maxDepth);
+      return utf16Reader;
+    }
+
     private Utf8JsonReader utf8Reader(byte[] input, int maxDepth) {
       utf8Reader.reset(input);
       utf8Reader.resetDepth(maxDepth);
       return utf8Reader;
     }
 
-    private void clearReaders() {
+    // Clear only readers reset by the current public parse entry; clearing the unused readers shows
+    // up on small byte-input parses and does not release additional retained input.
+    private void clearStringReaders() {
       latin1Reader.clearDepth();
       utf16Reader.clearDepth();
-      utf8Reader.clearDepth();
       latin1Reader.clear();
       utf16Reader.clear();
+    }
+
+    private void clearUtf8Reader() {
+      utf8Reader.clearDepth();
       utf8Reader.clear();
     }
 

java/fory-json/src/main/java/org/apache/fory/json/ForyJsonBuilder.java

@@ -26,6 +26,7 @@
 public final class ForyJsonBuilder {
   private boolean writeNullFields;
   private boolean codegenEnabled = true;
+  private boolean propertyDiscoveryEnabled = true;
   private int maxDepth = ForyJson.DEFAULT_MAX_DEPTH;
   private final CodecRegistry codecRegistry = new CodecRegistry();
 
@@ -43,6 +44,12 @@ public ForyJsonBuilder withCodegen(boolean codegenEnabled) {
     return this;
   }
 
+  /** Enables JavaBean getter/setter JSON property discovery. */
+  public ForyJsonBuilder withPropertyDiscovery(boolean propertyDiscoveryEnabled) {
+    this.propertyDiscoveryEnabled = propertyDiscoveryEnabled;
+    return this;
+  }
+
   /** Sets the maximum nested JSON object/array depth allowed while parsing. */
   public ForyJsonBuilder maxDepth(int maxDepth) {
     if (maxDepth < 1) {
@@ -59,6 +66,8 @@ public <T> ForyJsonBuilder registerCodec(Class<T> type, JsonCodec codec) {
   }
 
   public ForyJson build() {
-    return new ForyJson(writeNullFields, codegenEnabled, maxDepth, codecRegistry);
+    return new ForyJson(
+        new JsonConfig(
+            writeNullFields, codegenEnabled, propertyDiscoveryEnabled, maxDepth, codecRegistry));
   }
 }