从 demo 到生产 - 手把手写出实战需求的 Flink 广播程序

Flink 广播变量在实时处理程序中扮演着很重要的角色，适当的使用广播变量会大大提升程序处理效率。

本文从简单的 demo 场景出发，引入生产中实际的需求并提出思路与部分示例代码，应对一般需求应该没有什么问题，话不多说，赶紧来看看这篇干货满满的广播程序使用实战吧。

1 啥是广播

Flink 支持广播变量，允许在每台机器上保留一个只读的缓存变量，数据存在内存中，在不同的 task 所在的节点上的都能获取到，可以减少大量的 shuffle 操作。

换句话说，广播变量可以理解为一个公共的共享变量，可以把一个 dataset 的数据集广播出去，然后不同的 task 在节点上都能够获取到，这个数据在每个节点上只会存在一份。

如果不使用 broadcast，则在每个节点中的每个 task 中都需要拷贝一份 dataset 数据集，比较浪费内存（也就是一个节点中可能会存在多份 dataset 数据）

2 用法总结

//1 初始化数据
 
DataSet<Integer>  toBroadcast = env.fromElements(1,2,3)
 
//2 广播数据 api
 
withBroadcastSet(toBroadcast,"broadcastSetName")
 
//3 获取数据
 
Collection<integer> broadcastSet = getRuntimeContext().getBroadcastVariable("broadcastSetName");

注意：

广播变量由于要常驻内存，程序结束时才会失效，所以数据量不宜过大
广播变量广播在初始化后不支持修改（修改场景也有办法）

3 基础案例演示

基础案例广播变量使用

这种场景下广播变量就是加载参数表，参数表不会变化，记住第二部分常用总结公式即可。

/**
 * @author 大数据江湖
 * @version 1.0
 * @date 2021/5/17.
 *
 */
public class BaseBroadCast {
 
    /**
     * broadcast广播变量
     * 需求：
     *  flink会从数据源中获取到用户的姓名
     *  最终需要把用户的姓名和年龄信息打印出来
     *  分析：
     *  所以就需要在中间的map处理的时候获取用户的年龄信息
     *  建议吧用户的关系数据集使用广播变量进行处理
     *
     */
    public static void main(String[] args) throws Exception {
 
        //获取运行环境
        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
        //1：准备需要广播的数据
        ArrayList<Tuple2<String, Integer>> broadData = new ArrayList<>();
        broadData.add(new Tuple2<>("zs", 18));
        broadData.add(new Tuple2<>("ls", 20));
        broadData.add(new Tuple2<>("ww", 17));
        DataSet<Tuple2<String, Integer>> tupleData =
                env.fromCollection(broadData);
 
        //1.1:处理需要广播的数据,把数据集转换成map类型，map中的key就是用户姓名，value就是用户年龄
 
        DataSet<HashMap<String, Integer>> toBroadcast = tupleData.map(new MapFunction<Tuple2<String, Integer>, HashMap<String, Integer>>() {
            @Override
            public HashMap<String, Integer> map(Tuple2<String, Integer> value)
                    throws Exception {
                HashMap<String, Integer> res = new HashMap<>();
                res.put(value.f0, value.f1);
                return res;
            }
        });
        //源数据
        DataSource<String> data = env.fromElements("zs", "ls", "ww");
        //注意：在这里需要使用到RichMapFunction获取广播变量
        DataSet<String> result = data.map(new RichMapFunction<String, String>() {
 
            List<HashMap<String, Integer>> broadCastMap = new ArrayList<HashMap<String, Integer>>();
 
            HashMap<String, Integer> allMap = new HashMap<String, Integer>();
 
            /**
             * 这个方法只会执行一次
             * 可以在这里实现一些初始化的功能
             * 所以，就可以在open方法中获取广播变量数据
             */
            @Override
            public void open(Configuration parameters) throws Exception {
                super.open(parameters);
                //3:获取广播数据
                this.broadCastMap = getRuntimeContext().getBroadcastVariable("broadCastMapName");
                for (HashMap map : broadCastMap) {
                    allMap.putAll(map);
                }
            }
 
            @Override
            public String map(String value) throws Exception {
                Integer age = allMap.get(value);
                return value + "," + age;
            }
        }).withBroadcastSet(toBroadcast, "broadCastMapName");//2：执行广播数据的操作
        result.print();
    }
 
}

4 生产案例演示

实际生产中有时候是需要更新广播变量的，但不是实时更新的，一般会设置一个更新周期，几分钟，几小时的都很常见，根据业务而定。

