flink get_json

最新推荐文章于 2024-01-14 12:14:20 发布
最新推荐文章于 2024-01-14 12:14:20 发布
阅读量650 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_0128/article/details/118593948
本文介绍如何使用 Apache Flink 处理来自 Kafka 的 JSON 数据，包括解析 JSON 字符串、提取特定路径的数据，并通过 SQL 查询获取指定字段。此外，还展示了如何设置 Flink 环境、连接 Kafka 以及实现数据流的转换。

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>flinktest</groupId>
    <artifactId>com.flink</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>7</source>
                    <target>7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.11</artifactId>
            <version>1.10.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>1.10.0</version>
<!--            <scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.11</artifactId>
            <version>1.10.0</version>
<!--            <scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.11</artifactId>
            <version>1.10.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-client</artifactId>
            <version>1.7.0</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.apache.flink</groupId>-->
<!--            <artifactId>flink-connector-kafka_2.11</artifactId>-->
<!--            <version>1.10.0</version>-->
<!--        </dependency>-->
        <!-- https://mvnrepository.com/artifact/com.alibaba.otter/canal.client -->
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.4</version>
        </dependency>

<!--        <dependency>-->
<!--            <groupId>org.apache.flink</groupId>-->
<!--            <artifactId>flink-table-planner-blink_2.11</artifactId>-->
<!--            <version>1.10.0</version>-->
<!--&lt;!&ndash;            <scope>provided</scope>&ndash;&gt;-->
<!--        </dependency>-->

<!--        <dependency>-->
<!--            <groupId>org.apache.flink</groupId>-->
<!--            <artifactId>flink-table-common</artifactId>-->
<!--            <version>1.10.0</version>-->
<!--&lt;!&ndash;            <scope>provided</scope>&ndash;&gt;-->
<!--        </dependency>-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.11</artifactId>
            <version>1.10.0</version>
            <!--            <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner_2.11</artifactId>
            <version>1.10.0</version>
            <!--            <scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>com.alibaba.blink</groupId>
            <artifactId>flink-table_2.11</artifactId>
            <version>blink-3.2.2</version>
        </dependency>

    </dependencies>


</project>


package TestKudu;

import org.apache.flink.shaded.guava18.com.google.common.collect.Iterators;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.annotation.JsonValue;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.core.JsonFactory;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.core.JsonParser;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.databind.JavaType;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.flink.shaded.jackson2.com.fasterxml.jackson.databind.type.TypeFactory;
import org.apache.flink.table.functions.ScalarFunction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class GetJsonObject extends ScalarFunction {
    // 可选， open方法可以不写,若写的话需要import org.apache.flink.table.functions.FunctionContext;

    public long eval(String a) {
        return a == null ? 0 : a.length();
    }
//    public long eval(String b, String c) {
//        return eval(b) + eval(c);
//    }
    //可选，close方法可以不写
    @Override
    public void close() {
    }
    public static final Logger LOG = LoggerFactory.getLogger(GetJsonObject.class);
    public final Pattern patternKey = Pattern.compile("^([a-zA-Z0-9_\\-\\:\\s]+).*");
    public final Pattern patternIndex = Pattern.compile("\\[([0-9]+|\\*)\\]");

    public static final JsonFactory JSON_FACTORY = new JsonFactory();

    static {
        // Allows for unescaped ASCII control characters in JSON values
        JSON_FACTORY.enable(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS);
    }

    public static final ObjectMapper MAPPER = new ObjectMapper(JSON_FACTORY);
    public static final JavaType MAP_TYPE = TypeFactory.defaultInstance().constructMapType(Map.class, Object.class, Object.class);
    public static final JavaType LIST_TYPE = TypeFactory.defaultInstance().constructRawCollectionType(List.class);

    /**
     *An LRU cache using a linked hash map.
     */
    public static class HashCache<K, V> extends LinkedHashMap<K, V> {

        private static final int CACHE_SIZE = 16;
        private static final int INIT_SIZE = 32;
        private static final float LOAD_FACTOR = 0.6f;

        HashCache() {
            super(INIT_SIZE, LOAD_FACTOR);
        }

        private static final long serialVersionUID = 1;

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
            return size() > CACHE_SIZE;
        }

    }

    /**
     *An ThreadLocal cache using a linked hash map.
     */
    public static class ThreadLocalHashCache<K, V> {
        private ThreadLocal<HashCache<K, V>> cache = new ThreadLocal<>();

        public V get(K key) {
            HashCache<K, V> m = cache.get();
            if (m == null) {
                m = new HashCache<>();
                cache.set(m);
            }
            return m.get(key);
        }

        public V put(K key, V value) {
            HashCache<K, V> m = cache.get();
            if (m == null) {
                m = new HashCache<>();
                cache.set(m);
            }
            return m.put(key, value);
        }

        public void remove() {
            cache.remove();
        }
    }

    public static ThreadLocalHashCache<String, Object> extractObjectCache = new ThreadLocalHashCache<String, Object>();
    public static ThreadLocalHashCache<String, String[]> pathExprCache = new ThreadLocalHashCache<String, String[]>();
    public static ThreadLocalHashCache<String, ArrayList<String>> indexListCache =
            new ThreadLocalHashCache<String, ArrayList<String>>();
    public static ThreadLocalHashCache<String, String> mKeyGroup1Cache = new ThreadLocalHashCache<String, String>();
    public static ThreadLocalHashCache<String, Boolean> mKeyMatchesCache = new ThreadLocalHashCache<String, Boolean>();

    private static ThreadLocal<GetJsonObject> instance = new ThreadLocal<GetJsonObject>();

    public static void remove(){
        instance.remove();
    }

    public static GetJsonObject getInstance() {
        if (null == instance.get()) {
            instance.set(new GetJsonObject());
        }
        return instance.get();
    }

    public String eval(String jsonString, String pathString) {

        if (jsonString == null || jsonString.isEmpty() || pathString == null
                || pathString.isEmpty() || pathString.charAt(0) != '$') {
            LOG.debug("jsonString is null or empty, or path is null or empty, or path is not start with '$'! " +
                    "jsonString: " + jsonString + ", path: " + pathString);
            return null;
        }

        String result = new String();
        int pathExprStart = 1;
        boolean isRootArray = false;

        if (pathString.length() > 1) {
            if (pathString.charAt(1) == '[') {
                pathExprStart = 0;
                isRootArray = true;
            } else if (pathString.charAt(1) == '.') {
                isRootArray = pathString.length() > 2 && pathString.charAt(2) == '[';
            } else {
                LOG.debug("path String illegal! path String: " + pathString);
                return null;
            }
        }

        // Cache pathExpr
        String[] pathExpr = pathExprCache.get(pathString);
        if (pathExpr == null) {
            pathExpr = pathString.split("\\.", -1);
            pathExprCache.put(pathString, pathExpr);
        }

        // Cache extractObject
        Object extractObject = extractObjectCache.get(jsonString);
        if (extractObject == null) {
            JavaType javaType = isRootArray ? LIST_TYPE : MAP_TYPE;
            try {
                extractObject = MAPPER.readValue(jsonString, javaType);
            } catch (Exception e) {
                LOG.debug(
                        "Exception when read json value with type :" + javaType.toString() +
                                ", and json string: " + jsonString, e);
                return null;
            }
            extractObjectCache.put(jsonString, extractObject);
        }
        for (int i = pathExprStart; i < pathExpr.length; i++) {
            if (extractObject == null) {
                LOG.debug("path look up fail at: " + pathExpr[i - 1 >= 0 ? i - 1 : 0] +
                        ", pathString: " + pathString +
                        "json: " + jsonString);
                return null;
            }
            extractObject = extract(extractObject, pathExpr[i], i == pathExprStart && isRootArray);
        }
        if (extractObject instanceof Map || extractObject instanceof List) {
            try {
                result = MAPPER.writeValueAsString(extractObject);
            } catch (Exception e) {
                LOG.debug(
                        "Exception when MAPPER.writeValueAsString :" +
                                extractObject.toString(), e);
                return null;
            }
        } else if (extractObject != null) {
            result = extractObject.toString();
        } else {
            LOG.debug("path look up fail at: " + (pathExpr.length - 1 >= 0 ? pathExpr[pathExpr.length - 1] : null) +
                    ", pathString: " + pathString +
                    "json: " + jsonString);
            return null;
        }
        return result;
    }

    public String[] getJsonObjectsWithoutDollar(String jsonString, String[] pathStrings) {
        if (jsonString == null || jsonString.isEmpty() || pathStrings == null
                || pathStrings.length == 0) {
            LOG.debug("jsonString is null or empty, or path is null or empty! " +
                    "jsonString: " + jsonString);
            return new String[0];
        }

        int pathExprStart = 1;
        boolean isRootArray = false;

        Object rootExtractObject = extractObjectCache.get(jsonString);
        if (rootExtractObject == null) {
            JavaType javaType = isRootArray ? LIST_TYPE : MAP_TYPE;
            try {
                rootExtractObject = MAPPER.readValue(jsonString, javaType);
            } catch (Exception e) {
                LOG.debug(
                        "Exception when read json value with type :" + javaType.toString() +
                                ", and json string: " + jsonString, e);
                return new String[0];
            }
            extractObjectCache.put(jsonString, rootExtractObject);
        }

        String[] result = new String[pathStrings.length];
        for (int i = 0; i < pathStrings.length; i++) {
            String pathString = "$." + pathStrings[i];
            if (pathString == null || pathString.length() == 0){
                result[i] = null;
                LOG.debug(i + "th path String is null or empty! " +
                        "pathString: " + pathString);
                continue;
            }
            if (pathString.length() > 1) {
                if (pathString.charAt(1) == '[') {
                    pathExprStart = 0;
                    isRootArray = true;
                } else if (pathString.charAt(1) == '.') {
                    isRootArray = pathString.length() > 2 && pathString.charAt(2) == '[';
                } else {
                    result[i] = null;
                    LOG.debug(i + "th path String illegal! path String: " + pathString);
                    continue;
                }
            }

            // Cache pathExpr
            String[] pathExpr = pathExprCache.get(pathString);
            if (pathExpr == null) {
                pathExpr = pathString.split("\\.", -1);
                pathExprCache.put(pathString, pathExpr);
            }

            // Cache extractObject
            Object extractObject = rootExtractObject;
            if (extractObject == null) {
                JavaType javaType = isRootArray ? LIST_TYPE : MAP_TYPE;
                try {
                    extractObject = MAPPER.readValue(jsonString, javaType);
                } catch (Exception e) {
                    LOG.debug(
                            "Exception when read json value with type :" + javaType.toString() +
                                    ", and json string: " + jsonString, e);
                    result[i] = null;
                    continue;
                }
                extractObjectCache.put(jsonString, extractObject);
            }
            for (int j = pathExprStart; j < pathExpr.length; j++) {
                if (extractObject == null) {
                    result[i] = null;
                    LOG.debug(i + "th path look up fail at: " + pathExpr[j - 1 >= 0 ? j - 1 : 0] +
                            ", pathString: " + pathString +
                            "json: " + jsonString);
                    continue;
                }
                extractObject = extract(extractObject, pathExpr[j], j == pathExprStart && isRootArray);
            }
            if (extractObject instanceof Map || extractObject instanceof List) {
                try {
                    result[i] = MAPPER.writeValueAsString(extractObject);
                } catch (Exception e) {
                    LOG.debug(
                            "Exception when MAPPER.writeValueAsString :" +
                                    extractObject.toString(), e);
                    result[i] = null;
                    continue;
                }
            } else if (extractObject != null) {
                result[i] = extractObject.toString();
            } else {
                result[i] = null;
                LOG.debug(i + "th path look up fail at: " +
                        (pathExpr.length - 1 >= 0 ? pathExpr[pathExpr.length - 1] : null) +
                        ", pathString: " + pathString +
                        "json: " + jsonString);
                continue;
            }
        }
        return result;
    }

    protected Object extract(Object json, String path, boolean skipMapProc) {
        // skip MAP processing for the first path element if root is array
        if (!skipMapProc) {
            // Cache patternkey.matcher(path).matches()
            Matcher mKey = null;
            Boolean mKeyMatches = mKeyMatchesCache.get(path);
            if (mKeyMatches == null) {
                mKey = patternKey.matcher(path);
                mKeyMatches = mKey.matches() ? Boolean.TRUE : Boolean.FALSE;
                mKeyMatchesCache.put(path, mKeyMatches);
            }
            if (!mKeyMatches.booleanValue()) {
                return null;
            }

            // Cache mkey.group(1)
            String mKeyGroup1 = mKeyGroup1Cache.get(path);
            if (mKeyGroup1 == null) {
                if (mKey == null) {
                    mKey = patternKey.matcher(path);
                    mKeyMatches = mKey.matches() ? Boolean.TRUE : Boolean.FALSE;
                    mKeyMatchesCache.put(path, mKeyMatches);
                    if (!mKeyMatches.booleanValue()) {
                        return null;
                    }
                }
                mKeyGroup1 = mKey.group(1);
                mKeyGroup1Cache.put(path, mKeyGroup1);
            }
            json = extractJsonWithkey(json, mKeyGroup1);
        }
        // Cache indexList
        ArrayList<String> indexList = indexListCache.get(path);
        if (indexList == null) {
            Matcher mIndex = patternIndex.matcher(path);
            indexList = new ArrayList<String>();
            while (mIndex.find()) {
                indexList.add(mIndex.group(1));
            }
            indexListCache.put(path, indexList);
        }

        if (indexList.size() > 0) {
            json = extractJsonWithIndex(json, indexList);
        }

        return json;
    }

    private AddingList jsonList = new AddingList();

    private static class AddingList extends ArrayList<Object> {
        @Override
        public java.util.Iterator<Object> iterator() {
            return Iterators.forArray(toArray());
        }

        @Override
        public void removeRange(int fromIndex, int toIndex) {
            super.removeRange(fromIndex, toIndex);
        }
    }

    protected Object extractJsonWithIndex(Object json, ArrayList<String> indexList) {

        jsonList.clear();
        jsonList.add(json);
        AddingList tempJsonList = new AddingList();
        for (String index : indexList) {
            int targets = jsonList.size();
            if (index.equalsIgnoreCase("*")) {
                for (Object array : jsonList) {
                    if (array instanceof List) {
                        for (int j = 0; j < ((List<Object>) array).size(); j++) {
                            jsonList.add(((List<Object>) array).get(j));
                        }
                    }
                }
            } else {
                for (Object array : jsonList) {
                    int indexValue = Integer.parseInt(index);
                    if (!(array instanceof List)) {
                        continue;
                    }
                    List<Object> list = (List<Object>) array;
                    if (indexValue >= list.size()) {
                        continue;
                    }
                    tempJsonList.add(list.get(indexValue));
                }
                jsonList.addAll(tempJsonList);
            }
            if (jsonList.size() == targets) {
                return null;
            }
            jsonList.removeRange(0, targets);
        }
        if (jsonList.isEmpty()) {
            return null;
        }
        return (jsonList.size() > 1) ? new ArrayList<Object>(jsonList) : jsonList.get(0);
    }

    protected Object extractJsonWithkey(Object json, String path) {
        if (json instanceof List) {
            List<Object> jsonArray = new ArrayList<Object>();
            for (int i = 0; i < ((List<Object>) json).size(); i++) {
                Object jsonElem = ((List<Object>) json).get(i);
                Object jsonObj = null;
                if (jsonElem instanceof Map) {
                    jsonObj = ((Map<String, Object>) jsonElem).get(path);
                } else {
                    continue;
                }
                if (jsonObj instanceof List) {
                    for (int j = 0; j < ((List<Object>) jsonObj).size(); j++) {
                        jsonArray.add(((List<Object>) jsonObj).get(j));
                    }
                } else if (jsonObj != null) {
                    jsonArray.add(jsonObj);
                }
            }
            return (jsonArray.size() == 0) ? null : jsonArray;
        } else if (json instanceof Map) {
            return ((Map<String, Object>) json).get(path);
        } else {
            return null;
        }
    }
}


