refactor: 优化命令；迁移常用utils (jetlinks#101)

goten7 · web-flow · commit 9fd5b4fa82fa · 2025-08-25T10:39:55.000+08:00
diff --git a/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/DeleteByIdCommand.java b/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/DeleteByIdCommand.java
@@ -27,6 +27,10 @@ public class DeleteByIdCommand<T> extends OperationByIdCommand<T, DeleteByIdComm
     public DeleteByIdCommand() {
     }
 
+    public DeleteByIdCommand(Class<T> type) {
+        withConverter(CommandUtils.createConverter(ResolvableType.forClass(type)));
+    }
+
     /**
      * 使用指定的类型创建命令,执行命令后会将执行结果转换为指定类型
      *
diff --git a/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/QueryListCommand.java b/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/QueryListCommand.java
@@ -7,14 +7,9 @@
 import org.jetlinks.core.metadata.FunctionMetadata;
 import org.jetlinks.core.metadata.PropertyMetadata;
 import org.jetlinks.core.metadata.SimpleFunctionMetadata;
-import org.jetlinks.core.metadata.SimplePropertyMetadata;
-import org.jetlinks.core.metadata.types.ArrayType;
-import org.jetlinks.core.metadata.types.ObjectType;
-import org.jetlinks.core.metadata.types.StringType;
 import org.springframework.core.ResolvableType;
 import reactor.core.publisher.Flux;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -41,6 +36,14 @@ public QueryListCommand() {
 
     }
 
+    public QueryListCommand(Class<T> type) {
+        withConverter(CommandUtils.createConverter(ResolvableType.forClass(type)));
+    }
+
+    public QueryListCommand(Function<Object, T> converter) {
+        withConverter(converter);
+    }
+
 
     public static <T> FunctionMetadata metadata(Class<T> elementType) {
         return CommandMetadataResolver.resolve(QueryListCommand.class, elementType);
diff --git a/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/SaveCommand.java b/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/commons/cmd/SaveCommand.java
@@ -22,6 +22,14 @@ public class SaveCommand<T> extends BatchDataCommand<T, SaveCommand<T>> {
     public SaveCommand() {
     }
 
+    public SaveCommand(Class<T> type) {
+        withConverter(CommandUtils.createConverter(ResolvableType.forClass(type)));
+    }
+
+    public SaveCommand(Function<Object, T> converter) {
+        withConverter(converter);
+    }
+
     public static <T> SaveCommand<T> of(Class<T> type) {
         return of(CommandUtils.createConverter(ResolvableType.forClass(type)));
     }
diff --git a/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/template/SaveByTemplateCommand.java b/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/template/SaveByTemplateCommand.java
@@ -1,5 +1,6 @@
 package org.jetlinks.sdk.server.template;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
@@ -29,6 +30,7 @@
  * @since 1.0.1
  */
 @Slf4j
+@Schema(title = "根据模板保存数据")
 public class SaveByTemplateCommand extends AbstractConvertCommand<Flux<SaveByTemplateResult>, SaveByTemplateCommand> {
 
 
@@ -41,14 +43,21 @@ public final SaveByTemplateCommand withTemplate(List<EntityTemplateInfo> entityI
         return castSelf();
     }
 
-    public final List<EntityTemplateInfo> templateList() {
+    @Schema(title = "模板数据")
+    public final List<EntityTemplateInfo> getData() {
         return ConverterUtils.convertToList(readable().get(PARAMETER_KEY), EntityTemplateInfo::of);
     }
 
+    @Deprecated
+    public final List<EntityTemplateInfo> templateList() {
+        return getData();
+    }
+
     public final <E> List<E> templateList(Function<EntityTemplateInfo, E> converter) {
         return ConverterUtils.convertToList(readable().get(PARAMETER_KEY), f -> converter.apply(EntityTemplateInfo.of(f)));
     }
 
+    @Schema(title = "是否抛出错误")
     public boolean isThrowError() {
         return CastUtils.castBoolean(readable().getOrDefault("throwError", true));
     }
@@ -100,7 +109,7 @@ public <T> Flux<SaveByTemplateResult> execute(Function<EntityTemplateInfo, Mono<
                                                   Function<Flux<DataContext<T>>, Mono<Void>> handler,
                                                   int converterParallel) {
         return Flux
-            .fromIterable(templateList())
+            .fromIterable(getData())
             .flatMap(info -> converter
                 .apply(info)
                 .map(data -> DataContext.simple(info, data))
diff --git a/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/utils/ConverterUtils.java b/jetlinks-sdk-api/src/main/java/org/jetlinks/sdk/server/utils/ConverterUtils.java
@@ -2,23 +2,15 @@
 
 import com.fasterxml.jackson.databind.ObjectReader;
 import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-import io.netty.buffer.ByteBufUtil;
-import io.netty.buffer.Unpooled;
 import lombok.SneakyThrows;
-import org.apache.commons.collections4.MapUtils;
 import org.hswebframework.ezorm.core.param.Term;
 import org.hswebframework.web.api.crud.entity.TermExpressionParser;
 import org.hswebframework.web.bean.FastBeanCopier;
 import org.springframework.core.io.buffer.DataBuffer;
-import org.springframework.core.io.buffer.NettyDataBuffer;
-import org.springframework.core.io.buffer.NettyDataBufferFactory;
 import org.springframework.http.HttpHeaders;
-import org.springframework.util.MultiValueMap;
 
-import java.lang.reflect.Array;
-import java.nio.ByteBuffer;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -32,11 +24,7 @@ public class ConverterUtils {
      * @return 转换结果
      */
     public static Object tryConvertToList(Object value, Function<Object, Object> converter) {
-        List<Object> list = convertToList(value, converter);
-        if (list.size() == 1) {
-            return converter.apply(list.get(0));
-        }
-        return list;
+        return org.jetlinks.core.utils.ConverterUtils.tryConvertToList(value, converter);
     }
 
     /**
@@ -48,40 +36,7 @@ public static Object tryConvertToList(Object value, Function<Object, Object> con
      * @return 转换后的List
      */
     public static <T> List<T> convertToList(Object value, Function<Object, T> converter) {
-        if (value == null) {
-            return Collections.emptyList();
-        }
-
-        if (value instanceof String) {
-            String[] arr = ((String) value).split(",");
-            if (arr.length == 1) {
-                return Collections.singletonList(converter.apply(arr[0]));
-            }
-            List<T> list = new ArrayList<>(arr.length);
-            for (String s : arr) {
-                list.add(converter.apply(s));
-            }
-            return list;
-        }
-
-        if (value instanceof Collection) {
-            List<T> list = new ArrayList<>(((Collection<?>) value).size());
-            for (Object o : ((Collection<?>) value)) {
-                list.add(converter.apply(o));
-            }
-            return list;
-        }
-
-        if (value.getClass().isArray()) {
-            int len = Array.getLength(value);
-            List<T> list = new ArrayList<>(len);
-            for (int i = 0; i < len; i++) {
-                list.add(converter.apply(Array.get(value, i)));
-            }
-            return list;
-        }
-
-        return Collections.singletonList(converter.apply(value));
+        return org.jetlinks.core.utils.ConverterUtils.convertToList(value, converter);
     }
 
     /**
@@ -106,28 +61,7 @@ public static List<Object> convertToList(Object value) {
      */
     @SneakyThrows
     public static String[] convertMapToTags(Map<String, Object> map) {
-        if (MapUtils.isEmpty(map)) {
-            return new String[0];
-        }
-        String[] tags = new String[map.size() * 2];
-        int index = 0;
-        for (Map.Entry<String, Object> entry : map.entrySet()) {
-            String key = entry.getKey();
-            Object value = entry.getValue();
-            if (value == null) {
-                continue;
-            }
-            String strValue = value instanceof String
-                ? String.valueOf(value)
-                : ObjectMappers.JSON_MAPPER.writeValueAsString(value);
-
-            tags[index++] = key;
-            tags[index++] = strValue;
-        }
-        if (tags.length > index) {
-            return Arrays.copyOf(tags, index);
-        }
-        return tags;
+        return org.jetlinks.core.utils.ConverterUtils.convertMapToTags(map);
     }
 
     static final ObjectReader termReader = ObjectMappers.JSON_MAPPER.readerForListOf(Term.class);
@@ -171,98 +105,24 @@ public static List<Term> convertTerms(Object value) {
         }
     }
 
-    private static final NettyDataBufferFactory factory = new NettyDataBufferFactory(ByteBufAllocator.DEFAULT);
-
     public static DataBuffer convertDataBuffer(Object obj) {
-        if (obj == null) {
-            return null;
-        }
-        if (obj instanceof DataBuffer) {
-            return ((DataBuffer) obj);
-        }
-        return factory.wrap(convertNettyBuffer(obj));
+        return org.jetlinks.core.utils.ConverterUtils.convertDataBuffer(obj);
     }
 
     public static <T> ByteBuf convertNettyBuffer(T obj,
                                                  Function<T, ByteBuf> fallback) {
-        if (obj == null) {
-            return null;
-        }
-        if (obj instanceof ByteBuf) {
-            return ((ByteBuf) obj);
-        }
-
-        if (obj instanceof byte[]) {
-            return Unpooled.wrappedBuffer(((byte[]) obj));
-        }
-
-        if (obj instanceof NettyDataBuffer) {
-            return ((NettyDataBuffer) obj).getNativeBuffer();
-        }
-
-        if (obj instanceof DataBuffer) {
-            return Unpooled.wrappedBuffer(((DataBuffer) obj).asByteBuffer());
-        }
-
-        if (obj instanceof ByteBuffer) {
-            return Unpooled.wrappedBuffer(((ByteBuffer) obj));
-        }
-
-        if (obj instanceof String) {
-            String str = String.valueOf(obj);
-            // hex
-            if (str.startsWith("0x")) {
-                return Unpooled.wrappedBuffer(ByteBufUtil.decodeHexDump(str, 2, str.length() - 2));
-            }
-            //data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
-            if (str.startsWith("data:")) {
-                return Unpooled.wrappedBuffer(
-                    Base64
-                        .getDecoder()
-                        .decode(str.substring(str.indexOf(",") + 1)));
-            }
-            // base64
-            byte[] strBytes = str.getBytes();
-            if (org.apache.commons.codec.binary.Base64.isBase64(strBytes)) {
-                try {
-                    return Unpooled.wrappedBuffer(
-                        Base64
-                            .getDecoder()
-                            .decode(strBytes));
-                } catch (Throwable ignore) {
-                }
-            }
-            return Unpooled.wrappedBuffer(strBytes);
-        }
-
-        return fallback.apply(obj);
+        return org.jetlinks.core.utils.ConverterUtils.convertNettyBuffer(obj, fallback);
     }
 
     public static ByteBuf convertNettyBuffer(Object obj) {
-        return convertNettyBuffer(obj, val -> Unpooled.wrappedBuffer(String.valueOf(val).getBytes()));
+        return org.jetlinks.core.utils.ConverterUtils.convertNettyBuffer(obj);
     }
 
 
     @SuppressWarnings("all")
     public static HttpHeaders convertHttpHeaders(Object headers) {
-        if (headers instanceof HttpHeaders) {
-            return (HttpHeaders) headers;
-        }
-        if (headers instanceof MultiValueMap) {
-            return new HttpHeaders((MultiValueMap) headers);
-        }
-        if (headers instanceof Map<?, ?>) {
-            Map<?, ?> httpHeaders = (Map<?, ?>) headers;
-            HttpHeaders newHeader = new HttpHeaders();
-            for (Map.Entry<?, ?> entry : httpHeaders.entrySet()) {
-                newHeader.put(String.valueOf(entry.getKey()),
-                              convertToList(entry.getValue(), String::valueOf));
-            }
-            return newHeader;
-        }
-        return org.jetlinks.core.utils.ConverterUtils.convert(headers,HttpHeaders.class);
+        return org.jetlinks.core.utils.ConverterUtils.convertHttpHeaders(headers);
     }
 
 
-
 }

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,10 @@ public class DeleteByIdCommand<T> extends OperationByIdCommand<T, DeleteByIdComm`
`27`	`27`	`public DeleteByIdCommand() {`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ public DeleteByIdCommand(Class<T> type) {`
	`31`	`+ withConverter(CommandUtils.createConverter(ResolvableType.forClass(type)));`
	`32`	`+ }`
	`33`	`+`
`30`	`34`	`/**`
`31`	`35`	`* 使用指定的类型创建命令,执行命令后会将执行结果转换为指定类型`
`32`	`36`	`*`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,14 @@ public class SaveCommand<T> extends BatchDataCommand<T, SaveCommand<T>> {`
`22`	`22`	`public SaveCommand() {`
`23`	`23`	`}`
`24`	`24`
	`25`	`+ public SaveCommand(Class<T> type) {`
	`26`	`+ withConverter(CommandUtils.createConverter(ResolvableType.forClass(type)));`
	`27`	`+ }`
	`28`	`+`
	`29`	`+ public SaveCommand(Function<Object, T> converter) {`
	`30`	`+ withConverter(converter);`
	`31`	`+ }`
	`32`	`+`
`25`	`33`	`public static <T> SaveCommand<T> of(Class<T> type) {`
`26`	`34`	`return of(CommandUtils.createConverter(ResolvableType.forClass(type)));`
`27`	`35`	`}`