Flink实战(Java/MongoDB/Mysql)

于 2024-09-18 13:19:36 发布
阅读量282 收藏 10
点赞数 16
文章标签： flink java mysql mongodb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solutionier/article/details/142250517
版权

Flink安装方式可参考我之前的这篇：

Flink安装(单机模式、Windows)_flink 单机-CSDN博客

一、前言

本文目标：实现分别以流处理和批处理的形式，将MongoDB中的数据处理后存入Mysql

Flink搭配简单Java程序的教程网上很常见，本文不过多赘述。

二、程序设计

1、创建Springboot项目

我用的是Java 8

server url是阿里云，Springboot官方已经不支持Java8

https://start.aliyun.com

2、依赖

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
        <flink-version>1.14.6</flink-version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>${flink-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.12</artifactId>
            <version>${flink-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-base</artifactId>
            <version>${flink-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-jdbc_2.12</artifactId>
            <version>${flink-version}</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
            <optional>true</optional>
        </dependency>
        <!-- mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-mongodb</artifactId>
            <version>1.1.0-1.18</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>2.0.50</version>
        </dependency>

        <!-- Spring Boot Starter MyBatis -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.6</version>
        </dependency>

        <!-- MySQL Driver -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

3、批处理

实现逻辑：将MongoDB中record集合中所有数据取出，将这些数据按天划分，同一天的数据会被存入同一个时间窗口(相当于当天的数据集)，进而根据窗口内的数据计算每日平均、最高、最低温度，并存入Mysql的

3.1 表结构

MongoDB:

数据库名：flink_demo

集合名：record 

数据结构：

实体类

@Data
public class Record {

    /** 设备温度 */
    private Double temperature;

    private Date gatherTime;
}

Mysql

表结构

CREATE TABLE device_temperature (
    id VARCHAR(50) PRIMARY KEY,
    agv DOUBLE NOT NULL,
    max DOUBLE NOT NULL,
    min DOUBLE NOT NULL,
    gather_date VARCHAR(50)
);

实体类

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DeviceTemperature {

    private String id;
    /** 平均值 */
    private Double agv;
    /** 最大值 */
    private Double max;
    /** 最小值 */
    private Double min;
    /** 采集日期 格式yyyy-MM-dd */
    private String gatherDate;
}
3.2 工具类
public class CommonUtil {

    //用于生成id，没生成一个id累加一次
    private static int tag = 0;

    public static String generateId() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        String id = sdf.format(System.currentTimeMillis());
        tag++;
        if (tag > 9999) {
            tag = 0;
        }
        return id + String.format("%04d", tag);
    }
}
3.3 Main方法
public class BatchStatistics {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        MongoDeserializationSchema<Record> deserializationSchema = new MongoDeserializationSchema<Record>() {
            @Override
            public Record deserialize(BsonDocument document) {
                //将从mongodb中获取的数据转为Java对象，用于后续计算
                Record record = new Record();
                record.setTemperature(Double.parseDouble(document.getString("temperature").getValue()));
                record.setGatherTime(new Date(document.getDateTime("gather_time").getValue()));;
                return record;
            }

            @Override
            public TypeInformation<Record> getProducedType() {
                return TypeInformation.of(Record.class);
            }
        };
        MongoSource<Record> mongoSource = MongoSource.<Record>builder()
                .setUri("mongodb://127.0.0.1:27017")  //数据库uri
                .setDatabase("flink_demo") //数据库
                .setCollection("record") //集合
                .setFetchSize(100) //每次从 MongoDB 服务器获取多少文档
                .setLimit(3000000) //最多条数，超出数据不接收处理
                .setNoCursorTimeout(true) //如果设置为 true，MongoDB 游标将不会因长时间未被使用而超时。适用于长时间运行的查询
                .setPartitionStrategy(PartitionStrategy.SAMPLE)
                .setPartitionSize(MemorySize.parse("2GB"))  //每个分区的内存大小
                .setSamplesPerPartition(10) //每个分区中的样品数量
                .setDeserializationSchema(deserializationSchema)
                .build();
        DataStream<Record> sourceStream = env.fromSource(mongoSource, WatermarkStrategy.noWatermarks(), "MongoSource");
        sourceStream
                //把gatherTime用作时间窗口划分标准
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Record>forMonotonousTimestamps()
                                .withTimestampAssigner((record, timestamp) -> record.getGatherTime().getTime())
                )
                //将同一天的数据划分到一个时间窗口
                .windowAll(TumblingEventTimeWindows.of(Time.days(1)))
                .process(new ProcessAllWindowFunction<Record, DeviceTemperature, TimeWindow>() {
                    @Override
                    public void process(ProcessAllWindowFunction<Record, DeviceTemperature, TimeWindow>.Context context, Iterable<Record> elements, Collector<DeviceTemperature> out) {
                        BigDecimal sum = new BigDecimal(0);
                        Double max = null;
                        Double min = null;
                        int size = 0;
                        String gatherDate = null;
                        for (Record element : elements) {
                            if (max == null || max < element.getTemperature()) {
                                max = element.getTemperature();
                            }
                            if (min == null || min > element.getTemperature()) {
                                min = element.getTemperature();
                            }

                            //用BigDecimal计算防止精度丢失
                            sum = sum.add(new BigDecimal(element.getTemperature()));
                            size++;
                            //所有同一天数据被放入同一窗口处理，取第一条数据的时间即可
                            if (gatherDate == null) {
                                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
                                gatherDate = formatter.format(element.getGatherTime());
                            }
                        }
                        double doubleValue = sum.divide(new BigDecimal(size)).doubleValue();
                        DeviceTemperature result = DeviceTemperature.builder()
                                .id(CommonUtil.generateId())
                                .agv(doubleValue)
                                .max(max)
                                .min(min)
                                .gatherDate(gatherDate)
                                .build();
                        out.collect(result);
                    }
                }).addSink(JdbcSink.sink(
                        "INSERT INTO device_temperature (id, agv, max, min, gather_date) \n" +
                                "                        VALUES (?, ?, ?, ?, ?)",
                        (statement, deviceTemperature) -> {
                            // 预编译sql，准备插入mysql
                            try {
                                statement.setString(1, deviceTemperature.getId());
                                statement.setDouble(2, deviceTemperature.getAgv());
                                statement.setDouble(3, deviceTemperature.getMax());
                                statement.setDouble(4, deviceTemperature.getMin());
                                statement.setString(5, deviceTemperature.getGatherDate());
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        },
                        JdbcExecutionOptions.builder()
                                .withBatchSize(1) // 当准备插入的数据量达到batchSize时一起执行插入，或者全部数据处理完毕(流处理时只能等数据量达到batchSize时才执行插入)
                                .build(),
                        new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                                .withUrl("jdbc:mysql://127.0.0.1:3306/flink_demo")
                                .withDriverName("com.mysql.cj.jdbc.Driver")
                                .withUsername("root")
                                .withPassword("123456")
                                .build()
                ));
        env.execute("温度批处理");
    }

}
3.4 测试程序

MongoDB先插入一些示范数据

db.record.insertMany([
  { temperature: "22.5", gather_time: new ISODate("2024-09-16T08:00:00Z") },
  { temperature: "23.0", gather_time: new ISODate("2024-09-16T09:00:00Z") },
  { temperature: "22.8", gather_time: new ISODate("2024-09-16T10:00:00Z") },
  { temperature: "21.9", gather_time: new ISODate("2024-09-16T11:00:00Z") },
  { temperature: "22.2", gather_time: new ISODate("2024-09-16T12:00:00Z") },
  { temperature: "23.1", gather_time: new ISODate("2024-09-17T08:00:00Z") },
  { temperature: "22.7", gather_time: new ISODate("2024-09-17T09:00:00Z") },
  { temperature: "22.9", gather_time: new ISODate("2024-09-17T10:00:00Z") },
  { temperature: "21.8", gather_time: new ISODate("2024-09-17T11:00:00Z") },
  { temperature: "22.3", gather_time: new ISODate("2024-09-17T12:00:00Z") }
]);

执行mian方法 

正常结果是返回0

如果返回非0，则上滚查看 最下面 的那条 红色 异常 信息

正常结束后，Mysql数据表中应当已插入正确数据

3.5 生成jar包

build结束后，生成的jar在之前配置artifacts配置中output directory目录中，默认路径如下图

直接ctrl + shift + c复制文件目录

3.6 提交到Flink

如果上面用ctrl + shift + c复制了文件目录

下面文件名处直接 ctrl + v黏贴后直接打开即可

提交后，点击提交后显示的Job

点击submit

任务开始执行

异常信息可以在下面这里看

system.out.println等控制台输出可以在按下面步骤查看

4、流处理

实现逻辑：当任务运行时(直接运行项目或提交到Flink运行)，每当MongoDB插入数据，任务就能取得这些数据，并放入存放当天数据的窗口，当数据出现第二天数据时(第一天数据收集完毕)，统计计算第一天的平均、最大值、最小值温度值。

大致实现思路相同，本节只说明与批处理不一致的地方。

4.1 代码

本章3.3节 替换为下面的代码

public class MongoChangeStreamSource extends RichSourceFunction<Record> {
    private final String uri;
    private final String database;
    private final String collection;
    private volatile boolean isRunning = true;
    private MongoClient mongoClient;
    private MongoCollection<BsonDocument> mongoCollection;
    private ChangeStreamIterable<BsonDocument> changeStream;

    public MongoChangeStreamSource(String uri, String database, String collection) {
        this.uri = uri;
        this.database = database;
        this.collection = collection;
    }

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        mongoClient = MongoClients.create(uri);
        MongoDatabase mongoDatabase = mongoClient.getDatabase(database);
        mongoCollection = mongoDatabase.getCollection(collection, BsonDocument.class);
        changeStream = mongoCollection.watch();
    }

    @Override
    public void run(SourceContext<Record> ctx) {
        MongoCursor<ChangeStreamDocument<BsonDocument>> cursor = changeStream.iterator();
        while (isRunning && cursor.hasNext()) {
            ChangeStreamDocument<BsonDocument> next = cursor.next();
            synchronized (ctx.getCheckpointLock()) {
                //将从mongodb中获取的数据转为Java对象，用于后续计算
                ctx.collect(deserialize(next.getFullDocument()));
            }
        }
    }

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

    private Record deserialize(BsonDocument document) {
        Record record = new Record();
        record.setTemperature(Double.parseDouble(document.getString("temperature").getValue()));
        record.setGatherTime(new Date(document.getDateTime("gather_time").getValue()));;
        return record;
    }
}
public class StreamStatistics {

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        MongoChangeStreamSource mongoSource = new MongoChangeStreamSource(
                "mongodb://127.0.0.1:27017",
                "flink_demo",
                "record"
        );
        DataStream<Record> sourceStream = env.addSource(mongoSource,"MongoChangeStreamSource");
        sourceStream
                //把gatherTime用作时间窗口划分标准
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Record>forMonotonousTimestamps()
                                .withTimestampAssigner((record, timestamp) -> record.getGatherTime().getTime())
                )
                //将同一天的数据划分到一个时间窗口
                .windowAll(TumblingEventTimeWindows.of(Time.days(1)))
                .process(new ProcessAllWindowFunction<Record, DeviceTemperature, TimeWindow>() {
                    @Override
                    public void process(ProcessAllWindowFunction<Record, DeviceTemperature, TimeWindow>.Context context, Iterable<Record> elements, Collector<DeviceTemperature> out) {
                        BigDecimal sum = new BigDecimal(0);
                        Double max = null;
                        Double min = null;
                        int size = 0;
                        String gatherDate = null;
                        for (Record element : elements) {
                            if (max == null || max < element.getTemperature()) {
                                max = element.getTemperature();
                            }
                            if (min == null || min > element.getTemperature()) {
                                min = element.getTemperature();
                            }

                            //用BigDecimal计算防止精度丢失
                            sum = sum.add(new BigDecimal(element.getTemperature()));
                            size++;
                            //所有同一天数据被放入同一窗口处理，取第一条数据的时间即可
                            if (gatherDate == null) {
                                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
                                gatherDate = formatter.format(element.getGatherTime());
                            }
                        }
                        double doubleValue = sum.divide(new BigDecimal(size)).doubleValue();
                        DeviceTemperature result = DeviceTemperature.builder()
                                .id(CommonUtil.generateId())
                                .agv(doubleValue)
                                .max(max)
                                .min(min)
                                .gatherDate(gatherDate)
                                .build();
                        out.collect(result);
                    }
                }).addSink(JdbcSink.sink(
                        "INSERT INTO device_temperature (id, agv, max, min, gather_date) \n" +
                                "                        VALUES (?, ?, ?, ?, ?)",
                        (statement, deviceTemperature) -> {
                            // 预编译sql，准备插入mysql
                            try {
                                statement.setString(1, deviceTemperature.getId());
                                statement.setDouble(2, deviceTemperature.getAgv());
                                statement.setDouble(3, deviceTemperature.getMax());
                                statement.setDouble(4, deviceTemperature.getMin());
                                statement.setString(5, deviceTemperature.getGatherDate());
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        },
                        JdbcExecutionOptions.builder()
                                .withBatchSize(1) // 当准备插入的数据量达到batchSize时一起执行插入，或者全部数据处理完毕(流处理时只能等数据量达到batchSize时才执行插入)
                                .build(),
                        new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                                .withUrl("jdbc:mysql://127.0.0.1:3306/flink_demo")
                                .withDriverName("com.mysql.cj.jdbc.Driver")
                                .withUsername("root")
                                .withPassword("123456")
                                .build()
                ));
        env.execute("温度流处理");
    }

}
4.2 测试

