字典翻译EasyTrans简单使用分享

前言

最近太忙了，一直按在项目上摩擦，都没有时间写分享了。今天终于市把所有负责的模块都写完了，本次迭代引入了字典翻译，借这个机会顺便分享下。

一、什么是字典翻译

所谓的字典翻译其实简单理解就是一些不常更新的有键值对属性的数据转换。片面点理解就是一些下拉框、枚举值等等。

二、使用步骤

前任本来有自己实现的翻译，是利用反射+缓存+自定义注解+json序列配置等实现，我看了下太麻烦，而且场景比较片面，所以我就偷摸引入了easyTrans，早期只想方便自己用。后来大家看我的处理后，觉得比较香，所以也用上了。

1.引入库

这里注意引入不同的orm扩展支持，我这里orm是使用的mybatisPlus。

<dependency>
    <groupId>com.fhs-opensource</groupId>
    <artifactId>easy-trans-spring-boot-starter</artifactId>
    <version>2.1.16</version>
</dependency>
<dependency>
    <groupId>com.fhs-opensource</groupId>
    <artifactId>easy-trans-mybatis-plus-extend</artifactId>
    <version>2.1.16</version>
</dependency>

2.字典配置类

所有字典在这里一次性加载到缓存，如果有相应的管理界面，可以增加更新缓存机制。

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fhs.trans.service.impl.DictionaryTransService;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 字典配置类
 *
 * @author zhengwen
 */
@Configuration
public class DictionaryConfig implements InitializingBean {


    @Autowired
    private DictionaryTransService dictionaryTransService;

	//业务dao
    @Autowired
    private BaseDictionaryMapper baseDictionaryMapper;
	//业务dao
    @Resource
    private EventTypeMapper eventTypeMapper;

    @Override
    public void afterPropertiesSet() throws Exception {
        //将字典缓存刷新到翻译服务中
        Map<String, String> transMap = new HashMap<>();
        transMap.put("0", "禁用");
        transMap.put("1", "使用");
        dictionaryTransService.refreshCache("useStatus", transMap);

        //TODO 业务字典加载到缓存中
        QueryWrapper<EventType> eventTypeQw = new QueryWrapper<>();
        eventTypeQw.eq("type_", 2);
        List<EventType> eventTypeList = eventTypeMapper.selectList(eventTypeQw);
        //eventTypeList根据属性parentCode使用stream方法分组
        Map<String, List<EventType>> eventTypeMap = eventTypeList.stream().collect(java.util.stream.Collectors.groupingBy(EventType::getParentCode));
        if (CollectionUtil.isNotEmpty(eventTypeMap)) {
            eventTypeMap.entrySet().stream().forEach(entry -> {
                Map<String, String> eventTypeTransMap = new HashMap<>();
                String entryKey = entry.getKey();
                List<EventType> entryValue = entry.getValue();
                if (CollectionUtil.isNotEmpty(entryValue)) {
                    entryValue.stream().forEach(eventType -> {
                        eventTypeTransMap.put(eventType.getCode(), eventType.getName());
                    });
                }
                dictionaryTransService.refreshCache(entryKey, eventTypeTransMap);
            });
        }

        QueryWrapper<EventType> eventTypeAllQw = new QueryWrapper<>();
        List<EventType> allEventTypeList = eventTypeMapper.selectList(eventTypeAllQw);
        //eventType
        if (CollectionUtil.isNotEmpty(allEventTypeList)) {
            Map<String, String> allEventTypeTransMap = new HashMap<>();
            allEventTypeList.stream().forEach(eventType -> {
                allEventTypeTransMap.put(eventType.getCode(), eventType.getName());
            });
            dictionaryTransService.refreshCache("allEventType", allEventTypeTransMap);
        }

        //可以简单加个timer，定时刷新缓存（如果字典后面有界面操作字典，可能需要业务端操作后自己刷入缓存）

        //字典表数据放入其中
        IPage<BaseDictionary> selectPage = baseDictionaryMapper.selectPage(new Page(0, -1), new BaseDictionary());
        List<BaseDictionary> records = selectPage.getRecords();
        if (CollectionUtil.isNotEmpty(records)){
            //分组
            Map<String, List<BaseDictionary>> listMap = records.stream().filter(r -> StringUtils.isNotBlank(r.getCategoryCode()))
                    .collect(Collectors.groupingBy(BaseDictionary::getCategoryCode));
            listMap.forEach((k,v)->
                    //字典分类为key存入字典翻译缓存
                dictionaryTransService.refreshCache(k, v.stream().collect(Collectors.toMap(BaseDictionary::getDictCode,BaseDictionary::getDictDesc)))
            );
        }
    }

}

3.字典数据

在这里插入图片描述
这个就是我们的数据字典表，实际上就是把里面的数据加载到缓存。

4.配置文件

#easyTrans字典转换配置
easy-trans:
  #启用redis缓存 如果不用redis请设置为false
  is-enable-redis: true
  #启用全局翻译(拦截所有responseBody进行自动翻译)，如果对于性能要求很高可关闭此配置
  is-enable-global: true
  #启用平铺模式
  is-enable-tile: true
  #字典缓存放到redis 微服务模式请开启
  dict-use-redis: true
  # ruoyi相关的请开启
  is-enable-map-result: true

5.使用姿势

A.实体要实现implements TransPojo
B.实体对象属性上写注解标签@Trans(type = TransType.DICTIONARY, key = “deploy_strategy_type”)
key是字典码，对应3表的字典类型code值。

    /**
     * 布控任务类型，1人员，2车辆
     */
    @TableField("strategy_type_")
    @Trans(type = TransType.DICTIONARY, key = "deploy_strategy_type")
    private Integer strategyType;

以上只是easyTrans最简单的一个场景，实际上easyTrans还有很多使用场景，我这里也不想一个个演示，官方demo写的很清楚，我这里就抛砖引玉分享一个场景（其实也是我们自己暂时也用不到其他场景，比如springCloud等）官方文档见：https://www.kancloud.cn/shuaizai88/easy-trans/3100797