Flink Stream案例——使用Stream API 和Window API 对自定义数据流（循环生成1000条）进行处理并将数据存储于MySQL数据库中

案例介绍

示例:
自定义Source，模拟1000条订单数据，每条数据间隔1秒钟(订单编号ID、用户编号ID、商品编号ID、消费金额、消费时间 )

要求:

• 随机生成订单编号ID（UUID）
• 随机生成用户编号ID（user1-user10）
• 随机生成商品编号ID（goods1-goods20）
• 随机生成消费金额（100-1000）
• 消费时间为当前系统时间

统计：

1. 每30秒钟，统计一次各用户的最大消费订单信息，将结果写入MySQL；
2. 统计30秒内，各用户的消费总额和订单数量，该数据每10秒更新一次，将结果打印输出；
3. 统计30秒内，各商品的销售数量，该数据每10秒更新一次， 将结果打印输出。

---

开发步骤

1. 创建订单样例类；

2. 获取流处理环境；

3. 创建自定义数据源；

       （1）循环1000次；
       （2）随机构建订单信息；
       （3）上下文收集数据；
       （4）每隔一秒执行一次循环；
   

4. 处理数据；

5. 打印数据；

6. 写入MySQL；

7. 执行任务。

---

具体代码

定义样例类

 //样例类
  case class
  Order(itemId: String, userId: String, goodsId: String, price: Int, createTime: Long)

Environment和Source流程

//TODO:1.environment
val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)


//TODO:2.source,生产随机订单数据
val sourceDStream: DataStream[Order] = env.addSource(new OrderSourceFunction)

自定义随机生成订单类OrderSourceFunction

  //自定义随机生成订单类
  class OrderSourceFunction extends RichSourceFunction[Order] {
    //定义变量
    private var count: Long = 0L
    private var isRunning: Boolean = true

    override def run(sourceContext: SourceFunction.SourceContext[Order]): Unit = {
      // 使用while循环生成1000个订单(订单编号ID、用户编号ID、商品编号ID、消费金额、消费时间 )
      while (isRunning && count < 1000) {
        // 随机生成订单ID（UUID）
        val itemId: String = UUID.randomUUID().toString
        // 随机生成用户编号ID（user1-user10）
        val userID: String = "user" + (Random.nextInt(10) + 1)
        // 随机生成商品编号ID（goods1-goods20）
        val goodsID: String = "goods" + (Random.nextInt(20) + 1)
        // 随机生成消费金额（100~1000）
        val price = Random.nextInt(900) + 101
        // 消费时间为当前系统时间
        val createTime: Long = System.currentTimeMillis()
        //        println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(createTime)))

        // 收集数据
        sourceContext.collect(Order(itemId, userID, goodsID, price, createTime))
        // 统计生成的订单数
        count += 1

        // 每隔1秒生成一个订单
        TimeUnit.SECONDS.sleep(1)
        //        TimeUnit.MILLISECONDS.sleep(1)
      }
    }

    override def cancel(): Unit = {
      isRunning = false
    }
  }

Transformation流程，实现案例的需求

//TODO:3.transformation,对数据进行窗口统计，并将有些数据写入MySQl中
 （1）每30秒钟，统计一次各用户的最大消费订单信息，将结果写入MySQL；
// Order(7485091d-341c-4498-b00b-4cfca479de79,user6,goods9,815,1634218271508)
val resultDStream01: DataStream[Order] = sourceDStream
  .assignAscendingTimestamps(_.createTime)
  .keyBy(_.userId)
  .window(TumblingEventTimeWindows.of(Time.seconds(30)))
  .maxBy("price")

 （2）统计30秒内，各用户的消费总额和订单数量，该数据每10秒更新一次，将结果打印输出；
