Flink算子和入门案例（wordcount）

最新推荐文章于 2024-08-01 13:52:23 发布
最新推荐文章于 2024-08-01 13:52:23 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： # Flink 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43278189/article/details/121500550
版权

文章目录

入门案例：

1.Flink入门案例wordcount

先导入pom依赖

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <flink.version>1.11.2</flink.version>
        <scala.binary.version>2.11</scala.binary.version>
        <scala.version>2.11.12</scala.version>
        <log4j.version>2.12.1</log4j.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-walkthrough-common_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>


        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.36</version>
        </dependency>


    </dependencies>


    <build>

        <plugins>


            <!-- Java Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- Scala Compiler -->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <args>
                        <arg>-nobootcp</arg>
                    </args>
                </configuration>
            </plugin>


        </plugins>

    </build>

package com.liu.core

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

/**
 * @ Author : ld
 * @ Description : 实时统计word个数
 * @ Date : 2021/11/23 18:57
 * @ Version : 1.0
 */
object FlinkWordCount {
  def main(args: Array[String]): Unit = {
    //创建flink的环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //设置并行度
    env.setParallelism(2)
    //读取socket数据
    //启动master开启nc,没有的执行yum -install nc安装
    //nc -lk 8888
    env.socketTextStream("master",8888)
    //把单词拆分
      .flatMap(_.split(","))
    //转换成kv格式
      .map((_,1))
    //按单词分组
      .keyBy(_._1)
    //统计单词数量
      .sum(1)
    //打印结果
      .print()

    //启动flink
    env.execute()
  }
}

在这里插入图片描述
在这里插入图片描述

自定义source

2.基于本地构建DataStream,基于文件构建DataStream，基于socket构建DataStream，自定义source
package com.liu.source

import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.scala._


/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 19:26
 * @ Version : 1.0
 */
object Demo1Source {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    /**
     * 基于本地构建DataStream -- 有界流
     */
    val lisrDS: DataStream[Int] = env.fromCollection(List(1, 2, 3, 4, 5, 6, 7, 8, 9))
    lisrDS.print()

    /**
     * 基于文件构建DataStream --有界流
     */
    val studentDS: DataStream[String] = env.readTextFile("Flink/data/student.txt")

    studentDS
      .map(stu=>(stu.split(",")(4),1))
      .keyBy(_._1)
      .sum(1)
      .print()

    /**
     * 基于socket构建DataStream-- 无界流
     */
//    env.socketTextStream("master11",8888)
//      .print()


    /**
     * 自定义socket，实现SourceFunction接口
     */
    env.addSource(new MySource).print()

    env.execute()
  }
}

/**
 * 自定义source，实现SourceFunction接口
 * 实现run方法
 */
class MySource extends SourceFunction[Int]{
  /**
   * run方法只执行一次
   * @ param ctx:用于发送数据到下游task
   */
  override def run(ctx: SourceFunction.SourceContext[Int]): Unit = {
    var i=0
    while(true){//死循环，看完发送到下游结果就关闭吧
      //把数据发送到下游
      ctx.collect(i)
      //休眠50毫秒
      Thread.sleep(50)
      i+=1
    }

  }

  /**
   * cancel()方法再任务取消时执行用于回收资源
   */

  override def cancel(): Unit = {}
}
3.使用自定义source去读取MySQL数据库数据
package com.liu.source

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

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

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 20:05
 * @ Version : 1.0
 */
object Demo2MysqlSource {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(2)
    //使用自定义source
    val mysqlDS: DataStream[(Int, String, Int, String, String)] = env.addSource(new MysqlSource)
    mysqlDS.print()

    env.execute()
  }
}

/**
 * 自定义读取mysql---有界流
 * SourceFunction -- 单一source,run方法只会执行一次
 * ParallelSourceFunction-- 并行的source，并行度决定source个数
 * RichSourceFunction -- 比sourceFunction多了open和close方法
 * RichParallelSourceFunction --结合上面两个方法
 */

class MysqlSource extends RichSourceFunction[(Int, String, Int, String, String)] {
  /**
   * open方法会在run方法之前执行
   * @ param ctx
   */
  var conn: Connection = _

  override def open(parameters: Configuration): Unit = {
    //加载驱动
    Class.forName("com.mysql.jdbc.Driver")
    //建立连接
    conn = DriverManager.getConnection("jdbc:mysql://master:3306/test", "root", "123456")
  }
  /**
   * 在run方法后执行
   */
  override def close(): Unit = {
    //关闭连接
    conn.close()
  }