当任务运行时，MongoDB插入13-14号的数据

db.record.insertMany([
  { temperature: "24.5", gather_time: new ISODate("2024-09-14T08:00:00Z") },
  { temperature: "23.5", gather_time: new ISODate("2024-09-14T09:00:00Z") },
  { temperature: "21.4", gather_time: new ISODate("2024-09-14T10:00:00Z") },
  { temperature: "22", gather_time: new ISODate("2024-09-14T11:00:00Z") },
  { temperature: "22.2", gather_time: new ISODate("2024-09-14T12:00:00Z") },
  { temperature: "23.1", gather_time: new ISODate("2024-09-13T08:00:00Z") },
  { temperature: "20", gather_time: new ISODate("2024-09-13T09:00:00Z") },
  { temperature: "27", gather_time: new ISODate("2024-09-13T10:00:00Z") },
  { temperature: "26.2", gather_time: new ISODate("2024-09-13T11:00:00Z") },
  { temperature: "24.3", gather_time: new ISODate("2024-09-13T12:00:00Z") }
]);

Mysql数据库记录13号的统计信息

继续往MongoDB插入一条15号的数据

db.record.insertMany([
  { temperature: "20", gather_time: new ISODate("2024-09-15T08:00:00Z") }
]);

Mysql数据库记录14号数据

