ColumnHandler

src/main/java/org/redkale/boot/Application.java

@@ -303,9 +303,9 @@ public final class Application {
                 "jsonconvert", Convert.class, JsonFactory.root().getConvert());
         this.resourceFactory.register(
                 "protobufconvert", Convert.class, ProtobufFactory.root().getConvert());
-        BsonFactory.root().registerColumnHandlerConsumer(resourceFactory::inject);
+        BsonFactory.root().registerFieldFuncConsumer(resourceFactory::inject);
-        JsonFactory.root().registerColumnHandlerConsumer(resourceFactory::inject);
+        JsonFactory.root().registerFieldFuncConsumer(resourceFactory::inject);
-        ProtobufFactory.root().registerColumnHandlerConsumer(resourceFactory::inject);
+        ProtobufFactory.root().registerFieldFuncConsumer(resourceFactory::inject);
 
         // 系统内部模块组件
         moduleEngines.add(this.sourceModule); // 放第一，很多module依赖于source

src/main/java/org/redkale/convert/ConvertColumnHandler.java

@@ -8,7 +8,7 @@ package org.redkale.convert;
 import java.lang.annotation.*;
 import static java.lang.annotation.ElementType.*;
 import static java.lang.annotation.RetentionPolicy.*;
-import java.util.function.BiFunction;
+import org.redkale.util.ColumnHandler;
 
 /**
  * 字段值转换器，常见于脱敏操作
@@ -28,11 +28,11 @@ public @interface ConvertColumnHandler {
     /**
      * 字段值转换器
      *
-     * @return BiFunction<String, Object, Object>实现类
+     * @return ColumnHandler实现类
      *
      * @since 2.8.0
      */
-    Class<? extends BiFunction> value() default BiFunction.class;
+    Class<? extends ColumnHandler> value() default ColumnHandler.class;
 
     /**
      * 解析/序列化定制化的TYPE

src/main/java/org/redkale/convert/ConvertFactory.java

@@ -61,7 +61,7 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
 
     private final ConcurrentHashMap<AccessibleObject, ConvertColumnEntry> columnEntrys = new ConcurrentHashMap();
 
-    private final ConcurrentHashMap<Class, BiFunction> columnHandlers = new ConcurrentHashMap();
+    private final ConcurrentHashMap<Class, BiFunction> fieldFuncs = new ConcurrentHashMap();
 
     private final Set<Class> skipIgnores = new HashSet();
 
@@ -74,7 +74,7 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
 
     private boolean skipAllIgnore = false;
 
-    private Consumer<BiFunction> columnHandlerConsumer;
+    private Consumer<BiFunction> fieldFuncConsumer;
 
     protected ConvertFactory(ConvertFactory<R, W> parent, int features) {
         this.features = features;
@@ -436,17 +436,17 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
         }
         for (ConvertColumnHandler h : chs) {
             if (h.type().contains(ct)) {
-                Class<? extends BiFunction> handlerClass = h.value();
+                Class<? extends ColumnHandler> handlerClass = h.value();
-                if (handlerClass != BiFunction.class) {
+                if (handlerClass != ColumnHandler.class) {
                     colConvertType = h.type();
-                    colHandler = findColumnHandler(handlerClass);
+                    colHandler = findFieldFunc(handlerClass);
                     if (colHandler == null) {
                         try {
                             colHandler = handlerClass.getConstructor().newInstance();
                         } catch (Exception e) {
                             throw new ConvertException(e);
                         }
-                        Consumer<BiFunction> consumer = findColumnHandlerConsumer();
+                        Consumer<BiFunction> consumer = findFieldFuncConsumer();
                         if (consumer != null) {
                             consumer.accept(colHandler);
                         }
@@ -918,11 +918,11 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
         return child;
     }
 
-    private Consumer<BiFunction> findColumnHandlerConsumer() {
+    private Consumer<BiFunction> findFieldFuncConsumer() {
-        if (columnHandlerConsumer != null) {
+        if (fieldFuncConsumer != null) {
-            return columnHandlerConsumer;
+            return fieldFuncConsumer;
         }
-        return parent == null ? null : parent.findColumnHandlerConsumer();
+        return parent == null ? null : parent.findFieldFuncConsumer();
     }
 
     private Class findEntityAlias(String name) {
@@ -935,8 +935,8 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
      *
      * @param consumer ColumnHandler处理函数
      */
-    public final void registerColumnHandlerConsumer(Consumer<BiFunction> consumer) {
+    public final void registerFieldFuncConsumer(Consumer<BiFunction> consumer) {
-        this.columnHandlerConsumer = consumer;
+        this.fieldFuncConsumer = consumer;
     }
 
     /**
@@ -1110,12 +1110,12 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
         return result;
     }
 
-    public final <C extends BiFunction> BiFunction findColumnHandler(Class<C> type) {
+    public final <C extends BiFunction> BiFunction findFieldFunc(Class<C> type) {
-        BiFunction handler = columnHandlers.get(type);
+        BiFunction handler = fieldFuncs.get(type);
         if (handler != null) {
             return handler;
         }
-        return this.parent == null ? null : this.parent.findColumnHandler(type);
+        return this.parent == null ? null : this.parent.findFieldFunc(type);
     }
 
     // ----------------------------------------------------------------------
@@ -1124,7 +1124,7 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
     }
 
     public final <C extends BiFunction> void register(Class<C> clazz, C columnHandler) {
-        columnHandlers.put(Objects.requireNonNull(clazz), Objects.requireNonNull(columnHandler));
+        fieldFuncs.put(Objects.requireNonNull(clazz), Objects.requireNonNull(columnHandler));
     }
 
     public final <E> void register(final Type clazz, final SimpledCoder<R, W, E> coder) {

src/main/java/org/redkale/util/ColumnHandler.java

@@ -0,0 +1,29 @@
+/*
+
+*/
+
+package org.redkale.util;
+
+import java.util.function.BiFunction;
+
+/**
+ * 字段值转换器，常见于脱敏操作
+ *
+ * <p>详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.8.0
+ * @param <F> 泛型
+ * @param <V> 泛型
+ */
+public interface ColumnHandler<F, V> extends BiFunction<String, F, V> {
+
+    /**
+     * 字段值转换
+     * @param field 字段名
+     * @param value 字段值
+     * @return 新的字段值
+     */
+    @Override
+    public V apply(String field, F value);
+}

src/test/java/org/redkale/test/convert/ConvertColumnHandlerTest.java

@@ -4,10 +4,10 @@
 
 package org.redkale.test.convert;
 
-import java.util.function.BiFunction;
 import org.junit.jupiter.api.*;
 import org.redkale.convert.ConvertColumnHandler;
 import org.redkale.convert.json.JsonConvert;
+import org.redkale.util.ColumnHandler;
 
 /**
  *
@@ -57,7 +57,7 @@ public class ConvertColumnHandlerTest {
         }
     }
 
-    public static class ParamColumnHandler implements BiFunction<String, String, String> {
+    public static class ParamColumnHandler implements ColumnHandler<String, String> {
 
         @Override
         public String apply(String field, String value) {