java 实现自定义注解实现字典翻译

已于 2022-12-15 14:13:55 修改
阅读量3k 收藏 9
点赞数
分类专栏： java 文章标签： java
于 2022-04-24 15:57:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37741426/article/details/124384690
版权

  1. 1、定义接口

    /** * 数据字典注解 */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Dict {

    /**
 * 字典类型
 *
 * @return
 */
String dictCode();

/**
 * 返回属性名
 *
 * @return
 */
String dictText() default ""; }

    2、定义切面 /** * 数据字典切面 */
    @Aspect @Component @Slf4j public class
    DictAspect {

    /**
 * 字典后缀
 */
private static String DICT_TEXT_SUFFIX = "Text";

@Autowired
private ISysDictTypeService dictTypeService;

/**
 * 切点，切入 controller 包下面的所有方法
 */
@Pointcut("execution( * com.ruoyi.*.controller.huandian.*.*(..)) || execution( * com.ruoyi.*.controller.*.*(..)) ")
public void dict() {

}

@Around("dict()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    long time1 = System.currentTimeMillis();
    Object result = pjp.proceed();
    long time2 = System.currentTimeMillis();
    //  log.debug("获取JSON数据 耗时：" + (time2 - time1) + "ms");
    long start = System.currentTimeMillis();
    this.parseDictText(result);
    long end = System.currentTimeMillis();
    //   log.debug("解析注入JSON数据  耗时" + (end - start) + "ms");
    return result;
}

private void parseDictText(Object result) {
    List<JSONObject> items = new ArrayList<>();
    if (result instanceof AjaxResult) {
        AjaxResult rr = (AjaxResult) result;
        if (rr.getData() instanceof String) {
            //字符串直接返回
            rr.setData(rr.getData());
        } else {
            rr.setData(getDataModel(rr.getData()));
        }
    } else if (result instanceof TableDataInfo) {
        TableDataInfo rr = (TableDataInfo) result;
        List<?> list = (List<?>) rr.getRows();
        getData(items, list);
        rr.setRows(items);
    } else if (result instanceof PageDataInfo) {
        PageDataInfo rr = (PageDataInfo) result;
        List<?> list = (List<?>) rr.getData();
        getData(items, list);
        rr.setData(items);
    }
}


private void getData(List<JSONObject> items, List<?> listData) {
    List<?> list = listData;
    for (Object record : list) {
        ObjectMapper mapper = new ObjectMapper();
        String json = "{}";
        try {
            json = mapper.writeValueAsString(record);
        } catch (JsonProcessingException e) {
            log.error("Json解析失败：" + e);
        }
        JSONObject item = JSONObject.parseObject(json);
        for (Field field : ObjConvertUtils.getAllFields(record)) {
            if (field.getAnnotation(Dict.class) != null) {
                // 拿到注解的dictDataSource属性的值
                String dictType = field.getAnnotation(Dict.class).dictCode();
                // 拿到注解的dictText属性的值
                String text = field.getAnnotation(Dict.class).dictText();
                //获取当前带翻译的值
                String key = String.valueOf(item.get(field.getName()));
                //翻译字典值对应的text值
                String textValue = translateDictValue(dictType, key);
                //如果给了文本名
                if (!StringUtils.isBlank(text)) {
                    item.put(text, textValue);
                } else {
                    // 走默认策略
                    item.put(field.getName() + DICT_TEXT_SUFFIX, textValue);
                }
            }
            // date类型默认转换string格式化日期
            if ("java.util.Date".equals(field.getType().getName())
                    && field.getAnnotation(JsonFormat.class) == null
                    && item.get(field.getName()) != null) {
                SimpleDateFormat aDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
            }
        }
        items.add(item);
    }
}


private JSONObject getDataModel(Object data) {
    ObjectMapper mapper = new ObjectMapper();
    String json = "{}";
    try {
        json = mapper.writeValueAsString(data);
    } catch (JsonProcessingException e) {
        log.error("Json解析失败：" + e);
    }
    JSONObject item = JSONObject.parseObject(json);
    for (Field field : ObjConvertUtils.getAllFields(data)) {
        if (field.getAnnotation(Dict.class) != null) {
            String dictType = field.getAnnotation(Dict.class).dictCode();
            String text = field.getAnnotation(Dict.class).dictText();
            String key = String.valueOf(item.get(field.getName()));
            String textValue = translateDictValue(dictType, key);
            if (!StringUtils.isBlank(text)) {
                item.put(text, textValue);
            } else {
                // 走默认策略
                item.put(field.getName() + DICT_TEXT_SUFFIX, textValue);
            }
        }
        if ("java.util.Date".equals(field.getType().getName())
                && field.getAnnotation(JsonFormat.class) == null
                && item.get(field.getName()) != null) {
            SimpleDateFormat aDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
        }
    }
    return item;

}

/**
 * 翻译字典文本
 *
 * @param dictType
 * @param key
 * @return
 */
private String translateDictValue(String dictType, String key) {
    if (StringUtils.isEmpty(key)) {
        return null;
    }
    StringBuffer textValue = new StringBuffer();
    String[] keys = key.split(",");
    for (String k : keys) {
        if (k.trim().length() == 0) {
            continue;
        }
        String dict_label = "";
        List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
        if (null == data) {
            return dict_label;
        }
        for (SysDictData sysDictData : data) {
            if (sysDictData.getDictValue().equals(key)) {
                dict_label = sysDictData.getDictLabel();
            }
        }
        textValue.append(dict_label);
        //log.info("数据字典翻译: 字典类型：{}，当前翻译值：{}，翻译结果：{}", dictType, k.trim(), dict_label);
    }
    return textValue.toString();
} }

