flink 序列化 反序列化 flink 序列化问题

Flink自己定义了一套数据类型，对应Java中的基本类型、集合、POJO等，数据类型都是TypeInformation的子类，并且在每个子类中都重写了createSerializer方法来创建自己类型的TypeSerializer，然后使用TypeSerializer来实现序列化和反序列化。

如果Flink无法识别或推断类型，则使用Kryo序列化反序列化。如果Kryo无法实现序列化反序列化，可以使用强制avro或者为 Kryo 增加自定义的 Serializer 以增强 Kryo 的功能，实现序列化反序列化。

---------------------

Flink 的分布在不同节点上的 Task 的数据传输必须经过序列化/反序列化，因此序列化/反序列化也是影响 Flink 性能的一个重要因素。Flink 自有一套类型体系，即 Flink 有自己的类型描述类（TypeInformation）。Flink 希望能够掌握尽可能多的进出 operator 的数据类型信息，并使用 TypeInformation 来描述，这样做主要有以下 2 个原因：

• 类型信息知道的越多，Flink 可以选取更好的序列化方式，并使得 Flink 对内存的使用更加高效；
• TypeInformation 内部封装了自己的序列化器，可通过 createSerializer() 获取，这样可以让用户不再操心序列化框架的使用（例如如何将他们自定义的类型注册到序列化框架中，尽管用户的定制化和注册可以提高性能）。

总体上来说，Flink 推荐我们在 operator 间传递的数据是 POJOs 类型，对于 POJOs 类型，Flink 默认会使用 Flink 自身的 PojoSerializer 进行序列化，而对于 Flink 无法自己描述或推断的数据类型，Flink 会将其识别为 GenericType，并使用 Kryo 进行序列化。Flink 在处理 POJOs 时更高效，此外 POJOs 类型会使得 stream 的 grouping/joining/aggregating 等操作变得简单，因为可以使用如: dataSet.keyBy("username") 这样的方式直接操作数据流中的数据字段。

除此之外，我们还可以做进一步的优化：

• 显示调用 returns 方法，从而触发 Flink 的 Type Hint：

dataStream.flatMap(new MyOperator()).returns(MyClass.class)

returns 方法最终会调用 TypeExtractor.createTypeInfo(typeClass) ，用以构建我们自定义的类型的 TypeInformation。createTypeInfo 方法在构建 TypeInformation 时，如果我们的类型满足 POJOs 的规则或 Flink 中其他的基本类型的规则，会尽可能的将我们的类型“翻译”成 Flink 熟知的类型如 POJOs 类型或其他基本类型，便于 Flink 自行使用更高效的序列化方式。

//org.apache.flink.api.java.typeutils.PojoTypeInfo
@Override
@PublicEvolving
@SuppressWarnings("unchecked")
public TypeSerializer createSerializer(ExecutionConfig config) {
   if (config.isForceKryoEnabled()) {
      return new KryoSerializer<>(getTypeClass(), config);
   }

   if (config.isForceAvroEnabled()) {
      return AvroUtils.getAvroUtils().createAvroSerializer(getTypeClass());
   }

   return createPojoSerializer(config);
}

对于 Flink 无法“翻译”的类型，则返回 GenericTypeInfo，并使用 Kryo 序列化：

//org.apache.flink.api.java.typeutils.TypeExtractor

@SuppressWarnings({ "unchecked", "rawtypes" })
private  TypeInformation privateGetForClass(Class clazz, ArrayList typeHierarchy,
      ParameterizedType parameterizedType, TypeInformation in1Type, TypeInformation in2Type) {
   checkNotNull(clazz);
   // 尝试将 clazz转换为 PrimitiveArrayTypeInfo, BasicArrayTypeInfo, ObjectArrayTypeInfo
   // BasicTypeInfo, PojoTypeInfo 等，具体源码已省略
  //...

   //如果上述尝试不成功 , 则return a generic type
   return new GenericTypeInfo(clazz);
}

• 注册 subtypes: 通过 StreamExecutionEnvironment 或 ExecutionEnvironment 的实例的 registerType(clazz) 方法注册我们的数据类及其子类、其字段的类型。如果 Flink 对类型知道的越多，性能会更好
  ；
• 如果还想做进一步的优化，Flink 还允许用户注册自己定制的序列化器，手动创建自己类型的 TypeInformation，具体可以参考 Flink 官网：[3]；

在我们的实践中，最初为了扩展性，在 operator 之间传递的数据为 JsonNode，但是我们发现性能达不到预期，因此将 JsonNode 改成了符合 POJOs 规范的类型，在 1.1.x 的 Flink 版本上直接获得了超过 30% 的性能提升。在我们调用了 Flink 的 Type Hint 和 env.getConfig().enableForceAvro() 后，性能得到进一步提升。这些方法一直沿用到了 1.3.x 版本。

