BaseBroadcastProcessFunction自定义的

已于 2022-09-30 14:11:54 修改
阅读量161 收藏
点赞数
分类专栏： java flink 文章标签： 数据库 java redis
于 2022-09-30 12:09:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39291431/article/details/127120897
版权 
import com.alibaba.fastjson.JSON;
import com.flinkRisk.cache.GroupCache;
import com.flinkRisk.config.FlinkConfig;
import com.flinkRisk.constant.GeneralRuleType;
import com.flinkRisk.handler.impl.speedLimit.LimitSpeedData;
import com.flinkRisk.manager.HandlerManager;
import com.flinkRisk.model.*;
import com.flinkRisk.rule.*;
import com.flinkRisk.sink.mysql.MysqlOutPutDataDispatcher;
import com.flinkRisk.sink.redis.RedisOperationHandler;
import com.flinkRisk.sink.rocketmq.RocketMqOutPutDataDispatcher;
import com.flinkRisk.utils.HttpAsyncUtil;
import com.flinkRisk.utils.IdGenUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.flink.api.common.state.*;
import org.apache.flink.api.common.time.Time;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.co.KeyedBroadcastProcessFunction;
import org.apache.flink.util.Collector;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 自定义BroadcastProcessFunction
 * 当事件流中的车辆ID在规则配置中出现时，获取规则处理数据
 * Tuple4<String, String, String, Integer>: 第一个流(事件流)的数据类型
 * HashMap<String, Tuple2<String, Integer>>: 第二个流(配置流)的数据类型
 * Tuple6<String, String, String, Integer,String, Integer>: 返回的数据类型
 */
@Slf4j
public class BaseBroadcastProcessFunction extends KeyedBroadcastProcessFunction<Long, VehiclePosInfo, BaseRule, AlarmEvent> {
	 /**
     * 上一次车辆状态
     */
    private transient ValueState<VehicleState> lastVehicleState;
    /**
     * 车辆的报警状态:key:报警英文 value:报警事件
     */
    private transient MapState<String, AlarmEvent> alarmState;

    /**
     * 车辆规则
     */
    private Map<Long, Set<BaseRule>> vehicleRule = new ConcurrentHashMap<>();

    /**
     * 车组规则
     */
    private Map<Long, Set<BaseRule>> groupRule = new ConcurrentHashMap<Long, Set<BaseRule>>();
    /**
     * 车辆规则
     */
    private Map<Long, Set<BaseRule>> vehicleRuleTemp =null;

    /**
     * 车组规则
     */
    private Map<Long, Set<BaseRule>> groupRuleTemp = null;

    /**
     * key：行政编号 value:行政区域经纬度
     */
    public static Map<String, List<List<PointInfo>>> areaCodePointsMap=new ConcurrentHashMap<>();
    /**
     * 放道路分段限速信息 key：车牌 value:调用地图接口获取的道路限速信息
     */
    private final Map<Long, LimitSpeedData> limitSpeedDataMap=new ConcurrentHashMap<>();
    /**
     * 第三方监管疲劳驾驶规则
     */
    private ThirdPartyFatigueRule thirdPartyFatigueRule;
    /**
     * 第三方监管超速规则
     */
    private ThirdPartyOverSpeedRule thirdPartyOverSpeedRule;

    /**
     * 第三方监管夜间禁行规则
     */
    private ThirdPartyNotTrafficAtNightRule notTrafficAtNightRule;

    /**
     * 第三方平台长时间不定报警规则
     */
    private ThirdPartyLongTimeNoPosRule thirdPartyLongTimeNoPosRule;

    /**
     * 第三方平台离线位移
     *
     */
    private ThirdPartyOfflineDisplacementRule thirdPartyOfflineDisplacementRule ;
    /**
     * 第三那方推送报警等级规则
     */
    private ThirdPartyAlarmPushRule thirdPartyAlarmPushRule = new ThirdPartyAlarmPushRule();

    /**
     * 粤标普通规则
     */
    public static Map<String,GeneralRule> cacheGeneralRuleMap = null;

    /**
     * 存报警等级配置的数据，从这张表上获取alarm_level_conf
     */
    public static Map<String, Integer> alarmLevelMap=new ConcurrentHashMap<>();
	