3、工具类 /**  * 对象转换工具类  */ @SuppressWarnings("ALL") public class ObjConvertUtils {

/**
 * 获取类的所有属性，包括父类
 *
 * @param object
 * @return
 */
public static Field[] getAllFields(Object object) {
    Class<?> clazz = object.getClass();
    List<Field> fieldList = new ArrayList<>();
    while (clazz != null) {
        fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
        clazz = clazz.getSuperclass();
    }
    Field[] fields = new Field[fieldList.size()];
    fieldList.toArray(fields);
    return fields;
}

public static boolean isEmpty(Object object) {
    if (object == null) {
        return (true);
    }
    if ("".equals(object)) {
        return (true);
    }
    if ("null".equals(object)) {
        return (true);
    }
    return (false);
} }

    4、返回模型 import java.io.Serializable;

    /** * 操作消息提醒 * * @author Lion Li */
    @Data @NoArgsConstructor
    @AllArgsConstructor
    @Accessors(chain = true)
    @ApiModel(“操作消息提醒”)
    public class AjaxResult implements Serializable {

    private static final long serialVersionUID = 7364644042368216173L;

/**
 * 状态码
 */
@ApiModelProperty("状态码")
private int code;

/**
 * 返回内容
 */
@ApiModelProperty("返回内容")
private String msg;

/**
 * 数据对象
 */
@ApiModelProperty("数据对象")
private T data;

/**
 * 初始化一个新创建的 AjaxResult 对象
 *
 * @param code 状态码
 * @param msg  返回内容
 */
public AjaxResult(int code, String msg) {
    this.code = code;
    this.msg = msg;
}

/**
 * 返回成功消息
 *
 * @return 成功消息
 */
public static AjaxResult<Void> success() {
    return AjaxResult.success("操作成功");
}

/**
 * 返回成功数据
 *
 * @return 成功消息
 */
public static <T> AjaxResult<T> success(T data) {
    return AjaxResult.success("操作成功", data);
}

/**
 * 返回成功消息
 *
 * @param msg 返回内容
 * @return 成功消息
 */
public static AjaxResult<Void> success(String msg) {
    return AjaxResult.success(msg, null);
}

/**
 * 返回成功消息
 *
 * @param msg  返回内容
 * @param data 数据对象
 * @return 成功消息
 */
public static <T> AjaxResult<T> success(String msg, T data) {
    return new AjaxResult<>(HttpStatus.HTTP_OK, msg, data);
}

/**
 * 返回错误消息
 *
 * @return
 */
public static AjaxResult<Void> error() {
    return AjaxResult.error("操作失败");
}

/**
 * 返回错误消息
 *
 * @param msg 返回内容
 * @return 警告消息
 */
public static AjaxResult<Void> error(String msg) {
    return AjaxResult.error(msg, null);
}

/**
 * 返回错误消息
 *
 * @param msg  返回内容
 * @param data 数据对象
 * @return 警告消息
 */
public static <T> AjaxResult<T> error(String msg, T data) {
    return new AjaxResult<>(HttpStatus.HTTP_INTERNAL_ERROR, msg, data);
}

/**
 * 返回错误消息
 *
 * @param code 状态码
 * @param msg  返回内容
 * @return 警告消息
 */
public static AjaxResult<Void> error(int code, String msg) {
    return new AjaxResult<>(code, msg, null);
}

    }

    5、使用 添加注解即可
    @ApiModelProperty(value = “状态 0-使用中 1-已归还”)
    @Dict(dictCode = “orderStatus”)
    private Integer status; ```请添加图片描述
    请添加图片描述

用到的类

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.List;

/**
 * 表格分页数据对象
 *
 * @author Lion Li
 */

@Data
@NoArgsConstructor
@Accessors(chain = true)
@ApiModel("分页对象")
public class TableDataInfo<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 总记录数
     */
    @ApiModelProperty("总记录数")
    private long total;

    /**
     * 列表数据
     */
    @ApiModelProperty("列表数据")
    private List<T> rows;

    /**
     * 消息状态码
     */
    @ApiModelProperty("消息状态码")
    private int code;

    /**
     * 消息内容
     */
    @ApiModelProperty("消息内容")
    private String msg;

    /**
     * 分页
     *
     * @param list  列表数据
     * @param total 总记录数
     */
    public TableDataInfo(List<T> list, long total) {
        this.rows = list;
        this.total = total;
    }
    public TableDataInfo(List<T> list, long total,String msg,int code) {
        this.rows = list;
        this.total = total;
        this.msg = msg;
        this.code = code;
    }
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.List;

/**
 * 表格分页数据对象
 *
 * @author Lion Li
 */

@Data
@NoArgsConstructor
@Accessors(chain = true)
@ApiModel("分页响应对象")
public class PageDataInfo<T> implements Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * 总记录数
	 */
	@ApiModelProperty("总记录数")
	private long total;

	/**
	 * 列表数据
	 */
	@ApiModelProperty("列表数据")
	private List<T> data;

	/**
	 * 消息状态码
	 */
	@ApiModelProperty("消息状态码")
	private int code;

	/**
	 * 消息内容
	 */
	@ApiModelProperty("消息内容")
	private String msg;

	/**
	 * 分页
	 *
	 * @param list  列表数据
	 * @param total 总记录数
	 */
	public PageDataInfo(List<T> list, long total) {
		this.data = list;
		this.total = total;
	}

}

import cn.hutool.http.HttpStatus;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * 操作消息提醒
 *
 * @author Lion Li
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@ApiModel("操作消息提醒")
public class AjaxResult<T> implements Serializable {

    private static final long serialVersionUID = 7364644042368216173L;

    /**
     * 状态码
     */
    @ApiModelProperty("状态码")
    private int code;

    /**
     * 返回内容
     */
    @ApiModelProperty("返回内容")
    private String msg;

    /**
     * 数据对象
     */
    @ApiModelProperty("数据对象")
    private T data;

    /**
     * 初始化一个新创建的 AjaxResult 对象
     *
     * @param code 状态码
     * @param msg  返回内容
     */
    public AjaxResult(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static AjaxResult<Void> success() {
        return AjaxResult.success("操作成功");
    }

    /**
     * 返回成功数据
     *
     * @return 成功消息
     */
    public static <T> AjaxResult<T> success(T data) {
        return AjaxResult.success("操作成功", data);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @return 成功消息
     */
    public static AjaxResult<Void> success(String msg) {
        return AjaxResult.success(msg, null);
    }

    /**
     * 返回成功消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static <T> AjaxResult<T> success(String msg, T data) {
        return new AjaxResult<>(HttpStatus.HTTP_OK, msg, data);
    }

    /**
     * 返回错误消息
     *
     * @return
     */
    public static AjaxResult<Void> error() {
        return AjaxResult.error("操作失败");
    }

    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static AjaxResult<Void> error(String msg) {
        return AjaxResult.error(msg, null);
    }

    /**
     * 返回错误消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static <T> AjaxResult<T> error(String msg, T data) {
        return new AjaxResult<>(HttpStatus.HTTP_INTERNAL_ERROR, msg, data);
    }

    /**
     * 返回错误消息
     *
     * @param code 状态码
     * @param msg  返回内容
     * @return 警告消息
     */
    public static AjaxResult<Void> error(int code, String msg) {
        return new AjaxResult<>(code, msg, null);
    }


}
天空下sky
关注
专栏目录
java实现应用系统中字典统一翻译组件
F_Hello_World的博客
11-23 1637
字典翻译在我们应用里是一个很正常普遍的需求。 对于小型项目我们可能在数据库设计层面通常不会进行分库处理，那么对于此类项目，通常字典翻译会通过sql语句的子查询来处理，如果业务系统中存在较多的字段为code值时，我们需要编写大量的子查询用于code->name 的代码。在代码层面上造成代码的冗余，在查询数据体量较大的情况并且编写sql人员的能力的不足导致查询性能问题。 对于中大型项目我们可...
java bean 转bean_BeanUtils——JavaBean相互转换及字典翻译
weixin_34641420的博客
02-16 516
翻译JavaBean中带有@CacheFormat的属性/*** 翻译当前类中需要翻译的字典值@param source 待翻译的对象*/public static//判断原对象是否为nullAssert.notNull(source, "待翻译的原对象不能为null");//获取所有属性并翻译字典Field[] declaredFields = source.getClass().getDecl...
java如何自定义注解,实现对某一个字典进行翻译
weixin_44409773的博客
06-24 1025
java自定义注解实现对某个字段的字典进行翻译
自定义注解字典回显
最新发布
_紫陌纤尘的博客
06-19 346
业务：表中大量字段为字典值，列表查询需要关联多次字典表。为简化改过程，便有了该帖子。
JAVA 实战 字典自动翻译
qq_41867674的博客
12-28 845
java 字典自动翻译
java 注解 数据字典_Spring实现数据字典翻译
weixin_33549115的博客
03-05 2530
在开始之前，首先我们要了解一个类：BeanPropertyWriter。这个类是由SerializerFactory 工厂进行实例化的，其作用是对bean中的每个字段进行jackson操作的封装，其中封装了字段的一些元信息，和对此字段进行jackson序列化的操作。采用Spring项目进行Web服务开发时，在获取到数据后，Spring会通过BeanPropertyWriter对数据进行jackso...
一文了解 OutOfMemory 及解决方案
javarrr的博客
02-17 602
1. Java 堆空间 发生频率 5颗星 造成原因 无法在 Java 堆中分配对象 吞吐量增加 应用程序无意中保存了对象引用，对象无法被 GC 回收 应用程序过度使用 finalizer。finalizer 对象不能被 GC 立刻回收。finalizer 由结束队列服务的守护线程调用，有时 finalizer 线程的处理能力无法跟上结束队列的增长   解决方案 单位对应：GB -...
Java自定义注解+反射实现字典码值转换
晨港飞燕的专栏
03-27 2397
一.定义自定义注解 @Retention(RetentionPolicy.RUNTIME)//什么时候使用该注解，这里定义为运行时 @Target(ElementType.FIELD)//注解用于什么地方，这里定义为作用于属性上 public @interface Dict { //字典类型,必需(创建字典时的key值) String key(); //默认值,可选,值为null时使用默认值 String defaultValue() default "";
Aop+自定义注解实现数据字典翻译
Dawn.x的博客
11-30 2370
目录前言源码思维导图 前言 一般来说，项目开发会用自定义注解去实现日志监控等操作 在实际项目中，前后台数据交互时，每次都需要根据一个code值去进行查询数据库进行中间操作进行获取text值 本博文用自定义注解结合aop实现数据字典的自动翻译 源码 首先附上数据库表结构： 数据字典表（dict） 数据字典类型中间表（dict_type） 用户表（user） 注解类（Dict） package com.xiaoyang.annotation; import java.lang.annotation.E
使用自定义注解翻译字典项
leomoon
11-20 1099
使用自定义注解翻译字典项 使用拦截器/aop
注解实现字典值转换
东坡居士的博客
03-24 1227
字典值转换
java在线英汉字典
12-28
java在线字典 利用金山词霸在线翻译 很简单的
java翻译工具
08-04
java写的翻译工具，可以将java代码翻译成c++代码
基于Java技术的英汉互译词典
07-09
名称：基于Java英汉互译词典 技术：Java 环境：IDEA、mysql 包内容：英汉互译词典源码、mysql文件Word.sql、jar包
java 字典项翻译
weixin_44719155的博客
01-10 218
反射的场景小应用
[Java] 自定义注解
Pratise的Code成长史
02-25 145
@Target @Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。 作用：用于描述注解的使用范围（即：被描述的注解...
java 注解实现实体字段翻译(数据字典、枚举、数据库...)
u010012932的博客
07-05 3827
字段翻译(数据字典、部门...)
JAVA_翻译词典
Lan_Se_Tian_Ma的博客
07-08 1110
我是用Properties属性集做的,用它做的限制只有一个属性文件（txt文件）里的格式必须是这样的（可以用word替换成这样的格式，建议用台式机，差不多一个小时，笔记本就算了。。。）例：abaft=向船尾@在...后abalone=鲍鱼abandon=放弃;沉溺@放任abandoned=被抛弃的;自弃的;自甘堕落的abandonee=被遗弃者;被委付者abandoner=遗弃者;委付者aband...
java 通过自定义注解验签
11-29
根据提供的引用内容，我们可以看出这是一个Java Web项目，其中包含了自定义注解和拦截器的使用。在Java中，我们可以通过自定义注解和拦截器来实现验签功能。具体步骤如下： 1.定义自定义注解@Sign，用于标记需要验签的方法或类。 2.定义拦截器，在拦截器中获取请求参数和签名，并进行验签操作。 下面是一个简单的Java验签示例： ```java // 自定义注解 @Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface Sign { } // 拦截器 @Component public class SignInterceptor implements HandlerInterceptor { @Autowired private SignService signService; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 判断是否有@Sign注解 if (handler instanceof HandlerMethod) { HandlerMethod handlerMethod = (HandlerMethod) handler; Sign sign = handlerMethod.getMethodAnnotation(Sign.class); if (sign == null) { sign = handlerMethod.getBeanType().getAnnotation(Sign.class); } if (sign != null) { // 获取请求参数和签名 Map<String, String[]> parameterMap = request.getParameterMap(); String signValue = request.getHeader("sign"); // 验签 boolean verifyResult = signService.verifySign(parameterMap, signValue); if (!verifyResult) { // 验签失败，返回错误信息 response.setContentType("application/json;charset=UTF-8"); response.getWriter().write("{\"code\":400,\"msg\":\"验签失败\"}"); return false; } } } return true; } } // 验签服务 @Service public class SignService { // 验签密钥 private static final String SIGN_KEY = "123456"; /** * 验签 * * @param parameterMap 请求参数 * @param signValue 签名 * @return 验签结果 */ public boolean verifySign(Map<String, String[]> parameterMap, String signValue) { // 将请求参数按照字典序排序并拼接成字符串 StringBuilder sb = new StringBuilder(); parameterMap.keySet().stream().sorted().forEach(key -> { String[] values = parameterMap.get(key); Arrays.sort(values); sb.append(key).append("=").append(values[0]).append("&"); }); sb.append("key=").append(SIGN_KEY); // 计算签名 String sign = DigestUtils.md5Hex(sb.toString()); // 验证签名 return StringUtils.equals(sign, signValue); } } // 控制器 @RestController public class TestController { @Autowired private SignService signService; @PostMapping("/test") @Sign public ResponseBody<AuthCodeJson> getAuthCode(@CurrentUser UserInfo userInfo) { System.out.println(userInfo.getId()); System.out.println(ThreadContextHolder.getUserInfo().getUserId()); return this.success(); } } ``` 在上面的示例中，我们定义了一个自定义注解@Sign，用于标记需要验签的方法或类。然后定义了一个拦截器SignInterceptor，在拦截器中获取请求参数和签名，并进行验签操作。最后，在控制器TestController中使用@Sign注解标记了需要验签的方法getAuthCode。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值