需求
- 在服务端开发,数据库表中有些字段对应的是字典值,在查询的时候要展示字典值,这个时候可能就需要关联字典表查询,或者在前后端开发过程中,由前端页面展示的部分调取字典服务的接口来展示,但这样都有问题,前者是数据库字典变更时要修改SQL,都不合理,那有没有更优雅的方式来完成字典值翻译呢?
思路
- 现在都使用springboot来开发服务,springboot的注解太好用了,能不能使用切面拦截器的方式来完成字典翻译呢?
@TranslationDict({@DictParam(dictCode = "USER_GENDER_CODE",dictValueFiled = "gender",dictNameFiled = "genderName")})
- 启用AOP 拦截注解TranslationDict,注解里描述需要翻译的字段,字典CODE,和目标字段(翻译完成后对应的值存储)
一、新建注解类
package com.epf.dict;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 翻译字典值注解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
@Documented
public @interface TranslationDict {
DictParam[] value();
}
package com.epf.dict;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 需要翻译的字典值
*
* */
@Target(value={ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DictParam {
/**
* 字典CODE
* @return
*/
String dictCode() default "";
/**
* 需要翻译的字段名
* @return
*/
String dictValueFiled() default "";
/**
* 被翻译的字段名
* @return
*/
String dictNameFiled() default "";
}
二、新建拦截器
package com.epf.dict.aspect;
import static com.alibaba.fastjson.JSON.toJSONString;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.epf.dict.DictParam;
import com.epf.dict.TranslationDict;
import com.tiaim.system.entity.DictionariesEntity;
import com.tiaim.system.service.DictionariesService;
/**
* 翻译字典值的
*/
@Aspect
@Component
public class TranslationDictAspect {
@Autowired
DictionariesService dictionariesService ;
/**
* 非基本类型在 CLASS 中的定义
*/
private static final String FILED_NAME_TYPE = "TYPE";
private Map<String,String> dictInfoMap = new ConcurrentHashMap<>();
@Around("@annotation(translationDict)")
public Object Translation(final ProceedingJoinPoint pjp, TranslationDict translationDict) throws Throwable {
Object result = pjp.proceed();
// 第一步、获取返回值类型
Class returnType = ((MethodSignature) pjp.getSignature()).getReturnType();
//首先,取出要翻译字段的字典值
String returnJsonResult = toJSONString(result,SerializerFeature.WriteMapNullValue);
DictParam[] dictParams = translationDict.value();
for (DictParam dictParam : dictParams) {
//TODO 后期需优化读取Redis
List<DictionariesEntity> dictInfos = dictionariesService.getDictionariesListNoPage();
//先把字典值转成map
for (DictionariesEntity dictInfo : dictInfos) {
dictInfoMap.put(dictInfo.getDictKey(),dictInfo.getZhCn());
}
Pattern dictPattern= Pattern.compile("\"" + dictParam.dictValueFiled() +".*?,");
Matcher dictMatcher=dictPattern.matcher(returnJsonResult);
StringBuffer sb = new StringBuffer();
while (dictMatcher.find()){
//取出要翻译字段对应的值
Pattern dictValuePattern= Pattern.compile(":\"(.*?)\",");
Matcher dictValueMatcher = dictValuePattern.matcher(dictMatcher.group().toString());
if( dictValueMatcher.find()){
//翻译字典
String dictInfoName = dictInfoMap.get(dictValueMatcher.group(1));
String s = dictMatcher.group() + "\"" + dictParam.dictNameFiled() + "\":\"" +dictInfoName + "\",";
dictMatcher.appendReplacement(sb, s);
}else{
String s = dictMatcher.group() + "\"" + dictParam.dictNameFiled() + "\":\"\",";
dictMatcher.appendReplacement(sb, s);
}
}
dictMatcher.appendTail(sb);
returnJsonResult = sb.toString();
}
result = getJsonToResultObject(returnJsonResult,returnType);
return result;
}
private Object getJsonToResultObject(String returnJsonResult, Class returnType) {
// 对象复原
if (StringUtils.isNotBlank(returnJsonResult)) {
// 基本类型则直接返回封装类型则对象转换
if (returnType.isPrimitive()) {
return returnJsonResult;
} else {
try {
if ((returnType.getField(FILED_NAME_TYPE)
.getClass()).isPrimitive()) {
return returnJsonResult;
}
} catch (Exception e) {
return JSON.parseObject(returnJsonResult, returnType);
}
}
}
return null;
}
}
拦截器主要逻辑:拦截方法,把返回值转成JSON,然后根据注解翻译JSON, 从JSON中取出DictParam中的 dictValueFiled字段的值,然后根据DictParam中的dictCode翻译对一个的字典,然后将翻译好的值插入dictNameFiled这个字段
三、例:
- 例1:
- 返回JSON值为
{userId:1,geneder:1,userName:'zhangsan'}
- 注解为
@TranslationDict({@DictParam(dictCode = "USER_GENDER_CODE",dictValueFiled = "gender",dictNameFiled = "genderName")})
- 拦截器处理时取出gender字段对应的值“1”和字典“USER_GENDER_CODE”翻译为“男性”,然后将男性赋值给genderName字段
{userId:1,geneder:1,genderName:'男性',userName:'zhangsan'}
- 然后将JSON转对象返回即可,当然,要翻译的javabean必须要有genderName字段
- 例2:
@Override
@TranslationDict({
@DictParam(dictCode = "landType",dictValueFiled = "landType",dictNameFiled = "landTypeName"),
@DictParam(dictCode = "firstClassUse",dictValueFiled = "firstClassUse",dictNameFiled = "firstClassUseName")
})
public List<TSellEntity> getTSellList(Pager pager, Example example) {
// 分页属性设置
PageHelper.startPage(pager.getPageNo(), pager.getPageSize());
List<TSellEntity> list = tSellDao.selectByExample(example);
PageInfo<TSellEntity> page = new PageInfo<TSellEntity>(list);
/**
* 通过反射设置pager相关值,并在控制层获取。
**/
pager.setTotalPage(page.getPages());
pager.setTotalRecord((int) page.getTotal());
return list;
}
优化
- 拦截器优化,翻译字典从缓存里读取。。。