Flink DataType正反序列化 jackson方式探索

已于 2023-09-06 21:47:10 修改
阅读量282 收藏
点赞数
文章标签： flink 大数据
于 2023-08-06 01:03:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisacumt/article/details/132126402
版权

前言：

DataType 和 LogcialType的主要区别是，DataType包含了LogicalType并增加conversionClass的支持。

对于LogicalType官方给出了正反序列化的方式
（1）序列化 ： asSummaryString()
（2）反序列化：org.apache.flink.table.types.logical.utils.LogicalTypeParser#parse(java.lang.String) 方法即可。

DataType的toString() 方法也是调用其内部持有的logicalType的asSummaryString()

所以重点就是怎么能再序列化和反序列化中 支持 conversionClass

一、序列化Logical再set conversionClass

（仅支持AtomicDataType的DataType）
自定义注解实现正反序列化，对Logical使用官方方案，在用bridgedTo()方法设置conversionClass
由于获取并保存conversionClass时候仅获取并保存了当前的，并没有递归的获取如row类型各个字段的conversionClass，所以仅支持简单类型。

序列化-DataTypeSerializer类
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import org.apache.flink.table.types.DataType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
public class DataTypeSerializer extends StdSerializer<DataType> {
    private static final Logger LOG = LoggerFactory.getLogger(DataTypeSerializer.class);
    public static final String SEPARATOR = "&";
    public static ObjectMapper om = new ObjectMapper();

    protected DataTypeSerializer(Class<DataType> t) {
        super(t);
    }

    public DataTypeSerializer() {
        this(null);
    }

    @Override
    public void serialize(DataType value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        if (value != null) {
            String main = value.toString();
            Class<?> conversionClass = value.getConversionClass();
            String conversionClassStr = om.writeValueAsString(conversionClass);
            LOG.debug(String.format("serialize DataType:%s, conversion class: %s", main, conversionClass.toString()));
            String finalStr = main + SEPARATOR + conversionClassStr;
            gen.writeString(finalStr);
        } else {
            gen.writeNull();
            return;
        }
    }
}
反序列化-DataTypeDeserializer类
import com.fasterxml.jackson.core.JacksonException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import com.h3c.it_bigdata.module.transfer.util.type.CommonDataTypeFactory;
import org.apache.commons.lang.StringUtils;
import org.apache.flink.table.types.DataType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
public class DataTypeDeserializer extends StdDeserializer<DataType> {
    private static final Logger LOG = LoggerFactory.getLogger(DataTypeDeserializer.class);
    private static ObjectMapper om = new ObjectMapper();
    public static final String SEPARATOR = "&";
    private static final CommonDataTypeFactory factory = new CommonDataTypeFactory();

    public DataTypeDeserializer(Class<?> vc) {
        super(vc);
    }

    public DataTypeDeserializer() {
        this(null);
    }

    @Override
    public DataType deserialize(JsonParser p, DeserializationContext ctx) throws IOException, JacksonException {
        String str = p.getValueAsString();
        if (StringUtils.isBlank(str)) {
            return null;
        } else {
            String[] split = str.split(SEPARATOR);
            String lgTypeStr = split[0];
            String conversionClassStr = split[1];
            Class<?> conversionClass = om.readValue(conversionClassStr, Class.class);
            DataTypeFactory dataTypeFactory = TypeUtils.getDataTypeFactory();
            DataType dataType = dataTypeFactory.createDataType(str);
            dataType.bridgedTo(Class.forName(str));
            LOG.debug(String.format("deserialize DataType:%s, conversion class:%s", dataType.getLogicalType().toString(), conversionClass.toString()));
            return dataType;
        }
    }
}

DataType实例化工具，本质就是调用CatalogManager 的 getDataTypeFactory() 来构造DataType。
因为org.apache.flink.table.catalog.DataTypeFactoryImpl 的默认权限是包，不是public。需要借助CatalogManager 实现。
其实如果不使用DataTypeFactory 也是可以的。直接使用 switch(logicalType.getLogicalTypeRoot()){} 进行逐个枚举，再 return DataTypes. *** 也是可以的。这里偷了一个懒。