  override def run(ctx: SourceFunction.SourceContext[(Int, String, Int, String, String)]): Unit = {

    //查看数据
    val stat = conn.prepareStatement("select * from student")
    val res: ResultSet = stat.executeQuery()
    //解析数据
    while (res.next()) {
      val id: Int = res.getInt("id")
      val name: String = res.getString("name")
      val age: Int = res.getInt("age")
      val gender: String = res.getString("gender")
      val clazz: String = res.getString("clazz")
      //数据发送到下游
      ctx.collect((id, name, age, gender, clazz))

    }
  }


  override def cancel(): Unit = {

  }
}

算子

4.map
package com.liu.transformation

import org.apache.flink.api.common.functions.MapFunction
import org.apache.flink.streaming.api.scala._

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 20:54
 * @ Version : 1.0
 */
object Demo1Map {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val lineDS: DataStream[String] = env.socketTextStream("master11", 8888)

    /**
     * map函数
     * 传入一个函数
     * 传入一个接口的实现类 --MapFunction
     */
    lineDS.map(new MapFunction[String,String]{
      override def map(t: String): String = {
      t +"ok"
      }
    }).print()

    env.execute()

  }
}

在这里插入图片描述

5.flatMap
package com.liu.transformation

import org.apache.flink.api.common.functions.{FlatMapFunction, RichFlatMapFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 21:03
 * @ Version : 1.0
 */
object Demo2FlatMap {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(4)//设置并行度为4
    val linesDS: DataStream[String] = env.socketTextStream("master", 8888)

    /**
     * FlatMapFunction
     * RichSourceFunction--多了open和close方法，可以做初始化操作
     */

    val flatMapDS: DataStream[String] = linesDS.flatMap(new RichFlatMapFunction[String, String] {
      override def flatMap(line: String, out: Collector[String]): Unit = {
        /**
         * flatMap函数，每一条数据执行一次
         *
         * @ param line ： 一行数据
         * @ param out  ; 用于将数据发送到下游
         */
        line
          .split(",")
          .foreach(out.collect) //下面释内容简写
        //          .foreach(word=>{
        //            //发送数据
        //            out.collect(word)
        //          })
      }
    })

    flatMapDS.print()

    env.execute()
  }
}

在这里插入图片描述

6.filter
package com.liu.transformation

import org.apache.flink.api.common.functions.FilterFunction
import org.apache.flink.streaming.api.scala._
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 21:17
 * @ Version : 1.0
 */
object Demo3Filter {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    /**
     * filter的算子不是懒执行
     */
    val studentDS: DataStream[String] = env.readTextFile("Flink/data/student.txt")

    studentDS.filter(new FilterFunction[String]{
      override def filter(stu: String): Boolean = {
        //过滤出性别为男的所有学生
        stu.split(",")(3)=="男"
      }
    }).print()

    env.execute()
  }
}

在这里插入图片描述

7.KeyBy
package com.liu.transformation

import org.apache.flink.api.java.functions.KeySelector
import org.apache.flink.streaming.api.scala._
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 21:25
 * @ Version : 1.0
 */
object Demo4KeyBy {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(3)

    val linesDS: DataStream[String] = env.socketTextStream("master", 8888)

    /**
     * keyBy把相同的key发送到同一个task中
     */
    linesDS.keyBy(new KeySelector[String,String] {
      override def getKey(line: String): String ={
        line
      }
    }).print()

    env.execute()


  }
}

在这里插入图片描述

8.Reduce
package com.liu.transformation

import org.apache.flink.api.common.functions.ReduceFunction
import org.apache.flink.streaming.api.scala._

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:01
 * @ Version : 1.0
 */
object Demo5Reduce {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val lineDS: DataStream[String] = env.socketTextStream("master11", 8888)

    val keyByDS: KeyedStream[(String, Int), String] = lineDS
      .flatMap(_.split(","))
      .map((_, 1))
      .keyBy(_._1)

    /**
     * reduce:在keyBy之后进行聚合
     */
    keyByDS.reduce(new ReduceFunction[(String,Int)]{
      override def reduce(t: (String,Int), t1: (String,Int)): (String,Int) = {
        (t._1,t1._2+t1._2)
      }
    }).print()