由于广播变量需要更新，解决办法一般是需要将广播变量做成另一个 source，进行流与流之间的 connect 操作，定时刷新广播的source，从而达到广播变量修改的目的。

4.1.1 使用 redis 中的数据作为广播变量的思路：

消费 kafka 中的数据，使用 redis 中的数据作为广播数据，进行数据清洗后写到 kafka中。

示例代码分为三个部分：kafka 生产者，redis 广播数据源，执行入口类

构建 kafka 生成者，模拟数据（以下代码的消费消息来源均是此处生产）

/**
 * 模拟数据源
 */
public class kafkaProducer {
 
    public static void main(String[] args) throws Exception{
        Properties prop = new Properties();
        //指定kafka broker地址
        prop.put("bootstrap.servers", "10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
        //指定key value的序列化方式
        prop.put("key.serializer", StringSerializer.class.getName());
        prop.put("value.serializer", StringSerializer.class.getName());
        //指定topic名称
        String topic = "data_flink_bigdata_test";
 
        //创建producer链接
        KafkaProducer<String, String> producer = new KafkaProducer<String,String>(prop);
 
        //{"dt":"2018-01-01 10:11:11","countryCode":"US","data":[{"type":"s1","score":0.3,"level":"A"},{"type":"s2","score":0.2,"level":"B"}]}
 
        while(true){
            String message = "{\"dt\":\""+getCurrentTime()+"\",\"countryCode\":\""+getCountryCode()+"\",\"data\":[{\"type\":\""+getRandomType()+"\",\"score\":"+getRandomScore()+",\"level\":\""+getRandomLevel()+"\"},{\"type\":\""+getRandomType()+"\",\"score\":"+getRandomScore()+",\"level\":\""+getRandomLevel()+"\"}]}";
            System.out.println(message);
            //同步的方式，往Kafka里面生产数据
 
            producer.send(new ProducerRecord<String, String>(topic,message));
 
            Thread.sleep(2000);
        }
        //关闭链接
        //producer.close();
    }
 
    public static String getCurrentTime(){
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        return sdf.format(new Date());
    }
 
    public static String getCountryCode(){
        String[] types = {"US","TW","HK","PK","KW","SA","IN"};
        Random random = new Random();
        int i = random.nextInt(types.length);
        return types[i];
    }
 
    public static String getRandomType(){
        String[] types = {"s1","s2","s3","s4","s5"};
        Random random = new Random();
        int i = random.nextInt(types.length);
        return types[i];
    }
 
    public static double getRandomScore(){
        double[] types = {0.3,0.2,0.1,0.5,0.8};
        Random random = new Random();
        int i = random.nextInt(types.length);
        return types[i];
    }
 
    public static String getRandomLevel(){
        String[] types = {"A","A+","B","C","D"};
        Random random = new Random();
        int i = random.nextInt(types.length);
        return types[i];
    }
 
}

redis 数据作为广播数据

/**
 * redis中准备的数据源
 * source：
 *
 * hset areas AREA_US US
 * hset areas AREA_CT TW,HK
 * hset areas AREA_AR PK,KW,SA
 * hset areas AREA_IN IN
 *
 * result：
 *
 * HashMap
 *
 * US，AREA_US
 * TW，AREA_CT
 * HK，AREA_CT
 *
 */
public class BigDataRedisSource implements SourceFunction<HashMap<String,String>> {
 
    private Logger logger= LoggerFactory.getLogger(BigDataRedisSource.class);
 
    private Jedis jedis;
    private boolean isRunning=true;
 
    @Override
    public void run(SourceContext<HashMap<String, String>> cxt) throws Exception {
        this.jedis = new Jedis("localhost",6379);
        HashMap<String, String> map = new HashMap<>();
        while(isRunning){
          try{
              map.clear();
              Map<String, String> areas = jedis.hgetAll("areas");
              /**
               * AREA_CT TT,AA
               *
               * map:
               * TT,AREA_CT
               * AA,AREA_CT
               */
              for(Map.Entry<String,String> entry: areas.entrySet()){
                  String area = entry.getKey();
                  String value = entry.getValue();
                  String[] fields = value.split(",");
                  for(String country:fields){
                      map.put(country,area);
                  }
 
              }
              if(map.size() > 0 ){
                  cxt.collect(map);
              }
              Thread.sleep(60000);
          }catch (JedisConnectionException e){
              logger.error("redis连接异常",e.getCause());
              this.jedis = new Jedis("localhost",6379);
          }catch (Exception e){
              logger.error("数据源异常",e.getCause());
          }
 
        }
 
    }
 