public class TypeUtils{
    public static DataTypeFactory getDataTypeFactory() {
        Configuration tableConfig = new Configuration();
        EnvironmentSettings settings = EnvironmentSettings.newInstance().build();
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        CatalogManager catalogManager =
                CatalogManager.newBuilder()
                        .classLoader(classLoader)
                        .config(tableConfig)
                        .defaultCatalog(
                                settings.getBuiltInCatalogName(),
                                new GenericInMemoryCatalog(
                                        settings.getBuiltInCatalogName(),
                                        settings.getBuiltInDatabaseName()))
                        .build();
        return catalogManager.getDataTypeFactory();
    }
}

二、使用jackson反序列化 javabean再递归set conversionClass

可以配置（支持Row、Map、Array、Structrued类型）
序列化 使用ObjectMapper序列化成字符串。
反序列化：先生成java bean，再在java bean 中构造getDataType()使其能够递归调用。生成DataType

序列化-DataTypeSerializer类
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import org.apache.flink.table.types.DataType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
public class DataTypeSerializer extends StdSerializer<DataType> {
    // private static final Logger LOG = LoggerFactory.getLogger(DataTypeSerializer.class);
    public static ObjectMapper om = new ObjectMapper();

    protected DataTypeSerializer(Class<DataType> t) {
        super(t);
    }

    public DataTypeSerializer() {
        this(null);
    }

    @Override
    public void serialize(DataType value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        if (value != null) {
            String str = om.writeValueAsString(value);
            gen.writeString(str);
        } else {
            gen.writeNull();
            return;
        }
    }
}
反序列化-DataTypeDeserializer类
import com.fasterxml.jackson.core.JacksonException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import org.apache.commons.lang.StringUtils;
import org.apache.flink.table.types.DataType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
public class DataTypeDeserializer extends StdDeserializer<DataType> {
    // private static final Logger LOG = LoggerFactory.getLogger(DataTypeDeserializer.class);
    private static ObjectMapper om = new ObjectMapper();

    public DataTypeDeserializer(Class<?> vc) {
        super(vc);
    }

    public DataTypeDeserializer() {
        this(null);
    }

