【平台化引擎-2】— 参数扁平与结构化操作

作者: 小胖学编程 | 来源:发表于2024-02-04 18:34 被阅读0次

如何把非结构化的数据转结构化？
数组扁平化
理解RDD、DataFrame、Dataset区别
Apache kafka实战一认识Kafka
Pytest和Allure测试框架-超详细版+实战4
ES简介
Google Earth Engine谷歌地球引擎直方图与时间序
测量教研小记
对于个别点位实时流回溯正常，历史流回溯偏差逐步加大分析
大数据平台常见开源工具有哪些？

背景

如果提供一个平台化的页面供用户操作，如果用户想在页面上操作入参，需要将复杂的对象扁平化展示，以便用户操作。

页面操作流程.png

用户想在页面上操作数据流中的参数，是需要拿到结构化参数中的字段，为了便于用户操作，需要支持扁平化的操作

参数扁平化

原始数据：

{
    "address":[
        {
            "area":"白帝小区",
            "city":"洛阳",
            "phone":"13617172122",
            "province":"河南"
        },
        {
            "area":"邯郸小区",
            "city":"邯郸",
            "phone":"19917172122",
            "province":"河北"
        },
        {
            "area":"德州小区",
            "city":"德州",
            "phone":"18817172122",
            "province":"山东"
        }
    ],
    "balance":10.11,
    "birthday":{
        "day":"30",
        "mon":"11",
        "year":"2020"
    },
    "name":"小白",
    "uid":1001
}

结构化schema：

{
    "address":[
        {
            "area":"String",
            "city":"String",
            "phone":"String",
            "province":"String"
        }
    ],
    "balance":"BigDecimal",
    "birthday":{
        "day":"String",
        "mon":"String",
        "year":"String"
    },
    "name":"String",
    "uid":"Integer"
}

扁平化schema：

{
    "address":"LIST",
    "address.0":"MAP",
    "address.0.area":"String",
    "address.0.city":"String",
    "address.0.phone":"String",
    "address.0.province":"String",
    "balance":"BigDecimal",
    "birthday":"MAP",
    "birthday.day":"String",
    "birthday.mon":"String",
    "birthday.year":"String",
    "name":"String",
    "uid":"Integer"
}

如上图所示。我们可以拿到扁平化的schema结构后，那么在页面上可以输入address.0.area，就可以获取到Map中的对于的value值（作为Context上下文，执行脚本）。

代码实现

数据准备

public interface SourceParam {
    /**
     * 获取参数元数据
     */
    Map<String, Object> getParamMeta();
}

public class MockSourceParam implements SourceParam {
    @Override
    public Map<String, Object> getParamMeta() {
        //原数据
        UserInfo userInfo = new UserInfo();
        userInfo.setUid(1001L);
        userInfo.setName("小白");
        userInfo.setBalance(10.11);
        Birthday birthday = new Birthday();
        birthday.setYear("2020");
        birthday.setMon("11");
        birthday.setDay("30");
        userInfo.setBirthday(birthday);

        List<Address> addressList = Lists.newArrayList();
        addressList.add(Address.builder().province("河南").city("洛阳").area("白帝小区").phone("13617172122").build());
        addressList.add(Address.builder().province("河北").city("邯郸").area("邯郸小区").phone("19917172122").build());
        addressList.add(Address.builder().province("山东").city("德州").area("德州小区").phone("18817172122").build());

        userInfo.setAddress(addressList);
        System.out.println(JSON.toJSONString(userInfo));

        return JSON.parseObject(JSON.toJSONString(userInfo), Map.class);
    }

    @Data
    public static class UserInfo {

        private Long uid;

        private String name;

        private Birthday birthday;

        private double balance;

        private List<Address> address;

    }

    @Data
    public static class Birthday {
        private String year;
        private String mon;
        private String day;
    }

    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Address {
        private String province;
        private String city;
        private String area;
        private String phone;
    }
}

工具方案：


import com.google.common.collect.Maps;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.Map.Entry;

public class ParamHelper {
    /**
     * json的嵌套格式化
     */
    public static Map<String, Object> jsonSchema(Map<String, Object> data) {
        Map<String, Object> result = Maps.newHashMap();
        if (MapUtils.isEmpty(data)) {
            return result;
        }
        data.forEach((k, v) -> {
            result.put(k, v.getClass().getSimpleName());
            //如果Map
            if (v instanceof Map) {
                result.put(k, jsonSchema((Map<String, Object>) v));
                return;
            }

            if (v instanceof Collection) {
                Collection t = (Collection) v;
                Iterator iterator = t.iterator();
                Collection c1 = new ArrayList<>();
                if (iterator.hasNext()) {
                    Object o = iterator.next();
                    if (o instanceof Map) {
                        c1.add(jsonSchema((Map<String, Object>) o));
                    } else {
                        c1.add(o.getClass().getSimpleName());
                    }
                }
                result.put(k, c1);
            }
        });
        return result;
    }

    /**
     * 写入扁平化的数据
     */
    public static Map<String, Object> putFold(Map<String, Object> data) {
        Map<String, Object> result = Maps.newHashMap();
        if (MapUtils.isEmpty(data)) {
            return result;
        }
        data.forEach((k, v) -> {
            String[] splitKey = k.split("\\.");
            int index = 0;
            Map<String, Object> indexMap = result;

            while (index < splitKey.length - 1) {
                String subKey = splitKey[index];
                indexMap = foldGetFromMap(indexMap, subKey);
                index++;
            }

            indexMap.put(splitKey[index], v);
        });
        return convertDataArray(result);
    }