    @Override
    public void cancel() {
        isRunning=false;
        if(jedis != null){
            jedis.close();
        }
 
    }
}

程序入口类

/**
 * @author 大数据江湖
 * @version 1.0
 * @date 2021/4/25.
 *
 *
 * 使用 kafka 输出流和 redis 输出流 进行合并清洗
 *
 *
 */
public class 广播方式1分两个流进行connnect操作 {
    public static void main(String[] args) throws Exception {
 
        //1 获取执行环境
 
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
 
        env.setParallelism(3);//并行度取决于 kafka 中的分区数 保持与kafka 一致
 
        //2 设置 checkpoint
 
        //开启checkpoint 一分钟一次
        env.enableCheckpointing(60000);
        //设置checkpoint 仅一次语义
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        //两次checkpoint的时间间隔
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(5000);
        //最多只支持1个checkpoint同时执行
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
        //checkpoint超时的时间
        env.getCheckpointConfig().setCheckpointTimeout(60000);
        // 任务失败后也保留 checkPonit数据
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
 
        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                3, // 尝试重启的次数
                Time.of(10, TimeUnit.SECONDS) // 间隔
        ));
 
        // 设置 checkpoint 路径
       // env.setStateBackend(new FsStateBackend("hdfs://192.168.123.103:9000/flink/checkpoint"));
 
        //3 设置 kafka Flink 消费
 
        //创建 Kafka 消费信息
 
        String topic="data_flink_bigdata_test";
        Properties consumerProperties = new Properties();
        consumerProperties.put("bootstrap.servers","10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
        consumerProperties.put("group.id","data_test_new_1");
        consumerProperties.put("enable.auto.commit", "false");
        consumerProperties.put("auto.offset.reset","earliest");
 
        //4 获取 kafka 与 redis 数据源
 
        FlinkKafkaConsumer consumer = new FlinkKafkaConsumer<String>(topic, new SimpleStringSchema(), consumerProperties);
 
        DataStreamSource<String> kafkaSourceData = env.addSource(consumer);
 
        //直接使用广播的方式 后续作为两个数据流来操作
 
        DataStream<HashMap<String, String>> redisSourceData = env.addSource(new NxRedisSource()).broadcast();
 
        //5 两个数据源进行 ETL 处理 使用 connect 连接处理
 
        SingleOutputStreamOperator<String> etlData = kafkaSourceData.connect(redisSourceData).flatMap(new MyETLProcessFunction());
 
        //6 新创建一个 kafka 生产者 进行发送
        String outputTopic="allDataClean";
 
        // 输出给下游 kafka
 
        Properties producerProperties = new Properties();
        producerProperties.put("bootstrap.servers","10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
 
        FlinkKafkaProducer<String> producer = new FlinkKafkaProducer<>(outputTopic,
                new KeyedSerializationSchemaWrapper<String>(new SimpleStringSchema()),
                producerProperties);
 
        etlData.addSink(producer);
 
        //7 提交任务执行
 
        env.execute("DataClean");
 
    }
 
    /**
     * in 1 kafka source   ：
     *
     *  {"dt":"2018-01-01 10:11:11","countryCode":"US","data":[{"type":"s1","score":0.3,"level":"A"},{"type":"s2","score":0.2,"level":"B"}]}
     *
     *
     * in 2 redis source
     *
     *
     *  US，AREA_US
     *  TW，AREA_CT
     *  HK，AREA_CT
     *
     *
     *
     * out 合并后的source
     */
    private static class MyETLProcessFunction implements CoFlatMapFunction<String,HashMap<String,String>,String> {
 
        //用来存储 redis 中的数据
        HashMap<String,String> allMap = new HashMap<String,String>();
 
        @Override
        public void flatMap1(String line, Collector<String> collector) throws Exception {
 
            //将 kafka 数据 按 redis 数据进行替换
            // s -> kafka 数据
            //allMap -> redis 数据
 
            JSONObject jsonObject = JSONObject.parseObject(line);
            String dt = jsonObject.getString("dt");
            String countryCode = jsonObject.getString("countryCode");
            //可以根据countryCode获取大区的名字
            String area = allMap.get(countryCode);
            JSONArray data = jsonObject.getJSONArray("data");
            for (int i = 0; i < data.size(); i++) {
                JSONObject dataObject = data.getJSONObject(i);
                System.out.println("大区："+area);
                dataObject.put("dt", dt);
                dataObject.put("area", area);
                //下游获取到数据的时候，也就是一个json格式的数据
                collector.collect(dataObject.toJSONString());
            }
 
        }
 
        @Override
        public void flatMap2(HashMap<String, String> stringStringHashMap, Collector<String> collector) throws Exception {
            //将 redis 中 数据进行赋值
            allMap = stringStringHashMap;
 
        }
    }
}

4.1.2 使用 MapState 进行广播程序优化：

优化的点在于（下面代码中 TODO 标识点）：

进行数据广播时需要使用 MapStateDescriptor 进行注册
进行两个流合并处理时使用 process 函数
处理函数中使用 MapState 来存取 redis 中的数据

/**
 * @author 大数据江湖
 * @version 1.0
 * @date 2021/4/25.
 * <p>
 * 使用 kafka 输出流和 redis 输出流 进行合并清洗
 * <p>
 * 线上使用的方式
 */
public class 广播方式2使用MapState对方式1改造 {
    public static void main(String[] args) throws Exception {
 
        //1 获取执行环境
 
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
 
        env.setParallelism(3);//并行度取决于 kafka 中的分区数 保持与kafka 一致
 
        //2 设置 checkpoint
 
        //开启checkpoint 一分钟一次
        env.enableCheckpointing(60000);
        //设置checkpoint 仅一次语义
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        //两次checkpoint的时间间隔
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(5000);
        //最多只支持1个checkpoint同时执行
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
        //checkpoint超时的时间
        env.getCheckpointConfig().setCheckpointTimeout(60000);
        // 任务失败后也保留 checkPonit数据
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
 
        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                3, // 尝试重启的次数
                Time.of(10, TimeUnit.SECONDS) // 间隔
        ));
 