    env.execute()
  }
}
9.Agg
package com.liu.transformation

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

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:09
 * @ Version : 1.0
 */
object Demo6Agg {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val studentDS: DataStream[String] = env.readTextFile("Flink/data/student.txt")

    var stuDS: DataStream[Student] = studentDS.map(line => {
      val split = line.split(",")
      Student(split(0), split(1), split(2).toInt, split(3), split(4))
    })

    stuDS.keyBy(_.clazz)
      .sum("age")
      .print()
    /**
     * max 和 maxBy 之间的区别在于 max 返回流中的最大值，但 maxBy 返回具有最大值的键，
     */
    stuDS.keyBy(_.clazz)
      .maxBy("age")
      .print()

    env.execute()
  }
  case class Student(id:String,name:String,age:Int,gender:String,clazz:String)
}
10.Window
package com.liu.transformation

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 21:52
 * @ Version : 1.0
 */
object Demo7Window  {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val linesDS: DataStream[String] = env.socketTextStream("master11", 8888)

    /**
     * 每5秒统计一次单词数量
     */
    linesDS
      .flatMap(_.split(","))
      .map((_,1))
      .keyBy(_._1)
      .timeWindow(Time.seconds(5))
      .sum(1)
      .print()

    env.execute()



  }
}
11.union
package com.liu.transformation

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:27
 * @ Version : 1.0
 */
import org.apache.flink.streaming.api.scala._

object Demo8Union {
  def main(args: Array[String]): Unit = {

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val ds1: DataStream[Int] = env.fromCollection(List(1,2,3,4,5,6))

    val ds2: DataStream[Int] = env.fromCollection(List(4,5,6,7,8,9))

    /**
     * 合并DataStream 类型要一致
     *
     */
    val unionDS: DataStream[Int] = ds1.union(ds2)

    unionDS.print()


    env.execute()

  }

}
12.SideOutput
package com.liu.transformation

import org.apache.flink.streaming.api.functions.ProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:31
 * @ Version : 1.0
 */
object Demo9SideOutput {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    val studentDS = env.readTextFile("Flink/data/student.txt")
    /**
     * 将性别为男和性别为女学生单独拿出来
     */
    val man = OutputTag[String]("男")
    val women = OutputTag[String]("女")

    val processDS = studentDS.process(new ProcessFunction[String, String] {
      override def processElement(line: String, ctx: ProcessFunction[String, String]#Context, collector: Collector[String]): Unit = {
        val gender: String = line.split(",")(3)
        gender match {
          //旁路输出
          case "男" => ctx.output(man, line)
          case "女" => ctx.output(women, line)
        }
      }

    })
//获取旁路输出的DataStream
//    processDS.getSideOutput(man).print()
    processDS.getSideOutput(women).print()
    env.execute()
  }
}

自定义sink

13.自定义sink
package com.liu.sink

import org.apache.flink.streaming.api.functions.sink.SinkFunction
import org.apache.flink.streaming.api.scala._
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:47
 * @ Version : 1.0
 */
object Demo1Sink {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val studentDS = env.readTextFile("Flink/data/student.txt")

    //自定义sink
    studentDS.addSink(new MySink)
    env.execute()
  }
}

class MySink extends SinkFunction[String]{
  /**
   * invoke ： 每一条数据都会执行一次
   *
   * @ param line    数据
   * @ param context 上下文对象
   */
  override def invoke(value: String, context: SinkFunction.Context[_]): Unit = {
    print(value)
  }
  
}
14.自定义sink写数据到mysql
package com.liu.sink

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala._

import java.sql.{Connection, DriverManager}
/**
 * @ Author : ld
 * @ Description : 
 * @ Date : 2021/11/23 22:56
 * @ Version : 1.0
 */
object Demo2MysqlSink {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    val studentDS: DataStream[String] = env.readTextFile("Flink/data/student.txt")

    studentDS.addSink(new MysqlSink)

    env.execute()
  }
}

class MysqlSink extends RichSinkFunction[String]{
  /**
   * 在invoke 之前执行，每一个task中只只一次
   */
  var conn:Connection = _
  override def open(parameters: Configuration): Unit = {
    //加载驱动
    Class.forName("com.mysql.jdbc.Driver")
    //建立连接
    conn = DriverManager.getConnection("jdbc:mysql://master:3306/test", "root", "123456")
  }
  /**
   * 在run方法后执行
   */
  override def close(): Unit = {
    //关闭连接
    conn.close()
  }

