001 AOP切面使用注解翻译字典值

川长思鸟来 2022-02-27 05:18 201阅读 0赞

参考文献[：https://my.oschina.net/angelbo/blog/2875887][https_my.oschina.net_angelbo_blog_2875887]

> 感谢博主提供的解决思路方法

> 博主缺点：不能对字符串字典进行处理，已优化

## 需求 ##

*  在服务端开发，数据库表中有些字段对应的是字典值，在查询的时候要展示字典值，这个时候可能就需要关联字典表查询，或者在前后端开发过程中，由前端页面展示的部分调取字典服务的接口来展示，但这样都有问题，前者是数据库字典变更时要修改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;
    
    /**
     * 需要翻译的字典值
     *
     * */
    @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;
    }

## 优化 ##

*  拦截器优化，翻译字典从缓存里读取。。。

[https_my.oschina.net_angelbo_blog_2875887]: https://my.oschina.net/angelbo/blog/2875887/