        // 设置 checkpoint 路径
        //env.setStateBackend(new FsStateBackend("hdfs://192.168.123.103:9000/flink/checkpoint"));
 
        //3 设置 kafka Flink 消费
 
        //创建 Kafka 消费信息
 
        String topic = "data_flink_bigdata_test";
        Properties consumerProperties = new Properties();
        consumerProperties.put("bootstrap.servers", "10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
        consumerProperties.put("group.id", "data_flink_fpy_test_consumer");
        consumerProperties.put("enable.auto.commit", "false");
        consumerProperties.put("auto.offset.reset", "earliest");
 
        //4 获取 kafka 与 redis 数据源
 
        FlinkKafkaConsumer consumer = new FlinkKafkaConsumer<String>(topic, new SimpleStringSchema(), consumerProperties);
 
        DataStreamSource<String> kafkaSourceData = env.addSource(consumer);
 
        // 获取 redis 数据源并且进行广播  线上的广播也是 source + 广播方法
 
        MapStateDescriptor<String, String> descriptor = new MapStateDescriptor<String, String>(
                "RedisBdStream",
                String.class,
                String.class
        );
 
        //5 两个数据源进行 ETL 处理 使用 connect 连接处理 TODO process 替换 FlatMap
        //TODO 使用 MapState 来进行广播
        BroadcastStream<HashMap<String, String>> redisSourceData = env.addSource(new NxRedisSource()).broadcast(descriptor);
 
        SingleOutputStreamOperator<String> etlData = kafkaSourceData.connect(redisSourceData).process(new MyETLProcessFunction());
 
        //6 新创建一个 kafka 生产者 进行发送
        String outputTopic = "allDataClean";
 
        // 输出给下游 kafka
 
        Properties producerProperties = new Properties();
        producerProperties.put("bootstrap.servers","10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
 
        FlinkKafkaProducer<String> producer = new FlinkKafkaProducer<>(outputTopic,
                new KeyedSerializationSchemaWrapper<String>(new SimpleStringSchema()),
                producerProperties);
 
        etlData.addSink(producer);
 
        etlData.print();
 
        //7 提交任务执行
 
        env.execute("DataClean");
 
    }
 
    /**
     * in 1 kafka source
     * in 2 redis source
     * <p>
     * out 合并后的source
     */
    private static class MyETLProcessFunction extends BroadcastProcessFunction<String, HashMap<String, String>, String> {
 
        // TODO 注意此处 descriptor 的名称需要与 广播时 （99行代码） 名称一致
        MapStateDescriptor<String, String> descriptor =
                new MapStateDescriptor<String, String>(
                        "RedisBdStream",
                        String.class,
                        String.class
                );
 
        //逻辑的处理方法 kafka 的数据
        @Override
        public void processElement(String line, ReadOnlyContext readOnlyContext, Collector<String> collector) throws Exception {
            //将 kafka 数据 按 redis 数据进行替换
            // s -> kafka 数据
            //allMap -> redis 数据
            System.out.println("into  processElement ");
            JSONObject jsonObject = JSONObject.parseObject(line);
            String dt = jsonObject.getString("dt");
            String countryCode = jsonObject.getString("countryCode");
            //可以根据countryCode获取大区的名字
 
            // String area = allDataMap.get(countryCode);
            //TODO 从MapState中获取对应的Code
            String area = readOnlyContext.getBroadcastState(descriptor).get(countryCode);
 
            JSONArray data = jsonObject.getJSONArray("data");
 
            for (int i = 0; i < data.size(); i++) {
                JSONObject dataObject = data.getJSONObject(i);
                System.out.println("大区：" + area);
                dataObject.put("dt", dt);
                dataObject.put("area", area);
                //下游获取到数据的时候，也就是一个json格式的数据
                collector.collect(dataObject.toJSONString());
            }
 
        }
 
        //广播流的处理方法
        @Override
        public void processBroadcastElement(HashMap<String, String> stringStringHashMap, Context context, Collector<String> collector) throws Exception {
 
            // 将接收到的控制数据放到 broadcast state 中
            //key , flink
            // 将 RedisMap中的值放入 MapState 中
            for (Map.Entry<String, String> entry : stringStringHashMap.entrySet()) {
                //TODO 使用 MapState 存储 redis 数据
                context.getBroadcastState(descriptor).put(entry.getKey(), entry.getValue());
                System.out.println(entry);
            }
 
        }
    }
}

4.2 关系型数据库广播变量案例思路：

需求：

在 flink 流式处理中常常需要加载数据库中的数据作为条件进行数据处理，有些表作为系统表，实时查询效率很低，这时候就需要将这些数据作为广播数据，而同时这些数据可能也需要定期的更新。

思路：

数据库表的广播变量思路同redis等缓存广播数据的思路类似，也是使用两个source 进行 connect 处理 , 在数据库表的 source 中定时刷新数据就可以了。

不同点在于这里把数据库查询的操作转成另一个工具类，在初始化时使用了静态代码块，在广播时使用了流的 connect 操作。

示例代码分为三个部分：数据库表广播源，数据库操作类，执行入口类

数据库表广播源

/**
 * @author 大数据江湖
 * @Date:2021-5-17
 * DB source 源头 进行广播
 */
public class BigDataDBBroadSource extends RichSourceFunction<Map<String,Object>> {
 