ededddd
关注
58、Flink维表的实战-6种实现方式维表的join
alanchanchn的专栏
01-11 3万+
一、Flink 专栏Flink 专栏系统介绍某一知识点，并辅以具体的示例进行说明。1、Flink 部署系列 本部分介绍Flink的部署、配置相关基础内容。2、Flink基础系列 本部分介绍Flink 的基础部分，比如术语、架构、编程模型、编程指南、基本的datastream api用法、四大基石等内容。3、Flik Table API和SQL基础系列 本部分介绍Flink Table Api和SQL的基本用法，比如Table API和SQL创建库、表用法、查询、窗口函数、catalog等等内容。4、Flik
最新版Flink CDC MySQL同步MySQL（一）
热门推荐
hello.reader
07-05 1万+
Flink CDC 是Apache Flink ®的一组源连接器，使用变更数据捕获 (CDC) 从不同数据库中获取变更。Apache Flink 的 CDC Connectors集成 Debezium 作为捕获数据更改的引擎。所以它可以充分发挥 Debezium 的能力。
FlinkCDC将MySQL接入Doris实战
wangleigiser的博客
09-05 4559
FlinkCDC将MySQL接入Doris MySQL安装 Doris安装 Scala环境安装 Flink 环境安装 通过Flink CDC将MySQL数据同步到Doirs任务编写 1. 《图解Spark 大数据快速分析实战（异步图书出品）》 2. 《Offer来了：Java面试核心知识点精讲（第2版）(博文视点出品)》 3. 《Offer来了：Java面试核心知识点精讲（原理篇）(博文视点出品)》 4. 《Offer来了：Java面试核心知识点精讲（框架篇）(博文视点出品)》
RichSinkFunction 在 Flink IoT 项目中的应用实战
大模型大数据攻城狮的专栏
06-14 762
在 Flink 中，SinkFunction 是用于将数据流输出到外部系统的函数。与普通 SinkFunction 不同，RichSinkFunction 提供了更多的功能和灵活性。它允许用户访问 Flink 运行时的上下文信息，如状态管理、计时器和广播变量等。此外，RichSinkFunction 还可以处理异步 I/O 操作，提高数据输出的效率。
flink增量检查点降低状态依赖实现的详细步骤
goTsHgo的博客
09-11 1326
使用 Memcached 进行状态管理是一种灵活且高效的方法，尤其适用于频繁访问但不需要持久化的状态。通过将状态存储在 Memcached 中，Flink 作业可以减少本地状态存储的压力，并且通过外部缓存提高状态访问的速度。在实际应用中，需要根据业务需求调整 Memcached 的使用策略，以确保系统的高效性和可靠性。效果提高频繁访问状态的效率，减少状态恢复时间。通过状态拆分和外部化，可以显著降低 Flink 状态的恢复时间和存储压力。
Flink底层核心
Casual_Lei的博客
09-11 1062
Flink 将批处理视为有界的流处理，而流处理则是无界的数据处理。通过这种统一模型，Flink 能够有效地处理不同类型的数据任务。Flink 提供了严格的"精确一次"处理语义，确保在发生故障时，数据不会被重复处理或丢失。事件时间是 Flink 支持的时间语义，它根据事件发生的时间戳来处理数据。Flink 处理的数据流可能会依赖于中间状态（例如计算窗口聚合、join 或带状态的函数），这时状态管理显得尤为重要。JobManager 是 Flink 集群的控制中心，负责调度、管理和协调整个作业的执行。
Apache Doris Flink Connector 24.0.0 版本正式发布
SelectDB
09-11 639
亲爱的社区伙伴们，Apache Doris Flink Connector 24.0.0 版本已于 2024 年 9 月 5 日正式发布。该版本新增了对 Flink 1.20 的支持，并支持通过高速读取 Doris 中数据。此外，整库同步所依赖的 FlinkCDC，也需升级至 3.1.x 版本，以便更好的应用。
Flink 实现无界流
qq_41519442的博客
09-15 284
ExecutionEnvironment 是批处理的方式，DataSource会慢慢被淘汰。Flink 实现无界流。
大数据Flink（一百一十六）：Flink SQL的时间属性
Lansonli（蓝深李）的博客
09-10 1933
以事件时间举个例子，如果只是数据携带了时间，Flink 也消费了这个数据，但是在 Flink 中没有使用数据的这个时间作为计算的触发条件，也不能把这个 Flink 任务叫做事件时间的任务。：举个例子，比如用户可以自定义每隔 10s 的本地时间，或者消费到的数据的时间戳每增大 10s，就把计算结果输出一次，时间在此类应用中也是一种标识任务进度的作用。事件时间：指的是数据本身携带的时间，这个时间是在事件产生时的时间，而且在 Flink SQL 触发计算时，也使用数据本身携带的时间。它是时间的最简单概念。
Java-网络
2301_81543552的博客
09-14 706
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 633
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 287
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1149
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 729
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 664
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
Gradle
xiaocaij_icai的博客
09-15 195
");
Java8的Optional简介
最新发布
duke_ding2的博客
09-17 531
Java8的Optional简介
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 981
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
java.lang.NoClassDefFoundError: org/apache/flink/api/java/typeutils/ResultTypeQueryable
05-26
这个错误通常是由于 Flink 版本不兼容导致的。可能是您的代码使用了一个较新版本的 Flink API，而您的 Flink 运行时环境使用的是一个较旧的版本。 您可以尝试更新您的 Flink 运行时环境，或者查看您的代码中是否有指定依赖项版本的地方。另外，您可以在运行时查看 Flink 版本是否正确，确保代码和 Flink 版本一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值