jeecg-boot字典翻译改造(支持实体类详情查询自动翻译)

已于 2023-02-22 18:13:38 修改
阅读量2.4k 收藏 10
点赞数 6
分类专栏： jeecg-boot 文章标签： jeecg-boot jeecg-boot字典翻译 字典翻译 jeecg-boot改造 字典翻译改造
于 2021-04-10 15:24:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cjava_math/article/details/115577171
版权

  1. 找到字典切面类(DictAspect)

  2. 改造方法(parseDictText)

支持自动生成的列表接口/单个实体类查询翻译
代码如下:

private void parseDictText(Object result) {
        if (result instanceof Result) {
            if (((Result) result).getResult() instanceof IPage) {
                List<JSONObject> items = new ArrayList<>();
                for (Object record : ((IPage) ((Result) result).getResult()).getRecords()) {
                    ObjectMapper mapper = new ObjectMapper();
                    String json = "{}";
                    try {
                        //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                        json = mapper.writeValueAsString(record);
                    } catch (JsonProcessingException e) {
                        log.error("json解析失败" + e.getMessage(), e);
                    }
                    JSONObject item = JSONObject.parseObject(json);
                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    for (Field field : oConvertUtils.getAllFields(record)) {
                        //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
                            String key = String.valueOf(item.get(field.getName()));

                            //翻译字典值对应的txt
                            String textValue = translateDictValue(code, text, table, key);

                            log.debug(" 字典Val : " + textValue);
                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                            item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                        }
                        //date类型默认转换string格式化日期
                        if (field.getType().getName().equals("java.util.Date") && 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);
                }
                ((IPage) ((Result) result).getResult()).setRecords(items);
            } else {
                Object record = (Object) ((Result) result).getResult();
                ObjectMapper mapper = new ObjectMapper();
                String json = "{}";
                try {
                    //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                    json = mapper.writeValueAsString(record);
                } catch (JsonProcessingException e) {
                    log.error("json解析失败" + e.getMessage(), e);
                }
                try {
                    JSONObject item = JSONObject.parseObject(json);
                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    for (Field field : oConvertUtils.getAllFields(record)) {
                        //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
                            String key = String.valueOf(item.get(field.getName()));

                            //翻译字典值对应的txt
                            String textValue = translateDictValue(code, text, table, key);

                            log.debug(" 字典Val : " + textValue);
                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                            item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                        }
                        //date类型默认转换string格式化日期
                        if (field.getType().getName().equals("java.util.Date") && 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()))));
                        }
                    }
//                }
                    ((Result) result).setResult(item);
                }catch (Exception e){
                    log.info("########################此返回类型不支持字典翻译########################");
                }
            }
        }
    }

单个查询返回数据格式样例:

/**
 * 通过id查询
 *
 * @param id
 * @return
 */

@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
   ShgBanner shgBanner = shgBannerService.getById(id);
   if(shgBanner==null) {
      return Result.error("未找到对应数据");
   }
   return Result.ok(shgBanner);
}

第二版改造 : 2023/2/22

总结:

  1. 支持单个实体类解析
  2. 支持实体类集合解析
  3. 支持过滤基本类型集合不进行解析, 暂时过滤了三种 java.lang.String java.lang.long java.lang.Integer

完整方法如下 :

