src/org/redkale/mq/MessageAgent.java

@@ -7,7 +7,7 @@ package org.redkale.mq;
 
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.*;
 import java.util.logging.Logger;
 import javax.annotation.Resource;
 import org.redkale.boot.*;
@@ -54,8 +54,8 @@ public abstract class MessageAgent {
     public void init(AnyValue config) {
     }
 
-    public final CompletableFuture<MessageRecord> createSncpRespFuture(MessageRecord message) {
+    public final CompletableFuture<MessageRecord> createSncpRespFuture(AtomicLong counter, MessageRecord message) {
-        return this.sncpRespProcessor.createFuture(message.getSeqid());
+        return this.sncpRespProcessor.createFuture(message.getSeqid(), counter);
     }
 
     public final synchronized void startSncpRespConsumer() {

src/org/redkale/mq/MessageRespFutureNode.java

@@ -6,6 +6,7 @@
 package org.redkale.mq;
 
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * MQ管理器
@@ -23,10 +24,13 @@ public class MessageRespFutureNode {
 
     protected final long createtime;
 
+    protected final AtomicLong counter;
+
     protected final CompletableFuture<MessageRecord> future;
 
-    public MessageRespFutureNode(long seqid, CompletableFuture<MessageRecord> future) {
+    public MessageRespFutureNode(long seqid, AtomicLong counter, CompletableFuture<MessageRecord> future) {
         this.seqid = seqid;
+        this.counter = counter;
         this.future = future;
         this.createtime = System.currentTimeMillis();
     }
@@ -39,6 +43,10 @@ public class MessageRespFutureNode {
         return createtime;
     }
 
+    public AtomicLong getCounter() {
+        return counter;
+    }
+
     public CompletableFuture<MessageRecord> getFuture() {
         return future;
     }

src/org/redkale/mq/SncpRespProcessor.java

@@ -6,6 +6,7 @@
 package org.redkale.mq;
 
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.logging.*;
 
 /**
@@ -38,12 +39,13 @@ public class SncpRespProcessor implements MessageProcessor {
             logger.log(Level.WARNING, SncpRespProcessor.class.getSimpleName() + " process " + message + " error");
             return;
         }
+        if (node.getCounter() != null) node.getCounter().decrementAndGet();
         node.future.complete(message);
     }
 
-    public CompletableFuture<MessageRecord> createFuture(long seqid) {
+    public CompletableFuture<MessageRecord> createFuture(long seqid, AtomicLong counter) {
         CompletableFuture<MessageRecord> future = new CompletableFuture<>();
-        MessageRespFutureNode node = new MessageRespFutureNode(seqid, future);
+        MessageRespFutureNode node = new MessageRespFutureNode(seqid, counter, future);
         respNodes.put(seqid, node);
         return future;
     }

src/org/redkale/source/CacheMemorySource.java

@@ -13,6 +13,7 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.*;
 import java.util.logging.*;
 import javax.annotation.Resource;
+import org.redkale.convert.Convert;
 import org.redkale.convert.json.*;
 import org.redkale.net.sncp.*;
 import org.redkale.service.*;
@@ -481,11 +482,21 @@ public class CacheMemorySource<V extends Object> extends AbstractService impleme
         set(CacheEntryType.OBJECT, key, value);
     }
 
+    @Override
+    public <T> void set(String key, Convert convert, T value) {
+        set(CacheEntryType.OBJECT, key, value);
+    }
+
     @Override
     public <T> void set(String key, Type type, T value) {
         set(CacheEntryType.OBJECT, key, value);
     }
 
+    @Override
+    public <T> void set(String key, Convert convert, Type type, T value) {
+        set(CacheEntryType.OBJECT, key, value);
+    }
+
     @Override
 
     public void setString(String key, String value) {
@@ -499,18 +510,26 @@ public class CacheMemorySource<V extends Object> extends AbstractService impleme
     }
 
     @Override
-    
     public CompletableFuture<Void> setAsync(String key, V value) {
         return CompletableFuture.runAsync(() -> set(key, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }
 
+    @Override
+    public <T> CompletableFuture<Void> setAsync(String key, Convert convert, T value) {
+        return CompletableFuture.runAsync(() -> set(key, convert, value), getExecutor()).whenComplete(futureCompleteConsumer);
+    }
+
     @Override
     public <T> CompletableFuture<Void> setAsync(String key, Type type, T value) {
         return CompletableFuture.runAsync(() -> set(key, type, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }
 
     @Override
+    public <T> CompletableFuture<Void> setAsync(String key, Convert convert, Type type, T value) {
+        return CompletableFuture.runAsync(() -> set(key, convert, type, value), getExecutor()).whenComplete(futureCompleteConsumer);
+    }
 
+    @Override
     public CompletableFuture<Void> setStringAsync(String key, String value) {
         return CompletableFuture.runAsync(() -> setString(key, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }
@@ -540,13 +559,22 @@ public class CacheMemorySource<V extends Object> extends AbstractService impleme
         set(CacheEntryType.OBJECT, expireSeconds, key, value);
     }
 
+    @Override
+    public <T> void set(final int expireSeconds, String key, Convert convert, T value) {
+        set(CacheEntryType.OBJECT, expireSeconds, key, value);
+    }
+
     @Override
     public <T> void set(final int expireSeconds, String key, Type type, T value) {
         set(CacheEntryType.OBJECT, expireSeconds, key, value);
     }
 
     @Override
+    public <T> void set(final int expireSeconds, String key, Convert convert, Type type, T value) {
+        set(CacheEntryType.OBJECT, expireSeconds, key, value);
+    }
 
+    @Override
     public void setString(int expireSeconds, String key, String value) {
         set(CacheEntryType.STRING, expireSeconds, key, value);
     }
@@ -563,13 +591,22 @@ public class CacheMemorySource<V extends Object> extends AbstractService impleme
         return CompletableFuture.runAsync(() -> set(expireSeconds, key, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }
 
+    @Override
+    public <T> CompletableFuture<Void> setAsync(int expireSeconds, String key, Convert convert, T value) {
+        return CompletableFuture.runAsync(() -> set(expireSeconds, key, convert, value), getExecutor()).whenComplete(futureCompleteConsumer);
+    }
+
     @Override
     public <T> CompletableFuture<Void> setAsync(int expireSeconds, String key, Type type, T value) {
         return CompletableFuture.runAsync(() -> set(expireSeconds, key, type, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }
 
     @Override
+    public <T> CompletableFuture<Void> setAsync(int expireSeconds, String key, Convert convert, Type type, T value) {
+        return CompletableFuture.runAsync(() -> set(expireSeconds, key, convert, type, value), getExecutor()).whenComplete(futureCompleteConsumer);
+    }
 
+    @Override
     public CompletableFuture<Void> setStringAsync(int expireSeconds, String key, String value) {
         return CompletableFuture.runAsync(() -> setString(expireSeconds, key, value), getExecutor()).whenComplete(futureCompleteConsumer);
     }

src/org/redkale/source/CacheSource.java

@@ -9,7 +9,7 @@ import java.lang.reflect.Type;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.function.Function;
-import org.redkale.convert.ConvertColumn;
+import org.redkale.convert.*;
 import org.redkale.convert.json.JsonFactory;
 import org.redkale.util.ConstructorParameters;
 
@@ -70,12 +70,20 @@ public interface CacheSource<V extends Object> {
 
     public void set(final String key, final V value);
 
+    public <T> void set(final String key, final Convert convert, final T value);
+
     public <T> void set(final String key, final Type type, final T value);
 
+    public <T> void set(final String key, final Convert convert, final Type type, final T value);
+
     public void set(final int expireSeconds, final String key, final V value);
 
+    public <T> void set(final int expireSeconds, final String key, final Convert convert, final T value);
+
     public <T> void set(final int expireSeconds, final String key, final Type type, final T value);
 
+    public <T> void set(final int expireSeconds, final String key, final Convert convert, final Type type, final T value);
+
     public void setExpireSeconds(final String key, final int expireSeconds);
 
     public void remove(final String key);
@@ -219,12 +227,20 @@ public interface CacheSource<V extends Object> {
 
     public CompletableFuture<Void> setAsync(final String key, final V value);
 
+    public <T> CompletableFuture<Void> setAsync(final String key, final Convert convert, final T value);
+
     public <T> CompletableFuture<Void> setAsync(final String key, final Type type, final T value);
 
+    public <T> CompletableFuture<Void> setAsync(final String key, final Convert convert, final Type type, final T value);
+
     public CompletableFuture<Void> setAsync(final int expireSeconds, final String key, final V value);
 
+    public <T> CompletableFuture<Void> setAsync(final int expireSeconds, final String key, final Convert convert, final T value);
+
     public <T> CompletableFuture<Void> setAsync(final int expireSeconds, final String key, final Type type, final T value);
 
+    public <T> CompletableFuture<Void> setAsync(final int expireSeconds, final String key, final Convert convert, final Type type, final T value);
+
     public CompletableFuture<Void> setExpireSecondsAsync(final String key, final int expireSeconds);
 
     public CompletableFuture<Void> removeAsync(final String key);