    private  final Logger logger = LoggerFactory.getLogger(BigDataDBBroadSource.class);
    private volatile boolean isRunning = true;
 
    public BigDataDBBroadSource() {
 
    }
 
    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
 
    }
 
    @Override
    public void run(SourceContext<Map<String,Object>> sourceContext) throws Exception {
 
        while (isRunning) {
            //TODO  使用的是一个 DB 源头的 source 60 s 刷新一次 进行往下游发送
            TimeUnit.SECONDS.sleep(60);
 
            Map<String,Object> map = new HashMap<String,Object>();
 
            //规则匹配关键词
 
            final DbBroadCastListInitUtil.Build ruleListInitUtil = new DbBroadCastListInitUtil.Build();
 
            ruleListInitUtil.reloadRule();
 
            map.put("dbsource", ruleListInitUtil);
 
            if(map.size() > 0) {
                sourceContext.collect(map);
            }
        }
    }
 
    @Override
    public void cancel() {
        this.isRunning = false;
    }
 
    @Override
    public void close() throws Exception {
        super.close();
 
    }
}

执行数据库操作类

/**
 * 数据库规则表初始化
 *
 * @author 大数据江湖
 * @Date:2021-5-17
 *
 * US，AREA_US
 * TW，AREA_CT
 * HK，AREA_CT
 *
 */
public class DbBroadCastListInitUtil implements Serializable {
 
    private static final Logger LOG = LoggerFactory.getLogger(DbBroadCastListInitUtil.class);
 
    // 数据库规则信息
 
    public static Map<String, String> areasMap = new HashMap<String, String>();
 
