springboot+redis+切面实现数据字典和自动设置用户信息功能解放双手

背景：

       我们数据库为了减少存储容量和数据查询传输量以及增大查询效率，一般都会把字段进行编码而不是存中文，所以有时候字段值有可能是0 ==未处理，1 == 已处理。 但是，展示到前端需要将 值翻译成中文，如果人工来做会很麻烦，解放双手将此类工作交给程序来解决.

实现目标：

源码：自定义注解：DataDict，用于bo对象类，需要翻译的属性

package com.qboa.common.annotation.dict;

import java.lang.annotation.*;

/**
 * 说明：数据字典处理类
 * Created by luojie on 2019/05/29.
 */
//@DataDict(  dict="patType", source = "patType" )
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDict {

    /**
     * 方法描述 描述标准编码 或是用户字段(对应UserBo)
     * 与user配合使用,需要取的信息字段
     * 如：要去age 则配置age 要取 userName 则配置 userName
     *
     * @return
     */
    String dict() default "";

    /**
     * 翻译类型 "0" 标准代码  "1"用户
     *
     * @return
     */
    String busi() default "0";

    /**
     * 方法描述,可使用占位符获取参数:{{source}}
     * 主要标准编码之来源,
     * 查询用户信息时存储用户userId 的字段名称
     */
    String source() default "";

    /**
     * 对source 值是否需要对行转列进行拆分处理{{","}}
     * 需要对source值按逗号进行拆分后翻译，默认拆分转换
     * 若是{{$}}则按$进行拆分
     * 默认不处理
     * 如：
     * "proMode": "1,2",
     * "proModeName": "出售,结算",
     *
     * @return
     */
    String transferLineColumn() default "";

    /**
     * 方法描述 描述标准编码组
     * 翻译该字段需要哪些标准码
     *
     * @return
     */
    String[] dictArr() default {};

    /**
     * 方法描述 区分字段，先决条件
     * 决定取哪个标准编码
     *
     * @return
     */
    String differ() default "";

    /**
     * 方法描述 区分字段，先决条件比较值
     * 决定取哪个标准编码比较值
     * 满足条件获取下标 从dictArr 中取下标的标准代码
     *
     * @return
     */
    String[] differValues() default {};


}

自定义注解： 

DataDictClass  用来标注返回对象集合需要翻译的方法，本功能目前只支持bean对象的属性翻译

 

package com.zddts.common.annotation.dict;

import java.lang.annotation.*;

/**
 * 说明：
 * Created by luojie on 2019/05/29.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDictClass {

}

切面处理： DataDictAspect

package com.qboa.oa.aop;

import com.alibaba.fastjson.JSON;
import com.qboa.common.annotation.dict.DataDict;
import com.qboa.common.annotation.dict.DataDictClass;
import com.qboa.common.bo.admin.UserBo;
import com.qboa.common.bo.pubapp.puCode.PuCodeBo;
import com.qboa.common.contants.ReidsConstants;
import com.qboa.common.utils.BeanUtils;
import com.qboa.oa.client.PubAppClient;
import com.qboa.oa.util.UserUtil;
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.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 说明：数据字典切面类
 * Created by luojie on 2019/05/29.
 */
@Aspect
@Component
public class DataDictAspect {

    @Autowired
    PubAppClient pubappClient;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private UserUtil userUtil;


    /**
     * 非基本类型在 CLASS 中的定义
     */
    private static final String FILED_NAME_TYPE = "TYPE";

    private Map dictInfoMap = new ConcurrentHashMap<>();

    @Pointcut("@annotation(dataDictClass)")
    public void doDataDictClass(DataDictClass dataDictClass) {
    }

    @Around("@annotation(dataDictClass)")
    public Object translation(final ProceedingJoinPoint pjp, DataDictClass dataDictClass) throws Throwable {
        Object result = pjp.proceed();
        if (result == null) {
            return result;
        }
        Object obj;
        if (result instanceof List || result instanceof ArrayList) {

            List olist = ((List) result);
            if (olist.size() == 0) {
                return result;
            }
            obj = olist.get(0);
        } else if (result instanceof Page) {//支持Page类的数据字典转换
            List olist = ((Page) result).getContent();
            if (olist.size() == 0) {
                return result;
            }
            obj = olist.get(0);
        } else {
            obj = result;
        }
        /**
         * 获取翻译字段配置信息
         */
        Map dataDictMap = boDict(obj.getClass());
        if (dataDictMap.size() == 0) {
            return result;
        }

        /**
         * 获取字典信息
         */
        this.getPCodeInfo();
        /**
         * 开始翻译
         */
        if (result instanceof List || result instanceof ArrayList) {
            for (Object o : (List) result) {
                sign(o, dataDictMap, dictInfoMap);
            }
        } else if (result instanceof Page) {//支持Page类
            ((Page) result).forEach(o -> sign(o, dataDictMap, dictInfoMap));
        } else {
            sign(result, dataDictMap, dictInfoMap);
        }
        return result;
    }

    /**
     * 设置数据字典
     */
    public void getPCodeInfo() throws Exception {
        Object codeObj = redisTemplate.opsForValue().get(ReidsConstants.PUCODE_REDIS_ALL);
        List dictInfos;
        //缓存中没有重新从数据库中取
        if (codeObj == null) {
            dictInfos = pubappClient.getAllPuCode();
            redisTemplate.opsForValue().set(ReidsConstants.PUCODE_REDIS_ALL, dictInfos);
        } else {
            dictInfos = (List) codeObj;
        }
        if (dictInfos == null || dictInfos.size() == 0) {
            return;
        }
        //先把字典值转成map
        for (PuCodeBo puCodeBo : dictInfos) {
            dictInfoMap.put(puCodeBo.getCodeType() + puCodeBo.getCodeValue(), puCodeBo.getCodeName());
        }
    }

