java Flink（四十一）Flink+avro+广播流broadcast实现流量的清洗

已于 2024-03-08 17:08:04 修改
阅读量635 收藏 9
点赞数 9
分类专栏： Java Flink 文章标签： flink 大数据 网络
于 2024-02-29 20:40:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40771567/article/details/136379911
版权

背景简介

本文简单模拟对流量的处理，大概步骤如下：

1、通过获取一个维度流，内容是流量内容的元数据信息，获取解析并进行广播

2、获取实时流量流，做延迟处理（防止数据关联不上）

3、流量流关联元数据广播流，通过元数据信息获取对应的数据

4、打包成avro格式（自行百度）数据并进行sink

代码开发

1、pom引入

flink版本1.14

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>FlinkCode</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <jdk.version>1.8</jdk.version>
        <jar.name>ubs-data-converter</jar.name>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--Flink 版本-->
        <flink.version>1.14.4</flink.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.kafka</groupId>
                    <artifactId>kafka-clients</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-runtime-web_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.avro</groupId>
                <artifactId>avro-maven-plugin</artifactId>
                <version>1.9.2</version>
                <executions>
                    <execution>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>schema</goal>
                        </goals>
                        <configuration>
                            <sourceDirectory>${project.basedir}/src/main/resources/</sourceDirectory>
                            <outputDirectory>${project.basedir}/src/main/java/com/msxf</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.1.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>${jar.name}</finalName>
                            <artifactSet>
                                <excludes>
                                    <exclude>com.google.code.findbugs:jsr305</exclude>
                                    <exclude>org.slf4j:*</exclude>
                                    <exclude>log4j:*</exclude>
                                    <exclude>org.glassfish.jersey.core:jersey-common</exclude>
                                </excludes>
                            </artifactSet>
                            <relocations>
                                <relocation>
                                    <pattern>com.google.common</pattern>
                                    <shadedPattern>com.shade.google.common</shadedPattern>
                                </relocation>
                                <relocation>
                                    <pattern>org.apache.kafka</pattern>
                                    <shadedPattern>org.shade.apache.kafka</shadedPattern>
                                </relocation>
                            </relocations>
                            <filters>
                                <filter>
                                    <artifact>*</artifact>
                                    <includes>
                                        <include>org/apache/htrace/**</include>
                                        <include>org/apache/avro/**</include>
                                        <include>com/msxf/**</include>
                                        <include>org/apache/flink/streaming/**</include>
                                        <include>org/apache/flink/connector/**</include>
                                        <include>org/apache/kafka/**</include>
                                        <include>org/apache/hive/**</include>
                                        <include>org/apache/hadoop/hive/**</include>
                                        <include>org/apache/curator/**</include>
                                        <include>org/apache/zookeeper/**</include>
                                        <include>org/apache/jute/**</include>
                                        <include>org/apache/thrift/**</include>
                                        <include>org/apache/http/**</include>
                                        <include>org/I0Itec/**</include>
                                        <include>jline/**</include>
                                        <include>com/yammer/**</include>
                                        <include>kafka/**</include>
                                        <include>org/apache/hadoop/hbase/**</include>
                                        <include>com/alibaba/fastjson/**</include>
                                        <include>org/elasticsearch/action/**</include>
                                        <include>io/confluent/**</include>
                                        <include>com/fasterxml/**</include>
                                        <include>org/elasticsearch/**</include>
                                        <include>hbase-default.xml</include>
                                        <include>hbase-site.xml</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.apache.hadoop.hive.*:*</artifact>
                                    <excludes>
                                        <exclude></exclude>
                                        <exclude></exclude>
                                        <exclude></exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

2、模拟元数据流

正常数据流应该通过其他方式（比如访问数据库、KAFKA流）获取，本次我们直接自定义source

package source;

import org.apache.flink.streaming.api.functions.source.RichSourceFunction;


public class StringSource extends RichSourceFunction<String> {

    Boolean running = true;
    @Override
    public void run(SourceContext ctx) throws Exception {
        while (running){
            String value = String.format("{\"data\":[{\"name\":\"id\",\"comment\":\"ID\"}" +
                    ",{\"name\":\"age\",\"comment\":\"年龄\"}" +
                    ",{\"name\":\"sex\",\"comment\":\"性别\"}]}");
            ctx.collect(value);
            running=false;
        }
    }

    @Override
    public void cancel() {
        running=false;
    }
}

3、模拟流量流

模拟流量数据，本身也是通过KAFKA获取实时流量数据，本文是简单Demo，所以也通过自定义Source获取

package source;

import org.apache.flink.streaming.api.functions.source.RichSourceFunction;

import java.util.Arrays;
import java.util.List;
import java.util.Random;


public class FlowSourceFunction extends RichSourceFunction<String> {

    Boolean running=true;

    private final List<String> USERS = Arrays.asList("张三","李四","牛二");

    private final List<String> BEHAVIOR = Arrays.asList("login", "out", "delete");

    private final List<String> SEX = Arrays.asList("男", "女");

    Random random = new Random();

    @Override
    public void run(SourceContext<String> ctx) throws Exception {
        while (running){
            String id = USERS.get(random.nextInt(USERS.size()));
            String age = String.valueOf(random.nextInt(100));
            String sex = SEX.get(random.nextInt(SEX.size()));
            String time = String.valueOf(System.currentTimeMillis());
            String res = String.format("{\"id\":\"%s\"," +
                    "\"age\":\"%s\"," +
                    "\"sex\":\"%s\"," +
                    "\"time\":\"%s\"}",id,age,sex,time);
            ctx.collect(res);
            Thread.sleep(1000);
        }
    }

    @Override
    public void cancel() {
        running=false;
    }
}

4、MapFunction处理元数据信息

处理元数据信息

package func;

import bean.SchemaInfo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.avro.Schema;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.avro.SchemaBuilder;
import org.apache.flink.util.StringUtils;

import java.util.HashSet;
import java.util.stream.Stream;


public class MetaDataMapFunction extends RichMapFunction<String,SchemaInfo> {

    private String db;
    private String table;

    private final String NAME="name";

    public MetaDataMapFunction(String db, String table) {
        this.db = db;
        this.table = table;
    }

    @Override
    public SchemaInfo map(String value) throws Exception {
        String[] aliases = {db.concat(".").concat(table)};
        //存储fields
        HashSet<Object> fieldsSet = new HashSet<>();
        //schema支持多种类型，这里我们选择构建常见的record类型
        //初始化结果:
        //{"type":"record","name":"flow","namespace":"com.flow","doc":"fow_event","fields":[],"aliases":["db.table"]}
        SchemaBuilder.RecordBuilder<Schema> recordBuilder = SchemaBuilder.record("flow").namespace("com.flow").aliases(aliases).doc("fow_event");
        //初始化之后要完善schema中的fields,首先获取fields
        SchemaBuilder.FieldAssembler<Schema> fields = recordBuilder.fields();
        //处理元数据流
        JSONObject obj = JSON.parseObject(value);
        //过滤掉不包含ID的数据
        Stream<JSONObject> data= obj.getJSONArray("data").stream().filter(
                o -> !StringUtils.isNullOrWhitespaceOnly(JSON.parseObject(o.toString()).getOrDefault(NAME, "").toString())
        ).map(o->JSONObject.parseObject(o.toString()));
        data.forEach(
                o->{
                    String name = o.get("name").toString();
                    String comment = o.get("comment").toString();
                    buildFields(fields,name,comment);
                    fieldsSet.add(name);
                }
        );
        Schema schema = fields.endRecord();
        return new SchemaInfo(schema.toString(),fieldsSet);
    }

    public void buildFields(SchemaBuilder.FieldAssembler<Schema> fields,String name,String comment){
        fields.name(name)//字段名称
                .doc(comment)//描述内容、注释
                .orderAscending()//排序方式无
                .type()//类型
                .optional()
                .stringType();
    }
}

定义返回对象

package bean;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.HashSet;



@Data
@AllArgsConstructor
public class SchemaInfo {
    public String info;

    public HashSet set;

}

5、延迟处理主流（流量流）

package func;

import com.alibaba.fastjson.JSON;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.configuration.Configuration;

/**
 * 
 * 1、延时map的初始化，阻塞主流数据，等待广播流schema写入广播状态，保证主流数据可以获取到schema
 * 2、标准化数据
 */
