MyBatis通过枚举实现字段自动转义

Yohann-study

MyBatis通过枚举实现字段自动转义

定义接口规范

public interface TranslationEnum {
    /**
     * 获取枚举只
     *
     * @param code 枚举编号
     * @return 枚举值
     */
    Object getValue(Object code);
}

定义运行时注解

/**
 * 开启字段转化功能
 *
 * @author Yeung Wah
 * @since 2021/9/17
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EnableConvert {
}

/**
 * 枚举转化信息
 *
 * @author Yeung Wah
 * @since 2021/9/17
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ConvertEnum {
    /**
     * 枚举类
     *
     * @return 枚举类字节码信息
     */
    Class<? extends TranslationEnum> clazz();

    /**
     * 需要翻译的字段
     *
     * @return 字段名
     */
    String codeField();
}

POJO及枚举配置

@EnableConvert
public class TestEntity {
    @ConvertEnum(clazz = TestEnum.class, codeField = "age")
    private String name;
    private Integer age;
}

@Getter
public enum TestEnum implements TranslationEnum{
    /**
     * test enums
     */
    TEST_1(1, "test1"),
    TEST_2(2, "test2"),
    ;

    private Integer code;
    private String value;

    TestEnum(Integer code, String value) {
        this.code = code;
        this.value = value;
    }

    /**
     * 静态缓存枚举加速
     */
    private static final Map<Object, String> VALUE_MAP = new HashMap<>(TestEnum.values().length * 4 / 3);

    static {
        for (TestEnum value : TestEnum.values()) {
            VALUE_MAP.put(value.code, value.value);
        }
    }

    @Override
    public Object getValue(Object code) {
        return VALUE_MAP.get(code);
    }
}

工具类具体实现

@Slf4j
public class ConvertUtils {

    private ConvertUtils() {
    }

    public static <T> void convertEnums(T t) {
        //对象为空则直接结束
        if (Objects.isNull(t)) {
            return;
        }

        for (Class<?> clazz = t.getClass(); !clazz.equals(Object.class); clazz = clazz.getSuperclass()) {
            //开启翻译
            if (clazz.isAnnotationPresent(EnableConvert.class)) {
                Field[] fields = clazz.getDeclaredFields();
                Field.setAccessible(fields, true);

                for (Field field : fields) {
                    //枚举翻译
                    ConvertEnum convertEnum = field.getAnnotation(ConvertEnum.class);
                    if (Objects.nonNull(convertEnum)) {
                        //获取注解信息
                        Class<? extends TranslationEnum> enumClazz = convertEnum.clazz();

                        try {
                            //获取需要翻译的字段值
                            Field codeField = clazz.getDeclaredField(convertEnum.codeField());
                            codeField.setAccessible(true);
                            Object code = codeField.get(t);

                            //获取枚举实例对象 獲取映射字段
                            if (!enumClazz.isEnum()) {
                                throw new RuntimeException(enumClazz.getName() + "非枚举类型");
                            } else if (enumClazz.getEnumConstants().length == 0) {
                                throw new RuntimeException(enumClazz.getName() + "无实例");
                            }
                            TranslationEnum translationEnum = enumClazz.getEnumConstants()[0];
                            if (Objects.nonNull(translationEnum)) {
                                Object value = translationEnum.getValue(code);
                                field.set(t, value);
                            }
                        } catch (Exception e) {
                            LogUtils.debug("convert exception:" + e.getMessage(), e);
                        }
                    }
                }
            }
        }
    }

    public static <T> void convertEnums(List<T> list) {
        //集合为空则直接结束
        if (list.isEmpty()) {
            return;
        }

        list.forEach(ConvertUtils::convertEnums);
    }

}

mybatis拦截器转义结果集

@Configuration
public class MyBatisTranslateConfig {

    @Bean
    public TranslateInterceptor getInterceptor() {
        return new TranslateInterceptor();
    }

    /**
     * 自定义拦截器
     */
    @Intercepts({
            @Signature(
                    // 只拦截查询
                    method = "query",
                    type = Executor.class,
                    args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
            @Signature(
                    //处理结果集
                    type = ResultSetHandler.class,
                    method = "handleResultSets",
                    args = Statement.class)
    })
    private static class TranslateInterceptor implements Interceptor {
        @Override
        @SuppressWarnings("unchecked")
        public Object intercept(Invocation invocation) throws Throwable {
            List<Object> objects = (List<Object>) invocation.proceed();
            ConvertUtils.convertEnums(objects);
            return objects;
        }
    }
}