如何利用Java使用AOP实现数据字典转换

CREATE TABLE `t_user` (
  `id` BIGINT(12) NOT NULL AUTO_INCREMENT,
  `user_code` VARCHAR(20) NOT NULL,
  `user_name` VARCHAR(50) NOT NULL,
  `user_type` CHAR(5) NOT NULL COMMENT '用户类型 -> U0101：普通用户，U0102：VIP用户',
  `gender` CHAR(5) NOT NULL COMMENT '用户性别 -> U0299：未知，U0201：男，U0202：女',
  PRIMARY KEY (`id`) 
) CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

@GetMapping("/{userCode}")
public UserVo queryUser(@PathVariable("userCode") String userCode) {
    UserDto userDto = userService.queryUserByCode(userCode);
    return userMapStruct.userDtoToUserVo(userDto);
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DictParam {
    
    String targetField() default "";

    
    String field();

    
    String dictType();
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DictHelper {
    
    DictParam[] value();
}

@Slf4j
@Aspect
public class DictHelperAspect {
    public DictHelperAspect() {
    }
    @Around("@annotation(dictHelper)")
    public Object doAround(ProceedingJoinPoint joinPoint, DictHelper dictHelper) {
        try {
            // 执行方法得到结果
            Object result = joinPoint.proceed();

            DictParam[] values = dictHelper.values();
            if (values == null || values.length == 0) {
                return result;
            }

            // 字典转换开始（使用反射）
            for (DictParam value : values) {
                Class<?> clazz = result.getClass();
                // 反射调用get方法获取字段值
                Method sourceMethod = clazz.getMethod("get" + firstToUppercase(value.field()));
                Object fieldValue = sourceMethod.invoke(result);
                // 获取字典值
                String dictValue = DictConfig.DICT_MAPPER.get(value.dictType()).get(fieldValue.toString());
                // 获取目标方法进行设值
                String targetField = StringUtils.isBlank(value.targetField()) ? value.field() : value.targetField();
                Method targetMethod = clazz.getMethod("set" + firstToUppercase(targetField), dictValue.getClass());
                targetMethod.invoke(result, dictValue);
            }
            return result;
        }
        catch (Throwable throwable) {
            log.error("error:", throwable);
            return null;
        }
    }

    private String firstToUppercase(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

@DictHelper(values = {
        @DictParam(field = "userType", targetField = "userTypeShow", dictType = "USER_TYPE"),
        @DictParam(field = "gender", targetField = "genderShow", dictType = "GENDER")
})
public UserDto queryUserByCode(String userCode) {
    UserEntity userEntity = userMapper.selectUser(userCode);
    return userMapStruct.userEntityToUserDto(userEntity);
}

public class DictConfig {
    public static final Map<String, Map<String, String>> DICT_MAPPER = new HashMap<>();
    static {
        Map<String, String> USER_TYPE = new HashMap<>();
        USER_TYPE.put("U0101", "普通用户");
        USER_TYPE.put("U0102", "VIP用户");
        DICT_MAPPER.put("USER_TYPE", USER_TYPE);

        Map<String, String> GENDER = new HashMap<>();
        GENDER.put("U0201", "男");
        GENDER.put("U0202", "女");
        GENDER.put("U0299", "未知");
        DICT_MAPPER.put("GENDER", GENDER);
    }
}