增加ConvertEnumValue功能

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

@@ -0,0 +1,28 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package org.redkale.convert;
+
+import java.lang.annotation.*;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * 用于枚举类序列化的字段名<br>
+ *
+ *
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.8.0
+ */
+@Inherited
+@Documented
+@Target({TYPE})
+@Retention(RUNTIME)
+public @interface ConvertEnumValue {
+
+    String value();
+}

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

@@ -243,7 +243,7 @@ public abstract class ConvertFactory<R extends Reader, W extends Writer> {
     public abstract ConvertFactory createChild(boolean tiny);
 
     protected SimpledCoder createEnumSimpledCoder(Class enumClass) {
-        return new EnumSimpledCoder(enumClass);
+        return new EnumSimpledCoder(this, enumClass);
     }
 
     protected Type formatObjectType(Type type) {

src/main/java/org/redkale/convert/ext/EnumSimpledCoder.java

@@ -5,9 +5,10 @@
  */
 package org.redkale.convert.ext;
 
-import org.redkale.convert.Reader;
-import org.redkale.convert.SimpledCoder;
-import org.redkale.convert.Writer;
+import java.lang.reflect.*;
+import java.util.*;
+import org.redkale.convert.*;
+import org.redkale.util.RedkaleClassLoader;
 
 /**
  * 枚举 的SimpledCoder实现
@@ -22,14 +23,50 @@ import org.redkale.convert.Writer;
  */
 public final class EnumSimpledCoder<R extends Reader, W extends Writer, E extends Enum> extends SimpledCoder<R, W, E> {
 
-    public EnumSimpledCoder(Class<E> type) {
+    private final Encodeable valueEncoder;
+
+    private final Map<E, Object> enumToValues;
+
+    private final Map<String, E> valueToEnums;
+
+    public EnumSimpledCoder(final ConvertFactory factory, Class<E> type) {
         this.type = type;
+        ConvertEnumValue cev = type.getAnnotation(ConvertEnumValue.class);
+        if (cev == null) {
+            this.valueEncoder = null;
+            this.enumToValues = null;
+            this.valueToEnums = null;
+        } else {
+            try {
+                String fieldName = cev.value();
+                Field field = type.getDeclaredField(fieldName);
+                RedkaleClassLoader.putReflectionField(fieldName, field);
+                char[] chs = fieldName.toCharArray();
+                chs[0] = Character.toUpperCase(chs[0]);
+                String methodName = "get" + new String(chs);
+                Method method = type.getMethod(methodName);
+                RedkaleClassLoader.putReflectionMethod(methodName, method);
+                Map<E, Object> map1 = new HashMap<>();
+                Map<String, E> map2 = new HashMap<>();
+                for (E e : type.getEnumConstants()) {
+                    map1.put(e, method.invoke(e));
+                    map2.put(method.invoke(e).toString(), e);
+                }
+                this.valueEncoder = factory.loadEncoder(field.getType());
+                this.enumToValues = map1;
+                this.valueToEnums = map2;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
     }
 
     @Override
     public void convertTo(final W out, final E value) {
         if (value == null) {
             out.writeNull();
+        } else if (valueEncoder != null) {
+            valueEncoder.convertTo(out, enumToValues.get(value));
         } else {
             out.writeSmallString(value.toString());
         }
@@ -40,11 +77,16 @@ public final class EnumSimpledCoder<R extends Reader, W extends Writer, E extend
     public E convertFrom(final R in) {
         String value = in.readSmallString();
         if (value == null) return null;
-        return (E) Enum.valueOf((Class<E>) type, value);
+        if (valueToEnums != null) {
+            return valueToEnums.get(value);
+        } else {
+            return (E) Enum.valueOf((Class<E>) type, value);
+        }
     }
 
     @Override
     public Class<E> getType() {
         return (Class<E>) type;
     }
+
 }