快速入门Flink(7)——Flink中的流式处理DataSource与DataSinke

最新推荐文章于 2024-07-10 09:09:08 发布
最新推荐文章于 2024-07-10 09:09:08 发布
阅读量5.4k 收藏 6
点赞数 54
分类专栏： Flink 文章标签： Flink 批处理 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43791724/article/details/108696535
版权

在这里插入图片描述
        前几篇文章给大家讲解了个关于Flink批处理相关的技术点，今天给大家将讲解下关于流式处理的DataSource与DataSink ☛（Flink专辑）

一、入门案例

使用Flink的流式处理来计算wordCount
实现步骤：

  1. 获取Flink批处理运行环境
  2. 构建一个socket源
  3. 使用Flink操作进行单词统计
  4. 打印

说明：如果 linux 上没有安装 nc 服务 ,使用 yum 安装

yum install -y nc

参考代码:

import org.apache.flink.streaming.api.scala._
/**
 * @author 流处理wordCount
 * @date 2020/8/26 22:03
 * @version 1.0
 */
 object StreamWordCount{
  def main(args: Array[String]): Unit = {
    //1.构建流处理的运行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.使用socket来接收数据
    val socketData: DataStream[String] = env.socketTextStream("node01", 9999)
    //3.对数据进行切分将每个单词获取出来后面加1 使用keyBy进行分组使用sum进行求核
    val result = socketData.flatMap(_.split(" ")).map((_, 1)).keyBy(0).sum(1)
    //4.将结果输出并启动
    result.print("批处理wordCount")
    env.execute("批处理wordCount")
  }
}

二、Flink 在流处理上常见的 Source

注意：Flink 在流处理上常见的 Source ，Flink 在流处理上的 source 和在批处理上的 source 基本一致。

2.1 基本地集合的source

我在这就不给大家一一介绍了，我在这里给大家入门，想学习更多关于本地的Data Source请看☛DataSource

import org.apache.flink.streaming.api.scala._
/**
 * @author
 * @date 2020/9/20 18:57
 * @version 1.0
 */
object StreamDataSource {
  def main(args: Array[String]): Unit = {
   //1.构建流处理运行环境
   val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.使用fromCollection 构建数据集
    val data = env.fromCollection(List("张三", "李四", "王五"))
   //3.输出
    data.print()
    env.execute("StreamDataSource")
  }
}
2.2 基本地文件的Source

import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/20 19:05
 * @version 1.0
 */
object StreamFileSource {
  def main(args: Array[String]): Unit = {
    //1.构建流处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.使用文件构建数据集
    val dataSource = env.readTextFile("./data/wordcount.txt")
    //3.打印
    dataSource.print()
    env.execute("StreamFileSource")
  }
}
2.3 自定义Source

        除了预定义的 Source 外，我们还可以通过实现 SourceFunction 来自定义 Source，然 后通过 StreamExecutionEnvironment.addSource(sourceFunction)添加进来。 比如读取 Kafka 数据的 Source： addSource(new FlinkKafkaConsumer08<>); 我们可以实现以下三个接口来自定义 Source：

2.3.1 SourceFunction：创建非并行数据源
import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.scala._
/**
 * @author
 * @date 2020/9/20 19:22
 * @version 1.0
 */