    static {
        LOG.info("初始化 db 模块");
        Connection dbConn = null;
 
        try {
 
            if (dbConn == null || dbConn.isClosed()) {
                LOG.info("init dbConn start....");
                LOG.info("init dbConn end....");
            }
 
            HashMap<String, String> map = Maps.newHashMap();
 
            map.put("US","AREA_US");
            map.put("TW","AREA_CT");
            map.put("HK","AREA_CT");
 
            areasMap = map;
 
        } catch (Exception e) {
            LOG.error("init database [status:error]", e);
            throw new RuntimeException(" static article rule list db select error!  , "+e.getMessage()) ;
 
        } finally {
            if(dbConn != null) {
                try {
                    dbConn.close();
                } catch (SQLException e) {
                    LOG.error("dbConn conn close error!",e);
                }
            }
 
        }
    }
 
    public static class Build {
 
        // 数据库规则信息
 
        public static Map<String, String> newAreasMap = new HashMap<String, String>();
 
        public void reloadRule() throws Exception {
            LOG.info("重新初始化 DB reloadRule 模块");
            Connection dbConn = null;
            try {
                if (dbConn == null || dbConn.isClosed()) {
                    LOG.info("init dbConn start....");
                    LOG.info("init dbConn end....");
                }
 
                HashMap<String, String> map = Maps.newHashMap();
 
                map.put("US","AREA_US");
                map.put("TW","AREA_CT");
                map.put("HK","AREA_CT");
                map.put("AM","AREA_CT");
 
                newAreasMap = map;
 
            } catch (Exception e) {
                LOG.error("init database [status:error]", e);
                throw e;
            } finally {
                if(dbConn != null) {
                    try {
                        dbConn.close();
                    } catch (SQLException e) {
                        LOG.error("dbConn conn close error!",e);
                    }
                }
 
            }
        }
 
        public static Map<String, String> getNewAreasMap() {
            return newAreasMap;
        }
    }
 
    public static Build build() throws Exception {
        final DbBroadCastListInitUtil.Build build = new DbBroadCastListInitUtil.Build();
        build.reloadRule();
        return build;
    }
 
}

程序入口类

/**
 * @author 大数据江湖
 * @version 1.0
 * @date 2021/4/25.
 * <p>
 * 使用 kafka 输出流和 redis 输出流 进行合并清洗
 * <p>
 * 线上使用的方式
 */
