本文主要介绍福布湿在flink实时流处理中，state使用的一些经验和心得。本文默认围观的大神已经对flink有一定了解，如果围观过程中发现了有疑问的地方，欢迎在评论区留言。
1. 状态的类别
1.1 从数据角度看，flink中的状态分为2种：
- KeyedState
在按key分区的DataStream中，每个key拥有一个自己的state，换句话说，这个state能得到这个key所有的数据。
结合以上的描述，不难得出以下结论，KeyState只能在KeyedStream上使用。
- OperateState
OperateState得到的数据是当前算子实例接收到的数据，换句话说，有几个算子实例就有几个对应的OperateState。
1.2 从flink
runtime 对状态支持的机制不同也分为2种：
- 托管状态（Managed State）
flink runtime知道这类状态的内部数据结构，在状态进行保存和更新或者dataStream并行度发生改变以及内存管理方面flink runtime能对过程进行优化，提升效率。这类状态是官方推荐。
更重要的是，所有的DataStream function（map、filter、apply等其他所有操作函数）均支持managed state，但是raw state需要在实现操作符后才行。
- 原生状态（Raw State）
由用户自定义状态的内部数据结构，灵活度较高。但flink runtime不知道这类状态内部的数据结构，因此也无法进行相关优化。
| Managed State | Raw State | |
|---|---|---|
| KeyedState | ValueState < T > | - |
| ListState < T > | ||
| MapState |
||
| ReducingState < T > | ||
| AggregatingState |
||
| OperateState | CheckpointedFunction | - |
| ListCheckpointed < T extends Serializable > |
1.3 案例-不同店铺累计商品销售额排行
1.3.1 Scala版本
import org.apache.flink.contrib.streaming.state.RocksDBStateBackend
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.windowing.time.Time
// 这行引用十分重要，许多隐式转换以及Flink SQL中的列表达式等均包含在此引用中
import org.apache.flink.streaming.api.scala._
object StateExample {
case class Order(finishTime: Long, memberId: Long, productId: Long, sale: Double)
def main(args: Array[String]): Unit = {
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.enableCheckpointing(5000)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
/**
*设置状态存储方式，一般有以下几种存储方式：
* 类名 存储位置 一般使用环境
* 1 MemoryStateBackend 内存中 是用本地调试，或者是状态很小的情况
* 2 FsStateBackend 落地到文件系统，堆内存会缓存正在传输的数据 适用生产环境，满足HA，性能大于3小于1，但不支持增量更新
* 有OOM风险
* 3 RocksDBStateBackend 落地到文件系统，RocksDB数据库在本地磁盘上 适用生产环境（建议使用此项），满足HA，支持增量更新
* 缓存传输中的数据
**/
env.setStateBackend(new RocksDBStateBackend("oss://bigdata/xxx/order-state"))
val dataStream: DataStream[Order] = env
.fromCollection((1 to 25)
.map(i => Order(i, i % 7, i % 3, i + 0.1)))
/**
* 自定义事件时间
**/
.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[Order](Time.milliseconds(1)) {
override def extractTimestamp(element: Order): Long = element.finishTime
})
//实时输出 不同店铺累计商品销售额排行
dataStream.keyBy("memberId")
.mapWithState[List[Order],List[Order]] {
case (order: Order, None) => (order +: Nil,Some(List(order)))
case (order: Order, Some(orders:List[Order])) => {
val l = (orders :+ order).groupBy(_.productId).mapValues {
case List(o) => o
case l: List[Order] => l.reduce((a, b) => Order(if (a.finishTime > b.finishTime) a.finishTime else b.finishTime, a.memberId, a.productId, a.sale + b.sale))
}.values.toList.sortWith(_.sale > _.sale)
(l,Some(l))
}
}.print()
env.execute("example")
}
}
1.3.2 java版本
import org.apache.commons.collections.IteratorUtils;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.MapState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.state.StateTtlConfig;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.time.Time;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class StateExampleJ {
static final SimpleDateFormat YYYY_MM_DD_HH = new SimpleDateFormat("yyyyMMdd HH");
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
//env.setStateBackend(new RocksDBStateBackend("oss://bigdata/xxx/order-state"));
List data = new LinkedList<>();
for (long i = 1; i <= 25; i++)
data.add(new Order(i, i % 7, i % 3, i + 0.1));
DataStream dataStream = env.fromCollection(data).setParallelism(1).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor(Time.milliseconds(1)) {
@Override
public long extractTimestamp(Order element) {
return element.finishTime;
}
});
dataStream.keyBy(o -> o.memberId).map(
new RichMapFunction>() {
MapState mapState;
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
MapStateDescriptor productRank = new MapStateDescriptor("productRank", Long.class, Order.class);
mapState = getRuntimeContext().getMapState(productRank);
}
@Override
public List map(Order value) throws Exception {
if (mapState.contains(value.productId)) {
Order acc = mapState.get(value.productId);
value.sale += acc.sale;
}
mapState.put(value.productId, value);
return IteratorUtils.toList(mapState.values().iterator());
}
}
).print();
env.execute("exsample");
}
public static class Order {
//finishTime: Long, memberId: Long, productId: Long, sale: Double
public long finishTime;
public long memberId;
public long productId;
public double sale;
public Order() {
}
public Order(Long finishTime, Long memberId, Long productId, Double sale) {
this.finishTime = finishTime;
this.memberId = memberId;
this.productId = productId;
this.sale = sale;
}
}
}
2. 状态针对迟到数据的优化
实时处理面对的第一个难题就是迟到事件的处理（或者说是流乱序的处理）。想必各位同学都有被迟到事件折磨过的经验。虽然官方API提供了迟到数据处理的机制：
(1) assignTimestampsAndWatermarks
.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor(Time.milliseconds(1)) {
@Override
public long extractTimestamp(Order element) {
return element.finishTime;
}
});
(2) allowedLateness
.timeWindow(Time.days(1)).allowedLateness(Time.seconds(1)).sideOutputLateData(outputTag)
但是我想说，这2个迟到时间设太小满足不了精度要求，设太大又会导致性能问题，然后你就会拿历史数据分析计算合适的迟到时间，然后你会发现特么运气不好的时候依然会出现过大的误差。福布湿在这里给大家提供一种解决迟到问题的一种思路，废话不多说，直接上代码，关于其中的一些说明和解释福布湿在代码中已注释的形式说明。
代码框架沿用1.3.2
主要处理逻辑
static final SimpleDateFormat YYYY_MM_DD_HH = new SimpleDateFormat("yyyyMMdd HH");
// 实时输出每个小时每个店铺商品的排行
dataStream
.keyBy(o -> o.memberId)
.map(new RichMapFunction() {
MapState mapState;
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
StateTtlConfig ttlConfig = StateTtlConfig.newBuilder(org.apache.flink.api.common.time.Time.hours(1)) //设置状态的超时时间为1个小时
//设置ttl更新策略为创建和写，直观作用为如果一个key（例如20200101 01）1个小时内没有写入的操作，只有读的操作，那么这个key将被标记为超时
//值得注意的是，MapState ListState这类集合state，超时机制作用在每个元素上，也就是每个元素的超时是独立的
.updateTtlOnCreateAndWrite()
.cleanupInBackground() // 指定过期的key清除的操作策略
.build();
MapStateDescriptor descriptor = new MapStateDescriptor("hourRank", String.class, MemberRank.class);
descriptor.enableTimeToLive(ttlConfig);
mapState = getRuntimeContext().getMapState(descriptor);
}
@Override
public MemberRank map(Order value) throws Exception {
String key = YYYY_MM_DD_HH.format(value.finishTime);
MemberRank rank;
if (mapState.contains(key)) {
rank = mapState.get(key);
rank.merge(value);
} else {
rank = MemberRank.of(value);
}
mapState.put(key, rank);
return rank;
}
}).print();
内部类MemberRank
public static class MemberRank {
public String time;
public long memberId;
public List rank;
public MemberRank() {
}
public MemberRank(String time, long memberId, List rank) {
this.time = time;
this.memberId = memberId;
this.rank = rank;
}
public static MemberRank of(Order o) {
return new MemberRank(YYYY_MM_DD_HH.format(o.finishTime), o.memberId, Collections.singletonList(o));
}
public void merge(Order o) {
rank.forEach(e -> {
if (e.productId == o.productId) {
e.sale += o.sale;
}
});
rank.sort((o1, o2) -> Double.valueOf((o1.sale - o2.sale) * 1000).intValue());
}
}
3. 基于状态的维表关联
维表关联，flink已经有了很好很成熟的接口，福布湿用过的有：
（1） AsyncDataStream.unorderedWait()
（2） Join
（3） BroadcastStream
这几个各有特点，AsyncDataStream.unorderedWait效率最高，但是需要源支持异步客户端，join维表方面个人用的比较少，BroadcastStream没有什么特殊限制，性能也还行，算是比较通用，但是不能定期更新维表信息。
也许你想到了，当源不支持异步客户端，而维表数据又更新的相对较为频繁的时候，以上方式好像都不太适合，下面福布湿就把自己的一些经验介绍给大家。
废话不多说，直接上代码。
import com.fulu.stream.source.http.SyncHttpClient;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.state.StateTtlConfig;
import org.apache.flink.configuration.Configuration;
public class MainOrderHttpMap extends RichMapFunction {
transient MapState member;
transient SyncHttpClient client;
public MainOrderHttpMap() {}
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
StateTtlConfig updateTtl = StateTtlConfig
.newBuilder(org.apache.flink.api.common.time.Time.days(1))
.updateTtlOnCreateAndWrite()
.neverReturnExpired()
.build();
MapStateDescriptor memberDesc = new MapStateDescriptor("member-map", String.class, Member.class);
memberDesc.enableTimeToLive(updateTtl);
member = getRuntimeContext().getMapState(memberDesc);
}
@Override
public SimpleOrder map(SimpleOrder value) throws Exception {
value.profitCenterName = getProfitCenter(value.memberId);
return value;
}
private String getProfitCenter(String id) throws Exception {
String name = null;
int retry = 1;
while (name == null && retry <= 3) {
if (member.contains(id))
name = member.get(id).profitCenterName;
else {
Member m = client.queryMember(id);
if (m != null) {
member.put(id, m);
name = m.profitCenterName;
}
}
retry++;
}
return name;
}
@Override
public void close() throws Exception {
super.close();
client.close();
}
}
想必各位同学直接就能看懂，是的原理很简单，就是将维表缓存在状态中，同时制定状态的过期时间以达到定期更新的目的。
4. Distinct语义
细心的同学可能已经发现，DataStream类中没有distinct Operation。但是当源中存在少量重复数据时怎么办呢，没错，使用状态缓存所有的事件id ，然后使用filter进行过滤操作，由于原理确实很简单，福布湿就不贴代码了。
5. 结尾
福布湿在实时流处理方面最先接触的是spark-streaming，因此在初期学习flink时感觉最难啃的就是state这一块，因此在这里特地将福布斯关于状态的一些经验分享给大家。相信大家在熟悉state后会彻底爱上flink。
参考文献：
【1】 Flink官方文档：https://ci.apache.org/projects/flink/flink-docs-release-1.11/concepts/stateful-stream-processing.html
【2】 https://www.jianshu.com/p/ac0fff780d40?from=singlemessage
【3】 https://zhuanlan.zhihu.com/p/136722111