public class DelayEtlMap extends RichMapFunction<String,String> {

    private final long delayTime;

    public DelayEtlMap(long delayTime) {
        this.delayTime = delayTime;
    }

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        Thread.sleep(delayTime);
    }

    @Override
    public String map(String value) throws Exception {
        return value;
    }
}

6、双流关联，处理数据

package func;

import bean.FlowData;
import bean.SchemaInfo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.state.BroadcastState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.state.ReadOnlyBroadcastState;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.streaming.api.functions.co.BroadcastProcessFunction;
import org.apache.flink.util.Collector;

import java.text.SimpleDateFormat;
import java.util.HashMap;

/**
 * 
 * processElement 处理业务流数据
 * processBroadcastElement 处理广播流数据
 */
public class FlowBrodCastFunction extends BroadcastProcessFunction<String, SchemaInfo, FlowData> {

    @Override
    public void processElement(String value, BroadcastProcessFunction<String, SchemaInfo, FlowData>.ReadOnlyContext ctx, Collector<FlowData> out) throws Exception {
        ReadOnlyBroadcastState<String, SchemaInfo> flowMetaData = ctx.getBroadcastState(new MapStateDescriptor<String, SchemaInfo>(
                "flowMetaData"
                , TypeInformation.of(String.class)
                , TypeInformation.of(SchemaInfo.class)));
        SchemaInfo schema = flowMetaData.get("schema");
        JSONObject jsonObject = JSON.parseObject(value);
        Long time = jsonObject.getLong("time");
        //创建时间格式
        SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
        String dt = yyyyMMdd.format(time);
        //获取元数据字段
        HashMap<String, String> map = new HashMap<>();
        schema.getSet().forEach(
                o->{
                    map.put(o.toString(),jsonObject.get(o).toString());
                }
        );
        out.collect(new FlowData(schema.getInfo(),map,time));
    }