public class 广播方式3使用DB对方式广播 {
    public static void main(String[] args) throws Exception {
 
        //1 获取执行环境
 
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
 
        env.setParallelism(3);//并行度取决于 kafka 中的分区数 保持与kafka 一致
 
        //2 设置 checkpoint
 
        //开启checkpoint 一分钟一次
        env.enableCheckpointing(60000);
        //设置checkpoint 仅一次语义
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        //两次checkpoint的时间间隔
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(5000);
        //最多只支持1个checkpoint同时执行
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
        //checkpoint超时的时间
        env.getCheckpointConfig().setCheckpointTimeout(60000);
        // 任务失败后也保留 checkPonit数据
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
 
        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                3, // 尝试重启的次数
                Time.of(10, TimeUnit.SECONDS) // 间隔
        ));
 
        // 设置 checkpoint 路径
        //env.setStateBackend(new FsStateBackend("hdfs://192.168.123.103:9000/flink/checkpoint"));
 
        //3 设置 kafka Flink 消费
        //创建 Kafka 消费信息
 
        String topic = "data_flink_bigdata_test";
        Properties consumerProperties = new Properties();
        consumerProperties.put("bootstrap.servers", "10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
        consumerProperties.put("group.id", "data_flink_bigdata_test_consumer");
        consumerProperties.put("enable.auto.commit", "false");
        consumerProperties.put("auto.offset.reset", "earliest");
 
        //4 获取 kafka 与 redis 数据源
 
        FlinkKafkaConsumer consumer = new FlinkKafkaConsumer<String>(topic, new SimpleStringSchema(), consumerProperties);
 
        DataStreamSource<String> kafkaSourceData = env.addSource(consumer);
 
        // 获取 redis 数据源并且进行广播  线上的广播也是 source + 广播方法
 
        MapStateDescriptor<String, String> descriptor = new MapStateDescriptor<String, String>(
                "RedisBdStream",
                String.class,
                String.class
        );
 
        //使用 数据库源 来进行广播
 
        BroadcastStream<Map<String, Object>> broadcast = env.addSource(new BigDataDBBroadSource()).broadcast(descriptor);
 
        //5 两个数据源进行 ETL 处理 使用 connect 连接处理  数据库表信息进行广播
 
        SingleOutputStreamOperator<String> etlData = kafkaSourceData.connect(broadcast).process(new MyETLProcessFunction());
 
        //6 新创建一个 kafka 生产者 进行发送
        String outputTopic = "allDataClean";
 
        // 输出给下游 kafka
 
      /*  Properties producerProperties = new Properties();
        producerProperties.put("bootstrap.servers","10.20.7.20:9092,10.20.7.51:9092,10.20.7.50:9092");
 
        FlinkKafkaProducer<String> producer = new FlinkKafkaProducer<>(outputTopic,
                new KeyedSerializationSchemaWrapper<String>(new SimpleStringSchema()),
                producerProperties);
 
        etlData.addSink(producer);*/
 
        etlData.print();
 
        //7 提交任务执行
 
        env.execute("DataClean");
 
    }
 
    /**
     * in 1 kafka source
     * in 2 redis source
     * <p>
     * out 合并后的source
     *
     *
     * TODO 程序启动后发生的事：
     *
     * 1 运行 open 方法 ，触发静态方法给 areasMap 赋值
     * 2 运行 processElement 方法前， areasMap 肯定是值的，正常进行处理
     * 3 当到 BigDataDBBroadSource 轮训的时间后 ，刷新数据库表数据到 areasMap ，此时 areasMap 会加入新值，完成广播变量的更新
     * 4 广播变量更新后 继续进行 processElement 数据处理
     *
     */
    private static class MyETLProcessFunction extends BroadcastProcessFunction<String, Map<String, Object>, String> {
 
        public  Map<String, String> areasMap = new HashMap<String, String>();
 
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
 
            //触发静态方法去赋值
            areasMap = DbBroadCastListInitUtil.areasMap;
 
        }
 
        //逻辑的处理方法 kafka 的数据
        @Override
        public void processElement(String line, ReadOnlyContext readOnlyContext, Collector<String> collector) throws Exception {
            //将 kafka 数据 按 redis 数据进行替换
            // s -> kafka 数据
            //allMap -> redis 数据
            System.out.println("into  processElement ");
            JSONObject jsonObject = JSONObject.parseObject(line);
            String dt = jsonObject.getString("dt");
            String countryCode = jsonObject.getString("countryCode");
            //可以根据countryCode获取大区的名字
            // String area = allDataMap.get(countryCode);
            //从MapState中获取对应的Code
            String area =areasMap.get(countryCode);
 
            JSONArray data = jsonObject.getJSONArray("data");
            for (int i = 0; i < data.size(); i++) {
                JSONObject dataObject = data.getJSONObject(i);
                System.out.println("大区：" + area);
                dataObject.put("dt", dt);
                dataObject.put("area", area);
                //下游获取到数据的时候，也就是一个json格式的数据
                collector.collect(dataObject.toJSONString());
            }
 
        }
 
        @Override
        public void processBroadcastElement(Map<String, Object> value, Context ctx, Collector<String> out) throws Exception {
 
            //广播算子定时刷新后 将数据发送到下游
            if (value != null && value.size() > 0) {
                Object obj = value.getOrDefault("dbsource", null);
                if (obj != null) {
 
                    DbBroadCastListInitUtil.Build biulder = (DbBroadCastListInitUtil.Build) obj;
                    //更新了 数据库数据
                    areasMap = biulder.getNewAreasMap();
                    System.out.println("数据库刷新算子运行完成！");
 
                }
            }
 
        }
    }
 
}

注意看最后处理函数启动后发生的事：

运行 open 方法，触发数据库操作工具类静态方法给 areasMap 赋值
运行执行类 processElement 方法前，此时 areasMap 肯定是值的，正常进行处理
当到数据库源轮训的时间后，刷新数据库表数据到 areasMap ，此时 areasMap 会加入新值，完成广播变量的更新
广播变量更新后继续进行执行类 processElement 数据处理

至此广播程序的使用介绍完了, 对于广播数据不需要改变的情况参考基础样例；对于从缓存或数据库等获取广播变量，同时又需要改变的情况，参考生成样例即可。

PS: 文中代码地址 ---- https://gitee.com/fanpengyi0922/flink-window-broadcast

— THE END —

从 demo 到生产 - 手把手写出实战需求的 Flink 广播程序的更多相关文章