private void parseDictTextOne(Object result) {
        if (result instanceof Result) {
            if (((Result) result).getResult() instanceof IPage) {
                List<JSONObject> items = new ArrayList<>();
                for (Object record : ((IPage) ((Result) result).getResult()).getRecords()) {
                    ObjectMapper mapper = new ObjectMapper();
                    String json = "{}";
                    try {
                        //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                        json = mapper.writeValueAsString(record);
                    } catch (JsonProcessingException e) {
                        log.error("json解析失败" + e.getMessage(), e);
                    }
                    JSONObject item = JSONObject.parseObject(json);
                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    for (Field field : oConvertUtils.getAllFields(record)) {
                        //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
                            String key = String.valueOf(item.get(field.getName()));

                            //翻译字典值对应的txt
                            String textValue = translateDictValue(code, text, table, key);

                            log.debug(" 字典Val : " + textValue);
                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                            item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                        }
                        //date类型默认转换string格式化日期
                        if (field.getType().getName().equals("java.util.Date") && 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);
                }
                ((IPage) ((Result) result).getResult()).setRecords(items);
            } else if (((Result) result).getResult() instanceof List) {
                List result1 = (List) ((Result) result).getResult();
                if (CollectionUtils.isNotEmpty(result1)) {
                    Class<?> aClass = result1.get(0).getClass();
                    String className = aClass.getName();
                    log.info("------- List<T> 泛型 T is {}", className);
                    //只解析result中list泛型是object的数据, 基本数据类型不解析
                    /**
                     * 以下类型不解析
                     * java.lang.String
                     * java.lang.long
                     * java.lang.Integer
                     */
                    if (!className.equals("java.lang.String") && !className.equals("java.lang.long") && !className.equals("java.lang.Integer")) {
                        List<JSONObject> items = new ArrayList<>();
                        for (Object record : (List) ((Result) result).getResult()) {
                            ObjectMapper mapper = new ObjectMapper();
                            String json = "{}";
                            try {
                                //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                                json = mapper.writeValueAsString(record);
                            } catch (JsonProcessingException e) {
                                log.error("json解析失败" + e.getMessage(), e);
                            }
                            JSONObject item = JSONObject.parseObject(json);
                            //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                            //for (Field field : record.getClass().getDeclaredFields()) {
                            for (Field field : oConvertUtils.getAllFields(record)) {
                                //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                                if (field.getAnnotation(Dict.class) != null) {
                                    String code = field.getAnnotation(Dict.class).dicCode();
                                    String text = field.getAnnotation(Dict.class).dicText();
                                    String table = field.getAnnotation(Dict.class).dictTable();
                                    String key = String.valueOf(item.get(field.getName()));

                                    //翻译字典值对应的txt
                                    String textValue = translateDictValue(code, text, table, key);

                                    log.debug(" 字典Val : " + textValue);
                                    log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                                    item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                                }
                                //date类型默认转换string格式化日期
                                if (field.getType().getName().equals("java.util.Date") && 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);
                        }
                        ((Result) result).setResult(items);
                    }else {
                        log.info("只解析result中list<T>泛型是实体类的数据, 基本数据类型不解析: T is {}", className);
                    }
                }else {
                    log.info(" result中List<T> 为空,跳过不解析 ");
                }

            } else {
                Object record = (Object) ((Result) result).getResult();
                ObjectMapper mapper = new ObjectMapper();
                String json = "{}";
                try {
                    //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                    json = mapper.writeValueAsString(record);
                } catch (JsonProcessingException e) {
                    log.error("json解析失败" + e.getMessage(), e);
                }
                try {
                    JSONObject item = JSONObject.parseObject(json);
                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    for (Field field : oConvertUtils.getAllFields(record)) {
                        //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
                            String key = String.valueOf(item.get(field.getName()));

                            //翻译字典值对应的txt
                            String textValue = translateDictValue(code, text, table, key);

                            log.debug(" 字典Val : " + textValue);
                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                            item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                        }
                        //date类型默认转换string格式化日期
                        if (field.getType().getName().equals("java.util.Date") && 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()))));
                        }
                    }
                    ((Result) result).setResult(item);
                } catch (Exception e) {
                    log.info("########################此返回类型不支持字典翻译########################");
                }
            }
        }
    }

改造部分如下 :

else if (((Result) result).getResult() instanceof List) {
                List result1 = (List) ((Result) result).getResult();
                if (CollectionUtils.isNotEmpty(result1)) {
                    Class<?> aClass = result1.get(0).getClass();
                    String className = aClass.getName();
                    log.info("------- List<T> 泛型 T is {}", className);
                    //只解析result中list泛型是object的数据, 基本数据类型不解析
                    /**
                     * 以下类型不解析
                     * java.lang.String
                     * java.lang.long
                     * java.lang.Integer
                     */
                    if (!className.equals("java.lang.String") && !className.equals("java.lang.long") && !className.equals("java.lang.Integer")) {
                        List<JSONObject> items = new ArrayList<>();
                        for (Object record : (List) ((Result) result).getResult()) {
                            ObjectMapper mapper = new ObjectMapper();
                            String json = "{}";
                            try {
                                //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                                json = mapper.writeValueAsString(record);
                            } catch (JsonProcessingException e) {
                                log.error("json解析失败" + e.getMessage(), e);
                            }
                            JSONObject item = JSONObject.parseObject(json);
                            //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                            //for (Field field : record.getClass().getDeclaredFields()) {
                            for (Field field : oConvertUtils.getAllFields(record)) {
                                //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                                if (field.getAnnotation(Dict.class) != null) {
                                    String code = field.getAnnotation(Dict.class).dicCode();
                                    String text = field.getAnnotation(Dict.class).dicText();
                                    String table = field.getAnnotation(Dict.class).dictTable();
                                    String key = String.valueOf(item.get(field.getName()));

                                    //翻译字典值对应的txt
                                    String textValue = translateDictValue(code, text, table, key);

                                    log.debug(" 字典Val : " + textValue);
                                    log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                                    item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                                }
                                //date类型默认转换string格式化日期
                                if (field.getType().getName().equals("java.util.Date") && 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);
                        }
                        ((Result) result).setResult(items);
                    }else {
                        log.info("只解析result中list<T>泛型是实体类的数据, 基本数据类型不解析: T is {}", className);
                    }
                }else {
                    log.info(" result中List<T> 为空,跳过不解析 ");
                }

            } else {
                Object record = (Object) ((Result) result).getResult();
                ObjectMapper mapper = new ObjectMapper();
                String json = "{}";
                try {
                    //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
                    json = mapper.writeValueAsString(record);
                } catch (JsonProcessingException e) {
                    log.error("json解析失败" + e.getMessage(), e);
                }
                try {
                    JSONObject item = JSONObject.parseObject(json);
                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                    //for (Field field : record.getClass().getDeclaredFields()) {
                    for (Field field : oConvertUtils.getAllFields(record)) {
                        //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
                        if (field.getAnnotation(Dict.class) != null) {
                            String code = field.getAnnotation(Dict.class).dicCode();
                            String text = field.getAnnotation(Dict.class).dicText();
                            String table = field.getAnnotation(Dict.class).dictTable();
                            String key = String.valueOf(item.get(field.getName()));

                            //翻译字典值对应的txt
                            String textValue = translateDictValue(code, text, table, key);

                            log.debug(" 字典Val : " + textValue);
                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
                            item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                        }
                        //date类型默认转换string格式化日期
                        if (field.getType().getName().equals("java.util.Date") && 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()))));
                        }
                    }
                    ((Result) result).setResult(item);
                } catch (Exception e) {
                    log.info("########################此返回类型不支持字典翻译########################");
                }
            }