    /**
     * 获取bo中属性值
     *
     * @param cla
     * @return
     */
    private Map boDict(Class cla) {
        Field[] fields = cla.getDeclaredFields();
        Map map = new HashMap();
        for (Field field : fields) {
            if (field.isAnnotationPresent(DataDict.class)) {
                DataDict dataDict = field.getAnnotation(DataDict.class);
                String fieldName = field.getName();
                map.put(fieldName, dataDict);
            }
        }
        return map;
    }

    /**
     * 单个设置值
     *
     * @param obj
     * @param dataDictMap 注解字段
     * @param dictInfoMap
     */
    public void sign(Object obj, Map dataDictMap, Map dictInfoMap) {

        for (Map.Entry entry : dataDictMap.entrySet()) {
            String fileName = entry.getKey();
            DataDict dataDict = entry.getValue();
            String busi = StringUtils.isBlank(dataDict.busi()) ? "0" : dataDict.busi();
            //翻译类型
            if ("0".equals(busi)) {
                this.setPCode(obj, dataDict, fileName, dictInfoMap);
            } else if ("1".equals(busi)) {//翻译用户字段
                this.setUserInfo(obj, dataDict, fileName);
            }

        }


    }

    /**
     * 设置标准代码--字典
     *
     * @param obj
     * @param dataDict    属性的注解字段配置
     * @param fileName    需要赋值的字段
     * @param dictInfoMap 字典信息数据
     * @throws Exception
     */
    public void setPCode(Object obj, DataDict dataDict, String fileName, Map dictInfoMap) {
        if (dictInfoMap == null || dictInfoMap.size() == 0) {
            return;
        }
        String dict = dataDict.dict();
        if (StringUtils.isBlank(dict)) {
            String[] dictArr = dataDict.dictArr();//多个字典组 长度与differValues必须一致
            String differ = dataDict.differ();   // 字典  选择条件字段 作区分的字段
            String[] differValuesArr = dataDict.differValues();//differ 对应值的枚举值  匹配上选对应下标的dict字典来取值
            try {
                //作区分字段的值
                String differValue = (String) BeanUtils.getBeanFieldValue(obj.getClass(), obj, differ);
                if (StringUtils.isBlank(differValue)) {
                    //值无数据不比较
                    return;
                }
                for (int i = 0; i < differValuesArr.length; i++) {
                    if (differValue.equals(differValuesArr[i])) {
                        dict = dictArr[i];
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //未匹配上字典不设置
        if (StringUtils.isBlank(dict)) {
            return;
        }
        String source = dataDict.source();//需要翻译的字段
        String transferLineColumn = dataDict.transferLineColumn();//拆分符号 有则按照拆分符号拆分翻译
        try {
            //获取源编码值
            String sourceValue = (String) BeanUtils.getBeanFieldValue(obj.getClass(), obj, source);
            String dictCodeName = null; //字典值 翻译后的值
            //新增对例如1,2,3 多个值要标准码转换进行转换"proMode": "1,2",         "proModeName": "出售,结算",
            if (StringUtils.isNotBlank(transferLineColumn)) {
                if (StringUtils.isNotBlank(sourceValue) && sourceValue.indexOf(transferLineColumn) > 0) {
                    String[] s = sourceValue.split(transferLineColumn);
                    for (int i = 0; i < s.length; i++) {
                        String a = s[i];
                        if (i == 0) {
                            dictCodeName = dictInfoMap.get(dict + a);
                        } else {
                            dictCodeName = dictCodeName + transferLineColumn + dictInfoMap.get(dict + a);
                        }
                    }
                } else {
                    dictCodeName = dictInfoMap.get(dict + sourceValue);
                }
            } else {
                dictCodeName = dictInfoMap.get(dict + sourceValue);
            }
            //设置值
            BeanUtils.setBeanField(obj.getClass(), obj, fileName, dictCodeName);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 设置用户信息
     *
     * @param obj
     * @param dataDict 属性注解字段配置
     * @param fileName 需要赋值的字段
     * @throws Exception
     */
    public void setUserInfo(Object obj, DataDict dataDict, String fileName) {
        String source = dataDict.source(); //存储用户userId 的字段名称
        String dict = dataDict.dict();//获取用户目标信息的字段
        if (StringUtils.isBlank(dict)) {
            return;
        }
        try {
            Object userIdobj = BeanUtils.getBeanFieldValue(obj.getClass(), obj, source);
            if (userIdobj == null) {
                return;
            }
            String userIdstr = String.valueOf(userIdobj);
            if ("".equals(userIdstr)) {
                return;
            }
            Long userId = Long.valueOf(userIdstr);
            //查询用户信息 根据自己配置是数据库还是redis
            UserBo user = userUtil.getUserBoInRedis(userId);
            if (user == null) {
                return;
            }
            //todo 目前支持字符串类型 数值类型，不支持对象 类型 和时间类型 目标和源 的类型必须要一致
            Object fromValue = BeanUtils.getBeanFieldValue(user.getClass(), user, dict);
            //设置值
            BeanUtils.setBeanField(obj.getClass(), obj, fileName, fromValue);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }


    }

    /**
     * json处理 todo
     *
     * @param returnJsonResult
     * @param returnType
     * @return
     */
    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;
    }


}

工具类：主要用了反射机制

package com.zddts.common.utils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;

public class BeanUtils {

    /**
     * 方法说明：将List