Merge branch 'master' into 3.0.0

redisson/src/main/java/org/redisson/codec/CustomObjectInputStream.java

@@ -19,6 +19,9 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectStreamClass;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * 
@@ -27,7 +30,7 @@ import java.io.ObjectStreamClass;
  */
 public class CustomObjectInputStream extends ObjectInputStream {
 
-    private ClassLoader classLoader;
+    private final ClassLoader classLoader;
     
     public CustomObjectInputStream(ClassLoader classLoader, InputStream in) throws IOException {
         super(in);
@@ -44,4 +47,16 @@ public class CustomObjectInputStream extends ObjectInputStream {
         }
     }
     
+    @Override
+    protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
+        List<Class<?>> loadedClasses = new ArrayList<Class<?>>(interfaces.length);
+        
+        for (String name : interfaces) {
+            Class<?> clazz = Class.forName(name, false, classLoader);
+            loadedClasses.add(clazz);
+        }
+        
+        return Proxy.getProxyClass(classLoader, loadedClasses.toArray(new Class[loadedClasses.size()]));
+    }
+    
 }

redisson/src/main/java/org/redisson/codec/SnappyCodecV2.java

@@ -0,0 +1,103 @@
+/**
+ * Copyright 2018 Nikita Koksharov
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.redisson.codec;
+
+import java.io.IOException;
+
+import org.redisson.client.codec.BaseCodec;
+import org.redisson.client.codec.Codec;
+import org.redisson.client.handler.State;
+import org.redisson.client.protocol.Decoder;
+import org.redisson.client.protocol.Encoder;
+import org.xerial.snappy.SnappyInputStream;
+import org.xerial.snappy.SnappyOutputStream;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufOutputStream;
+
+/**
+ * Google's Snappy compression codec.
+ * Uses inner <code>Codec</code> to convert object to binary stream.
+ * <code>FstCodec</code> used by default.
+ * <p>
+ * Based on <a href="https://github.com/xerial/snappy-java">https://github.com/xerial/snappy-java</a>
+ *
+ * @see org.redisson.codec.FstCodec
+ *
+ * @author Nikita Koksharov
+ *
+ */
+public class SnappyCodecV2 extends BaseCodec {
+
+    private final Codec innerCodec;
+
+    public SnappyCodecV2() {
+        this(new FstCodec());
+    }
+
+    public SnappyCodecV2(Codec innerCodec) {
+        this.innerCodec = innerCodec;
+    }
+
+    public SnappyCodecV2(ClassLoader classLoader) {
+        this(new FstCodec(classLoader));
+    }
+    
+    private final Decoder<Object> decoder = new Decoder<Object>() {
+        
+        @Override
+        public Object decode(ByteBuf buf, State state) throws IOException {
+            SnappyInputStream input = new SnappyInputStream(new ByteBufInputStream(buf));
+            ByteBuf bf = ByteBufAllocator.DEFAULT.buffer(buf.readableBytes());
+            bf.writeBytes(input, buf.readableBytes());
+            try {
+                return innerCodec.getValueDecoder().decode(bf, state);
+            } finally {
+                bf.release();
+            }
+        }
+    };
+
+    private final Encoder encoder = new Encoder() {
+
+        @Override
+        public ByteBuf encode(Object in) throws IOException {
+            ByteBuf encoded = innerCodec.getValueEncoder().encode(in);
+            ByteBuf out = ByteBufAllocator.DEFAULT.buffer(encoded.readableBytes());
+            try {
+                SnappyOutputStream output = new SnappyOutputStream(new ByteBufOutputStream(out));
+                encoded.readBytes(output, encoded.readableBytes());
+                output.flush();
+            } finally {
+                encoded.release();
+            }
+            return out;
+        }
+    };
+
+    @Override
+    public Decoder<Object> getValueDecoder() {
+        return decoder;
+    }
+
+    @Override
+    public Encoder getValueEncoder() {
+        return encoder;
+    }
+    
+}

redisson/src/test/java/org/redisson/RedissonCodecTest.java

@@ -23,10 +23,10 @@ import org.redisson.codec.FstCodec;
 import org.redisson.codec.JsonJacksonCodec;
 import org.redisson.codec.KryoCodec;
 import org.redisson.codec.LZ4Codec;
-import org.redisson.codec.MsgPackJacksonCodec;
 import org.redisson.codec.SerializationCodec;
 import org.redisson.codec.SmileJacksonCodec;
 import org.redisson.codec.SnappyCodec;
+import org.redisson.codec.SnappyCodecV2;
 import org.redisson.config.Config;
 
 import com.fasterxml.jackson.core.type.TypeReference;
@@ -44,6 +44,7 @@ public class RedissonCodecTest extends BaseTest {
     private Codec cborCodec = new CborJacksonCodec();
     private Codec fstCodec = new FstCodec();
     private Codec snappyCodec = new SnappyCodec();
+    private Codec snappyCodecV2 = new SnappyCodecV2();
 //    private Codec msgPackCodec = new MsgPackJacksonCodec();
     private Codec lz4Codec = new LZ4Codec();
     private Codec jsonListOfStringCodec = new JsonJacksonMapCodec(
@@ -127,6 +128,25 @@ public class RedissonCodecTest extends BaseTest {
 
         test(redisson);
     }
+    
+    @Test
+    public void testSnappyV2() {
+        Config config = createConfig();
+        config.setCodec(snappyCodecV2);
+        RedissonClient redisson = Redisson.create(config);
+
+        test(redisson);
+    }
+    
+    @Test
+    public void testSnappyBigV2() throws IOException {
+        Codec sc = new SnappyCodecV2();
+        String randomData = RandomString.make(Short.MAX_VALUE*2 + 142);
+        ByteBuf g = sc.getValueEncoder().encode(randomData);
+        String decompressedData = (String) sc.getValueDecoder().decode(g, null);
+        assertThat(decompressedData).isEqualTo(randomData);
+    }
+
 
     @Test
     public void testJson() {