INTERNAL: add option to disable optimization in CollectionTranscoder

Author: oliviarla

src/main/java/net/spy/memcached/transcoders/CollectionTranscoder.java

@@ -34,6 +34,8 @@ public class CollectionTranscoder extends SerializingTranscoder implements
    */
   public static final int MAX_ELEMENT_BYTES = 32 * 1024;
 
+  private boolean optimize = true;
+
   /**
    * Get a serializing transcoder with the default max data size.
    */
@@ -52,6 +54,11 @@ public CollectionTranscoder(int max, ClassLoader cl) {
     super(max, cl);
   }
 
+  private CollectionTranscoder(int max, ClassLoader cl, boolean optimize) {
+    super(max, cl);
+    this.optimize = optimize;
+  }
+
   public static int examineFlags(ElementValueType type) {
     int flags = 0;
     if (type == ElementValueType.STRING) {
@@ -78,8 +85,14 @@ public static int examineFlags(ElementValueType type) {
     return flags;
   }
 
+  @Override
   public Object decode(CachedData d) {
     byte[] data = d.getData();
+
+    if (!optimize) {
+      return deserialize(data);
+    }
+
     Object rv = null;
     int flags = d.getFlags() & SPECIAL_MASK;
     if ((d.getFlags() & SERIALIZED) != 0 && data != null) {
@@ -119,7 +132,12 @@ public Object decode(CachedData d) {
     return rv;
   }
 
+  @Override
   public CachedData encode(Object o) {
+    if (!optimize) {
+      return new CachedData(SERIALIZED, serialize(o), getMaxSize());
+    }
+
     byte[] b = null;
     int flags = 0;
     if (o instanceof String) {
@@ -155,4 +173,36 @@ public CachedData encode(Object o) {
     assert b != null;
     return new CachedData(flags, b, getMaxSize());
   }
+
+  public static class Builder {
+    private int max = MAX_ELEMENT_BYTES;
+    private boolean optimize = true;
+    private ClassLoader cl;
+
+    public Builder setMaxElementBytes(int max) {
+      this.max = max;
+      return this;
+    }
+
+    /**
+     * By default, this transcoder uses Java serialization only if the type is a user-defined class.
+     * This mechanism may cause malfunction if you store Object type values
+     * into an Arcus collection item and the values are actually
+     * different types like String, Integer.
+     * In this case, you should disable optimization.
+     */
+    public Builder disableOptimization() {
+      this.optimize = false;
+      return this;
+    }
+
+    public Builder setClassLoader(ClassLoader cl) {
+      this.cl = cl;
+      return this;
+    }
+
+    public CollectionTranscoder build() {
+      return new CollectionTranscoder(max, cl, optimize);
+    }
+  }
 }

src/test/manual/net/spy/memcached/collection/transcoder/CollectionTranscoderTest.java

@@ -0,0 +1,83 @@
+package net.spy.memcached.collection.transcoder;
+
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+import net.spy.memcached.collection.BaseIntegrationTest;
+import net.spy.memcached.collection.CollectionAttributes;
+import net.spy.memcached.transcoders.CollectionTranscoder;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CollectionTranscoderTest extends BaseIntegrationTest {
+
+  private static final String KEY = "CollectionTranscoderTest";
+
+  private final CollectionTranscoder transcoder = new CollectionTranscoder.Builder()
+          .disableOptimization()
+          .build();
+
+  @AfterEach
+  @Override
+  protected void tearDown() throws Exception {
+    mc.delete(KEY);
+    super.tearDown();
+  }
+
+  @Test
+  void decodeIntegerAsString() throws ExecutionException, InterruptedException {
+    // given
+    Boolean b1 = mc.asyncMopInsert(KEY, "mkey1", "value", new CollectionAttributes()).get();
+    Boolean b2 = mc.asyncMopInsert(KEY, "mkey2", 35, new CollectionAttributes()).get();
+    assertTrue(b1);
+    assertTrue(b2);
+
+    // when
+    Map<String, Object> map1 = mc.asyncMopGet(KEY, "mkey1", false, false).get();
+    Map<String, Object> map2 = mc.asyncMopGet(KEY, "mkey2", false, false).get();
+
+    // then
+    assertEquals("value", map1.get("mkey1"));
+    assertEquals("#", map2.get("mkey2"));
+  }
+
+  @Test
+  void failToDecodeString() throws ExecutionException, InterruptedException {
+    // given
+    Boolean b2 = mc.asyncMopInsert(KEY, "mkey3", 35, new CollectionAttributes())
+            .get();
+    Boolean b1 = mc.asyncMopInsert(KEY, "mkey4", "value", new CollectionAttributes())
+            .get();
+    assertTrue(b1);
+    assertTrue(b2);
+
+    // when & then
+    Map<String, Object> map1 = mc.asyncMopGet(KEY, "mkey3", false, false).get();
+    assertEquals(35, map1.get("mkey3"));
+    assertThrows(AssertionError.class, () -> mc.asyncMopGet(KEY, "mkey4", false, false).get());
+  }
+
+  @Test
+  void decodeStringAndInteger() throws ExecutionException, InterruptedException {
+    // given
+    Boolean b1 = mc.asyncMopInsert(KEY, "mkey1", "value", new CollectionAttributes(), transcoder)
+            .get();
+    Boolean b2 = mc.asyncMopInsert(KEY, "mkey2", 35, new CollectionAttributes(), transcoder)
+            .get();
+    assertTrue(b1);
+    assertTrue(b2);
+
+    // when
+    Map<String, Object> map1 = mc.asyncMopGet(KEY, "mkey1", false, false, transcoder).get();
+    Map<String, Object> map2 = mc.asyncMopGet(KEY, "mkey2", false, false, transcoder).get();
+
+    // then
+    assertEquals("value", map1.get("mkey1"));
+    assertEquals(35, map2.get("mkey2"));
+  }
+}