在升级至 1.7.x 时，如果使用 env.getConfig().enableForceAvro() 这个配置，我们的代码会引起校验空字段的异常。因此我们取消了这个配置，并尝试使用 Kyro 进行序列化，并且注册我们的类型的所有子类到 Flink 的 ExecutionEnvironment 中，目前看性能尚可，并优于旧版本使用 Avro 的性能。但是最佳实践还需要经过比较和压测 KryoSerializerAvroUtils.getAvroUtils().createAvroSerializerPojoSerializer 才能总结出来，大家还是应该根据自己的业务场景和数据类型来合理挑选适合自己的 serializer。

https://www.huaweicloud.com/articles/d0591d3f6870a381b34e669c208684c4.html

---------------------

以上如此多的类型，在Flink中，统一使用TypeInformation类表示。比如，POJO在Flink内部使用PojoTypeInfo来表示，PojoTypeInfo继承自CompositeType，CompositeType继承自TypeInformation。下图展示了TypeInformation的继承关系，可以看到，前面提到的诸多数据类型，在Flink中都有对应的类型。TypeInformation的一个重要的功能就是创建TypeSerializer序列化器，为该类型的数据做序列化。每种类型都有一个对应的序列化器来进行序列化。

TypeInformation继承关系

使用前面介绍的各类数据类型时，Flink会自动探测传入的数据类型，生成对应的TypeInformation，调用对应的序列化器，因此用户其实无需关心类型推测。比如，Flink的map函数Scala签名为：def map[R: TypeInformation](fun: T => R): DataStream[R]，传入map的数据类型是T，生成的数据类型是R，Flink会推测T和R的数据类型，并使用对应的序列化器进行序列化。

Flink数据类型推断和序列化

上图展示了Flink的类型推断和序列化过程，以一个字符串String类型为例，Flink首先推断出该类型，并生成对应的TypeInformation，然后在序列化时调用对应的序列化器，将一个内存对象写入内存块。

-------

Java POJO

Java的话，需要定义POJO类，定义POJO类有一些注意事项：

• 该类必须用public修饰。
• 该类必须有一个public的无参数的构造函数。
• 该类的所有非静态（non-static）、非瞬态（non-transient）字段必须是public，如果字段不是public则必须有标准的getter和setter方法，比如对于字段A a有A getA()和setA(A a)。
• 所有子字段也必须是Flink支持的数据类型。

下面三个例子中，只有第一个是POJO，其他两个都不是POJO，非POJO类将使用Kryo序列化工具。

public class StockPrice {
    public String symbol;
    public Long timestamp;
    public Double price;

    public StockPrice() {}
    public StockPrice(String symbol, Long timestamp, Double price){
        this.symbol = symbol;
        this.timestamp = timestamp;
        this.price = price;
    }
}

// NOT POJO
public class StockPrice1 {

    // LOGGER 无getter和setter 
    private Logger LOGGER = LoggerFactory.getLogger(StockPrice1.class);

    public String symbol;
    public Long timestamp;
    public Double price;

    public StockPrice1() {}
    public StockPrice1(String symbol, Long timestamp, Double price){
        this.symbol = symbol;
        this.timestamp = timestamp;
        this.price = price;
    }
}

// NOT POJO
public class StockPrice2 {

    public String symbol;
    public Long timestamp;
    public Double price;

    // 缺少无参数构造函数

    public StockPrice2(String symbol, Long timestamp, Double price){
        this.symbol = symbol;
        this.timestamp = timestamp;
        this.price = price;
    }
}

如果不确定是否是POJO，可以使用下面的代码检查：

System.out.println(TypeInformation.of(StockPrice.class).createSerializer(new ExecutionConfig()));

结果显示这个类在是否在使用KryoSerializer。

此外，使用Avro生成的类可以被Flink识别为POJO。

https://zhuanlan.zhihu.com/p/100150042

 

 

Flink 的数据类型

Flink 在其内部构建了一套自己的类型系统，Flink 现阶段支持的类型分类如图所示，从图中可以看到 Flink 类型可以分为基础类型（Basic）、数组（Arrays）、复合类型（Composite）、辅助类型（Auxiliary）、泛型和其它类型（Generic）。Flink 支持任意的 Java 或是 Scala 类型。不需要像 Hadoop 一样去实现一个特定的接口（org.apache.hadoop.io.Writable），Flink 能够自动识别数据类型。

那这么多的数据类型，在 Flink 内部又是如何表示的呢？图示中的 Person 类，复合类型的一个 Pojo 在 Flink 中是用 PojoTypeInfo 来表示，它继承至 TypeInformation，也即在 Flink 中用 TypeInformation 作为类型描述符来表示每一种要表示的数据类型。

TypeInformation

TypeInformation 的思维导图如图所示，从图中可以看出，在 Flink 中每一个具体的类型都对应了一个具体的 TypeInformation 实现类，例如 BasicTypeInformation 中的 IntegerTypeInformation 和 FractionalTypeInformation 都具体的对应了一个 TypeInformation。然后还有 BasicArrayTypeInformation、CompositeType 以及一些其它类型，也都具体对应了一个 TypeInformation。