// (user9,3440,4)
val resultDStream02: DataStream[(String, Int, Int)] = sourceDStream
  .assignAscendingTimestamps(_.createTime)
  .map(Data => (Data.userId, Data.price, 1))
  .keyBy(_._1)
  .window(SlidingEventTimeWindows.of(Time.seconds(30), Time.seconds(19)))
  .reduce((preData, curData) => (preData._1, preData._2 + curData._2, preData._3 + curData._3))

 （3）统计30秒内，各商品的销售数量，该数据每10秒更新一次， 将结果打印输出。
// (goods10,2)
val resultDStream03: DataStream[(String, Int)] = sourceDStream
  .assignAscendingTimestamps(_.createTime)
  .map(Data => (Data.goodsId, 1))
  .keyBy(_._1)
  .window(SlidingEventTimeWindows.of(Time.seconds(30), Time.seconds(10)))
  .reduce((preData, curData) => (preData._1, preData._2 + curData._2))

Sink与Execution流程

//TODO:4.sink
resultDStream01.print("用户的最大消费订单信息:")
resultDStream01.addSink(new MySQLSinkFunction)
resultDStream02.print("用户的消费总额和订单数量：")
resultDStream03.print("商品的销售数量：")
//    sourceDStream.writeAsCsv("src\\main\\resources\\new_OrderSource.csv", WriteMode.OVERWRITE)


//TODO:5.execution
env.execute("OrderStream Job")

自定义MySQLSinkFunction类，将数据存储于MySQL中

  //自定义MySQLSinkFunction类，将数据存储于MySQL中
  class MySQLSinkFunction extends RichSinkFunction[Order] {
    var connection: Connection = null
    var ps: PreparedStatement = null

    override def open(parameters: Configuration): Unit = {
      //加载驱动，打开连接
      Class.forName("com.mysql.jdbc.Driver")
      connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/数据库名?useSSL=false&characterEncoding=utf8",
        "用户名",
        "密码")

      ps = connection.prepareStatement("insert into 表名(itemId,userId,goodsId,price,createTime) values (?,?,?,?,?)")
    }

    override def invoke(value: Order, context: SinkFunction.Context): Unit = {
      //元组的主键，取系统此时的时间戳
      ps.setString(1, value.itemId)
      ps.setString(2, value.userId)
      ps.setString(3, value.goodsId)
      ps.setInt(4, value.price)
      ps.setLong(5, value.createTime)
      //执行sql语句
      ps.executeUpdate()

    }

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

  }

---

实现结果

在控制台输出的结果：

存储于MySQL中的数据：
（数据表的结构）

表中数据

（查询产生的数据的数目）

---

本案例的完整代码

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment, _}
import org.apache.flink.streaming.api.windowing.assigners.{SlidingEventTimeWindows, TumblingEventTimeWindows}
import org.apache.flink.streaming.api.windowing.time.Time

import java.util.UUID
import java.util.concurrent.TimeUnit
import scala.util.Random
import java.sql.{Connection, DriverManager, PreparedStatement}


object OrderStream {

  //样例类
  case class
  Order(itemId: String, userId: String, goodsId: String, price: Int, createTime: Long)

  def main(args: Array[String]): Unit = {
    //TODO:1.environment
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)


    //TODO:2.source,生产随机订单数据
    val sourceDStream: DataStream[Order] = env.addSource(new OrderSourceFunction)


    //TODO:3.transformation,对数据进行窗口统计，并将有些数据写入MySQl中
     （1）每30秒钟，统计一次各用户的最大消费订单信息，将结果写入MySQL；
    // Order(7485091d-341c-4498-b00b-4cfca479de79,user6,goods9,815,1634218271508)
    val resultDStream01: DataStream[Order] = sourceDStream
      .assignAscendingTimestamps(_.createTime)
      .keyBy(_.userId)
      .window(TumblingEventTimeWindows.of(Time.seconds(30)))
      .maxBy("price")

     （2）统计30秒内，各用户的消费总额和订单数量，该数据每10秒更新一次，将结果打印输出；
    // (user9,3440,4)
    val resultDStream02: DataStream[(String, Int, Int)] = sourceDStream
      .assignAscendingTimestamps(_.createTime)
      .map(Data => (Data.userId, Data.price, 1))
      .keyBy(_._1)
      .window(SlidingEventTimeWindows.of(Time.seconds(30), Time.seconds(19)))
      .reduce((preData, curData) => (preData._1, preData._2 + curData._2, preData._3 + curData._3))