    @Override
    public void processBroadcastElement(SchemaInfo value, BroadcastProcessFunction<String, SchemaInfo, FlowData>.Context ctx, Collector<FlowData> out) throws Exception {
        if(value != null){
            BroadcastState<String, SchemaInfo> flowMetaData = ctx.getBroadcastState(new MapStateDescriptor<String, SchemaInfo>(
                    "flowMetaData"
                    , TypeInformation.of(String.class)
                    , TypeInformation.of(SchemaInfo.class)));
            flowMetaData.put("schema", value);
        }
    }
}

FlowData对象

package bean;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.HashMap;


@Data
@AllArgsConstructor
public class FlowData {
    public String schema;

    public HashMap<String, String> values;

    private long time;
}

7、主代码

package ubs.app;

import bean.FlowData;
import bean.SchemaInfo;
import func.DelayEtlMap;
import func.FlowBrodCastFunction;
import func.FlowSinkFunction;
import func.MetaDataMapFunction;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.datastream.BroadcastStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.StringUtils;
import source.FlowSourceFunction;
import source.StringSource;

import java.util.Objects;


public class FlowApp {
    public static void main(String[] args) throws Exception{
        //解析参数
        ParameterTool parameterTool = ParameterTool.fromArgs(args);
        //获取参数 db
        String db = parameterTool.get("db")==null?"":parameterTool.get("db");
        //获取参数 table
        String table = parameterTool.get("table")==null?"":parameterTool.get("table");
        //初始化环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //模拟元数据流，后续获取到元数据进行广播
        DataStreamSource<String> configSource = env.addSource(new StringSource());
        //设置并行度
        configSource.setParallelism(1);
        //获取实时流量数据流:kafka source
//        KafkaSource<String> source = SourceGetter.getValueOnlySimpleStrDesSource(parameterTool);
//        DataStreamSource<String> realData = env.fromSource(source, WatermarkStrategy.noWatermarks(), "liuliang");
        DataStreamSource<String> realData = env.addSource(new FlowSourceFunction());
        realData.print("realData: ");
//        //处理元数据并广播：将元数据流接收并处理为schema
        BroadcastStream<SchemaInfo> metaData = configSource.filter(data -> !StringUtils.isNullOrWhitespaceOnly(data))
                .setParallelism(1)
                .map(new MetaDataMapFunction("a", "b"))
                .broadcast(new MapStateDescriptor<String, SchemaInfo>(
                        "flowMetaData"
                        , TypeInformation.of(String.class)
                        , TypeInformation.of(SchemaInfo.class)
                ));
        //延迟主流
        SingleOutputStreamOperator<String> realData2 = realData.map(new DelayEtlMap(1000))
                .filter(Objects::nonNull);
        //连接流，解析数据
        SingleOutputStreamOperator<FlowData> res = realData2.connect(metaData).process(new FlowBrodCastFunction());
        res.addSink(new FlowSinkFunction());
        res.print("res");
        env.execute();
    }
}

