SpringBoot实现@FieldDict(source = DictEnum.ENUM, type = “general-status“, target = “feeStatusName“)

@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@Schema(description = "费率列表分页条件查询VO")
public class FeePageVO extends BaseVO {

    private static final long serialVersionUID = -2607204035474327417L;

    @Schema(description = "费率ID")
    private String id;

    @FieldDict(source = DictEnum.REDIS, type = "station", target = "stationName")
    @Schema(description = "站点ID")
    private String stationId;

    @Schema(description = "站点名称")
    private String stationName;

    @Schema(description = "费率名称")
    private String feeName;

    @FieldDict(source = DictEnum.ENUM, type = "general-status", target = "feeStatusName")
    @Schema(description = "费率状态：1、停用；0、启用；")
    private Integer feeStatus;

    @Schema(description = "费率状态名称")
    private String feeStatusName;
}

@Getter
@AllArgsConstructor
public enum DictEnum {

    ENUM, REDIS, OTHER

}

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})
public @interface FieldDict {

    /**
     * 数据来源
     */
    DictEnum source() default DictEnum.OTHER;

    /**
     * 数据标识
     */
    String type() default "";

    /**
     * 数据目标字段
     */
    String target() default "";

}

@Aspect
@Component
public class FieldDictAspect extends SimpleAspect {

    private static final long serialVersionUID = -4034897445169933339L;

    @Resource
    private RedissonClient redissonClient;

    @AfterReturning(pointcut = "execution(* *..*Service.*(..))", returning = "result")
    public Object afterReturning(Object result) {
        return judgeResult(result);
    }

    /**
     * 判断
     *
     * @param result x
     * @return x
     */
    private Object judgeResult(Object result) {
        if (ObjectUtil.isNotNull(result)) {
            if (result instanceof PageResult) {
                convertReturn(((PageResult<?>) result).getRecords());
                return result;
            }
            if (result instanceof ArrayList<?>) {
                convertReturn((List<?>) result);
                return result;
            }
            convertReturn(ListUtil.of(result));
            return result;
        }
        return result;
    }

    /**
     * 转化List
     *
     * @param list x
     */
    private void convertReturn(List<?> list) {
        if (CollUtil.isNotEmpty(list)) {
            Class<?> clazz = list.get(0).getClass();
            Field[] declaredFields = clazz.getDeclaredFields();
            list.forEach(obj -> {
                MetaObject metaObject = MetaObject.forObject(obj, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
                Arrays.stream(declaredFields).forEach(field -> { //判断属性之上是否有自己定义的注解
                    FieldDict annotation = field.getAnnotation(FieldDict.class);
                    if (ObjectUtil.isNotEmpty(annotation)) {
                      setTarget(field, annotation, metaObject);
                    }
                });
            });
        }
    }

    /**
     * 设置目标对象属性
     *
     * @param field      x
     * @param annotation x
     * @param metaObject x
     */
    private void setTarget(Field field, FieldDict annotation, MetaObject metaObject) {
        //如果有，则进行转换
        Object filedValue = metaObject.getValue(field.getName());
        if (ObjectUtil.isNotEmpty(filedValue)) {
            String targetField = annotation.target();
            switch (annotation.source()) {
                case ENUM:
                    metaObject.setValue(targetField, getEnum(filedValue, annotation));
                    break;
                case REDIS:
                    metaObject.setValue(targetField, getRedis(filedValue, annotation));
                    break;
                case OTHER:
                    System.err.println(""); //待定
                    break;
                default:
                    break;
            }
        }
    }

    /**
     * @param filedValue x
     * @param annotation x
     * @return x
     */
    private String getEnum(Object filedValue, FieldDict annotation) {
        Optional<KeyValueVO<?, ?>> optional = ConstantEnumService.mapEnum.get(annotation.type()).stream().filter(item -> item.getValue().equals(filedValue)).findFirst();
        if (optional.isPresent()) {
            return (String) optional.get().getKey();
        }
        return "";
    }

    private String getRedis(Object filedValue, FieldDict annotation) {
        String key = new StringBuilder().append("dict:").append(annotation.type()).toString().toUpperCase();
        Object obj = redissonClient.getMap(key).get(filedValue);
        if (ObjectUtils.isNotEmpty(obj)) {
            return obj.toString();
        }
        return "";
    }
}