     （3）统计30秒内，各商品的销售数量，该数据每10秒更新一次， 将结果打印输出。
    // (goods10,2)
    val resultDStream03: DataStream[(String, Int)] = sourceDStream
      .assignAscendingTimestamps(_.createTime)
      .map(Data => (Data.goodsId, 1))
      .keyBy(_._1)
      .window(SlidingEventTimeWindows.of(Time.seconds(30), Time.seconds(10)))
      .reduce((preData, curData) => (preData._1, preData._2 + curData._2))


    //TODO:4.sink
    resultDStream01.print("用户的最大消费订单信息:")
    resultDStream01.addSink(new MySQLSinkFunction)
    resultDStream02.print("用户的消费总额和订单数量：")
    resultDStream03.print("商品的销售数量：")
    //    sourceDStream.writeAsCsv("src\\main\\resources\\new_OrderSource.csv", WriteMode.OVERWRITE)


    //TODO:5.execution
    env.execute("OrderStream Job")

  }

  //自定义随机生成订单类
  class OrderSourceFunction extends RichSourceFunction[Order] {
    //定义变量
    private var count: Long = 0L
    private var isRunning: Boolean = true

    override def run(sourceContext: SourceFunction.SourceContext[Order]): Unit = {
      // 使用while循环生成1000个订单(订单编号ID、用户编号ID、商品编号ID、消费金额、消费时间 )
      while (isRunning && count < 1000) {
        // 随机生成订单ID（UUID）
        val itemId: String = UUID.randomUUID().toString
        // 随机生成用户编号ID（user1-user10）
        val userID: String = "user" + (Random.nextInt(10) + 1)
        // 随机生成商品编号ID（goods1-goods20）
        val goodsID: String = "goods" + (Random.nextInt(20) + 1)
        // 随机生成消费金额（100~1000）
        val price = Random.nextInt(900) + 101
        // 消费时间为当前系统时间
        val createTime: Long = System.currentTimeMillis()
        //        println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(createTime)))

        // 收集数据
        sourceContext.collect(Order(itemId, userID, goodsID, price, createTime))
        // 统计生成的订单数
        count += 1

        // 每隔1秒生成一个订单
        TimeUnit.SECONDS.sleep(1)
        //        TimeUnit.MILLISECONDS.sleep(1)
      }
    }

    override def cancel(): Unit = {
      isRunning = false
    }
  }

  //自定义MySQLSinkFunction类，将数据存储于MySQL中
  class MySQLSinkFunction extends RichSinkFunction[Order] {
    var connection: Connection = null
    var ps: PreparedStatement = null

    override def open(parameters: Configuration): Unit = {
      //加载驱动，打开连接
      Class.forName("com.mysql.jdbc.Driver")
      connection = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/数据库名?useSSL=false&characterEncoding=utf8",
        "用户名",
        "密码")

      ps = connection.prepareStatement("insert into 表名(itemId,userId,goodsId,price,createTime) values (?,?,?,?,?)")
    }

    override def invoke(value: Order, context: SinkFunction.Context): Unit = {
      //元组的主键，取系统此时的时间戳
      ps.setString(1, value.itemId)
      ps.setString(2, value.userId)
      ps.setString(3, value.goodsId)
      ps.setInt(4, value.price)
      ps.setLong(5, value.createTime)
      //执行sql语句
      ps.executeUpdate()

    }

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

  }

}

---

总结：本案例使用Stream API 和·Window API 对自定义数据流（循环生成1000条）进行处理并将数据存储于MySQL数据中！

后续会继续更新有关Flink Stream及Flink SQL的内容!
（注：第12次发文，如有错误和疑问，欢迎在评论区指出!）
——2021.10.14