Cleanups

Author: alextwoods

.changes/next-release/feature-AWSSDKforJavav2-439f346.json

@@ -2,5 +2,5 @@
     "type": "feature",
     "category": "AWS SDK for Java v2",
     "contributor": "",
-    "description": "Optimized JSON marshalling performance for JSON RPC and REST JSON protocols."
-}
+    "description": "Optimized JSON marshalling performance for JSON RPC, REST JSON and RPCv2 Cbor protocols."
+}

core/protocols/aws-json-protocol/src/main/java/software/amazon/awssdk/protocols/json/ExposedByteArrayOutputStream.java

@@ -17,7 +17,9 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.io.SequenceInputStream;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -135,6 +137,38 @@ public byte[] toByteArray() {
         return result;
     }
 
+    /**
+     * Resets this stream so that all currently accumulated output is discarded, including any
+     * overflow chunks. After calling this method, the stream can be reused as if freshly constructed.
+     */
+    @Override
+    public void reset() {
+        super.reset();
+        overflowing = false;
+        overflowChunks = null;
+        overflowChunkOffset = 0;
+        overflowTotalBytes = 0;
+    }
+
+    /**
+     * Writes the complete contents of this stream to the specified output stream, including
+     * any overflow chunks.
+     */
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        if (!overflowing) {
+            super.writeTo(out);
+            return;
+        }
+        // Write base buffer
+        out.write(buf, 0, count);
+        // Write overflow chunks
+        for (int i = 0; i < overflowChunks.size(); i++) {
+            int len = (i < overflowChunks.size() - 1) ? overflowChunks.get(i).length : overflowChunkOffset;
+            out.write(overflowChunks.get(i), 0, len);
+        }
+    }
+
     /**
      * Returns a {@link ContentStreamProvider} that streams directly from the internal buffers
      * without creating a contiguous copy. For small payloads this wraps the single base buffer;
@@ -143,7 +177,7 @@ public byte[] toByteArray() {
      */
     ContentStreamProvider contentStreamProvider() {
         if (!overflowing) {
-            // Small payload: single buffer, wrap directly (same as ExposedByteArrayOutputStream)
+            // Small payload: single buffer, wrap directly
             byte[] b = buf;
             int c = count;
             return () -> new ByteArrayInputStream(b, 0, c);

core/protocols/aws-json-protocol/src/main/java/software/amazon/awssdk/protocols/json/SdkByteArrayOutputStream.java

@@ -15,11 +15,13 @@
 
 package software.amazon.awssdk.protocols.json;
 
+import java.io.ByteArrayInputStream;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.time.Instant;
 import software.amazon.awssdk.annotations.SdkProtectedApi;
+import software.amazon.awssdk.http.ContentStreamProvider;
 
 /**
  * Interface for generating a JSON
@@ -102,6 +104,11 @@ public StructuredJsonGenerator writeValue(ByteBuffer bytes) {
             return this;
         }
 
+        @Override
+        public StructuredJsonGenerator writeBinaryValue(byte[] bytes) {
+            return this;
+        }
+
         @Override
         public StructuredJsonGenerator writeValue(Instant instant) {
             return this;
@@ -193,4 +200,28 @@ default StructuredJsonGenerator writeBinaryValue(byte[] bytes) {
      */
     @Deprecated
     String getContentType();
+
+    /**
+     * Returns the size of the generated content in bytes without copying. The default
+     * implementation falls back to {@link #getBytes()}.length.
+     */
+    default int contentSize() {
+        byte[] bytes = getBytes();
+        return bytes == null ? 0 : bytes.length;
+    }
+
+    /**
+     * Returns a {@link ContentStreamProvider} that streams the generated content. The default
+     * implementation wraps the result of {@link #getBytes()} in a {@code ByteArrayInputStream}.
+     * Implementations may override this to stream directly from internal buffers without copying.
+     *
+     * @return a content stream provider, or {@code null} if {@link #getBytes()} returns null
+     */
+    default ContentStreamProvider contentStreamProvider() {
+        byte[] bytes = getBytes();
+        if (bytes == null) {
+            return null;
+        }
+        return () -> new ByteArrayInputStream(bytes);
+    }
 }

core/protocols/aws-json-protocol/src/main/java/software/amazon/awssdk/protocols/json/StructuredJsonGenerator.java

@@ -53,7 +53,6 @@
 import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
 import software.amazon.awssdk.protocols.json.AwsJsonProtocolMetadata;
 import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
-import software.amazon.awssdk.protocols.json.SdkJsonGenerator;
 import software.amazon.awssdk.protocols.json.StructuredJsonGenerator;
 import software.amazon.awssdk.protocols.json.internal.ProtocolFact;
 
@@ -70,6 +69,8 @@ public class JsonProtocolMarshaller implements ProtocolMarshaller<SdkHttpFullReq
 
     // Caches the resolved marshaller for non-PAYLOAD fields, keyed by SdkField identity.
     // SdkField instances are static final per generated model class, so identity-based lookup is correct.
+    // The cache is effectively bounded by the total number of non-payload SdkField instances across all
+    // loaded service models — each SdkField is inserted at most once, and no eviction is needed.
     // ConcurrentHashMap is used for thread safety; the one-time put per SdkField is negligible.
     private static final ConcurrentHashMap<SdkField<?>, JsonMarshaller<Object>> MARSHALLER_CACHE =
         new ConcurrentHashMap<>();
@@ -290,25 +291,13 @@ private SdkHttpFullRequest finishMarshalling() {
                 jsonGenerator.writeEndObject();
             }
 
-            if (jsonGenerator instanceof SdkJsonGenerator) {
-                // Optimized path: stream directly from chunked buffers, avoiding a single
-                // contiguous byte[] allocation that can cause G1GC humongous allocations.
-                SdkJsonGenerator sdkGenerator = (SdkJsonGenerator) jsonGenerator;
-                ContentStreamProvider contentProvider = sdkGenerator.contentStreamProvider();
+            ContentStreamProvider contentProvider = jsonGenerator.contentStreamProvider();
+            if (contentProvider != null) {
                 request.contentStreamProvider(contentProvider);
-                int contentSize = sdkGenerator.contentSize();
+                int contentSize = jsonGenerator.contentSize();
                 if (contentSize > 0) {
                     request.putHeader(CONTENT_LENGTH, Integer.toString(contentSize));
                 }
-            } else {
-                byte[] content = jsonGenerator.getBytes();
-
-                if (content != null) {
-                    request.contentStreamProvider(() -> new ByteArrayInputStream(content));
-                    if (content.length > 0) {
-                        request.putHeader(CONTENT_LENGTH, Integer.toString(content.length));
-                    }
-                }
             }
         }