支持如下返回方式 :

// 单个实体解析
@GetMapping(value = "/queryById")
public Result<?> queryById(@RequestParam(name="id",required=true) String id) {
   ShgBanner shgBanner = shgBannerService.getById(id);
   if(shgBanner==null) {
      return Result.error("未找到对应数据");
   }
   return Result.ok(shgBanner);
}

// 列表实体解析
@GetMapping("/queryRawMaters")
public Result<?> queryRawMaters(){
	List<HgRawMaterial> rawMaterialList = hgFinishedProductSonService.queryRawMaters();
	return Result.OK(rawMaterialList);
}
微微一笑满城空
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java 字典 转换 实体字典互转 翻译
Pans
05-14 3487
Java对比两个对象的不同 JDK版本：1.8 （由于用到了lambda、stream） Maven <!-- 用到了hutool的一些工具类方法 hutool版本比较老了 可去 https://mvnrepository.com 使用最新版 --> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version&g
jeecgboot数据字典使用(1)，分享一点面试小经验
2401_84092727的博客
04-03 1254
JDate,},dictCode为数据字典中定义的code。list页面显示 数据字典处理前处理后dicCode为数据字典中定义的code。2. 修改table column定义title:‘类型’,},dataIndex值为字段名+“_dictText”修改后也可以在vue中查看数据源。list页面显示 表关联处理前处理后。
jeecgboot字典翻译
weixin_43096562的博客
04-20 1008
@Autowired private CommonAPI commonAPI; String a = commonAPI.translateDict("code","key"); String b = commonAPI.translateDictFromTable("表名","text","code","key"); 基于：CommonAPI package org.jeecg.common.api; import org.jeecg.common.system.vo.*; import .
Jeecg-boot字典翻译改造
折骨成诗的博客
09-14 1338
三.修改后的parseDictText方法，支持IPage、List、Object。一.找到字典切面类(DictAspect)二.改造方法(parseDictText)六.增加检测是否可转换为JSON字符串方法。四.提取公共代码作为单独的方法进行翻译。五.增加中文检测方法。
jeecgboot改造：枚举加入字典，控制器返回列表翻译字典
随记
08-17 2240
jeecgboot版本：2.4.5 虽然jeecg提供了数据字典功能，使用很方便，但在实际业务中，有根据不同值编写不同代码进行操作的需求，如果将这些代码写进数据字典中，那么字典值一旦被人修改，就会使代码运行不正常。使用枚举，就是为了避免此类问题，经尝试，改了些代码后，将枚举项的使用与数据字典一致化，使用起来会方便些。 枚举加入字典的方法 修改 SysDictServiceImpl.getDictItems @Override public List<DictModel> getDictI
jeecgboot后台获取字典值
一切都会好起来的，即使不在今天
10-29 4072
`注入 ``java @Autowired private ISysDictService sysDictService; 根据字典编码查询处所有字典内容 ```java List<DictModel> dictItemsByCode = sysDictService.queryDictItemsByCode("system_module");
Jeecg-Boot技术文档
03-24
**Jeecg-Boot 技术文档概览** Jeecg-Boot 是一个基于BPM的高效低代码开发平台，旨在提升开发效率，减少重复工作，让开发者更专注于业务逻辑。该框架集成了多种现代技术和工具，实现了前后端分离，支持一键代码生成...
jeecgboot集成jeecg-boot-activiti1
08-03
【集成jeecg-boot-activiti1】是一个关于在Jeecg Boot项目中整合Activiti工作流引擎的教程。本文档详细介绍了如何将Activiti 5.22.0版本集成到Jeecg Boot 2.4.2的环境中，以实现业务流程自动化管理。 1. **目标**：...
JEECG-BOOT 企业级快速平台产品介绍PPT-20200327_jeecg-boot_jeecg_
10-02
- **代码自动化生成**：Jeecg-Boot 提供了强大的代码生成器，能够自动生成基于MyBatis Plus的后台代码，以及Vue.js的前端代码，大大减少了手动编写基础代码的工作量。 - **前后端分离**：采用前后端分离的设计模式...
基于jeecg-boot-activiti的Vue工作流管理系统设计源码
最新发布
04-12
本Vue工作流管理系统基于jeecg-boot-activiti开源项目开发，包含1928个文件，包括Java源代码、SQL脚本、Vue组件、PNG图片、JavaScript脚本、BCMAP文件、Java源代码、HTML页面、XML配置文件、JSON配置文件。...
word源码java-jeecg-boot-activiti-pro:jeecg-boot-activiti-pro
06-05
JeecgBoot 是一款基于代码生成器的低代码平台！前后端分离架构 SpringBoot2.x，SpringCloud，Ant Design&Vue，Mybatis-plus，Shiro，JWT，支持微服务。强大的代码生成器让前后端代码一键生成，实现低代码开发! Jeecg...
增加jeecg的dict aop功能
rocklee的专栏
07-08 436
目标： 现时jeect的dict aop只拦截翻译Result为IPage的记录集，需要修改它能实现拦截List类型的并能拦截深层的对象 原创不易，转载请注明出处：jeecg的dict aop用的是around方式实现了对执行结果的IPage类型进行Dict的翻译处理。org.jeecg.common.aspect.DictAspect 2、增强 2.1 废弃原dict aop 将源dictaspect注释掉，不让ioc加载 2.2 建立自己的dict aop 增加适应List的返回数据类型，并且深入记录对
【JAVA日常】关于jeecgBoot @Dict注解的使用不生效问题
weixin_45456848的博客
09-11 2736
关于jeecgBoot @Dict注解的使用不生效问题
jeecgboot后端字典项拦截注入工具类DictAspect升级和优化
qq_38127559的博客
12-07 1061
统计管理平台使用jeecgboot-3.5开源框架，在功能开发的过程中，涉及到字典项的数据，仅当返回值类型为“com.baomidou.mybatisplus.core.metadata.IPage”才有字典翻译文本字段和值，而系统目前需要支持“java.util.Collection”和“java.util.Map.Entry”两种类型，于是基于查jeecg-boot-base-core-3.5.3版本的DictAspect处理逻辑，对该拦截注入字典数
Vue JeecgBoot 下拉选使用数据字典，设置默认值，默认选中第一个值 - 附完整示例
m0_48968874的博客
06-19 5001
vue jeecg - boot 下拉选使用数据字典，设置默认值，默认选中第一个值
jeecgboot 数据字典下拉框j-dict-select-tag使用
热门推荐
level_Tiller的博客
09-04 2万+
页面配置数据字典product_type 后端 @Dict(dicCode = "product_type") private String type; 前端 <j-dict-select-tag v-decorator="['type', validatorRules.type]" placeholder="请选择商品类型" dictCode="product_type" :trigger-change="true" @change="getType
【Jeecgboot】数据字典的概念及使用方法
weixin_45156425的博客
12-17 5660
问题描述 在笔者通过Jeecgboot平台进行表单开发时，需要实现一个在新增页面 中通过选择框完成选择的树型选择功能，选择完后点击确定会在生成表单中出现。但是笔者在完成选择后，发现在表单中出现的数据是我们数据字典相应字段对应的code，而不是笔者希望的code对应的别名。 数据字典原理阐述 什么是数据字典？其实本质上来说，数据字典就是一个数据库表单，在这个表单中有两个重要的值，分别是编码（code）和别名（dict_text）,我们通过编码来获取到我们自定义的别名，再将别名传递到前端页面，才能映入客户们的眼
jeecg-boot 入门-小白避坑篇
LavaStrom
04-21 8443
jeecg-boot 入门 为小白避坑用的 视频教程 https://edu.csdn.net/learn/25027 说明文档 http://jeecg-boot.mydoc.io/
JEECG BOOT 前端记录
qq_60782107的博客
11-15 548
JJECG BOOT 前端记录
Jeecg-Boot：基于BPM的低代码开发平台
"Jeecg-Boot是一款基于BPM的低代码开发平台，结合SpringBoot、...Jeecg-Boot是一个全面的低代码开发平台，它将开发过程中的标准化工作自动化，同时保留了足够的灵活性，是Java开发者快速构建高效、灵活应用的理想选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

微微一笑满城空

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值