    @Override
    public DataType deserialize(JsonParser p, DeserializationContext ctx) throws IOException, JacksonException {
        String str = p.getValueAsString();
        if (StringUtils.isBlank(str)) {
            return null;
        } else {
            DataTypeProto dataTypeProto = om.readValue(str, DataTypeProto.class);
            DataType output = null;
            try {
                output = dataTypeProto.getDataType();
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
            return output;
        }
    }
}
DataType原型-DataTypeProto类

其中对Structured的转换不太确定。

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.types.DataType;
import org.apache.flink.table.types.logical.LogicalTypeRoot;
import java.util.*;
@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class DataTypeProto {
    private LogicalTypeProto logicalType;
    private String conversionClass;
    private List<DataTypeProto> children;

    @JsonIgnore
    public DataType getDataType() throws ClassNotFoundException {
        DataType dt = getDataTypeWithoutNullable();
        if (logicalType.isNullable()) {
            return dt.nullable();
        } else {
            return dt.notNull();
        }
    }

    @JsonIgnore
    public DataType getDataTypeWithoutNullable() throws ClassNotFoundException {
        LogicalTypeRoot logicalTypeRoot = getLogicalTypeRoot();
        switch (logicalTypeRoot) {
            case CHAR:
                return DataTypes.CHAR(logicalType.getLength()).bridgedTo(Class.forName(conversionClass));
            case VARCHAR:
                return DataTypes.VARCHAR(logicalType.getLength()).bridgedTo(Class.forName(conversionClass));
            case BOOLEAN:
                return DataTypes.BOOLEAN().bridgedTo(Class.forName(conversionClass));
            case BINARY:
                return DataTypes.BINARY(logicalType.getLength()).bridgedTo(Class.forName(conversionClass));
            case VARBINARY:
                return DataTypes.VARBINARY(logicalType.getLength()).bridgedTo(Class.forName(conversionClass));
            case DECIMAL:
                return DataTypes.DECIMAL(logicalType.getPrecision(), logicalType.getScale()).bridgedTo(Class.forName(conversionClass));
            case TINYINT:
                return DataTypes.TINYINT().bridgedTo(Class.forName(conversionClass));
            case SMALLINT:
                return DataTypes.SMALLINT().bridgedTo(Class.forName(conversionClass));
            case INTEGER:
                return DataTypes.INT().bridgedTo(Class.forName(conversionClass));
            case BIGINT:
                return DataTypes.BIGINT().bridgedTo(Class.forName(conversionClass));
            case FLOAT:
                return DataTypes.FLOAT().bridgedTo(Class.forName(conversionClass));
            case DOUBLE:
                return DataTypes.DOUBLE().bridgedTo(Class.forName(conversionClass));
            case DATE:
                return DataTypes.DATE().bridgedTo(Class.forName(conversionClass));
            case TIME_WITHOUT_TIME_ZONE:
                return DataTypes.TIME(logicalType.getPrecision()).bridgedTo(Class.forName(conversionClass));
            case TIMESTAMP_WITHOUT_TIME_ZONE:
                return DataTypes.TIMESTAMP(logicalType.getPrecision()).bridgedTo(Class.forName(conversionClass));
            case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
                return DataTypes.TIMESTAMP_WITH_LOCAL_TIME_ZONE(logicalType.getPrecision()).bridgedTo(Class.forName(conversionClass));
            case TIMESTAMP_WITH_TIME_ZONE:
                return DataTypes.TIMESTAMP_WITH_TIME_ZONE(logicalType.getPrecision()).bridgedTo(Class.forName(conversionClass));
            case ARRAY:
                return DataTypes.ARRAY(children.get(0).getDataType()).bridgedTo(Class.forName(conversionClass));
            case MULTISET:
                return DataTypes.MULTISET(children.get(0).getDataType()).bridgedTo(Class.forName(conversionClass));
            case MAP:
                return DataTypes.MAP(children.get(0).getDataType(), children.get(1).getDataType()).bridgedTo(Class.forName(conversionClass));
            case ROW:
                List<DataTypes.Field> rowFields = new ArrayList<>();
                for (int i = 0; i < children.size(); i++) {
                    DataType rowFieldDataType = children.get(i).getDataType();
                    String rowFieldName = logicalType.getFieldNames().get(i);
                    rowFields.add(DataTypes.FIELD(rowFieldName, rowFieldDataType));
                }
                return DataTypes.ROW(rowFields.toArray(new DataTypes.Field[0])).bridgedTo(Class.forName(conversionClass));
            case NULL:
                return DataTypes.NULL().bridgedTo(Class.forName(conversionClass));
            case STRUCTURED_TYPE:
                List<DataTypes.Field> structFields = new ArrayList<>();
                for (int i = 0; i < children.size(); i++) {
                    DataType rowFieldDataType = children.get(i).getDataType();
                    String rowFieldName = logicalType.getAttributes().get(i).getName();
                    structFields.add(DataTypes.FIELD(rowFieldName, rowFieldDataType));
                }
                // STRUCTURED还不太确定。
                return DataTypes.STRUCTURED(
                        Class.forName(conversionClass),
                        structFields.toArray(new DataTypes.Field[0])
                ).bridgedTo(Class.forName(conversionClass));
            case DISTINCT_TYPE:
            case RAW:
            case SYMBOL:
            case INTERVAL_YEAR_MONTH:
            case INTERVAL_DAY_TIME:
            default:
                throw new UnsupportedOperationException("Unsupported type: " + logicalTypeRoot);
        }
    }

    @JsonIgnore
    public LogicalTypeRoot getLogicalTypeRoot() {
        return LogicalTypeRoot.valueOf(logicalType.getTypeRoot());
    }
}
LogicalType原型-LogicalTypeProto类
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class LogicalTypeProto {
    private String typeRoot;
    private boolean nullable;
    private int precision;
    private int scale;
    private int length;
    private List<String> fieldNames;
    private List<Attribute> attributes;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Attribute {
        private String name;
    }
}

三、jackson序列化举例

下面是Row类型的DataType