	@Override
    public void open(Configuration conf) {
		//初始化
        ParameterTool parameterTool = (ParameterTool) getRuntimeContext().getExecutionConfig().getGlobalJobParameters();
        //线上模式时，算子的配置不共享，需要重新获取配置
        FlinkConfig.init(parameterTool);
        FlinkConfig.initRule(parameterTool, vehicleRule, groupRule);
        // 第三方规则
        FlinkConfig.initThirdPartyRule(true, parameterTool, null, thirdPartyOverSpeedRule, null, null,null, null, null);

        //http异步请求工具初始化
        HttpAsyncUtil.init();
        //初始化mysql数据处理
        MysqlOutPutDataDispatcher.init(parameterTool);
        //初始化mq数据处理
        RocketMqOutPutDataDispatcher.init(parameterTool);
        //redis操作
        RedisOperationHandler.init(parameterTool);
        long indexTask= getRuntimeContext().getIndexOfThisSubtask()+1L;
         if(indexTask<30){
            IdGenUtil.init(3L,getRuntimeContext().getIndexOfThisSubtask()+1L);
        }
        if(indexTask>=30&&indexTask<60){
            IdGenUtil.init(11L,indexTask-30);
        }
        if(indexTask>=60&&indexTask<90){
            IdGenUtil.init(12L,indexTask-60);
        }
        // 上次车辆状态
        StateTtlConfig ttlConfig = StateTtlConfig
                //超过15天没有数据清除状态
                .newBuilder(Time.days(30))
                .setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite)
                .setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired)
                .build();
                ValueStateDescriptor<VehicleState> lastAction = new ValueStateDescriptor<>("lastVehicleState", Types.POJO(VehicleState.class));
        lastAction.enableTimeToLive(ttlConfig);
        lastVehicleState = getRuntimeContext().getState(lastAction);
        //车辆当前报警状态
        StateTtlConfig ttlAlarmState = StateTtlConfig
                //超过15天没有数据清除状态
                .newBuilder(Time.days(30))
                .setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite)
                .setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired)
                .build();
	    MapStateDescriptor<String, AlarmEvent> mapStateDescriptor = new MapStateDescriptor<>("alarmState", Types.STRING, Types.POJO(AlarmEvent.class));
		mapStateDescriptor.enableTimeToLive(ttlAlarmState);
        alarmState = getRuntimeContext().getMapState(mapStateDescriptor);

	}
	 @Override
    public void close() throws Exception {
        super.close();
        HttpAsyncUtil.close();
        MysqlOutPutDataDispatcher.close();
        RocketMqOutPutDataDispatcher.close();
        RedisOperationHandler.close();
        // 将疲劳连续三个点超过阈值的标志清掉
        lastVehicleState.value().setFatigueSpeedSign(0);
    }
 /**
     * 读取状态，并基于状态，处理事件流中的数据
     * 在这里，从上下文中获取状态，基于获取的状态，对事件流中的数据进行处理
     *
     * @param posInfo 事件流中的数据
     * @param ctx     上下文
     * @param out     输出零条或多条数据
     * @throws Exception
     */
    @Override
    public void processElement(VehiclePosInfo posInfo, ReadOnlyContext ctx, Collector<AlarmEvent> out) throws Exception {
		Set<BaseRule> vehicleRules = vehicleRule.get(posInfo.getVehicleId());
        Set<BaseRule> groupRules = groupRule.get((long) posInfo.getGroupId());
        RuleParam ruleParam = getVehicleRuleParam(vehicleRules, groupRules);
        ruleParam.setThirdPartyFatigueRule(thirdPartyFatigueRule);
        ruleParam.setThirdPartyOverSpeedRule(thirdPartyOverSpeedRule);
        ruleParam.setNotTrafficAtNightRule(notTrafficAtNightRule);
        ruleParam.setThirdPartyLongTimeNoPosRule(thirdPartyLongTimeNoPosRule);
        ruleParam.setThirdPartyOfflineDisplacementRule(thirdPartyOfflineDisplacementRule);
        ruleParam.setThirdPartyAlarmPushRule(thirdPartyAlarmPushRule);
        
        HandlerManager.handler(posInfo, ruleParam, ctx, lastVehicleState, alarmState, out, limitSpeedDataMap);

	}
