从jeecg开源代码看泛型类型擦除之妙用

已于 2023-12-28 23:41:29 修改
阅读量446 收藏 14
点赞数 10
文章标签： windows
于 2023-12-26 10:54:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/celul/article/details/135199619
版权

啥叫类型擦除

看代码与输出

public static void main(String[] args) {
        /**
         * 类型擦除试验
         */
        List<String> sList = new ArrayList<>();
        sList.add("a");
        sList.add("b");
        fillInteger(sList);
        System.out.println(sList); // 输出为 [1, 2]
    }

    private static void fillInteger(List sList) {
        sList.clear();
        sList.add(1);
        sList.add(2);
    }

可以看出类型已被擦除，泛型不匹配或不指定只会产生编译告警，并不会产生编译错误，更不会运行错误。

Jeecg的字典翻译功能

1、可以先移步JEECG官网查看@Dict的功能JeecgBoot 文档中心

即如果我的java POJO定义为

 /**
  * 性别（字典字配置2条记录 [1：男 2：女]）
  */
 @Dict(dicCode = "sex")
  private Integer sex;

前端收到的报文如下，会多显示一个字段

{
  "sex": 1,
  "sex_dictText": "男"
}

Jeecg字典翻译功能代码

见github，也可自己下源码查看:　https://github.com/jeecgboot/jeecg-boot/blob/master/jeecg-boot-base-core/src/main/java/org/jeecg/common/aspect/DictAspect.java代码主要逻辑

１、只对IPage对象里的recordList有用，且只翻译第一层属性

2、收集所有的@Dict注解集中查库或缓存

3、将record里的T（泛型）对象，替换为JSON对象，并动态给JSON对象添加“sex_dictText”属性，就在这里进行的泛型擦除与重新赋值

为啥要弄清楚这个原理呢，是因为我们想扩展这个功能。我们可能有如下需求

1、非IPage对象也可以使用字典功能

2、对象子对象也可能使用字典功能

字典翻译功能扩展

原理就是参照上面的3个步骤，主要是子对象递归依靠什么规则，我们这里以公司的包名来限定哪些子对象需要递归扩展翻译

代码如下

private Object parseDictText(Object result) {
        if (result instanceof Result) {
            if (((Result) result).getResult() instanceof IPage) {
                    ......
            } else {
                 // 这里
            }
}

找到parseDictText函数，添加else代码块

else 代码块

else {
                Object ret = ((Result<?>) result).getResult();
                if (ret == null) {
                    return;
                }
                ObjectDict objDict = ret.getClass().getAnnotation(ObjectDict.class);
                if (objDict == null) {
                    return;
                }

                Map<String, Set<String>> dataSetMap = new HashMap<>(5);
                try {
                    // 1. 递归遍历出所有dict，并生成翻译缓存
                    deepRecallFindDict(ret, dataSetMap);
                    Map<String, List<String>> dataListMap = new HashMap<>(dataSetMap.size());
                    dataSetMap.forEach((key, value) -> dataListMap.put(key, new ArrayList<>(value)));
                    Map<String, List<DictModel>> transResultMap = this.translateAllDict(dataListMap);

                    // 2. 递归填充所有dict
                    JSONObject retJson = this.getJsonObject(ret);
                    deepRecallFillDict(ret, retJson, transResultMap);
                    ((Result) result).setResult(retJson);
                } catch (IllegalAccessException e) {
                    log.warn("", e);
                }
}

其它支撑函数

private static final String PACKAGE_SUFFIX = "com.github.你自己的包....";
private JSONObject getJsonObject(Object record) {
        ObjectMapper mapper = new ObjectMapper();
        String json="{}";
        try {
            //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
             json = mapper.writeValueAsString(record);
        } catch (JsonProcessingException e) {
            log.error("json解析失败"+e.getMessage(),e);
        }
        //update-begin--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
        JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
        return item;
    }

    private void deepRecallFillDict(Object ret, JSON retJson, Map<String, List<DictModel>> transResultMap) throws IllegalAccessException {
        if (ret == null) {
            return;
        }
        if (ret instanceof Collection) {
            Object[] objects = ((Collection<?>) ret).toArray();
            int i= 0;
            for (Object object : objects) {
                deepRecallFillDict(object, (JSON)(((JSONArray)retJson).get(i++)), transResultMap);
            }
        } else {
            if (!ret.getClass().getPackage().getName().startsWith(PACKAGE_SUFFIX)) {
                return;
            }
            JSONObject json = (JSONObject) retJson;
            for (Field field : oConvertUtils.getAllFields(ret)) {
                field.setAccessible(true);
                Object value = field.get(ret);
                field.setAccessible(false);
                if (value instanceof Collection) {
                    JSON jsonCollection = (JSON) json.get(field.getName());
                    deepRecallFillDict(value, jsonCollection, transResultMap);
                } else if (field.getType().getCanonicalName().startsWith(PACKAGE_SUFFIX)) {
                    JSON jsonObj = (JSON) json.get(field.getName());
                    deepRecallFillDict(value, jsonObj, transResultMap);
                }
                //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 dictCode = code;
                    if (!org.apache.commons.lang3.StringUtils.isEmpty(table)) {
                        dictCode = String.format("%s,%s,%s", table, text, code);
                    }

                    if (oConvertUtils.isNotEmpty(value)) {
                        List<DictModel> dictModels = transResultMap.get(dictCode);
                        if(dictModels==null || dictModels.size()==0){
                            continue;
                        }

                        String textValue = this.translDictText(dictModels, Optional.ofNullable(value).map(String::valueOf).orElse(null));
                        log.debug(" 字典Val : " + textValue);
                        log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);

                        // TODO-sun 测试输出，待删
                        log.debug(" ---- dictCode: " + dictCode);
                        log.debug(" ---- value: " + value);
                        log.debug(" ----- text: " + textValue);
                        log.debug(" ---- dictModels: " + JSON.toJSONString(dictModels));

                        json.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
                    }
                }
            }
        }
    }

    private void deepRecallFindDict(Object ret, Map<String, Set<String>> dataListMap) throws IllegalAccessException {
        if (ret == null) {
            return;
        }
        if (ret instanceof Collection) {
            Object[] objects = ((Collection<?>) ret).toArray();
            for (Object object : objects) {
                deepRecallFindDict(object, dataListMap);
            }
        } else {
            if (!ret.getClass().getPackage().getName().startsWith(PACKAGE_SUFFIX)) {
                return;
            }
            for (Field field : oConvertUtils.getAllFields(ret)) {
                field.setAccessible(true);
                Object value = field.get(ret);
                field.setAccessible(false);
                if (value instanceof Collection) {
                    deepRecallFindDict(value, dataListMap);
                }  else if (field.getType().getCanonicalName().startsWith(PACKAGE_SUFFIX)) {
                    deepRecallFindDict(value, dataListMap);
                }
                //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();


                    Set<String> dataSet;
                    String dictCode = code;
                    if (!org.apache.commons.lang3.StringUtils.isEmpty(table)) {
                        dictCode = String.format("%s,%s,%s", table, text, code);
                    }
                    dataSet = dataListMap.computeIfAbsent(dictCode, k -> new HashSet<>());
                    Optional.ofNullable(value).map(String::valueOf).ifPresent(dataSet::add);
                }
            }
        }
    }

用法

使用ObjectDict注解需要返回的类即可

    @ObjectDict
    public class JeecgOrderCustomer implements Serializable {
        String name;
        @Dict(dicCode="sex")
        int sex;
        List<JeecgOrder> orders;
    }

    public class JeecgOrder implements Serializable {
        String id;
        @Dict(dicCode="category")
        int category;
    }

 那在controller里调用时，只要使用Result包装，即可生效