object StreamCustomerNoParallelSource {
  def main(args: Array[String]): Unit = {
    //1.构建流式处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.使用自定义数据流
    val dataSource = env.addSource(new MyNoParallel()).setParallelism(1)
    //3.打印
    dataSource.print()
    //4.执行程序
    env.execute("StreamCustomerNoParallelSource")
  }
  class MyNoParallel() extends SourceFunction[Long] {
    // 定义一个变量
    var number: Long = 1L
    var isRunning: Boolean = true
    override def run(sourceContext: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning) {
        sourceContext.collect(number)
        number += 1
        Thread.sleep(1000)
        if (number == 10) {
          cancel()
        }
      }
    }
    override def cancel(): Unit = {
      isRunning = false
    }
  }
}
2.3.2 ParallelSourceFunction：创建并行数据源。
import org.apache.flink.streaming.api.functions.source.{ParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/20 20:40
 * @version 1.0
 */
object StreamCustomerParallelSource {
  def main(args: Array[String]): Unit = {
    //1.构建流处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.基于自定义ParallelSource数据源创建并行的数据
    val source = env.addSource(new MyParallelSource()).setParallelism(1)
    //3.打印输出
    source.print()
    //4.执行任务
    env.execute("StreamCustomerParallelSource")
  }

  class MyParallelSource() extends ParallelSourceFunction[Long] {
    //1.定义一个Long类型的变量
    var number: Long = 1L
    //2.定义一个变量
    var isRunning: Boolean = true

    override def run(sourceContext: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning) {
        sourceContext.collect(number)
        number += 1
        if (number > 20) {
          cancel()
        }
      }
    }

    override def cancel(): Unit = {
      isRunning = false
    }
  }
}
2.3.3 RichParallelSourceFunction：创建并行数据源。
import org.apache.flink.streaming.api.functions.source.{RichParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/20 20:48
 * @version 1.0
 */
object StreamCustomerRichParallelSource {
  def main(args: Array[String]): Unit = {
    //1.构建流式处理数据集
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.基于RichParallelSource并行数据源构建数据集
    val dataSource = env.addSource(new RichParallelSource()).setParallelism(2)
    dataSource.map(line=>{
      println("接收到的数据：" + line)
      line
    })
    env.execute("StreamCustomerRichParallelSource")
  }
  class RichParallelSource() extends RichParallelSourceFunction[Long]{
    //1.定义一个Long类型的变量
    var number: Long = 1L
    //2.定义一个变量
    var isRunning: Boolean = true
    override def run(sourceContext: SourceFunction.SourceContext[Long]): Unit = {
      while (isRunning) {
        sourceContext.collect(number)
        number += 1
        Thread.sleep(1000)
        if (number > 20) {
          cancel()
        }
      }
    }
    override def cancel(): Unit = {
      isRunning=false
    }
  }
}
2.3.4 基于 kafka 的 source 操作

在这里我就不过多讲解了关于Kafka的常用的命令，如果想学的可以点击-> kfka常用的操作

代码示例：

import java.util.Properties
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011

/**
 * @author 消费kafka中的数据
 * @date 2020/9/21 22:53
 * @version 1.0
 */
object StreamKafkaSource {
  def main(args: Array[String]): Unit = {
    //1.构建流处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.指定消费主题
    var topic = "FlinkAsKafka"
    //2.1设置配置信息
    val porps = new Properties()
    porps.setProperty("bootstrap.servers", "node01:9092,node02:9092,node03:9092")
    porps.setProperty("group.id", "test01")
    porps.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    porps.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    //3.基于Flink构建kafka消费者
    val kafka = new FlinkKafkaConsumer011[String](topic, new SimpleStringSchema(), porps)
    //4.设置Flink层最新的数据开始消费
    kafka.setStartFromLatest()
    //5.基于kafka构建数据源
    val data = env.addSource(kafka)
    //6.打印输出
    data.print()
    env.execute("StreamKafkaSource")
  }
}
2.3.5 基于 mysql 的 source 操作

上面就是 Flink 自带的 Kafka source，那么接下来就模仿着写一个从 MySQL 中读取数据 的 Source。


import java.sql.{Connection, DriverManager, PreparedStatement}

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

/**
 * @author 基于MySQL的source操作
 * @date 2020/9/21 23:17
 * @version 1.0
 */
object StreamFromMysqlSource {

  case class User(id: String, user_id: String, user_name: String, phone: String, lan_id: String, region_id: String)


  def main(args: Array[String]): Unit = {
    //1.创建流式执行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.添加自定义mysql数据源
    val source = env.addSource(new MySqlSource())
    //3.输出
    source.print()
    //4.任务执行
    env.execute("StreamFromMysqlSource")
  }

  class MySqlSource() extends RichSourceFunction[User] {
    //1.声明Connection对象
    var connection: Connection = null
    //2.声明 PreparedStatement 对象
    var ps: PreparedStatement = null

    override def open(parameters: Configuration): Unit = {
      var driver = "com.mysql.jdbc.Driver"
      var url = "jdbc:mysql://node01:3306/datax_web"
      var username = "root"
      var password = "123456"
      Class.forName(driver)
      connection = DriverManager.getConnection(url, username, password)
      var sql =
        """
          |SELECT id,user_id,user_name,phone,lan_id,region_id
          |FROM user
          |""".stripMargin
      ps = connection.prepareStatement(sql)
    }

    override def run(sourceContext: SourceFunction.SourceContext[User]): Unit = {
      val queryResultSet = ps.executeQuery()
      while (queryResultSet.next()) {
        val id = queryResultSet.getString("id")
        val user_id = queryResultSet.getString("user_id")
        val user_name = queryResultSet.getString("user_name")
        val phone = queryResultSet.getString("phone")
        val lan_id = queryResultSet.getString("lan_id")
        val region_id = queryResultSet.getString("region_id")
        sourceContext.collect(User(id, user_id, user_name, phone, lan_id, region_id))
      }
    }

    override def cancel(): Unit = {
      if (connection != null) {
        connection.close()
      }
      if (ps != null) {
        ps.close()
      }
    }
  }

}

三、Flink 常用的DataSink

3.1 将数据 sink 到本地文件
import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/22 22:41
 * @version 1.0
 */
object StreamFileSourceSinkFile {
  def main(args: Array[String]): Unit = {
    //1.构建流式处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.读取本地文件构建数据集
    val data = env.readTextFile("./data/wordcount.txt")
    //3.文件输出
    data.writeAsText("./data/wordcountSink.txt").setParallelism(1)
    //4.开始执行
    env.execute("StreamFileSourceSinkFile")
  }
}
3.2 Sink 到本地集合

import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/22 22:50
 * @version 1.0
 */
object StreamFromCollectionSourceFile {
  def main(args: Array[String]): Unit = {
    //1.构建流处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.使用FromCollection构建数据集
    val data = env.fromCollection(List((1, "张三"), (2, "李四"), (1, "赵刘")))
    //3.将文件输出
    data.writeAsText("./data/fromCollection.txt").setParallelism(1)
    //4.执行任务
    env.execute("StreamFromCollectionSourceFile")
  }
}
3.3 Sink将数据 到 HDFS

import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/22 22:41
 * @version 1.0
 */
object StreamFileSourceSinkFileHDFS {
  def main(args: Array[String]): Unit = {
    //1.构建流式处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.读取本地文件构建数据集
    val data = env.readTextFile("./data/wordcount.txt")
    //3.文件输出
    data.writeAsText("hdfs://node01:8020/data/wordcountSink.txt").setParallelism(1)
    //4.开始执行
    env.execute("StreamFileSourceSinkFile")
  }
}
3.4 Sink将数据 到 Kafka
import java.util.Properties
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.{FlinkKafkaConsumer011, FlinkKafkaProducer011}

/**
 * @author
 * @date 2020/9/22 23:17
 * @version 1.0
 */
object StreamKafkaSink {
  def main(args: Array[String]): Unit = {
    //1.构建流处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    val dataSource: DataStream[String] = env.fromElements("1,小丽,北京,女")
    //3.构建配置文件
    val prop = new Properties()
    prop.setProperty("bootstrap.servers", "node01:9092,node02:9092,node03:9092")
    //4.连接Kafka
    val producer: FlinkKafkaProducer011[String] = new FlinkKafkaProducer011[String]("FlinkAsKafka", new SimpleStringSchema(), prop)
    //5.将数据打入kafka
    dataSource.addSink(producer)
    //6.执行任务
    env.execute("StreamKafkaSink")
  }
}
3.4 Sink将数据 到 MySQL
import java.sql.{Connection, DriverManager, PreparedStatement}
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

/**
 * @author
 * @date 2020/9/22 23:35
 * @version 1.0
 */
object StreamMysqlSink {

  case class Student(id: Int, name: String, addr: String, sex: String)

  def main(args: Array[String]): Unit = {
    //1.构建流式处理运行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.数据准备
    val dataSource: DataStream[Student] = env.fromElements(
      Student(1, "张三", "上海", "男"),
      Student(2, "李四", "北京", "女"),
      Student(3, "王五", "上海", "男"),
      Student(4, "赵刘", "广东", "男")
    )
    dataSource.addSink(new StudentSinkToMysql)
    env.execute("StreamMysqlSink")
  }

  class StudentSinkToMysql extends RichSinkFunction[Student] {
    var connection: Connection = null
    var ps: PreparedStatement = null

    override def open(parameters: Configuration): Unit = {
      var driver = "com.mysql.jdbc.Driver"
      var url = "jdbc:mysql://node01:3306/text?characterEncoding=utf-8&useSSL=false"
      var username = "root"
      var password = "123456"
      //加载驱动
      Class.forName(driver)
      //创建连接
      connection = DriverManager.getConnection(url,username,password)
      ps = connection.prepareStatement("insert into student(id,name,addr,sex) values (?,?,?,?);")
    }

    override def close(): Unit = {
      if (connection != null) {
        connection.close()
      }
      if (ps != null) {
        ps.close()
      }
    }

    override def invoke(value: Student): Unit = {
      ps.setInt(1,value.id)
      ps.setString(2,value.name)
      ps.setString(3,value.addr)
      ps.setString(4,value.sex)
      ps.executeUpdate()
    }
  }
}
大数据老哥
关注
专栏目录
Flink / Scala - 3.DataSource 之 DataStream 获取数据总结
BITDDD小栈
03-07 2280
DataStream API 得名于特殊的 DataStream 类，该类用于表示 Flink 程序中的数据集合。你可以认为 它们是可以包含重复项的不可变数据集合。这些数据可以是有界（有限）的，也可以是无界（无限）的，但用于处理它们的API是相同的。下面将介绍 DataStream 的常见初始化方法。...
Apache Flink连载（六）：Apache Flink快速入门 - Flink案例实现
qq_32020645的博客
12-04 930
目录1. Flink 批数据处理案例2. Flink流式数据处理案例3. Flink批和流案例总结数据源分为有界和无界之分，有界数据源可以编写批处理程序，无界数据源可以编写流式程序。DataSet API用于批处理，DataStream API用于流式处理。批处理使用ExecutionEnvironment和DataSet，流式处理使用StreamingExecutionEnvironment和DataStream。DataSet和DataStream是Flink中表示数据的特殊类，DataSet处理的数据
快速入门Flink (7) —— 小白都喜欢看的Flink流处理之DataSources和DataSinks（转载）
shuirenbushijun的博客
08-18 275
写在前面： 博主是一名软件工程系大数据应用开发专业的学生，昵称来源于《爱丽丝梦游仙境》中的Alice和自己的昵称。作为一名互联网小白，写博客一方面是为了记录自己的学习历程，一方面是希望能够帮助到很多和自己一样处于起步阶段的萌新。由于水平有限，博客中难免会有一些错误，有纰漏之处恳请各位大佬不吝赐教！个人小站:http://alices.ibilibili.xyz/ , 博客主页:https://alice.blog.csdn.net/ 尽管当前水平可能不及各位大佬，但我还是希望自己能够做得更好，因为一天的生活
深入探索Apache Flink：流处理的艺术与实践
最新发布
weixin_53840353的博客
07-10 1227
Apache Flink是一个分布式处理引擎，支持批处理和流处理。它提供了DataStream API和DataSet API，分别用于处理无界和有界数据集。Flink的核心优势在于其能够以事件时间（event-time）处理数据，确保即使在乱序或延迟数据的情况下，也能得到准确的结果。本文详细介绍了如何使用Apache Flink进行流处理，并通过多个代码示例展示了Flink的基本用法和高级特性。
【03】Flink 之 DataStream API（一）：Data Source 和 自定义Source
努力学习的大小宝
05-13 3788
实现无并行度的自定义Source 1、run方法重写（主要的方法）： 启动一个source 注意：继承接口 SourceFunction的时候需要指定泛型，否则会报错 如：SourceFunction，即run中产生的数据类型 SourceFunction 和 SourceContext 都需要指定 在大部分情况下，都需要在这个run方法中实现一个循环，就可以循环产生数据 传入参数 (S...
Flink 1.12.2 源码浅析 : DataSource如何获取数据并返回DataStream
张伯毅的专栏
04-13 1161
.一 .前言二 .代码分析2.1. 入口2.2. SocketTextStreamFunction2.2.1. SourceFunction接口2.2.2. SourceContext2.2.3. 属性2.2.4. 构造方法2.2.5. run(SourceContext ctx)2.2.6. cancle ()2.2.7. 官方提供的SourceFunction示例2.3. addSource三 .StreamSource四 .DataStreamSource五 .ParallelSourceFuncti
Flink初次练习（Source、Sink）
曦玥Moonight的博客
11-08 204
Flink的官网：https://flink.apache.org/ 使用的软件：IntelliJ IDEA Community Edition 第一个练习： 读取目录下的文件并打印输出 package cn.tedu.dataset; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataSource; import org.apache.flink.st
（二）Flink从入门到项目实战——Flink入门程序
董长春
02-04 1536
目录 Flink环境准备 开发工具及环境要求 Maven依赖坐标 Flink入门程序 Flink批处理 Flink流式处理 总结开发过程 Flink环境准备 开发工具及环境要求 IDE最好使用IntelliJ IDEA (eclipse存在插件不兼容的风险) 唯一的要求是使用 Maven 3.0.4 和安装 Java 8.x（或更高版本）。 Maven依赖坐标 <...
一文聊透 Flink 的 Temporal Join
Laurence的技术博客
03-25 2132
Flink的Temporal Join以及Temporal Table （时态表）关系密切，在知识结构上有点混乱，可能是历史原因造成的。本文希望把所有与 Temporal Join 相关的概念进行一次统一梳理，用更规范的知识结构把 Flink 的 Temporal Join 介绍清楚，包括：以 Temporal Table DDL 方式实现基于事件时间的 Temporal Join;以 Temporal Table DDL 方式实现基于处理时间的 Temporal Join;以 Temporal Table
【Flink入门修炼】1-3 Flink WordCount 入门实现
笨鸟先飞的博客
02-07 1852
本篇文章将带大家运行 Flink 最简单的程序 WordCount。先实践后理论，对其基本输入输出、编程代码有初步了解，后续篇章再对 Flink 的各种概念和架构进行介绍。 下面将从创建项目开始，介绍如何创建出一个 Flink 项目；然后从 DataStream 流处理和 FlinkSQL 执行两种方式来带大家学习 WordCount 程序的开发。
Flink流处理
胜利的曙光的博客
02-22 1186
Flink流处理相关操作。
Flink-- 数据输出Data Sinks
05-20 184
flink在批处理中常见的sink 1.基于本地集合的sink（Collection-based-sink） 2.基于文件的sink（File-based-sink） 基于本地集合的sink（Collection-based-sink） //1.定义环境 val env = ExecutionEnvironment.getExecutionEnvironme...
Apache Flink源码分析---flink DataSource介绍
wjandy0211的博客
10-16 429
本文主要介绍flink datasource flink作为一个明星级别的流处理框架，编程模式很简单： 1. 获取一个执行环境，并根据实际情况配置 2. 加载/创建初始化数据 3. 指定操作数据的transformation算子 4. 指定计算好的数据存放位置 5. 调用execute()出发执行程序 Data Sources 是什么呢？就字面意思其实就可以知道：数据源。 ...
Flink 流处理和批处理测试小代码
weixin_40817778的博客
07-30 265
批处理： import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataSource; import org.apache.flink.api.java.tu
Apache Flink——DataStream的DataSource以及DataSink（章节二）
qq_38040765的博客
03-17 470
DataStream的DataSource以及DataSink DataSource DataSource是flink数据的来源，用户可以通过env,addSource(SourceFunction)将SourceFunction添加到程序中，Flink内置许多已经实现的SourceFunction,但是用户也可以自定义实现SourceFunction(非并行化)接口，也可以实现ParallelS...
flink（二）：数据接入DataSource和数据输出DataSink
幻神舞的专栏
04-23 1438
文章目录说明DataSource 数据接入内置数据源文件socketflink集合数据源第三方数据源kafka Connector解析类自定义数据源连接器单线程数据源连接器并发数据源连接器DataSink 数据输出基本输出类型第三放输出类型总结 说明 本博客每周五更新一次。 flink数据处理过程分为三部分：DataSource、Transformation、DataSink，分别处理数据的接入、处理和输出，由于处理部分内容较多，下次分享，本文只介绍数据接入和数据输出。 DataSource 数据接入
Flink 流处理 API
song_quan_的博客
11-03 158
Flink 流处理 API Environment getExecutionEnvironment 创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则 此方法返回本地执行环境；如果从命令行客户端调用程序以提交到集群，则此方法 返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方 式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。 如果没有设置并行度，会以 flink-conf.yaml 中的配..
1、Flink流处理（DataStream API）概览（Data Source、Data Sink）
飞朋的博客
08-20 1339
Flink中的DataStream程序是在数据流上实现转换的常规程序(例如，filtering, updating state, defining windows, aggregating)。数据流最初是由不同的源创建的(例如，message queues, socket streams, files)。结果通过接收器返回，例如，接收器可以将数据写入文件或标准输出(例如the command li...
Flink批处理和流处理两种方式实现WordCount代码示例
张伟的专栏
04-17 1705
本文使用 Flink 的两种方式实现 WordCount 基于流计算 基于批计算 先说一下我的环境： Flink 1.9 开发工具：Idea Maven版本：3.3.9 Linux：CentOS 7 演示语言：Scala 2.11 1. Idea 新建 Maven 项目并配置以下依赖 <dependencies> <dependency> <groupId>org.apache.flink</groupId> ...
评论 57
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大数据老哥

欢迎支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值