refactoring

redisson/src/main/java/org/redisson/RedissonBaseAdder.java

@@ -102,10 +102,6 @@ public abstract class RedissonBaseAdder<T extends Number> extends RedissonExpira
 
     protected abstract void doReset();
 
-    public T sum() {
-        return get(sumAsync());
-    }
-    
     public void reset() {
         get(resetAsync());
     }

redisson/src/main/java/org/redisson/RedissonDoubleAdder.java

@@ -28,38 +28,37 @@ import org.redisson.command.CommandAsyncExecutor;
  * @author Nikita Koksharov
  *
  */
-public class RedissonDoubleAdder extends RedissonExpirable implements RDoubleAdder {
+public class RedissonDoubleAdder extends RedissonBaseAdder<Double> implements RDoubleAdder {
 
     private final DoubleAdder counter = new DoubleAdder();
-    private final RedissonBaseAdder<Double> adder;
+    private final RAtomicDouble atomicDouble;
     
     public RedissonDoubleAdder(CommandAsyncExecutor connectionManager, String name, RedissonClient redisson) {
-        super(connectionManager, name);
+        super(connectionManager, name, redisson);
         
-        final RAtomicDouble atomicDouble = redisson.getAtomicDouble(getName());
-        adder = new RedissonBaseAdder<Double>(connectionManager, name, redisson) {
-            @Override
-            protected void doReset() {
-                counter.reset();
-            }
-
-            @Override
-            protected RFuture<Double> addAndGetAsync() {
-                return atomicDouble.getAndAddAsync(counter.sum());
-            }
+        atomicDouble = redisson.getAtomicDouble(getName());
+    }
 
-            @Override
-            protected RFuture<Double> getAsync() {
-                return atomicDouble.getAsync();
-            }
-        };
+    @Override
+    protected void doReset() {
+        counter.reset();
+    }
+    
+    @Override
+    protected RFuture<Double> addAndGetAsync() {
+        return atomicDouble.getAndAddAsync(counter.sum());
+    }
+    
+    @Override
+    protected RFuture<Double> getAsync() {
+        return atomicDouble.getAsync();
     }
 
     @Override
     public void add(double x) {
         counter.add(x);
     }
-
+    
     @Override
     public void increment() {
         add(1L);
@@ -72,27 +71,7 @@ public class RedissonDoubleAdder extends RedissonExpirable implements RDoubleAdd
     
     @Override
     public double sum() {
-        return adder.sum();
-    }
-    
-    @Override
-    public void reset() {
-        adder.reset();
-    }
-    
-    @Override
-    public RFuture<Double> sumAsync() {
-        return adder.sumAsync();
-    }
-
-    @Override
-    public RFuture<Void> resetAsync() {
-        return adder.resetAsync();
-    }
-
-    @Override
-    public void destroy() {
-        adder.destroy();
+        return get(sumAsync());
     }
 
 }

redisson/src/main/java/org/redisson/RedissonLongAdder.java

@@ -27,32 +27,30 @@ import org.redisson.misc.LongAdder;
  * @author Nikita Koksharov
  *
  */
-public class RedissonLongAdder extends RedissonExpirable implements RLongAdder {
+public class RedissonLongAdder extends RedissonBaseAdder<Long> implements RLongAdder {
 
     private final RAtomicLong atomicLong;
     private final LongAdder counter = new LongAdder();
-    private final RedissonBaseAdder<Long> adder;
     
     public RedissonLongAdder(CommandAsyncExecutor connectionManager, String name, RedissonClient redisson) {
-        super(connectionManager, name);
+        super(connectionManager, name, redisson);
         
         atomicLong = redisson.getAtomicLong(getName());
-        adder = new RedissonBaseAdder<Long>(connectionManager, name, redisson) {
-            @Override
-            protected void doReset() {
-                counter.reset();
-            }
-
-            @Override
-            protected RFuture<Long> addAndGetAsync() {
-                return atomicLong.getAndAddAsync(counter.sum());
-            }
+    }
 
-            @Override
-            protected RFuture<Long> getAsync() {
-                return atomicLong.getAsync();
-            }
-        };
+    @Override
+    protected void doReset() {
+        counter.reset();
+    }
+    
+    @Override
+    protected RFuture<Long> addAndGetAsync() {
+        return atomicLong.getAndAddAsync(counter.sum());
+    }
+    
+    @Override
+    protected RFuture<Long> getAsync() {
+        return atomicLong.getAsync();
     }
 
     @Override
@@ -69,30 +67,10 @@ public class RedissonLongAdder extends RedissonExpirable implements RLongAdder {
     public void decrement() {
         add(-1L);
     }
-    
+
     @Override
     public long sum() {
-        return adder.sum();
+        return get(sumAsync());
     }
     
-    @Override
-    public void reset() {
-        adder.reset();
-    }
-    
-    @Override
-    public RFuture<Long> sumAsync() {
-        return adder.sumAsync();
-    }
-
-    @Override
-    public RFuture<Void> resetAsync() {
-        return adder.resetAsync();
-    }
-
-    @Override
-    public void destroy() {
-        adder.destroy();
-    }
-
 }

redisson/src/test/java/org/redisson/RedissonDoubleAdderTest.java

@@ -3,7 +3,6 @@ package org.redisson;
 import org.assertj.core.api.Assertions;
 import org.junit.Test;
 import org.redisson.api.RDoubleAdder;
-import org.redisson.api.RLongAdder;
 
 public class RedissonDoubleAdderTest extends BaseTest {