小菜菜1223
关注
专栏目录
Apache Flink 和 Apache Kafka 两者之间的集成架构 Flink and Apache Kafka: A Winning Partnership
AI天才研究院
07-17 1664
作者：禅与计算机程序设计艺术 Apache Flink 和 Apache Kafka 是构建可靠、高吞吐量和低延迟的数据管道（data pipeline）的两个著名的开源项目。2019年4月，两者宣布合作共赢。在这次合作中，Apache Kafka 将提供强大的消息存储能力、Flink 将作为一个分布式数据流处理平台来对其进行实时计算和分
Apache Flink 各项核心特性，与其它大数据引擎的优势比较
AI天才研究院
07-27 1129
2020年是Apache Flink诞生的一年，Flink被国内多个大公司和金融机构采用。截至目前，Apache Flink已覆盖了五个主要的云服务平台，并于2021年7月发布1.12版，面向生产环境的稳定运行速度得到了保证。它是一个开源的分布式流处理框架，具有高容错性、可靠性、低延迟等特征，能够支持实时计算场景下的超大数据量、高吞吐量的数据处理需求。技术选型标准：无论是开源还是商用版本，Apache Flink都已经成为多家大厂领跑者之一。
java Flink（三十三）Flink的广播流状态实例
qq_40771567的博客
07-20 1205
实例介绍： 广播状态在双流的应用，其中一个流当做另一个流的状态。 DEMO： import org.apache.flink.api.common.state.MapStateDescriptor; import org.apache.flink.api.common.typeinfo.BasicTypeInfo; import org.apache.flink.configuration.Configuration; import org.apache.flink.streaming.api.da
Flink广播状态清理
Johnson8702的博客
04-06 2121
在Flink实时计算的实际项目中，广播中的状态，可能并不是需要一直存在，只需要当天存在，之后不再会用到。 这种情况下，如果状态数据一直不清理，量会越来越庞大，占用内存，时间长，甚至会导致内存溢出。所以需要对过期的广播状态进行清理。 但是状态过期清理的机制，目前仅是对keyed state来说的有效，对广播状态不起作用。因此，需要自己手动去处理。 按照flink keyed state过期处理的思想，手动实现对过期的广播状态的清理；主要逻辑如下： （1）广播状态设置一个状态，专门存储一个时间戳毫秒值，通
Flink消费Avro格式数据 - java
Hermes333的博客
12-25 601
把生成的pojo 放入项目中，在进行调用时，会调用其内部的一个方法 .getSchema() ，其本质就是 avsc文件里的内容，进行解析，封装成schema。这里的 io.transwarp.de.bean 是生成的bean的路径，要提前想好 bean要放哪，不然改起来很麻烦。上游数据被封装为confluenAvro 格式，使用flink 进行消费，avro 使用版本 1.10.1。使用avro-tool 进行pojo 生成。genericRecord 可看成map。
Flink 广播变量Broadcast 代码
BF-Lone Silver Wind 的博客
01-17 358
package com.xxxxx.flink.batch; import org.apache.flink.api.common.functions.RichFilterFunction; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataS...
基于flink broadcast实现目标用户的智能筛选
qq_44962429的博客
08-19 510
1、broadcast简介 支持Operator State的第三种类型是广播状态，其中需要将来自一个流的某些或者全部数据广播到所有下游任务，广播的状态将存储在本地，用于处理另一个流上所有传入的元素。 2、API使用 博主分享两个案例分别描述key_broadcast和nonKeyed_broadcast。 需求描述：某电商系统，需要通过监控用户的浏览记录，根据不同商品的营销活动规则，筛选出目标用户，实现促销。 案例一： nonKeyed_broadcast (1) 实体类准备 package com.le
Flink - Java篇
热门推荐
.
02-28 1万+
文章目录前言一、概述1 Flink是什么2 架构分层3 数据处理流水线4 运行组件TaskManagerJobManagerResourceManagerDispatcher5 其他流式计算框架二、入门与使用1 Flink基本安装1.1 Linux1.2 Java1.3 Scala（待补充）1.4 集群模式2 常用API2.1 DataStream 流处理DataSourceTransformationSink示例一：自定义数据源（SourceFunction）示例二：自定义分区示例三：Socket通信示例
Flink入门及实战-下.pptx
09-23
#### 四、Flink Broadcast、Accumulators、Counters 和 Distributed Cache - **Broadcast**：允许将少量数据广播到所有并行任务，用于共享只读数据。 - **Accumulators**：用于收集和汇总全局任务状态，如计数器、...
flink-training-exercises
04-23
Apache Flink是一个流行的开源流处理框架，用于实时和批处理数据。Flink Training Exercises是针对想要深入了解Flink功能和操作的开发者的宝贵资源。这个存储库包含了一系列的练习，涵盖了从基本操作到复杂数据处理...
flink学习之广播流与合流操作demo
cclovezbf的博客
09-06 709
比如lol，每天不断有人再投诉举报，客服根本忙不过来，腾讯内部做了一个判断，只有vip3以上的客户的投诉才会有人工一对一回复，过了一段时间大家都发现vip3才有人工，都开始充钱到vip3，此时人还是很多，于是只有vip4上的客户才能人工回复。demo思想：以上述vip做例子，获取用户不断投诉的id和vip等级， 数据库保存可以享受人工服务的vip等级，该等级可以自行调整(我是随着时间变化主键增大)。但是task10 task9都还是vip=0 ，说明流没有广播，除非此处并行度设置为1。
Flink实现自定义Avro序列化(Source/Sink)到kafka 详解
chenshun123的博客
06-13 2372
Flink实现自定义Avro序列化(Source/Sink)到kafka
Flink解决广播配置流滞后数据流的问题
on the way . . .
09-02 3857
【代码】Flink解决广播配置流滞后数据流的问题。
Flink的广播流状态实例
cts618
07-11 706
Flink的广播流状态实例
Flink专题七：Flink 中广播流之BroadcastStream
beyond的博客
03-24 7395
由于工作需要最近学习flink 现记录下Flink介绍和实际使用过程 这是flink系列的第七篇文章 Flink 中广播流之BroadcastStream使用场景使用案例数据流和广播流connect方法BroadcastProcessFunction 和 KeyedBroadcastProcessFunction重要注意事项 使用场景 背景： 我们定义两个流，一个流包含图形（Item），具有颜色和形状两个属性。 另一个流包含特定的规则（Rule），代表希望寻找的模式。 在图形流中，我们需要首先使用颜.
Flink广播流 BroadcastStream
最新发布
老码农的博客
03-14 3487
Flink中的广播流（BroadcastStream）是一种特殊的流处理方式，它允许将一个流（通常是一个较小的流）广播到所有的并行任务中，从而实现在不同任务间共享数据的目的。广播流在处理配置信息、小数据集或者全局变量等场景下特别有用，因为这些数据需要在所有任务中保持一致且实时更新。定义MapStateDescriptor：首先需要定义一个MapStateDescriptor来描述要广播的数据的格式。这个描述器指定了数据的键值对类型。创建广播流：然后，需要将一个普通的流转换为广播流。这通常通过调用流的。
分享一个较全的Flink maven依赖文件
Black_8的博客
08-07 3039
使用的是 scala 版本的flink （flink1.11.0）依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.v
一个非常好的编译Flink的Maven mirrors
橙心橙意橙续缘的博客
01-10 615
<mirror> <id>nexus-aliyun</id> <mirrorOf>*,!jeecg,!jeecg-snapshots,!mapr-releases</mirrorOf> <name>Nexus aliyun</name> <ur...
Flink广播流(BroadcastStream)实例 简单易懂
weixin_44651989的博客
04-02 2759
import java.text.SimpleDateFormat import org.apache.flink.api.common.state.MapStateDescriptor import org.apache.flink.api.common.typeinfo.BasicTypeInfo import org.apache.flink.api.scala._ import org.a...
Flink CDC教程：全量+增量流批一体化处理详解
本视频教程深入解析了大数据技术中的Flink CDC，它是一种由Flink社区开发的关键组件Flink-cdc-connector。该组件专为从诸如MySQL、PostgreSQL等关系型数据库中高效地获取全量数据和增量变化数据而设计。Flink CDC的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值