  //每条数据都会执行一次
  override def invoke(value: String, context: SinkFunction.Context[_]): Unit ={
    val split = value.split(",")
    val stat = conn.prepareStatement("insert into student(id,name,age,gender,clazz) values(?,?,?,?,?)")
    stat.setString(1,split(0))
    stat.setString(2,split(1))
    stat.setInt(3,split(2).toInt)
    stat.setString(4,split(3))
    stat.setString(5,split(4))
    stat.execute()
  }

}
落幕7
关注
专栏目录
Flink wordcount
csdn问鼎
02-14 412
1.pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocatio...
Flink WordCount 应用程序
http://www.54tianzhisheng.cn/
09-22 220
在 2.2 中带大家讲解了下 Flink 的环境安装，这篇文章就开始我们的第一个 Flink 案例实战，也方便大家快速开始自己的第一个 Flink 应用。大数据里学习一门技术一般都是从 WordCount 开始入门的，那么我还是不打破常规了，所以这篇文章我也将带大家通过 WordCount 程序来初步了解 Flink。 Maven 创建项目 Flink 支持 Maven 直接构建模版项目，你在终端...
Flink基础(入门程序WordCount实例)
qq_62233345的博客
11-27 960
【代码】Flink基础(入门程序WordCount实例)
Flink入门案例WordCount
鸟人的博客
07-11 845
大数据领域避不可谈的就是实时流数据处理了，Flink作为流处理的中坚力量，有着广泛的应用，下面来结合WordCount来简单理解如何使用Flink吧Flink处理数据流程如下注：需要建立一个Maven项目，而不是SpringBoot项目，项目结构如下 pom properties dependency 代码 结果注：文件放在项目根目录下...............
【大数据Flink】入门案例 -- WordCount
buffedon的博客
02-06 1422
Flink-WordCount 下面主要是使用 DataSet 的方式去实现，在 Flink 1.14版本之后，DataSet 的方式被弃用，主要开始使用 DataStream 的方式 1. env 环境准备 ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); 2. Source 加载数据 用 , 分隔表示两行数据 DataSet<String> lineDS = env.fromElements
Flink学习三：WordCount
码上中年的博客
07-22 244
读取文件进行批量计算WordCount 1.1 代码 import org.apache.flink.api.scala.ExecutionEnvironment import org.apache.flink.api.scala._ /** * 批处理wordcount */ object WordCount { def main(args: Array[String]): Unit = { // 创建一个执行环境 val env = ExecutionEnvironme.
大数据开发-Flink-Flink简介和入门
Hoult丶吴邪
03-21 370
Flink作为大数据生态中重要的一个组件，现在在实时流处理方面占据着很重要的地位，其实时流处理方面支持基于事件的时间流处理方式，另外也推荐流批一体化，而现在处理实时数据较常用的架构 Flink + Kafka，当然市面上的流处理引擎不止Flink一种，其他的比如Storm、SparkStreaming、Trident等，实际应用时如何进行选型，下面是一些建议参考 流数据要进行状态管理，选择使用Trident、Spark Streaming或者Flink 消息投递需要保证At-least-once（至少一
Flink DataStream API编程入门
最新发布
L
08-01 294
DataStream API的名称来自于DataStream类，该类用于表示Flink程序中的数据集合。您可以将它们视为包含重复项的不可变数据集合。这些数据可以是有限的，也可以是无限的，但是用于处理它们的API是相同的。在使用方面，数据流与常规Java Collection类似，但在一些关键方面有很大不同。DataStream是不可变的，这意味着一旦创建了它们，就不能添加或删除元素。您不仅可以简单地检查其中的元素，还可以使用DataStream API算子（也称为转换）对它们进行处理。
Flink批处理入门
胜利的曙光的博客
02-19 2052
Flink批处理之DataSource、Transformation、Sink、广播变量、累加器、分布式缓存相关内容介绍。
Flink-简单了解及入门WordCount
clearlxj的博客
08-24 1145
Flink简介 Flink 项目的理念是:“Apache Flink 是为分布式、高性能、随时可用以及准确的流处理应用程序打造的开源流处理框架”。 Apache Flink 是一个框架和分布式处理引擎,用于对无界和有界数据流进行有状态计算。Flink 被设计在所有常见的集群环境中运行,以内存执行速度和任意规模来执行计算。 流数据处理以及批处理的差别：流处理是更低延迟的批处理。 比如设备的实时数据采集和显示、实时告警等都可以使用Flink，可以做实时结算和通知推送,实时检测异常行为等。 storm：第一代大
大数据HelloWorld-Flink实现WordCount
10-16
主要介绍了大数据HelloWorld-Flink实现WordCount的相关知识，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
Flink入门之wordcount
空港
02-27 624
Flink入门之wordcount的写法 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.tuple.Tuple2; import org.apache.flink.ut.
大数据——Flink 入门程序（wordcount）
热门推荐
Vicky_Tang
08-24 1万+
目录 一、编程模型 二、编程步骤 三、DataStream 实时 wordcount ​四、DataSet 离线wordcount 一、编程模型 Flink提供了不同级别的编程抽象，通过调用抽象的数据集调用算子构建DataFlow就可以实现对分布式的数据进行流式计算和离线计算，DataSet是批处理的抽象数据集，DataStream是流式计算的抽象数据集，他们的方法都分别为Source、Transformation、Sink Source主要负责数据的读取 Transfor...
Flink-demo速成与常见算子
咖啡的博客
10-14 545
1、一个flink任务的不同状态 我们先来简单看下，一个flink任务从创建到消亡会经历哪些状态。在启动一个Flink job的时候，可以从控制台看到job和task的多个状态的切换 Flink job的状态变化 在执行ExecutionMap期间，每个并行任务经历多个阶段，从创建到完成或失败。 2、一个简单的flink任务 //1. 构建执行环境 final Str...
Flink1.8实现wordcount
zhangvalue的博客
06-21 1552
之前已经记录了在Mac上安装Flink1.8 https://blog.csdn.net/zhangvalue/article/details/93166895 1️⃣、开始创建一个项目名为flink_begin的maven项目 2️⃣、pom.xml文件添加如下dependency： <dependencies> <dependency> ...
flink 一、wordCount入门示例
weixin_43761300的博客
08-28 174
1、Java版本batch wordcount import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.AggregateOpera
Flink官方例子解析：WordCount
修破立生
01-31 1729
今天介绍的是官方子项目flink-examples-streaming里面的WordCount例子。WordCount ，中文：单词统计，是大数据计算常用的例子。
Flink 入门实战之二WordCount
xiaoc100200的博客
11-21 197
感受flink 常用Transform算子 flatMap（多进一出、一斤多出） map （一进一出） keyBy （分区） sum （求和） package com.day import org.apache.flink.streaming.api.scala._ object WordCount { def main(args: Array[String]): Unit = { // 1、获取流式环境变量 val env = StreamExecutionEnvironment
Flink实现WordCount（实操详细步骤）
bboy枫亭的博客
08-10 7322
本文使用 Flink 的两种方式实现 WordCount 基于流计算 基于批计算 文章目录1. Idea 新建 Maven 项目并配置以下依赖2. 实现代码及详细注释2.1 Flink 基于流计算实现 WordCount2.2 Flink 基于批计算实现 WordCount2.3 附件：完整代码 先说一下我的环境： Flink 1.9 开发工具：Idea Maven版本：3.3.9 Linux：CentOS 7 演示语言：Scala 2.11 1. Idea 新建 Maven 项目并配置以下依赖 &lt
flink 算子如何结束
07-11
Flink 算子的结束可以通过以下几种方式来实现： 1. 数据源结束：当数据源没有更多的数据可供处理时，Flink 算子会自动结束。这通常发生在流式处理任务中，当数据源没有新的事件到达时。 2. 窗口操作：使用窗口操作可以控制算子的结束时机。例如，时间窗口（Tumbling Window、Sliding Window）可以按照时间间隔或事件数量来触发算子的结束。 3. 自定义触发器：Flink 提供了自定义触发器的功能，可以根据特定的条件来触发算子的结束。通过实现 Trigger 接口，您可以定义自己的触发器逻辑，并在满足触发条件时结束算子。 4. 停止任务：您可以通过手动停止 Flink 任务来结束算子。可以调用执行环境（ExecutionEnvironment）或流处理环境（StreamExecutionEnvironment）的 `cancel()` 方法来停止任务，并触发所有算子的结束。 需要根据具体情况选择适合的方法来结束 Flink 算子。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值