    public static Map<String, Object> jsonSchemaForUnfold(Map<String, Object> data) {
        Map<String, String> unfoldData = jsonSchemaForUnfold("", data);
        Map<String, Object> res = Maps.newHashMap();

        for (Entry<String, String> entry : unfoldData.entrySet()) {
            String key = entry.getKey();
            String fieldType = entry.getValue();
            res.put(key, fieldType);
        }

        return res;
    }

    public static Map<String, String> jsonSchemaForUnfold(String prefix, Map<String, Object> data) {
        Map<String, String> result = Maps.newHashMap();
        if (MapUtils.isEmpty(data)) {
            return result;
        }
        data.forEach((k, v) -> {
            String unfoldKey;
            if (StringUtils.isNotBlank(prefix)) {
                unfoldKey = prefix + "." + k;
            } else {
                unfoldKey = k;
            }

            if (v instanceof Map) {
                result.put(unfoldKey, "MAP");
                result.putAll(jsonSchemaForUnfold(unfoldKey, (Map<String, Object>) v));
                return;
            }
            if (v instanceof Collection) {
                result.put(unfoldKey, "LIST");

                result.putAll(jsonSchemaForUnfold(unfoldKey, convertToMap((Collection) v)));
                return;
            }
            result.put(unfoldKey, v.getClass().getSimpleName());
        });
        return result;
    }
    private static Map<String, Object> convertToMap(Collection<?> collection) {
        Map<String, Object> result = Maps.newHashMap();
        if (CollectionUtils.isEmpty(collection)) {
            return result;
        }
        Iterator<?> iterator = collection.iterator();
        result.put(String.valueOf(0), iterator.next());
        return result;

    }
    private static Map<String, Object> foldGetFromMap(Map<String, Object> map, String key) {
        Object subNode = map.get(key);
        if (Objects.nonNull(subNode) && subNode instanceof Map) {
            return (Map<String, Object>) subNode;
        }
        Map<String, Object> result = Maps.newHashMap();
        map.put(key, result);
        return result;
    }

    private static Map<String, Object> convertDataArray(Map<String, Object> map) {
        Map<String, Object> result = Maps.newHashMap();
        if (MapUtils.isEmpty(map)) {
            return map;
        }
        for (Entry<String, Object> entry : map.entrySet()) {
            String k = entry.getKey();
            Object v = entry.getValue();
            if (!(v instanceof Map)) {
                result.put(k, v);
                continue;
            }
            Map<String, Object> valueMap = convertDataArray((Map<String, Object>) v);
            if (valueMap.keySet().stream().allMatch(StringUtils::isNumeric)) {
                result.put(k, valueMap.values());
                continue;
            }
            result.put(k, valueMap);
        }
        return result;
    }
}

工具类实现：

public class Test {
    public static void main(String[] args) {
        SourceParam mockSourceParam = new MockSourceParam();
        Map<String, Object> paramMeta = mockSourceParam.getParamMeta();
        //获取到json串schema结构
        System.out.println(JSON.toJSON(ParamHelper.jsonSchema(paramMeta)));
        //获取到扁平的json的schema结构
        System.out.println(JSON.toJSON(ParamHelper.jsonSchemaForUnfold(paramMeta)));
        //存储扁平化的数据
        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("userInfo.uid", 1);
        hashMap.put("userInfo.name", "tom");
        Map<String, Object> stringObjectMap = putFold(hashMap);
        System.out.println(JSON.toJSON(stringObjectMap));
    }
}

如何把非结构化的数据转结构化？
1.流程： 1. 数据获取 2. 非结构化数据转化成结构化数据 3. 构建知识图谱、构建搜索及推荐引擎 2.如何建...
数组扁平化
let arr = [1, 2, [1, 2, [1, 2]]]; 如何将数组实现扁平化操作？ 1. 利用for循...
理解RDD、DataFrame、Dataset区别
先上图 rdd 优点1.强大，内置很多函数操作，group，map，filter等，方便处理结构化或非结构化数据2...
Apache kafka实战一认识Kafka
1，消息引擎系统 1）Kafka是消息引擎系统，两个重要因素: 消息设计、传输协议设计。2）Kafka消息是结构化...
Pytest和Allure测试框架-超详细版+实战4
四，参数化与数据驱动框架实现参数化1 参数化2：单个参数附上多个值参数化3: 多个参数的参数化4: 登录参...
ES简介
Elasticsearch概述分布式搜索、分析引擎提供实时检索、分析各种类型的数据（结构化、非结构化文本；数字...
Google Earth Engine谷歌地球引擎直方图与时间序
本文主要对GEE中的依据栅格图像绘制直方图与时间序列图并调整图像可视化参数操作加以介绍。本文是谷歌地球引擎（G...
测量教研小记
一、知识问题与教学问题区分测量结构化知识问题3类 1.认识（测量工具及单位的认识） 2.操作（测量的操作:精确测...
对于个别点位实时流回溯正常，历史流回溯偏差逐步加大分析
1. 从结构化流程上看，视频结构化结果是来自结构化后元数据存储到大数据平台，结构化的图片本地存储，在结构化过程中v...
大数据平台常见开源工具有哪些？
大数据平台是对海量结构化、非结构化、半机构化数据进行采集、存储、计算、统计、分析处理的一系列技术平台。大数据平台处...