/**
     * 车辆,车组规则合并
     *
     * @param vehicleRules
     * @param groupRules
     * @return
     */
     private RuleParam getVehicleRuleParam(Set<BaseRule> vehicleRules, Set<BaseRule> groupRules) {
        RuleParam param = new RuleParam();
        //车辆规则优先于车组规则
        if (groupRules != null && groupRules.size() > 0) {
            for (BaseRule rule : groupRules) {
                addRule(rule, param);
            }
        }
        if (vehicleRules != null && vehicleRules.size() > 0) {
            for (BaseRule rule : vehicleRules) {
                addRule(rule, param);
            }
        }
        return param;
    }
	private void addRule(BaseRule rule, RuleParam param) {
		if (rule.getRuleTheme() == 1) {
			switch (rule.getRuleType()) {
				case 1:
                    param.getGeneralRuleMap().put(GeneralRuleType.OFFLINE_RULE, (GeneralRule) rule);
                    break;
                case 2:
                    param.getGeneralRuleMap().put(GeneralRuleType.LONG_TIME_NO_POS_RULE, (GeneralRule) rule);
                    break;
                case 3:
                    param.getGeneralRuleMap().put(GeneralRuleType.NO_TRAFFIC_AT_NIGHT_RULE, (GeneralRule) rule);
                    break;
                case 4:
                    param.getGeneralRuleMap().put(GeneralRuleType.TEMPERATURE_ALARM_RULE, (GeneralRule) rule);
                    break;
                case 6:
                param.getGeneralRuleMap().put(GeneralRuleType.NO_LEVEL_SETTING_ALARM_RULE, (GeneralRule) rule);
                    break;
                case 7:
                    param.getGeneralRuleMap().put(GeneralRuleType.ALARM_AUTO_HANDLE_RULE, (GeneralRule) rule);
                    break;
                case 8:
                    param.getGeneralRuleMap().put(GeneralRuleType.OVER_FLOW_RULE, (GeneralRule) rule);
                    break;
                case 11:
                    param.getGeneralRuleMap().put(GeneralRuleType.ABNORMAL_STOP_RULE, (GeneralRule) rule);
                    break;
                    case 12:
                    param.getGeneralRuleMap().put(GeneralRuleType.OFFLINE_DISPLACEMENT_RULE, (GeneralRule) rule);
                    break;
                case 15:
                    param.getGeneralRuleMap().put(GeneralRuleType.FATIGUE_RULE, (GeneralRule) rule);
                    break;
                case 19:
                    param.getGeneralRuleMap().put(GeneralRuleType.OIL_PRE_FULL_RULE, (GeneralRule) rule);
                    break;
                case 20:
                    param.getGeneralRuleMap().put(GeneralRuleType.REVERSAL_RULE, (GeneralRule) rule);
                    break;
                    case 25:
                    param.getGeneralRuleMap().put(GeneralRuleType.OVER_SPEED_PLATFORM, (GeneralRule) rule);
                    break;
                case 22:
                    param.getGeneralRuleMap().put(GeneralRuleType.IS_START_RISK_RULE, (GeneralRule) rule);
                    break;
                default:
                    break;
			}
		}
		if (rule.getRuleTheme() == 2) {
            param.getPathRules().add((PathRule)rule);
        }
        if (rule.getRuleTheme() == 3) {

            param.getAreaRules().add((AreaRule)rule);
        }
        if (rule.getRuleTheme() == 5) {
            param.getRoadRules().add((RoadSpeedLimitRule)rule);
        }
        if (rule.getRuleTheme() == 6) {
            param.setSedimentCarWayBillRule((SedimentCarWayBillRule)rule);
        }
	}