 DataType rowType= DataTypes.ROW(
                DataTypes.FIELD("id", DataTypes.BIGINT()),
                DataTypes.FIELD("name", DataTypes.STRING().bridgedTo(StringData.class)),
                DataTypes.FIELD("address", DataTypes.STRING(), "home town"),
                DataTypes.FIELD("info", DataTypes.ROW(DataTypes.FIELD("telephone", DataTypes.STRING()), DataTypes.FIELD("birth", DataTypes.TIMESTAMP(3).bridgedTo(TimestampData.class))).bridgedTo(RowData.class)),
                DataTypes.FIELD("age", DataTypes.INT()),
                DataTypes.FIELD("props", DataTypes.MAP(DataTypes.STRING(), DataTypes.TIME(3)))
        );

与之对应的objectMapper.writeValueAsString(rowType) 的结果：

{
	"logicalType": {
		"typeRoot": "ROW",
		"fields": [
			{
				"name": "id",
				"type": {
					"typeRoot": "BIGINT",
					"children": [],
					"defaultConversion": "java.lang.Long",
					"nullable": true
				},
				"description": {
					"present": false
				}
			},
			{
				"name": "name",
				"type": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"description": {
					"present": false
				}
			},
			{
				"name": "address",
				"type": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"description": {
					"present": true
				}
			},
			{
				"name": "info",
				"type": {
					"typeRoot": "ROW",
					"fields": [
						{
							"name": "marige",
							"type": {
								"typeRoot": "VARCHAR",
								"length": 2147483647,
								"children": [],
								"defaultConversion": "java.lang.String",
								"nullable": true
							},
							"description": {
								"present": false
							}
						},
						{
							"name": "birth",
							"type": {
								"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
								"kind": "REGULAR",
								"precision": 3,
								"children": [],
								"defaultConversion": "java.time.LocalDateTime",
								"nullable": true
							},
							"description": {
								"present": false
							}
						}
					],
					"children": [
						{
							"typeRoot": "VARCHAR",
							"length": 2147483647,
							"children": [],
							"defaultConversion": "java.lang.String",
							"nullable": true
						},
						{
							"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
							"kind": "REGULAR",
							"precision": 3,
							"children": [],
							"defaultConversion": "java.time.LocalDateTime",
							"nullable": true
						}
					],
					"defaultConversion": "org.apache.flink.types.Row",
					"fieldNames": [
						"marige",
						"birth"
					],
					"fieldCount": 2,
					"nullable": true
				},
				"description": {
					"present": false
				}
			},
			{
				"name": "age",
				"type": {
					"typeRoot": "INTEGER",
					"children": [],
					"defaultConversion": "java.lang.Integer",
					"nullable": true
				},
				"description": {
					"present": false
				}
			},
			{
				"name": "props",
				"type": {
					"typeRoot": "MAP",
					"keyType": {
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					"valueType": {
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					"children": [
						{
							"typeRoot": "VARCHAR",
							"length": 2147483647,
							"children": [],
							"defaultConversion": "java.lang.String",
							"nullable": true
						},
						{
							"typeRoot": "VARCHAR",
							"length": 2147483647,
							"children": [],
							"defaultConversion": "java.lang.String",
							"nullable": true
						}
					],
					"defaultConversion": "java.util.Map",
					"nullable": true
				},
				"description": {
					"present": false
				}
			}
		],
		"children": [
			{
				"typeRoot": "BIGINT",
				"children": [],
				"defaultConversion": "java.lang.Long",
				"nullable": true
			},
			{
				"typeRoot": "VARCHAR",
				"length": 2147483647,
				"children": [],
				"defaultConversion": "java.lang.String",
				"nullable": true
			},
			{
				"typeRoot": "VARCHAR",
				"length": 2147483647,
				"children": [],
				"defaultConversion": "java.lang.String",
				"nullable": true
			},
			{
				"typeRoot": "ROW",
				"fields": [
					{
						"name": "marige",
						"type": {
							"typeRoot": "VARCHAR",
							"length": 2147483647,
							"children": [],
							"defaultConversion": "java.lang.String",
							"nullable": true
						},
						"description": {
							"present": false
						}
					},
					{
						"name": "birth",
						"type": {
							"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
							"kind": "REGULAR",
							"precision": 3,
							"children": [],
							"defaultConversion": "java.time.LocalDateTime",
							"nullable": true
						},
						"description": {
							"present": false
						}
					}
				],
				"children": [
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					{
						"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
						"kind": "REGULAR",
						"precision": 3,
						"children": [],
						"defaultConversion": "java.time.LocalDateTime",
						"nullable": true
					}
				],
				"defaultConversion": "org.apache.flink.types.Row",
				"fieldNames": [
					"marige",
					"birth"
				],
				"fieldCount": 2,
				"nullable": true
			},
			{
				"typeRoot": "INTEGER",
				"children": [],
				"defaultConversion": "java.lang.Integer",
				"nullable": true
			},
			{
				"typeRoot": "MAP",
				"keyType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"valueType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"children": [
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					}
				],
				"defaultConversion": "java.util.Map",
				"nullable": true
			}
		],
		"defaultConversion": "org.apache.flink.types.Row",
		"fieldNames": [
			"id",
			"name",
			"address",
			"info",
			"age",
			"props"
		],
		"fieldCount": 6,
		"nullable": true
	},
	"conversionClass": "org.apache.flink.types.Row",
	"children": [
		{
			"logicalType": {
				"typeRoot": "BIGINT",
				"children": [],
				"defaultConversion": "java.lang.Long",
				"nullable": true
			},
			"conversionClass": "java.lang.Long",
			"children": []
		},
		{
			"logicalType": {
				"typeRoot": "VARCHAR",
				"length": 2147483647,
				"children": [],
				"defaultConversion": "java.lang.String",
				"nullable": true
			},
			"conversionClass": "org.apache.flink.table.data.StringData",
			"children": []
		},
		{
			"logicalType": {
				"typeRoot": "VARCHAR",
				"length": 2147483647,
				"children": [],
				"defaultConversion": "java.lang.String",
				"nullable": true
			},
			"conversionClass": "java.lang.String",
			"children": []
		},
		{
			"logicalType": {
				"typeRoot": "ROW",
				"fields": [
					{
						"name": "marige",
						"type": {
							"typeRoot": "VARCHAR",
							"length": 2147483647,
							"children": [],
							"defaultConversion": "java.lang.String",
							"nullable": true
						},
						"description": {
							"present": false
						}
					},
					{
						"name": "birth",
						"type": {
							"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
							"kind": "REGULAR",
							"precision": 3,
							"children": [],
							"defaultConversion": "java.time.LocalDateTime",
							"nullable": true
						},
						"description": {
							"present": false
						}
					}
				],
				"children": [
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					{
						"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
						"kind": "REGULAR",
						"precision": 3,
						"children": [],
						"defaultConversion": "java.time.LocalDateTime",
						"nullable": true
					}
				],
				"defaultConversion": "org.apache.flink.types.Row",
				"fieldNames": [
					"marige",
					"birth"
				],
				"fieldCount": 2,
				"nullable": true
			},
			"conversionClass": "org.apache.flink.types.Row",
			"children": [
				{
					"logicalType": {
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					"conversionClass": "java.lang.String",
					"children": []
				},
				{
					"logicalType": {
						"typeRoot": "TIMESTAMP_WITHOUT_TIME_ZONE",
						"kind": "REGULAR",
						"precision": 3,
						"children": [],
						"defaultConversion": "java.time.LocalDateTime",
						"nullable": true
					},
					"conversionClass": "java.time.LocalDateTime",
					"children": []
				}
			]
		},
		{
			"logicalType": {
				"typeRoot": "INTEGER",
				"children": [],
				"defaultConversion": "java.lang.Integer",
				"nullable": true
			},
			"conversionClass": "java.lang.Integer",
			"children": []
		},
		{
			"logicalType": {
				"typeRoot": "MAP",
				"keyType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"valueType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"children": [
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					{
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					}
				],
				"defaultConversion": "java.util.Map",
				"nullable": true
			},
			"conversionClass": "java.util.Map",
			"keyDataType": {
				"logicalType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"conversionClass": "java.lang.String",
				"children": []
			},
			"valueDataType": {
				"logicalType": {
					"typeRoot": "VARCHAR",
					"length": 2147483647,
					"children": [],
					"defaultConversion": "java.lang.String",
					"nullable": true
				},
				"conversionClass": "java.lang.String",
				"children": []
			},
			"children": [
				{
					"logicalType": {
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					"conversionClass": "java.lang.String",
					"children": []
				},
				{
					"logicalType": {
						"typeRoot": "VARCHAR",
						"length": 2147483647,
						"children": [],
						"defaultConversion": "java.lang.String",
						"nullable": true
					},
					"conversionClass": "java.lang.String",
					"children": []
				}
			]
		}
	]
}
lisacumt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Flink】Flink-Kafka序列化反序列化
一杯咖啡半杯糖的博客
01-05 2605
最简单的是SimpleStringSchema，对字符串进行序列化反序列化，这个Schema中既实现了了序列化，也实现了反序列化 new SimpleStringSchema() union.addSink(new FlinkKafkaProducer011[String]("localhost:9092", "test", new SimpleStringSchema())) val stream3 = env.addSource(new FlinkKafkaConsumer011[String](
常用的三个反序列化：JavaType、MapType、CollectionType的运用
追梦赤子的博客
12-20 537
首先要了解他们之间的关系 当我们跟踪MapType能看到;MapType->MapLikeType->TypeBase->JavaType然后实现json实例化接口JsonSerializable 当我们跟踪CollectionType能看到：CollectionType->CollectionLikeType->TypeBase->JavaType然后实现js...
Flink入门及实战（11）- Flink支持的DataType
一角残叶的博客
08-23 1362
1 Flink支持的DataType 2 序列化 3 广播变量 3.1 DataStreaming 中的 Broadcast package com.tzb.demo.streaming.streamAPI; import com.tzb.demo.streaming.customSource.MyNoParaSource; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.stre
【18】Flink 之 支持的DataType和序列化
努力学习的大小宝
06-05 1614
1、Flink支持的DataType Java Tuple 和 Scala case class Java POJOs：java实体类   - Primitive Types    默认支持java和scala基本数据类型   - General Class Types    默认支持大多数java和scala class   - Hadoop Writables    支持hadoop...
写给大忙人的Flink的Data Types
shengjk1的博客
03-16 1317
一.Flink 中 Data Type 组成 基本数据类型：java 的 8 中基本数据类型加上它们各自的包装类型，在加上 void , String, Date,BigDecimal, BigInteger. 基本数据类型的数据和 Object 类型的数组 复合类型 Flink Java Tuples scala case classes Row POJOs: 如果要被 Flink...
Flink 1.9 Table API& Sql支持的Data Type
数据工匠记
02-11 8126
Flink 1.9 Table API & SQL 新特性主要包括如下： 全新的 SQL 类型系统：Table API & SQL 1.9 引入了全新的 SQL 的类型系统。以往的Table 层的类型系统复用了 Runtime 的 TypeInformation，但在实际操作过程当中遇到较多的限制。引入全新的 SQL 类型系统可以更好的对齐 SQL 语义。 DDL初步支持：这个...
flink-kafka 反序列化例子
最新发布
04-11
flink 的版本为 1.14.6； kafka 的版本为 kafka_2.12-2.6.3； 作为案例，介绍如何序列化 并进行相关条件判定。
Flink 数据类型与序列化.pdf
07-17
Flink 2019峰会 阿里大牛的技术， 在线教程有github:*，第6个文档 简明扼要的讲解Flink的数据类型和转换的源码分析。值得收藏
Flinkcdc监测mysql数据库，自定义反序列化，利用flinkApi和flinkSql两种方式
04-05
在这个场景下，我们将深入探讨如何使用Flink CDC来监测MySQL数据库，并且实现自定义反序列化，以及如何通过Flink API和Flink SQL两种方式进行数据处理。 首先，让我们理解什么是CDC。CDC是一种数据库复制技术，它...
Flink state 优化以及远程 state 的探索.pdf
03-21
"Flink State 优化与 Remote State 探索" Flink state 优化是指对 Flink 中的状态（State）进行优化，以提高 Flink 任务的性能和可靠性。状态是 Flink 任务中的一种特殊数据结构，用于存储任务执行过程中的中间结果...
Flink Table API & SQL 类型系统 DataType
SmartSi
05-03 1206
Flink 版本：1.13.5 由于历史原因，在 Flink 1.9 之前，Flink 的 Table API & SQL 数据类型与 Flink 的 TypeInformation 紧密耦合。TypeInformation 主要用于 DataStream 和 DataSet API 中，为系统序列化和反序列化基于 JVM 的对象提供必要的信息。 但是，TypeInformation 原本的设计目的并不能表示不同实际 JVM 类的逻辑类型。因此 SQL 的标准类型很难与这种抽象进行映射。此外，某.
（二十一）Flink Table API & SQL 编程指南 Data Types
京河小蚁的博客
06-13 1575
Flink SQL 有丰富的native数据类型。数据类型描述表生态系统中值的逻辑类型。它可用于声明输入和/或输出类型的操作。Flink 的数据类型类似于 SQL 标准的数据类型术语，但也包含有关有效处理标量表达式的值的可空性的信息。比如：可以在下面找到所有预定义数据类型的列表。基于 JVM 的 API 的用户在表 API 中使用 org.apache.flink.table.types.DataType 的实例，或者在定义连接器、目录或用户定义的函数时使用。数据类型实例有两个职责：对于基于JVM的语言，所
Flink反序列化之JsonDeserializationSchema和JSONKeyValueDeserializationSchema
热门推荐
qq_44962429的博客
12-27 1万+
1、引言 Flink Kafka的使用者需要知道如何将Kafka中的二进制数据转换为Java / Scala对象，大多数的程序员都会使用new SimpleStringSchema()来反序列化Kafka中的数据，然后使用alibaba提供的fastJson来解析数据，虽然这样可以实现业务的需求，但是存在很多不确定的因素。比如由于业务的原因，接受的json数据字段不稳定，有的数据多一个字段，有的业...
Flink 任务 Jackson 解析 JSON 使用不当引发的反压问题
JasonLee实时计算
08-29 847
背景最近业务方反馈线上一个 topic 的数据延迟比较大,然后我查看了这个 topic 的数据是由一个 Flink 任务产生的,于是就找到了这个任务开始排查问题,发现这个任务是一个非常简单...
flink-connector-mysql-cdc编译——flink-1.15.2版本
qq_42418398的博客
08-29 6034
目前flink cdc的版本不支持flink1.15.*版本，可以自己编译cdc的源码，本文主要介绍编译过程中遇到的问题和需要注意的地方
30.flink table 中的数据类型映射
笔生花的博客
10-02 2572
flinkTable中的所有数据类型都是class封装的，在这之中有一个基类： org.apache.flink.table.types.DataType， 所有的类型都是该类的实现类。除此之外Flink table还提供了一个final类型的类，该类提供了大量的静态方法可以指定访问实现了 org.apache.flink.table.types.DataType接口的真正实现类， 这个final类型的类是： org.apache.flink.table.api.DataTypes。
flink jar包运行报错 java.lang.NullPointerException at org.json4s.Extraction$.decompose(Extraction.scala:2
yy的博客
12-18 650
情况 本地运行正常 提交后报错java.lang.NullPointerException at org.json4s.Extraction$.decompose(Extraction.scala:256) 失败代码 implicit val formats: AnyRef with Formats = Serialization.formats(NoTypeHints) input:DataStream[Output].map(x =>{ write(x) .
Flink Java CDC 之自定义反序列化器
weixin_46376562的博客
07-07 2549
以上两种都是原本就提供的，显然第二种更便于下游进行数据处理，那么自定义的会更好,可读性更强。
flinkkafkaproducer序列化模式
06-02
FlinkKafkaProducer支持多种序列化模式，可以根据具体需求进行设置。常用的序列化模式包括： 1. SimpleStringSchema：将String类型的消息序列化为字节数组。 2. JSONKeyValueSerializationSchema：将消息转换为JSON格式，并按照键值对的方式进行序列化。 3. AvroSerializationSchema：使用Avro序列化框架将消息序列化为字节数组，需要提前定义Avro Schema。 4. ProtobufSerializationSchema：使用Google Protobuf序列化框架将消息序列化为字节数组，需要提前定义Protobuf Message。 5. 自定义序列化器：FlinkKafkaProducer还支持自定义序列化器，可以根据业务需求实现自己的序列化逻辑。 在使用FlinkKafkaProducer时，可以通过withSchema()方法设置序列化模式。例如，使用SimpleStringSchema进行序列化的代码如下所示： ``` FlinkKafkaProducer<String> producer = new FlinkKafkaProducer<>( "topic", new SimpleStringSchema(), properties ); ``` 需要注意的是，不同的序列化模式会对性能和数据大小产生不同的影响，需要根据实际情况进行选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值