在Seismic.NET下用最少的语句写出一个剖面显示程序
用Seismic.NET开发地震剖面显示程序可以节省大量的时间,下面的代码展开了如何用最少的代码显示一个SEGY文件. // 用一行语句把 reader, pipeline, view 和 plot ...
《重学 Java 设计模式》PDF 出炉了 - 小傅哥，肝了50天写出18万字271页的实战编程资料
作者:小傅哥博客:https://bugstack.cn 沉淀.分享.成长,让自己和他人都能有所收获! @ 目录一.前言二.简介 1. 谁发明了设计模式? 2. 我怎么学不会设计模式? 3. 适 ...
Swing：LookAndFeel 教程第一篇——手把手教你写出自己的 LookAndFeel
本文是 LookAndFeel 系列教程的第一篇. 是我在对 Swing 学习摸索中的一些微薄经验. 我相信,细致看全然系列之后.你就能写出自己的 LookAndFeel. 你会发现 Swing 原来 ...
写出易调试的SQL(修订版)
h4 { background: #698B22 !important; color: #FFFFFF; font-family: "微软雅黑", "宋体", ...
写出易调试的SQL
h4 { background: #698B22 !important; color: #FFFFFF; font-family: "微软雅黑", "宋体", ...
setTimeout和setInterval的区别以及如何写出效率高的倒计时
1.setTimeout和setInterval都属于js中的定时器,可以规定延迟时间再执行某个操作,不同的是setTimeout在规定时间后执行完某个操作就停止了,而setInterval则可以一直 ...
如何用java写出无副作用的代码
搞java的同学们可能对无副作用这个概念比较陌生,这是函数式编程中的一个概念,无副作用的意思就是: 一个函数(java里是方法)的多次调用中,只要输入参数的值相同,输出结果的值也必然相同,并且在这个函 ...
手把手写一个html_json信息源
html_json用于从网页里提取json数据. 这里用新浪读书的书讯举个例子,手把手写一个html_json信息源. 打开新浪读书的首页,可以看到页面下方有最新.书讯.童书.小说等几个Tab,这里我 ...
写出形似QML的C++代码
最开始想出的标题是<Declarative C++ GUI库>,但太标题党了.只写了两行代码,连Demo都算不上,怎么能叫库呢……后来想换掉“库”这个字,但始终找不到合适词来替换.最后还是 ...

随机推荐

1.mysql读写
一.数据库读取(mysql) 参数接受作用默认 sql or table_name string 读取的表名,或sql语句无 con 数据库连接数据库连接信息无 index_col Int ...
python-类的隐藏和封装
7 """ 8 封装是面对对象的三大特征之一(另外两个是集成和多态),它指的是将对象> 的信息隐藏在对象的内部,不允许外部程序直接访问对象内部信息,而是通> ...
Kubernetes 常见问题总结
Kubernetes 常见问题总结如何删除不一致状态下的 rc,deployment,service 在某些情况下,经常发现 kubectl 进程挂起现象,然后在 get 时候发现删了一半,而另外的 ...
Golang学习的方法和建议
学习方法: 学习方向:go方向是没有问题的学习方法:多思考多练习,注重语法和关键词练习,切记哑巴学习,会看不会写,切记注意多写课外学习,数据结构和算法:清华谭浩强老师(链表.数组.排序...等等 ...
我的xshell配色方案,绿色/护眼/留存/备份
[mycolor] text(bold)=e9e9e9 magenta(bold)=ff00ff text=00ff80 white(bold)=fdf6e3 green=80ff00 red(bol ...
一文带大家彻底搞懂Hystrix！
前言? Netflix Hystrix断路器是什么? Netflix Hystrix是SOA/微服务架构中提供服务隔离.熔断.降级机制的工具/框架.Netflix Hystrix是断路器的一种实现,用 ...
SpringBoot 集成测试
一. 测试一般程序(Service/DAO/Util类) 1. 在pom.xml中引入依赖 2. 生成测试类 <1> 如果使用IntelliJ IDEA,可以使用快捷键直接生成: Wind ...
python工业互联网应用实战13—基于selenium的功能测试
本章节我们再来说说测试,单元测试和功能测试.单元测试我们在数据验证章节简单提过了,本章我们进一步如何用单元测试来测试view的功能代码:同时,也涉及一下基于selenium的功能测试做法.笔者过去的项 ...
破解class文件的第一步：深入理解JAVA Class文件
摘要: java定义了一套与操作系统,硬件无关的字节码格式,这个字节码就是用java class文件来表示的,java class文件内部定义了虚拟机可以识别的字节码格式,这个格式是平台无关性的. j ...
Day16_89_通过反射机制获取所有构造方法
通过反射机制获取某个特定的构造方法 * 代码 import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; publ ...

从 demo 到生产 - 手把手写出实战需求的 Flink 广播程序

从 demo 到生产 - 手把手写出实战需求的 Flink 广播程序的更多相关文章

随机推荐

热门专题