Use JSON with compression

Author: KodaiD

core/build.gradle

@@ -196,7 +196,6 @@ dependencies {
     implementation("com.google.cloud:google-cloud-storage:${googleCloudStorageVersion}") {
         exclude group: 'org.slf4j', module: 'slf4j-api'
     }
-    implementation "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:${jacksonVersion}"
     implementation "org.apache.commons:commons-text:${commonsTextVersion}"
     implementation "com.github.ben-manes.caffeine:caffeine:${caffeineVersion}"
     testImplementation platform("org.junit:junit-bom:${junitVersion}")

core/src/main/java/com/scalar/db/storage/objectstorage/Serializer.java

@@ -5,18 +5,20 @@
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.dataformat.cbor.CBORFactory;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 public class Serializer {
   public static final int MAX_STRING_LENGTH_ALLOWED = Integer.MAX_VALUE;
   private static final ObjectMapper jsonMapper = new ObjectMapper();
-  private static final ObjectMapper cborMapper = new ObjectMapper(new CBORFactory());
 
   static {
     configureMapper(jsonMapper);
-    configureMapper(cborMapper);
   }
 
   private static void configureMapper(ObjectMapper mapper) {
@@ -35,18 +37,40 @@ public static <T> T deserialize(byte[] data, TypeReference<T> typeReference) {
         // JSON format (backward compatibility)
         return jsonMapper.readValue(new String(data, StandardCharsets.UTF_8), typeReference);
       }
-      // CBOR format
-      return cborMapper.readValue(data, typeReference);
+      // GZIP-compressed JSON format
+      byte[] decompressed = decompress(data);
+      return jsonMapper.readValue(new String(decompressed, StandardCharsets.UTF_8), typeReference);
     } catch (Exception e) {
       throw new RuntimeException("Failed to deserialize the object.", e);
     }
   }
 
   public static <T> byte[] serialize(T object) {
     try {
-      return cborMapper.writeValueAsBytes(object);
+      return compress(jsonMapper.writeValueAsBytes(object));
     } catch (Exception e) {
       throw new RuntimeException("Failed to serialize the object.", e);
     }
   }
+
+  private static byte[] compress(byte[] data) throws IOException {
+    ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
+    try (GZIPOutputStream gzip = new GZIPOutputStream(bos)) {
+      gzip.write(data);
+    }
+    return bos.toByteArray();
+  }
+
+  private static byte[] decompress(byte[] data) throws IOException {
+    ByteArrayInputStream bis = new ByteArrayInputStream(data);
+    try (GZIPInputStream gzip = new GZIPInputStream(bis)) {
+      ByteArrayOutputStream bos = new ByteArrayOutputStream();
+      byte[] buffer = new byte[1024];
+      int len;
+      while ((len = gzip.read(buffer)) != -1) {
+        bos.write(buffer, 0, len);
+      }
+      return bos.toByteArray();
+    }
+  }
 }

core/src/test/java/com/scalar/db/storage/objectstorage/SerializerTest.java

@@ -54,16 +54,17 @@ public void deserializeBytes_JsonFormatGiven_ShouldDeserializeCorrectly() {
   }
 
   @Test
-  public void serialize_ShouldNotStartWithOpenBrace() {
+  public void serialize_ShouldStartWithGzipMagicBytes() {
     // Arrange
     ObjectStoragePartition partition = new ObjectStoragePartition(null);
 
     // Act
     byte[] serialized = Serializer.serialize(partition);
 
-    // Assert - CBOR should not start with '{' (0x7B), which is used for JSON detection
-    assertThat(serialized.length).isGreaterThan(0);
-    assertThat(serialized[0]).isNotEqualTo((byte) '{');
+    // Assert - GZIP magic bytes: 0x1F 0x8B
+    assertThat(serialized.length).isGreaterThanOrEqualTo(2);
+    assertThat(serialized[0]).isEqualTo((byte) 0x1F);
+    assertThat(serialized[1]).isEqualTo((byte) 0x8B);
   }
 
   @Test