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

已于 2023-02-22 18:13:38 修改
阅读量2.8k 收藏 12
点赞数 6
分类专栏： jeecg-boot 文章标签： jeecg-boot jeecg-boot字典翻译 字典翻译 jeecg-boot改造 字典翻译改造
于 2021-04-10 15:24:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Cjava_math/article/details/115577171
版权
本文介绍了一种针对字典切面类的改造方法，重点在于支持自动翻译代码生成，适用于列表接口及单个实体类查询。该方法通过解析实体类字段，实现字典字段的自动翻译，并对日期类型字段进行格式化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  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);
}
Java基于jeecg-boot 的实体翻译自定义类
qq_31908927的博客
04-19 375
基础jeecgboot的实体翻译自定义工具类，个人封装，可对实体中的字典进行翻译
jeecgboot数据字典使用(1)，分享一点面试小经验
2401_84092727的博客
04-03 1955
JDate,},dictCode为数据字典中定义的code。list页面显示 数据字典处理前处理后dicCode为数据字典中定义的code。2. 修改table column定义title:‘类型’,},dataIndex值为字段名+“_dictText”修改后也可以在vue中查看数据源。list页面显示 表关联处理前处理后。
Jeecgboot字典值自动转换：DictAspect支持IPage、List自动转化
最新发布
qq_46130855的博客
04-29 246
除IPage外，List也支持字典转换，基本数据类型的数组不进行处理。
jeecgboot字典翻译
weixin_43096562的博客
04-20 1218
@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 1633
三.修改后的parseDictText方法，支持IPage、List、Object。一.找到字典切面类(DictAspect)二.改造方法(parseDictText)六.增加检测是否可转换为JSON字符串方法。四.提取公共代码作为单独的方法进行翻译。五.增加中文检测方法。
jeecgboot改造：枚举加入字典，控制器返回列表翻译字典
随记
08-17 2588
jeecgboot版本：2.4.5 虽然jeecg提供了数据字典功能，使用很方便，但在实际业务中，有根据不同值编写不同代码进行操作的需求，如果将这些代码写进数据字典中，那么字典值一旦被人修改，就会使代码运行不正常。使用枚举，就是为了避免此类问题，经尝试，改了些代码后，将枚举项的使用与数据字典一致化，使用起来会方便些。 枚举加入字典的方法 修改 SysDictServiceImpl.getDictItems @Override public List<DictModel> getDictI
Jeecg-Boot 使用字典
白开水
03-03 821
组件是 “JDictSelectTag”。在属性上加入@Dict注解 dicCode 是 字典编码。dataIndex值为“字段名”+"_dictText"新建数据字典，字典编码，新建字典列表。修改data 列表数据。修改data 表单数据。
jeecg-boot-master2.0.zip
02-08
Jeecg-Boot 包含了一套强大的代码生成器，可以从数据库表结构自动生成前后端代码，包括实体类、Mapper、Service、Controller以及Vue页面等，这极大地减少了重复劳动，提高了开发速度。 5. **权限管理** Jeecg-...
jeecg-boot.rar
03-27
1. src/main/java：存放Java源代码，包括实体类、Service、Controller等核心组件。 2. src/main/resources：配置文件所在目录，如application.properties、mybatis配置等。 3. src/main/webapp：前端资源文件夹，...
JeecgBoot3.61 实现实体类对象和请求参数映射构建查询，主要解决需要根据数据库外键展示相关信息的需求
VIP_1205169154的博客
01-26 1350
JeecgBoot3.61 实现实体类对象和请求参数映射构建查询，主要解决需要根据数据库外键展示相关信息的需求
解析jeecg-boot的数据字典，涉及到了vue的组件封装、ajax请求等
zhangkegu的博客
01-13 2232
jeecg-boot中的数据字典本质其实是一个封装好的组件，然后在使用时单独传入后端给的code码给组件需要的字段，在数据字典组件里再通过接收到的code码发起ajax请求从而获取字典数据。 字典组件html结构如图： 定义props属性，用于从父组件获取数据字典组件所需的数据信息，具体如下： 下面是对该组件处理数据的部分了： 然后是关键逻辑了： 接下来看看在业务组件里的使用是神魔样子的吧！ 这里数据字典表格中是这样用的，原理和上面差不多，都是事先封装好组件和取字典的通用..
jeecgboot后台获取字典值
一切都会好起来的，即使不在今天
10-29 4741
`注入 ``java @Autowired private ISysDictService sysDictService; 根据字典编码查询处所有字典内容 ```java List<DictModel> dictItemsByCode = sysDictService.queryDictItemsByCode("system_module");
增加jeecg的dict aop功能
rocklee的专栏
07-08 513
目标： 现时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的返回数据类型，并且深入记录对
jeecgboot后端字典项拦截注入工具类DictAspect升级和优化
qq_38127559的博客
12-07 1377
统计管理平台使用jeecgboot-3.5开源框架，在功能开发的过程中，涉及到字典项的数据，仅当返回值类型为“com.baomidou.mybatisplus.core.metadata.IPage”才有字典翻译文本字段和值，而系统目前需要支持“java.util.Collection”和“java.util.Map.Entry”两种类型，于是基于查jeecg-boot-base-core-3.5.3版本的DictAspect处理逻辑，对该拦截注入字典数
JEECG BOOT 前端记录
qq_60782107的博客
11-15 1009
JJECG BOOT 前端记录
jeecg-boot 入门-小白避坑篇
LavaStrom
04-21 9487
jeecg-boot 入门 为小白避坑用的 视频教程 https://edu.youkuaiyun.com/learn/25027 说明文档 http://jeecg-boot.mydoc.io/
jeecgboot开启微服务后 项目使用导出excel 字典无法使用
qq_37322924的博客
12-03 3666
jeecgboot切换成微服务后 某个属性添加@Excel注解 /**人员*/ @Excel(name = "人员", dictTable = "sys_user", dicCode = "username", dicText = "realname", width = 15) @Dict(dictTable = "sys_user", dicText = "realname", dicCode = "username") @ApiModelProperty(value = "人员") .
jeecg boot 框架学习（4）— 数据字典使用
热门推荐
08-30 1万+
1. input页面下拉框使用 效果展示 实现 定义数据字典 引用并调用JDictSelectTag组件import JDictSelectTag from '@/components/dict/JDictSelectTag.vue' export default { .... components: { JDate, CustomerModal...
开发指南专题八：JEECG微云快速开发平台数据字典
iteye_14984的博客
05-16 445
 开发指南专题八：JEECG微云快速开发平台数据字典的使用 1.标签中使用数据字典 数据字典为系统中可能用到的字典类型数据提供了使用的便利性和可维护性。以下拉框标签&lt;t:dictSelect&gt;为例进行讲解 1.1.标签参数 属性名 类型 描述 是否必须 ...
jeecg-boot +ant-vue字典项配置
12-11
Jeecg Boot是一个基于Spring Boot的企业级快速开发平台，它提供了一系列强大的功能，包括轻量级的微服务架构、权限管理系统、工作流引擎等。Ant Design Vue是基于Ant Design设计体系的Vue组件库。 如果你想要在Jeecg Boot项目中集成Ant Design Vue，并配置字典项（通常用于存储可选择的选项，如性别、角色等），可以按照以下步骤操作： 1. **添加依赖**：首先，在你的`pom.xml`文件中添加Ant Design Vue的依赖： ```xml <dependency> <groupId>com.azelcast</groupId> <artifactId>ant-design-vue</artifactId> <version>最新版本号</version> </dependency> ``` 记得替换为实际的版本号。 2. **全局注册组件**：在`application.yml`或`application.properties`中配置Vue组件的引入路径： ```yaml jeecg: vue: global-components-dir: classpath:/static/components/ ``` 这将允许你在模板文件中直接使用Ant Design Vue组件。 3. **创建字典表**：在数据库中创建一个表来存储字典项数据，例如`dict_table`，字段可能包括`id`, `code`, `name`, 等。 4. **实体模型映射**：创建一个Java实体类，比如`DictEntity`，并用它来映射数据库的字典表。 5. **注入字典服务**：在需要的地方，通过Jeecg提供的服务注入机制，注入一个处理字典数据的服务，例如`DictService`。 6. **获取和显示字典项**：在视图层，调用`DictService`的方法来获取特定类型的字典项，然后在前端展示给用户选择。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

微微一笑满城空

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

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

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

打赏作者

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

抵扣说明：

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

余额充值