17、Flink实战:容错机制(七)深入理解KeyedState,使用keyedState实现累加功能

实际执行按键隔离的 ValueState 累加,区分状态句柄、检查点配置与尚未验证的故障恢复。

简明结论

ValueState 按当前 key 访问;开启检查点不自动保证 socket 源和外部业务端到端 Exactly-Once。

ValueState 在 keyed operator 中按当前 key 访问状态。它不是给所有 key 共用的一个普通字段,也不是只要加上 transient 就不需要持久化;transient 通常用于运行时状态句柄,状态数据由 Flink 后端管理。

完整的按键累加实验

复用 Flink 简介的 POM,将以下测试放入 src/test/java/site。输入 A=2、B=5、A=3,只有相同 key 的记录共享累计值;首次读取状态可能为 null,需要明确初始化策略。

package site;

import java.util.List;
import java.util.TreeMap;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class KeyedStateTest {
  public static class Accumulator extends RichMapFunction<Tuple2<String,Integer>,Tuple2<String,Integer>> {
    private transient ValueState<Integer> total;
    public void open(Configuration configuration) {
      total=getRuntimeContext().getState(new ValueStateDescriptor<>("total",Types.INT));
    }
    public Tuple2<String,Integer> map(Tuple2<String,Integer> row) throws Exception {
      Integer previous=total.value();
      int next=(previous==null ? 0 : previous)+row.f1;
      total.update(next);
      return Tuple2.of(row.f0,next);
    }
  }
  @Test void isolatesStatePerKeyInARealLocalJob() throws Exception {
    var env=StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);
    var output=env.fromData(List.of(Tuple2.of("A",2),Tuple2.of("B",5),Tuple2.of("A",3)))
        .keyBy(row -> row.f0).map(new Accumulator());
    var latest=new TreeMap<String,Integer>();
    try (var results=output.executeAndCollect()) {
      while (results.hasNext()) { var row=results.next();latest.put(row.f0,row.f1); }
    }
    assertEquals(5,latest.get("A"));assertEquals(5,latest.get("B"));
    System.out.println("keyed-totals="+latest+"; recovery-tested=false");
  }
}
mvn -Dtest=KeyedStateTest test

本次实际输出 keyed-totals={A=5, B=5}; recovery-tested=false。这是 Flink 本地任务中真实 ValueState 的执行,不是用普通 Map 模拟状态。结果只验证按键隔离与累加,没有注入故障或从检查点恢复。

检查点与 Exactly-Once 的前提

启用 checkpoint 协调算子状态快照,还需要可回放的数据源、相应的恢复配置,以及支持目标一致性语义的输出端。旧例的 socketTextStream 与 print 并不能仅凭开启 EXACTLY_ONCE 模式就保证业务端到端恰好一次。

open 的调用随算子实例与执行尝试发生,不能把它说成整个作业生命周期只执行一次。更新状态后应返回与该条输入对应的新值;处理 null、整数溢出、状态 TTL 和 schema 变更则应按业务另行设计。本例未测试这些边界。

下一步阅读

原资料片段(未重建原环境)

下方保留原资料的上下文、示例与截图;本轮验证只对应上方新增文件,未将旧运行结果记为本轮结果。

直接上代码如下:

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.restartstrategy.RestartStrategies;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.CheckpointConfig;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
public class KeyedStateDeepReview {
    public static void main(String[] args) throws Exception {
        //1.创建一个 flink steam 程序的执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 2. 重启相关配置
        // 只有开启了checkpointing,才会有重启策略
        env.enableCheckpointing(5000);    // 5秒为一个周期

//        // 设置最多重启3次,每次间隔两秒
        // 默认的重启策略是  延迟无限重启CheckpointConfig
        env.getConfig().setRestartStrategy(RestartStrategies.fixedDelayRestart(3, 2000));

        // 检查点只是一致性机制的一部分,socket 源与 print 输出不因此获得端到端恰好一次
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);

        //3. 创建DataStream
        DataStreamSource<String> lines = env.socketTextStream( "192.168.***.***", 8888);

        //Transformation(s) 对数据进行处理操作
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = lines.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String word) {
                //将每个单词与 1 组合,形成一个元组
                return Tuple2.of(word, 1);
            }
        });

        //4. Transformation 进行分组聚合(keyBy:将key相同的分到一个组中)
        KeyedStream<Tuple2<String, Integer>, Tuple> keyedStream = wordAndOne.keyBy(0);

        // 使用 KeyedState 通过中间状态求和
        SingleOutputStreamOperator<Tuple2<String, Integer>> summed = keyedStream.map(new KeyedStateSum());

        //5.调用Sink (Sink必须调用)
        summed.print();

        //6. 启动
        env.execute("KeyedStateDeepReview");
    }
}
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;

public class KeyedStateSum extends RichMapFunction<Tuple2<String,Integer>, Tuple2<String,Integer>> {

    //transient 修饰运行时状态句柄;托管状态数据本身仍由 Flink 状态后端管理
    private transient ValueState<Tuple2<String,Integer>> valueState;

    // open 在算子实例初始化时调用,新的执行尝试会重新初始化
    @Override
    public void open(Configuration parameters) throws Exception {
        ValueStateDescriptor<Tuple2<String,Integer>> stateDescriptor =
                new ValueStateDescriptor<>("wc-keyed-state", Types.TUPLE(Types.STRING, Types.INT));
        // 每一个组key都有自己的状态,无需特别指定是哪个word组的状态
        valueState = getRuntimeContext().getState(stateDescriptor);
    }

    @Override
    public Tuple2<String, Integer> map(Tuple2<String, Integer> value) throws Exception {
        //输入的单词
        String word = value.f0;
        //输入的次数
        Integer count = value.f1;
        //根据State获取中间数据
        Tuple2<String,Integer> historyKV = valueState.value();

        //根据State中间数据,进行累加
        if (historyKV != null) {
            historyKV.f1 += count;
            //累加后,更新State数据
            valueState.update(historyKV);
        } else {
            // 更新历史数据
            valueState.update(value);
        }
//                return historyKV;  //这样写会报空指针异常
//                return Tuple2.of(word,valueState.value().f1);
        return valueState.value();
    }

}

原资料报告了累加结果;本轮没有重建此 socket 源与旧 API 环境。

 

版权声明:本文不是「本站」原创文章,版权归原作者所有 | 原文地址: