Flink状态妙用

最新推荐文章于 2023-07-01 18:40:32 发布

置顶 GOOMHOOM

最新推荐文章于 2023-07-01 18:40:32 发布

阅读量675

点赞数 4

分类专栏： Flink 文章标签： flink 大数据

本文链接：https://blog.csdn.net/GOOMHOOM/article/details/107907649

版权

Flink 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Flink状态妙用

本文主要介绍福布湿在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	-
	ListState
	MapState<UK,UV>
	ReducingState
	AggregatingState<IN, OUT>
OperateState	CheckpointedFunction	-
	ListCheckpointed

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   内存中                                    是用本地调试，或者是状态很小(默认情况下单个key不超过5M)的情况
     * 2  FsStateBackend       落地到文件系统，堆内存会缓存正在传输的数据有OOM风险    适用生产环境，满足HA，性能大于3小于1，但不支持增量更新
     * 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")
// 返回值中_1是同一个店铺不同商品累计值的列表，_2是该key（店铺ID）的状态值，这里用的是//ListState，所以类型参数是_2 的List[Order],当然也可以是MapState，那么_2的类型参数就是//Map[Long,Order]
      .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.configuration.Configuration;
import org.apache.flink.contrib.streaming.state.RocksDBStateBackend;
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.io.IOException;
import java.util.LinkedList;
import java.util.List;

public class StateExampleJ {
    public static void main(String[] args) throws IOException {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.setStateBackend(new RocksDBStateBackend("oss://bigdata/xxx/order-state"));
        List<Order> data = new LinkedList<>();
        for (long i = 1; i <= 25; i++)
            data.add(new Order(i, i % 7, i % 3, i + 0.1));
        DataStream<Order> dataStream=env.fromCollection(data).setParallelism(1).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.milliseconds(1)) {
            @Override
            public long extractTimestamp(Order element) {
                return element.finishTime;
            }
        });
        dataStream.keyBy(o -> o.memberId).map(
            new RichMapFunction<Order, List<Order>>() {
                MapState<Long,Order> mapState;

                @Override
                public void open(Configuration parameters) throws Exception {
                    super.open(parameters);
                    MapStateDescriptor<Long,Order> productRank = new MapStateDescriptor<Long, Order>("productRank",Long.class,Order.class);
                    mapState = getRuntimeContext().getMapState(productRank);
                }

                @Override
                public List<Order> 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(new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.milliseconds(1)) {
            @Override
            public long extractTimestamp(Order element) {
                return element.finishTime;
            }
        });

(2)	window().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<Order, MemberRank>() {
	// key为事件时间的"yyyyMMdd HH" 字符串
            MapState<String,MemberRank> 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<String,MemberRank> descriptor = new MapStateDescriptor<String, MemberRank>("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<Order> rank;
    public MemberRank(){}
    public MemberRank(String time, long memberId, List<Order> 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<SimpleOrder, SimpleOrder> {
    transient MapState<String, Member> 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<String, Member> memberDesc = new MapStateDescriptor<String, Member>("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。

福禄ICH·大数据开发团队
福布湿
2020年6月

参考文献：

【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

GOOMHOOM

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
Flink状态妙用

Flink状态妙用本文主要介绍福布湿在flink实时流处理中，state使用的一些经验和心得。本文默认围观的大神已经对flink有一定了解，如果围观过程中发现了有疑问的地方，欢迎在评论区留言。1. 状态的类别1.1 从数据角度看，flink中的状态分为2种：KeyedState在按key分区的DataStream中，每个key拥有一个自己的state，换句话说，这个state能得到这个key所有的数据。结合以上的描述，不难得出以下结论，KeyState只能在KeyedStream上使用。
复制链接

扫一扫