public Result<?> queryOrderCustomerListByMainId(@RequestParam(name = "id", required = true) String id) {
        List<JeecgOrderCustomer> jeecgOrderCustomerList = jeecgOrderCustomerService.selectCustomersByMainId(id);
        return Result.ok(jeecgOrderCustomerList);
    }

扩展功能的不足与注意

1、扩展功能的范围是以包命来限制的，所以这里需要配置包名，可能也是因为这个原因官方才没有做这个扩展

2、扩展暂时不支持Map

3、代码中ObjectDict是一个注解，仅在最外层的Class上注解可以生效

123celul
关注
  • 10
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java泛型类型擦除后的补偿
03-16
NULL 博文链接：https://hyzhaolt.iteye.com/blog/443661
Java 泛型，你了解类型擦除吗？
热门推荐
frank 的专栏
08-05 10万+
泛型，一个孤独的守门者。 大家可能会有疑问，我为什么叫做泛型是一个守门者。这其实是我个人的看法而已，我的意思是说泛型没有其看起来那么深不可测，它并不神秘与神奇。泛型是 Java 中一个很小巧的概念，但同时也是一个很容易让人迷惑的知识点，它让人迷惑的地方在于它的许多表现有点违反直觉。文章开始的地方，先给大家奉上一道经典的测试题。List&lt;String&gt; l1 = new ArrayList&lt;Stri
Jeecg-boot字典翻译改造
折骨成诗的博客
09-14 1200
三.修改后的parseDictText方法，支持IPage、List、Object。一.找到字典切面类(DictAspect)二.改造方法(parseDictText)六.增加检测是否可转换为JSON字符串方法。四.提取公共代码作为单独的方法进行翻译。五.增加中文检测方法。
【JAVA日常】关于jeecgBoot @Dict注解的使用不生效问题
weixin_45456848的博客
09-11 2024
关于jeecgBoot @Dict注解的使用不生效问题
Java 泛型总结（一）：基本用法与类型擦除
08-31
本文主要介绍了Java泛型的使用以及类型擦除相关的问题。具有很好的参考价值。下面跟着小编一起来看下吧
Java泛型与类型擦除
01-21
“编译器会进行泛型擦除”是一个常识了（好吧，实际擦除的是参数和自变量的类型）。这个过程由“类型擦除”实现。但是并非像许多开发者认为的那样，在 <..> 符号内的东西都被擦除了。看下面这段代码： public ...
Java编程探索之泛型擦除实例解析
08-29
主要介绍了Java编程探索之泛型擦除实例解析，具有一定参考价值，需要的朋友可以了解下。
详解java 中泛型中的类型擦除和桥方法
08-30
主要介绍了详解java 中泛型中的类型擦除和桥方法的相关资料,需要的朋友可以参考下
使用Mybatis映射时间 DateTime ==＞ LocalDateTime
qq_58341172的博客
04-25 327
此处有弊端，请移步下一篇……service：接口。
C语言：数据结构（双向链表）
weixin_66058866的博客
04-28 471
带头链表里的头节点，实际为“放哨的”，哨兵位节点不存储任何有效元素，只是站在这里“放哨的”，“哨兵位”存在的意义：遍历循环链表避免死循环。
循环双链表的操作
一个正在学习C/C++的博主
04-25 201
【代码】循环双链表的操作。
pve(Proxmox VE)安装i225v网卡驱动
qq_43158436的博客
04-27 401
我的网卡名是enp7s0，所以我是ifup enp7s0。内核版本就是 6.8.4-2-pve。执行命令安装pve-headers。下载完成后，传到pve节点上解压。在pve shell执行命令。使用unzip命令可进行解压。改为：也就是前面加#改为：也就是前面加#查看当前内核版本，如。执行命令进行安装驱动。
使用C++实现尾插式循环链表结构
AndrewYZWang的博客
04-24 500
总结起来，这段代码提供了一个简洁而实用的尾插式循环链表的实现，适用于需要高效进行顺序添加和按最近添加顺序删除元素的场景。用于创建新节点并将新节点插入到链表的尾部，即每次新增节点都会成为新的末尾节点。因此有必要实现一款属于自己的双向链表，这样在有需要的时候就能随时增加自己的特性，让链表更好的服务于其他模块。在使用C++实现链表时，我们需要实现两个主要的类：1. node节点类 ，2. 链接node节点的类。，该节点的前驱和后继均指向自身，形成一个空链表的“闭环”。，它作为链表中的实际节点实现。
Java设计模式 _结构型模式_过滤器模式
weisian的博客
04-28 301
过滤器模式是对一组数据进行过滤，从而达到我们希望数据的设计模式。首先需要定义统一过滤方法，之后就是根据需要编写各种实现类，对需要的场景搭配不同的过滤器链路，让数据经过这些过滤器链路后获取我们需要数据的过程。过滤器，顾名思义，就是对一组数据进行过滤，从而最终获取到我们预期的数据。（3）、封装类中定义过滤器类的集合，添加过滤器到封装类中，定义和实现数据过滤的具体方法。（1）、定义过滤器的规范接口（生明接口，定义统一的过滤方法）。（2）、定义过滤器实现类，实现规范接口的过滤方法。运行结果可以看出实现了过滤效果。
【python】给函数参数和返回值标注类型
hutaotaotao的博客
04-25 443
如何给python中函数的参数和返回值标注类型，以及标注为复杂类型
用 Python 创建 Voronoi 图
gis收藏家的博客
04-26 607
假设有人很快就会耗尽汽油，他/她需要在为时已晚之前找到最近的加油站，解决这个问题的最佳解决方案是什么？当然，驾驶员可以检查地图来找到最近的加油站，但如果该地区有多个加油站，并且他/她需要快速确定哪个加油站是最近的，则可能会出现问题。所以在多边形内，最近的 POI 肯定是多边形内的点。Geovoronoi 是一个用于在地理区域内创建和绘制 Voronoi 区域的软件包。在这个项目中，我根据 POI 数据在地图上创建 Voronoi 区域。创建新的数据框来收集每个 Voronoi 区域内的街道网络。
STL——List常用接口模拟实现及其使用
m0_70289867的博客
04-25 302
List基本模拟实现和常用接口的使用
边循环边删除List中的数据
G_whang的博客
04-30 276
删除的所有，但是最终还留下两个值，这是因为当一个元素被移除时，该List的大小(size)就会缩减，同时也改变了索引的指向，也就是上面的代码只会循环两次，长度在不断减少，第一次循环0 < 4 ，第二次循环 1 < 3 ，不满足下一次循环条件 2 < 2，故只有两次循环就结束。这是因为，在 foreach循环中，编译器使得 remove()方法先于next()方法被调用，因为先执行了remove()方法，导致next()获取的数组长度和remove()后的数组长度不一致，则抛出异常。List边循环，边删除；
后端开发是一个涉及广泛技术和工具的领域.docx
最新发布
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
泛型的类型擦除机制
05-24
Java 中的泛型是通过类型擦除机制来实现的。类型擦除是指编译器在编译时将泛型类型转换为它们的原始类型，即将泛型类型中的类型参数替换为它们的限定类型或 Object 类型。 例如，在下面的代码中： ``` List<String> list = new ArrayList<>(); list.add("hello"); String str = list.get(0); ``` 编译器会将 List<String> 转换为 List，并在编译时将所有的 String 类型替换为 Object 类型。这样，在运行时，List 中的元素类型就变成了 Object。 这种类型擦除机制是为了保证 Java 泛型的向后兼容性。由于泛型是在 JDK 5.0 中引入的，为了让早期版本的 Java 代码能够与泛型代码一起使用，编译器需要将泛型类型转换为它们的原始类型。 尽管类型擦除机制可以保证 Java 泛型的向后兼容性，它也带来了一些限制。例如，由于泛型类型在编译时被擦除，所以不能在运行时获取泛型类型的实际参数类型。这使得在某些情况下，无法对泛型类型进行操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值