/**
     * 处理广播流中的每一条数据，并更新状态
     *
     * @param rule 广播流中的数据
     * @param ctx  上下文
     * @param out  输出零条或多条数据
     * @throws Exception
     */
    @Override
    public void processBroadcastElement(BaseRule rule, Context ctx, Collector<AlarmEvent> out) {
		if(rule==null){
            return;
        }
        //开始更新
        if(rule.getRuleTheme()==555){
            vehicleRuleTemp=new ConcurrentHashMap<>();
            groupRuleTemp=new ConcurrentHashMap<>();
            cacheGeneralRuleMap = new ConcurrentHashMap<>();
        }
        //结束更新
       if(rule.getRuleTheme()==666){
           vehicleRule=mapCopy(vehicleRuleTemp);
           groupRule=mapCopy(groupRuleTemp);
           FlinkConfig.generalRuleMap=mapCopy(cacheGeneralRuleMap);
           vehicleRuleTemp.clear();
           groupRuleTemp.clear();
           cacheGeneralRuleMap.clear();

       }
       FlinkConfig.addRuleMap(rule, vehicleRuleTemp, groupRuleTemp);

        if(rule.getRuleTheme()==333){
           AreaCode areaCode = (AreaCode) rule;
            areaCodePointsMap.put(areaCode.getAreaCode(),areaCode.getPointInfo());
        }
        //更新车组缓存
        if (rule.getRuleTheme() == 888) {
            VehicleGroup group = (VehicleGroup) rule;
            GroupCache.addGroupMap(group.getGroupId(), group);
            if (group.getUpdateFlag() == 1) {
                GroupCache.buildCompanyGroupMap();
            }
        }
		if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 301) {
            thirdPartyOverSpeedRule = (ThirdPartyOverSpeedRule) rule;
            log.info("规则thirdPartyOverSpeedRule：{}", JSON.toJSONString(thirdPartyOverSpeedRule));
        }
        if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 302) {
            thirdPartyFatigueRule = (ThirdPartyFatigueRule) rule;
            log.info("规则thirdPartyFatigueRule：{}",JSON.toJSONString(thirdPartyFatigueRule));
        }
		
		if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 303) {
            notTrafficAtNightRule = (ThirdPartyNotTrafficAtNightRule) rule;
            log.info("规则notTrafficAtNightRule：{}",JSON.toJSONString(notTrafficAtNightRule));
        }
        if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 305){
            thirdPartyLongTimeNoPosRule = (ThirdPartyLongTimeNoPosRule) rule;
            log.info("规则thirdParthLongTimeNoPosRule：{}",JSON.toJSONString(thirdPartyLongTimeNoPosRule));
        }
        if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 306){
            thirdPartyOfflineDisplacementRule = (ThirdPartyOfflineDisplacementRule) rule;
            log.info("规则thirdPartyOfflineDisplacementRule：{}",JSON.toJSONString(thirdPartyOfflineDisplacementRule));
        }

        if (rule.getRuleTheme()!=null&&rule.getRuleTheme() == 307){
            thirdPartyAlarmPushRule = (ThirdPartyAlarmPushRule) rule;
            log.info("规则thirdPartyAlarmPushRule：{}",JSON.toJSONString(thirdPartyAlarmPushRule));
        }
        if (rule.getRuleTheme()!=null && rule.getRuleTheme()==308){
            AlarmLevel alarmLevel = (AlarmLevel) rule;
            alarmLevelMap.put(alarmLevel.getAlarmType(),alarmLevel.getAlarmLevel());
        }
        if (rule.getRuleTheme()==111){
            GeneralRule generalRule = (GeneralRule) rule;
            if (rule.getParam()!=null){
                // 超速规则
                if (generalRule.getRuleType()==26){
                    OverSpeedRule overSpeedRule = JSON.parseObject(generalRule.getParam(), OverSpeedRule.class);
                    String vehicleShapes = overSpeedRule.getVehicleShape();
                    if (vehicleShapes !=null){
                        String[] split = vehicleShapes.split(",");
                        // 车辆类型加 规则类型
                        for (String vehicleShape : split) {
                            cacheGeneralRuleMap.put(vehicleShape+FlinkConfig.ovType,generalRule);
                        }
                    }
                }
       // 夜间禁行规则
       if (generalRule.getRuleType()==3){
              String params = generalRule.getParam();
              String[] split = params.split(";");
              if (split.length==5) {
                  String vehicleShapes = split[1];
                  if (vehicleShapes !=null) {
                      String[] split1 = vehicleShapes.split(",");
                            for (String vehicleShape : split1) {
                                cacheGeneralRuleMap.put(vehicleShape+FlinkConfig.niType,generalRule);

                            }
                        }

                    }
                }
		// 疲劳报警规则
		if (generalRule.getRuleType()==15){
                    FatigueDrivingRuleParam fatigueDrivingRuleParam = JSON.parseObject(generalRule.getParam(), FatigueDrivingRuleParam.class);
                    String vehicleShapes = fatigueDrivingRuleParam.getVehicleShape();
                    if (vehicleShapes!=null) {
                        String[] split = vehicleShapes.split(",");
                        for (String vehicleShape : split) {
                            cacheGeneralRuleMap.put(vehicleShape+FlinkConfig.faType,generalRule);
                        }
                    }

                }
         // 是否启用风险规则
		if (generalRule.getRuleType()==22){
                    RiskRule riskRule = JSON.parseObject(rule.getParam(),RiskRule.class);
                    if (riskRule !=null){
                        cacheGeneralRuleMap.put(FlinkConfig.isStarRisk, generalRule);
                    }
                }
			}
		}

	}
	/**
     * 复制map对象
     * @explain 将paramsMap中的键值对全部拷贝到resultMap中；
     * paramsMap中的内容不会影响到resultMap（深拷贝）
     * @param paramsMap
     *     被拷贝对象
     *     拷贝后的对象
     */
	public static Map mapCopy(Map paramsMap) {
       Map resultMap = new HashMap();

        Iterator it = paramsMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Object key = entry.getKey();
            resultMap.put(key, paramsMap.get(key) != null ? paramsMap.get(key) : "");

        }
        return resultMap;
    }
}
qq_39291431
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink Broadcast State 使用示例
yuchuanchen的专栏
03-29 7492
什么是 Broadcast State Broadcast State 是 Flink 1.5 引入的新特性。在开发过程中，如果遇到需要下发/广播配置、规则等低吞吐事件流到下游所有 task 时，就可以使用 Broadcast State 特性。下游的 task 接收这些配置、规则并保存为 BroadcastState, 将这些配置应用到另一个数据流的计算中 。英语好的同学可以直接移步 Flink...
flink job同时使用BroadcastProcessFunction和KeyedBroadcastProcessFunction例子
lixia0417mul2的博客
11-02 841
广播状态使用示例
基本处理函数（ProcessFunction）
最新发布
2301_77578187的博客
01-25 1105
处理函数在数据流处理中扮演着核心角色，负责定义数据流的转换操作。在Flink中，处理函数作为一种特殊的转换算子，提供了强大的功能来处理数据流。Flink几乎所有的转换算子都提供了对应的函数类接口，处理函数也不例外。它所对应的函数类被称为ProcessFunction。ProcessFunction为开发者提供了一种灵活的方式来处理数据流，可以根据实际需求对数据进行各种复杂的转换和处理操作。通过使用ProcessFunction，您可以实现自定义的数据流转换逻辑，以满足各种复杂的数据处理需求。
3.3、Flink流处理（Stream API）- State & Fault Tolerance（状态和容错）之 The Broadcast State Pattern（广播状态模式）
飞朋的博客
10-23 483
目录 提供的APIs BroadcastProcessFunction and KeyedBroadcastProcessFunction 重要内容 使用状态描述算子状态，该状态在恢复时均匀地分布在算子的并行任务中，或者统一使用整个状态来初始化恢复后的并行任务。 第三种受支持的操作符状态是广播状态。广播状态被引入以支持这样的用例：来自一个流的一些数据需要广播到所有下游任务，在那里它被本地...
[源码分析] 从实例和源码入手看 Flink 之广播 Broadcast
罗西的思考
05-15 1333
本文将通过源码分析和实例讲解，带领大家熟悉Flink的广播变量机制。
《Flink应用实战》(一)--广播状态
一锅粥
05-16 2528
《Flink一起学》之广播状态的使用
Flink：把状态State全都扒光，远走他乡(二)：广播状态
热门推荐
weixin_43272605的博客
03-05 3万+
受到
【Flink】【第八章】 ProcessFunctionAPI
weixin_43589563的博客
01-20 862
1.ProcessFunction介绍 1.1 API上的说明 A function that processes elements of a stream. For every element in the input stream processElement(Object, ProcessFunction.Context, Collector) is invoked. This can produce zero or more elements as output. Implementa
Flink ProcessFunction详解
菜鸟也学大数据的博客
01-05 3109
前言 我们之前学习的转换算子是无法访问事件的时间戳信息和水位线信息的。而这.在一.些应用场景下，极为重要。例如MapFunction这样的map转换算子就无法访问时间戳或者当前事件的事件时间。 基于此，DataStreamAPI提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的-一些事件，例如超时事件等。ProcessFunction用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的window函数和转换算子无法实现)。例如，Flink
Flink 状态编程 广播状态（Broadcast State）案例
cts618
07-11 224
Flink 状态编程 广播状态（Broadcast State）案例
Flink Broadcast State实用指南
purisuit_knowledge的专栏
03-23 500
转载自： https://blog.csdn.net/wflh323/article/details/102918111 https://yq.aliyun.com/articles/706760 使用过spark的人都知道广播变量这个概念。广播变量相当于一个共享变量，将一个小数据集复制分发到每个task，task直接从本地读取。flink中有两种广播变量，一种静态...
解决java和scala的Tuple混用问题
L13763338360的博客
09-11 1753
背景简述 平时日常数据开发主要用idea，确实挺强大。近日写了个flink任务，非广播流和广播流合并，然后过滤处理。 处理逻辑都很通用，大概是这样：BroadcastConnectedStream的process调用了WhitelistBroadcastProcess类，该类继承BroadcastProcessFunction，并实现processElement和processBroadcastElement方法，分别处理广播流和非广播流。 问题描述 上图中红色波浪线提示错误 Cannot
Flink / Scala 实战- 4.BroadCast 广播流数据先到再处理 Source 数据
BITDDD小栈
08-11 1417
Flink 支持增加 DataStream KeyBy 之后 conncet BroadCastStream 形成 BroadConnectedStream，广播流内数据一般为不间断更新的上下文信息，这里介绍如果等待广播流初始化完毕再处理 Source 数据
【推荐实践】Flink 状态(State)管理在推荐场景中的应用
m0_37586850的博客
04-05 938
导语Flink 提供了灵活丰富的状态管理，可轻松解决数据之间的关联性。本文介绍了Flink 状态(State)管理在推荐场景中的应用，大家结合自己的应用场景与业务逻辑，选择合适的状态管...
Flink源码分析: 广播状态流实现动态更新或字段参数变更
徐腾瑞的博客
08-04 1736
前言： 在使用Flink流式计算时，代码功能实现重要的同时，后期的可维护性一样很重要。作者在开发过程中就遇见过这样一个场景：如果实时计算过程中，我源表突然增加一个字段怎么办，难道Flink程序要改代码重启吗，虽然Flink是有Savepoint机制，但是这样还是会造成延迟，而且后期维护不是很友好。 为了解决这样问题，小编发现了一个Flink的一个功能很强大: 广播状态流机制。 BroadCast State Stream： ...
大数据实操篇 No.18-Flink 处理函数介绍和使用（ProcessFunction）
pezynd的专栏
07-01 612
第1章 简介 第2章 处理函数类型 Flink提供了8种不同的处理函数： ProcessFunction：处理函数 KeyedProcessFunction：键值分区的处理函数 CoProcessFunction：双流处理函数 ProcessJoinFunction：多流join处理函数 BroadcastProcessFunction：广播流处理函数 KeyedBroadcastProcessFunction：键值分区的广播流处理函数 ProcessWindowFunction：
Flink1.10进阶：ProcessFunction介绍及KeyedProcessFunction实例
陆继森的技术专栏
04-14 4517
微信公众号：大数据开发运维架构 关注可了解更多大数据相关的资讯。问题或建议，请公众号留言; 如果您觉得“大数据开发运维架构”对你有帮助，欢迎转发朋友圈 从微信公众号拷贝过来，格式有些错乱，建议直接去公众号阅读 一、ProcessFunction介绍 从之前的文章我们知道，转换算子是无法访问事件的时间戳信息和水位线信息的。而这在一些应用场景下，极为重要。例如我们常用的MapFunc...
Flink-处理函数(ProcessFunction、KeyedProcessFunction、ProcessWindowFunctionHe侧输出流)
迷雾总会解
02-20 1508
而在很多应用需求中，要求我们对时间有更精细的控制，需要能够获取水位线，甚至要“把控时间”、定义什么时候做什么事，这就不是基本的时间窗口能够实现的了。所以我们会看到，程序运行后先在控制台输出“数据到达”的信息，等待 10 秒之后，又会输出“定时器触发”的信息，打印出的时间间隔正是 10 秒。因为最后的排序还是基于每个时间窗口的，所以为了让输出的统计结果中包含窗口信息，我们可以借用自定义 POJO 类 UrlViewCount 来表示，它包含了 url、浏览量（count）以及窗口的起始结束时间。
Flink DataStream基于Broadcast State动态更新配置以实现实时过滤数据并增加字段
王佩的CSDN博客
08-17 1万+
Flink从1.5.0开始支持广播状态(Broadcast State)。广播状态可以用来解决如下问题: 一条流需要根据规则或配置处理数据，而规则或配置又是随时变化的。此时，就可将规则或配置作为广播流广播出去，并以Broadcast State的形式存储在下游Task中。下游Task根据Broadcast State中的规则或配置来处理常规流中的数据。 场景举例: 动态更新计算规则: 如事件流...
Flink专题七：Flink 中广播流之BroadcastStream
beyond的博客
03-24 6969
由于工作需要最近学习flink 现记录下Flink介绍和实际使用过程 这是flink系列的第七篇文章 Flink 中广播流之BroadcastStream使用场景使用案例数据流和广播流connect方法BroadcastProcessFunction 和 KeyedBroadcastProcessFunction重要注意事项 使用场景 背景： 我们定义两个流，一个流包含图形（Item），具有颜色和形状两个属性。 另一个流包含特定的规则（Rule），代表希望寻找的模式。 在图形流中，我们需要首先使用颜.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值