package TestKudu;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.types.Row;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import static org.apache.calcite.sql.fun.SqlStdOperatorTable.JSON_EXISTS;

/**
 * @author 
 * @date 2020/3/19 16:57
 * @explain
 */
public class KafkaSinkTest {
    public static void main(String[] args) throws Exception{
        // 初始化 flink 执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        EnvironmentSettings fsSettings = EnvironmentSettings.newInstance().useOldPlanner().inStreamingMode().build();
//        StreamExecutionEnvironment fsEnv = StreamExecutionEnvironment.getExecutionEnvironment();
        StreamTableEnvironment fsTableEnv = StreamTableEnvironment.create(env, fsSettings);

        // 生成数据源
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", ":9092");

        properties.setProperty("group.id", "test1");
        FlinkKafkaConsumer<String> consumer = new FlinkKafkaConsumer<>("user_behavior1", new SimpleStringSchema(), properties);
        consumer.setStartFromEarliest();
        DataStream<String> stream = env
                .addSource(consumer);

         fsTableEnv.registerDataStream("table1",stream,"a");
//         fsTableEnv.registerFunction("testlength",new StringLengthUdf());
        fsTableEnv.registerFunction("json_value1",new GetJsonObject());
//        Table query = fsTableEnv.sqlQuery("select testlength(a) from table1");

        //{"name":"Liza", "password":"123"}
        Table query = fsTableEnv.sqlQuery("select json_value1(a,'$.password') from table1");


        DataStream<Row> dsRow = fsTableEnv.toAppendStream(query, Row.class);
        dsRow.print();

//
        env.execute("sink-test");
    }

}
【FLink】Flink SQL 解析嵌套的 JSON 数据
九师兄
05-20 7403
1.概述 在日常的开发中,最常用的数据格式是 JSON ,并且有的时候 JSON 的格式是非常复杂的(嵌套的格式),那在 Flink SQL 中进行解析的时候也会相当麻烦一点,下面将会演示如何在 DDL 里面定义 Map、Array、Row 类型的数据,以及在 SQL 里面如何获里面的值 数据格式如下: 以下数据完全是自己造的,没有任何实际含义 { "funcName": "test", "data": { "snapshots": [{ "content_type": "applicati.
flink1.17 实现 udf scalarFunctoin get_json_object 支持 非标准化json
yy的博客
08-17 1386
相比官方的json_value,该函数支持非标准化json,比如v是个object,但是非标准json会外套一层引号,内部有反引号.支持value为 100L 这种java格式的bigint. {"k":999L}基于jsonPath 方便,可以获取多层级内部值。
flink sql 处理自定义json解析
qq276726581的博客
04-02 6136
最近要把公司flinknginx日志入库的代码，修改成flinksql的方式执行。这样日志的入库通过sql更加方便。 但是flinksql没有提供对json的解析方式，而nginx日志又是json字符串无法完全使用sql来完成日志的入库。 因此，需要修改flink来完成json的自定义解析。 首先 定义source表 CREATE TABLE kafka ( json_data string, type string, ts TIMESTAMP(3) METADATA FROM...
flink-json-1.12.2.jar
03-27
flink-json-1.12.2.jar
flinksql和json对应数据类型转换
少年阿宏
08-28 1611
无
Flink 窗口、Scala泛型通配符、Flink 窗口的底层 API、解析 json 格式的数据
赤兔胭脂小吕布的博客
03-21 594
目录Flink 窗口Time WindowSession WindowCount WindowFlink 窗口的底层 API卡口过车需求案例解析 json 格式的数据导入 fastjson 依赖fastJson解析json字符串实现需求Flink 窗口 1、Time Window 时间窗口 2、Session Window 会话窗口 如果一段时间没有数据生成一个窗口 3、Count Wi...
Flink处理kafka中复杂json数据、自定义get_json_object函数实现打印数据
bigdata_users的博客
05-12 4098
最近用到flink处理复杂json，原生flink不支持json_value
flink sql 知其所以然（十八）：在 flink 中还能使用 hive udf？附源码
qq_34608620的博客
02-13 1882
1.序篇 源码公众号后台回复1.13.2 sql hive udf获取。 废话不多说，咱们先直接上本文的目录和结论，小伙伴可以先看结论快速了解博主期望本文能给小伙伴们带来什么帮助： 背景及应用场景介绍：博主期望你能了解到，其实很多场景下实时数仓的建设都是随着离线数仓而建设的（相同的逻辑在实时数仓中重新实现一遍），因此能够在 flink sql 中复用 hive udf 是能够大大提高人效的。 flink 扩展支持 hive 内置 udf：flink sql 提供了扩展 udf 的能力，即 modul
PyFlink SQL的json解析函数
joomlaer的专栏
10-22 1136
当你遇到大数据里含有json时候，离线数仓开发，hive有特别好用的get_json函数。 例如下面的： SELECT get_json_object(xjson,"$.[0].age") FROM person 但遇到实时处理该咋办？ 同学们会说，Flink SQL里不是有吗？好吧，你太想当然了。 在FlinkSQL，特别是最好用的FlinkSQL里，居然没有成型的JSON解析函数。 根据遇到的情形，有好几种方式。 如果遇到的是json有固定结构，那在定义flinkSQL的表结构里可以。比
Flink Table：解析 JSON 类型的字段为新的列
TechChamp的博客
09-14 389
Flink Table：解析 JSON 类型的字段为新的列在 Flink 中，Table API 和 SQL 提供了一种方便的方式来处理结构化和半结构化数据。当我们处理包含 JSON 类型字段的数据时，我们经常需要将这些字段解析为新的列，以便进行进一步的分析和处理。本文将介绍如何使用 Flink Table API 和 SQL 将 JSON 类型的字段解析为新的列，并提供相应的源代码示例。
flink-streaming实战-json数组解析
huobumingbai1234的博客
02-17 6000
之前实际开发都是用的blink-sql模式，还没实际开发过streaming模式的作业，有个简单的例子，特意记录下 因为下游我们是odps，目前没有jar包，这个之后调通了再加上 作业描述： 上游是kafka，原始数据格式为json数组，输出为json对象，本地日志打印输出，source连接参照阿里云的例子 package com.alibaba.blink.datastreaming; import com.google.gson.JsonArray; import com.goog...
Flink Format系列(1)-JSON
chanyue123的博客
07-22 3757
Flink sql解析复杂json
flink数据格式转换，DataStream转换成指定对象
qq_41321549的博客
11-03 4500
flink实时流学习项目介绍：        目前在个某市商业银行做实时数据展示、数据处理；项目中使用到flink框架，进行数据加工处理。针对使用到的几个业务场景，和目前学习的flink阶段自己搭建了一个实时数据加工的处理项目。 目前处在学习、整理、分享的阶段，并不具备成型、系统的理念；本次介绍的是，在flink进行数据格式的转换，为数据的统计、对比、计算奠定基础。      &nbsp
flink table解析json类型的字段为新的列
yy的博客
06-24 1131
目的 希望把source端的表格中某个字段(实际上是个json字符串)解析为多个列. flink verison 1.13.0 source端输入 insert into person(name,age) values ('{"father":"bbb23","mon":"aaa20"}',11); idea打印内容 代码 import org.apache.flink.streaming.api.scala._ import org.apache.flink.table...
Flink SQL JSON Format 源码解析
JasonLee实时计算
10-29 5072
用 Flink SQL 解析 JSON 格式的数据是非常简单的,只需要在 DDL 语句中设置 Format 为 json 即可,像下面这样:CREATETABLEkafka_sourc...
idea maven完整pom示例
qq_38250124的博客
03-22 1418
mvn clean package --skipTest <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
flink自定义udf函数解析json数据—类似json_value函数
diyicedaan的专栏
01-14 1229
在flink的计算中，需要预定义udf函数解析kafka的json数据，本文使用java编写flink udf函数实现解析json功能，该类需要继承ScalarFunction,并使用fastjson库。要在Flink中使用这个自定义的ScalarFunction，可以在SQL查询或Table API中注册它，并在表达式中使用它。函数对输入表中的JSON字符串进行解析，提取指定字段的值。方法从JSONObject中获取指定字段的值，并将其返回。在上面的示例中，我们创建了一个名为。然后，我们注册了自定义的。
String转Json的几种方式
热门推荐
qq_41908456的博客
11-08 3万+
..
Flink操作json数据
盛源的博客
03-02 6470
1 kafka中的json数据 关键词：json、嵌套、复杂结构、Map、Array、Row 1. Flink SQL 解析嵌套的 JSON 数据_JasonLee_后厂村程序员-CSDN博客 2 内置json函数 1. 官方文档 ​​​​​​​System (Built-in) Functions | Apache Flink 2. 函数使用 JSON_VALUE('{"a":}', '$.a') --> null JSON_VALUE('{"a":""}', '$.a')..
flink sqk解析json array
最新发布
08-05
在 Flink SQL 中解析 JSON 数组时，通常需要将 JSON 数据结构映射为 Flink 表定义中的 `ARRAY` 或 `ROW` 类型。Flink 提供了强大的类型系统，可以处理嵌套和数组结构的数据，从而支持复杂的 JSON 栮式解析。 ### 使用 `JSON` 函数解析 JSON 数组 Flink SQL 提供了内置的 `JSON` 函数族，例如 `JSON_ARRAY_GET`、`JSON_OBJECT` 和 `JSON_PARSE`，用于解析和提取 JSON 数据中的数组元素。 ```sql SELECT JSON_ARRAY_GET(json_column, 0) AS first_element, JSON_ARRAY_GET(json_column, 1) AS second_element FROM json_table; ``` 上述查询从 `json_column` 字段中提取数组的第 0 和第 1 个元素。如果 `json_column` 的内容为 `["value1", "value2"]`，则 `first_element` 为 `"value1"`，`second_element` 为 `"value2"` [^2]。 ### 定义嵌套的 `ARRAY` 类型 在 Flink SQL 的 DDL 中，可以通过定义 `ARRAY` 类型来处理 JSON 数组。例如，如果 JSON 数据中包含一个嵌套的数组字段，则可以将其映射为 `ARRAY<ROW>` 类型。 ```sql CREATE TABLE json_array_table ( id INT, data ARRAY<ROW<name STRING, value INT>> ) WITH ( 'connector' = 'kafka', 'format' = 'json' ); ``` 在这个例子中，`data` 字段是一个 JSON 数组，每个元素是一个包含 `name` 和 `value` 的对象。通过定义 `ARRAY<ROW<name STRING, value INT>>`，Flink 可以正确解析嵌套结构 [^4]。 ### 提取嵌套数组中的字段 在 SQL 查询中，可以使用 `LATERAL TABLE` 来展开数组，并对每个元素进行操作。例如，假设 `data` 是一个包含多个对象的数组，可以通过以下方式提取每个对象的字段： ```sql SELECT t.id, element.name, element.value FROM json_array_table AS t, LATERAL TABLE (EXPLODE(t.data)) AS element; ``` 该查询使用 `EXPLODE` 函数将 `data` 数组展开为多行，每行包含数组中的一个元素，并将其映射到 `element` 别名中 [^2]。 ### 自定义 JSON 解析器 在某些复杂场景下，可能需要自定义 JSON 解析器来处理特定的 JSON 结构。Flink 允许通过实现 `JsonStreamTableProcessFunction` 等类来定义自定义解析逻辑。例如，可以定义一个表并指定自定义的解析类： ```java StreamTableUtil.createStreamTable(fsTableEnv, "CREATE TABLE to_json (\n" + " json_data$reuest_url STRING,\n" + " json_data$resp_code INT\n" + ") WITH (\n" + " 'table' = 'kafka',\n" + " 'stream' = 'org.apache.flink.streaming.JsonStreamTableProcessFunction'\n" + ")"); ``` 在这个例子中，`JsonStreamTableProcessFunction` 被用作自定义的 JSON 解析器，用于处理包含嵌套字段的 JSON 数据 [^3]。 ### 示例：解析嵌套 JSON 数组 假设有一个 JSON 字段 `json_data`，其内容如下： ```json { "json_data": { "reuest_url": "http://www.baidu.com", "items": [ {"name": "item1", "price": 10}, {"name": "item2", "price": 20} ] } } ``` 可以定义一个表并使用 `ARRAY<ROW>` 类型来解析 `items` 数组： ```sql CREATE TABLE json_nested_array ( reuest_url STRING, items ARRAY<ROW<name STRING, price INT>> ) WITH ( 'connector' = 'kafka', 'format' = 'json' ); ``` 然后使用 `LATERAL TABLE` 提取 `items` 中的每个元素： ```sql SELECT t.reuest_url, element.name, element.price FROM json_nested_array AS t, LATERAL TABLE (EXPLODE(t.items)) AS element; ``` 这个查询将 `items` 数组展开为多行，并分别提取每个对象的 `name` 和 `price` 字段 [^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值