TypeInformation 是 Flink 类型系统的核心类。对于用户自定义的 Function 来说，Flink 需要一个类型信息来作为该函数的输入输出类型，即 TypeInfomation。该类型信息类作为一个工具来生成对应类型的序列化器 TypeSerializer，并用于执行语义检查，比如当一些字段在作为 joing 或 grouping 的键时，检查这些字段是否在该类型中存在。

如何使用 TypeInformation？下面的实践中会为大家介绍。

Flink 的序列化过程

在 Flink 序列化过程中，进行序列化操作必须要有序列化器，那么序列化器从何而来？每一个具体的数据类型都对应一个 TypeInformation 的具体实现，每一个 TypeInformation 都会为对应的具体数据类型提供一个专属的序列化器。通过 Flink 的序列化过程图可以看到 TypeInformation 会提供一个 createSerialize() 方法，通过这个方法就可以得到该类型进行数据序列化操作与反序化操作的对象 TypeSerializer。

对于大多数数据类型 Flink 可以自动生成对应的序列化器，能非常高效地对数据集进行序列化和反序列化，比如，BasicTypeInfo、WritableTypeIno 等，但针对 GenericTypeInfo 类型，Flink 会使用 Kyro 进行序列化和反序列化。其中，Tuple、Pojo 和 CaseClass 类型是复合类型，它们可能嵌套一个或者多个数据类型。在这种情况下，它们的序列化器同样是复合的。它们会将内嵌类型的序列化委托给对应类型的序列化器。

简单的介绍下 Pojo 的类型规则，即在满足一些条件的情况下，才会选用 Pojo 的序列化进行相应的序列化与反序列化的一个操作。即类必须是 Public 的，且类有一个 public 的无参数构造函数，该类（以及所有超类）中的所有非静态 no-static、非瞬态 no-transient 字段都是 public 的（和非最终的 final）或者具有公共 getter 和 setter 方法，该方法遵循 getter 和 setter 的 Java bean 命名约定。当用户定义的数据类型无法识别为 POJO 类型时，必须将其作为 GenericType 处理并使用 Kryo 进行序列化。

Flink 自带了很多 TypeSerializer 子类，大多数情况下各种自定义类型都是常用类型的排列组合，因而可以直接复用，如果内建的数据类型和序列化方式不能满足你的需求，Flink 的类型信息系统也支持用户拓展。若用户有一些特殊的需求，只需要实现 TypeInformation、TypeSerializer 和 TypeComparator 即可定制自己类型的序列化和比较大小方式，来提升数据类型在序列化和比较时的性能。

序列化就是将数据结构或者对象转换成一个二进制串的过程，在 Java 里面可以简单地理解成一个 byte 数组。而反序列化恰恰相反，就是将序列化过程中所生成的二进制串转换成数据结构或者对象的过程。下面就以内嵌型的 Tuple 3 这个对象为例，简述一下它的序列化过程。Tuple 3 包含三个层面，一是 int 类型，一是 double 类型，还有一个是 Person。Person 包含两个字段，一是 int 型的 ID，另一个是 String 类型的 name，它在序列化操作时，会委托相应具体序列化的序列化器进行相应的序列化操作。从图中可以看到 Tuple 3 会把 int 类型通过 IntSerializer 进行序列化操作，此时 int 只需要占用四个字节就可以了。根据 int 占用四个字节，这个能够体现出 Flink 可序列化过程中的一个优势，即在知道数据类型的前提下，可以更好的进行相应的序列化与反序列化操作。相反，如果采用 Java 的序列化，虽然能够存储更多的属性信息，但一次占据的存储空间会受到一定的损耗。

Person 类会被当成一个 Pojo 对象来进行处理，PojoSerializer 序列化器会把一些属性信息使用一个字节存储起来。同样，其字段则采取相对应的序列化器进行相应序列化，在序列化完的结果中，可以看到所有的数据都是由 MemorySegment 去支持。MemorySegment 具有什么作用呢？

MemorySegment 在 Flink 中会将对象序列化到预分配的内存块上，它代表 1 个固定长度的内存，默认大小为 32 kb。MemorySegment 代表 Flink 中的一个最小的内存分配单元，相当于是 Java 的一个 byte 数组。 每条记录都会以序列化的形式存储在一个或多个 MemorySegment 中。

 

 

实践–Kryo 序列化

对于 Flink 无法序列化的类型（例如用户自定义类型，没有 registerType，也没有自定义 TypeInfo 和 TypeInfoFactory），默认会交给 Kryo 处理，如果 Kryo 仍然无法处理（例如 Guava、Thrift、Protobuf 等第三方库的一些类），有两种解决方案：

• 强制使用 Avro 来代替 Kryo。

env.getConfig().enableForceAvro();

• 为 Kryo 增加自定义的 Serializer 以增强 Kryo 的功能。

env.getConfig().addDefaultKryoSerializer(clazz, serializer);

注：如果希望完全禁用 Kryo（100% 使用 Flink 的序列化机制），可以通过 Kryo-env.getConfig().disableGenericTypes() 的方式完成，但注意一切无法处理的类都将导致异常，这种对于调试非常有效。