Flink学习——处理不同数据源的流数据，存入不同的Sink端

已于 2023-05-24 11:07:44 修改
阅读量1k 收藏 2
点赞数
分类专栏： # Flink-scala版 文章标签： flink 学习 scala
于 2023-05-17 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helen_1997_1997/article/details/130704427
版权

目录

一、单机版安装

(一)添加依赖

(二)数据源——Source

1.加载元素数据

2.加载集合数据

3.加载文件目录

4.加载端口

5.加载kafka的topic——重要&常用

6.加载自定义数据源

(三)输出端——Sink

1.读取文件中的数据，处理后输出到另一个文件

2.Source——文件&Sink——Mysql

3.读取kafka的数据，处理后传入mysql中

4.加载kafka中topic的数据，处理后传入另一个topic

5.加载kafka中topic的数据，处理后传入HBase中

6. 加载kafka中topic的数据，处理后传入redis中

一、单机版安装

Flink单机版的安装只需要把压缩包解压即可。

[root@ant168 install]# ls
flink-1.13.2-bin-scala_2.12.tgz  mongodb-linux-x86_64-4.0.10.tgz
kafka_2.12-2.8.0.tgz             zookeeper-3.4.5-cdh5.14.2.tar.gz
[root@ant168 install]# tar -zxf /opt/install/flink-1.13.2-bin-scala_2.12.tgz -C /opt/soft/

# 开启flink客户端
[root@ant168 flink-1.13.2]# ./bin/start-cluster.sh 

[root@ant168 flink-1.13.2]# jps
9050 Jps
1628 StandaloneSessionClusterEntrypoint
1903 TaskManagerRunner

WebUI：localhost:8081

(一)添加依赖

创建maven项目，quickstart

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <flink.version>1.13.2</flink.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <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.commons</groupId>
      <artifactId>commons-compress</artifactId>
      <version>1.21</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-connector-kafka_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-statebackend-rocksdb_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-table-planner_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-table-planner-blink_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-csv</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.29</version>
    </dependency>
    <!--<dependency>-->
    <!--<groupId>org.apache.bahir</groupId>-->
    <!--<artifactId>flink-connector-redis_2.12</artifactId>-->
    <!--<version>1.0</version>-->
    <!--</dependency>-->

    <!--  scala  -->
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-scala_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <artifactId>flink-streaming-scala_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>

    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <version>3.1.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-hdfs</artifactId>
      <version>3.1.3</version>
    </dependency>
    <dependency>
      <groupId>org.apache.flink</groupId>
      <!--<artifactId>flink-connector-kafka-0.11_2.11</artifactId>-->
      <artifactId>flink-connector-kafka_2.12</artifactId>
      <version>${flink.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-client</artifactId>
      <version>2.3.5</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-server</artifactId>
      <version>2.3.5</version>
    </dependency>
  </dependencies>

(二)数据源——Source

1.加载元素数据

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

object SourceTest {
  def main(args: Array[String]): Unit = {
    // TODO 1.创建环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) // 设置并行度

    // TODO 2.添加数据源
    // TODO 加载元素
    val stream1: DataStream[Any] = env.fromElements(1, 2, 3, 4, 5, "hello")

    // TODO 3.输出
    stream1.print()
    env.execute("sourcetest")
  }
}

运行结果：
1
2
3
4
5
hello

2.加载集合数据

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

// 定义一个样例类——温度传感器
case class SensorReading(id: String, timestamp: Long, temperature: Double)

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

    val dataList = List(
          SensorReading("sensor_1", 1684201947, 36.8),
          SensorReading("sensor_2", 1684202000, 35.7),
          SensorReading("sensor_3", 1684202064, 36.3),
          SensorReading("sensor_4", 1684202064, 35.8)
        )
    val stream1: DataStream[SensorReading] = env.fromCollection(dataList)

    stream1.print()
    env.execute("sourcetest")
  }
}

运行结果：

SensorReading(sensor_1,1684201947,36.8)
SensorReading(sensor_2,1684202000,35.7)
SensorReading(sensor_3,1684202064,36.3)
SensorReading(sensor_4,1684202064,35.8)

3.加载文件目录

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

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

    val path = "D:\\javaseprojects\\flinkstu\\resources\\sensor.txt"
    val stream1: DataStream[String] = env.readTextFile(path)

    stream1.print()
    env.execute("sourcetest")
  }
}

运行结果：
sensor_1,1684201947,36.8
sensor_7,1684202000,17.7
sensor_4,1684202064,20.3
sensor_2,1684202064,35.8

4.加载端口

虚拟机要下载nc命令，已经下载的可以忽略

yum -y install nc
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment

object SourceTest {
  def main(args: Array[String]): Unit = {
    // TODO 1.创建环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)    
    val stream1: DataStream[String] = env.socketTextStream("ant168", 7777)
    stream1.print()
    env.execute("sourcetest")
  }
}

5.加载kafka的topic——重要&常用

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.apache.kafka.clients.consumer.ConsumerConfig

import java.util.Properties

object SourceTest {
  def main(args: Array[String]): Unit = {
    // TODO 1.创建环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val properties = new Properties()
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "ant168:9092")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "sensorgroup1")
    val stream1: DataStream[String] = env.addSource(new FlinkKafkaConsumer[String]("sensor", new SimpleStringSchema(), properties))
    // 注意：重新启动就不会读取topic之前的数据

    stream1.print()
    env.execute("sourcetest")
  }
}

运行结果：

hello
world
# 1.开启zookeeper和kafka
zkServer.sh status
nohup kafka-server-start.sh /opt/soft/kafka212/config/server.properties &

# 2.创建topic
kafka-topics.sh --create --zookeeper ant168:2181 --topic sensor --partitions 1 --replication-factor 1

# 3.开始生产消息
kafka-console-producer.sh --topic sensor --broker-list ant168:9092
>hello
>world

6.加载自定义数据源

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

import scala.util.Random

// 定义一个样例类——温度传感器
case class SensorReading(id: String, timestamp: Long, temperature: Double)

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

   // TODO 读取自定义数据源
    val stream1: DataStream[SensorReading] = env.addSource(new MySensorSource)

    // TODO 3.输出
    stream1.print()
    env.execute("sourcetest")
  }
}

// 自定义数据源
class MySensorSource() extends SourceFunction[SensorReading] {
  override def run(sourceContext: SourceFunction.SourceContext[SensorReading]): Unit = {
    val random = new Random()
    while (true) {
      val i: Int = random.nextInt()
      sourceContext.collect(SensorReading("生成: " + i, 1, 1))
    }
    Thread.sleep(500)
  }

  override def cancel(): Unit = {
  }
}

运行结果：

SensorReading(生成: -439723144,1,1.0)
SensorReading(生成: -937590179,1,1.0)
SensorReading(生成: -40987764,1,1.0)
SensorReading(生成: 525868361,1,1.0)
SensorReading(生成: -840926328,1,1.0)
SensorReading(生成: -998392768,1,1.0)
SensorReading(生成: -1308765349,1,1.0)
SensorReading(生成: -806454922,1,1.0)

(三)输出端——Sink

1.读取文件中的数据，处理后输出到另一个文件

import source.SensorReading
import org.apache.flink.api.common.serialization.SimpleStringEncoder
import org.apache.flink.core.fs.Path
import org.apache.flink.streaming.api.functions.sink.filesystem.StreamingFileSink
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment

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

    val path = "D:\\javaseprojects\\flinkstu\\resources\\sensor.txt"
    val stream1: DataStream[String] = env.readTextFile(path)

    val dataStream: DataStream[SensorReading] = stream1.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
    })

//    dataStream.print()
//    writeAsCsv方法已过时
//    dataStream.writeAsCsv("D:\\javaseprojects\\flinkstu\\resources\\out.txt")

    dataStream.addSink(
      StreamingFileSink.forRowFormat(
      new Path("D:\\javaseprojects\\flinkstu\\resources\\out1.txt"),
      new SimpleStringEncoder[SensorReading]()
    ).build()
    )

    env.execute("sinktest")
  }
}

out1.txt文件内容：

SensorReading(sensor_1,1684201947,36.8)
SensorReading(sensor_7,1684202000,17.7)
SensorReading(sensor_4,1684202064,20.3)
SensorReading(sensor_2,1684202064,35.8)

2.Source——文件&Sink——Mysql

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

import java.sql.{Connection, DriverManager, PreparedStatement}
/**
 * 将flink处理后的数据传入mysql中
 */
object JdbcSinkTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) 

    // TODO 从文件中读取数据存入mysql中
    val path = "D:\\javaseprojects\\flinkstu\\resources\\sensor.txt"
    val stream1: DataStream[String] = env.readTextFile(path)

    // TODO 处理文件数据
    val dataStream: DataStream[SensorReading] = stream1.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
    })

    dataStream.addSink(new MyJdbcSink)
    env.execute("jdbc sink test")
  }
}

class MyJdbcSink extends RichSinkFunction[SensorReading] {
  var connection: Connection = _

  var insertState: PreparedStatement = _
  var updateState: PreparedStatement = _

  override def open(parameters: Configuration): Unit = {
    connection = DriverManager.getConnection("jdbc:mysql://192.168.180.141:3306/kb21?useSSL=false", "root", "root")

    insertState = connection.prepareStatement("insert into sensor_temp(id,temp) value (?,?)")
    updateState = connection.prepareStatement("update sensor_temp set temp=? where id=?")
  }

  override def invoke(value: SensorReading, context: SinkFunction.Context): Unit = {
    updateState.setDouble(1, value.temperature)
    updateState.setString(2, value.id)
    val i: Int = updateState.executeUpdate()
    println(i)
    // 当原表中没有数据时，就不能执行update语句，所以影响的行数==0，而是执行insert语句
    // 反之，当原表中有数据，就执行update语句，影响的行数为1
    if (i == 0) {
      insertState.setString(1, value.id)
      insertState.setDouble(2, value.temperature)
      insertState.execute()
    }
  }

  override def close(): Unit = {
    insertState.close()
    updateState.close()
    connection.close()
  }
}

数据源：

D:\javaseprojects\flinkstu\resources\sensor.txt

sensor_1,1684201947,36.8
sensor_2,1684202000,17.7
sensor_1,1684202064,20.3
sensor_2,1684202068,35.8

DataGrip操作：

drop table sensor_temp;
create table sensor_temp(
    id varchar(32),
    temp double
);

select * from sensor_temp;

每次只获取最新的数据。

3.读取kafka的数据，处理后传入mysql中

import source.SensorReading
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.apache.kafka.clients.consumer.ConsumerConfig

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

/**
 * 将flink处理kafka后的数据传入mysql中
 */
object KafkaToMysqlSinkTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) // 设置并行度

    // TODO 从kafka中读取数据
    val properties = new Properties()
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "ant168:9092")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "sensorgroup1")

    // TODO 订阅topic
    val stream1: DataStream[String] = env.addSource(new FlinkKafkaConsumer[String]("sensor", new SimpleStringSchema(), properties))

    // TODO 处理topic数据
    val dataStream: DataStream[SensorReading] = stream1.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
    })

    // TODO 处理后的topic数据存入mysql中
    dataStream.addSink(new MysqlSink)
    env.execute("kafka sink test")
  }
}

class MysqlSink extends RichSinkFunction[SensorReading] {
  var connection: Connection = _

  var insertState: PreparedStatement = _
  var updateState: PreparedStatement = _

  override def open(parameters: Configuration): Unit = {
    connection = DriverManager.getConnection("jdbc:mysql://192.168.180.141:3306/kb21?useSSL=false", "root", "root")

    insertState = connection.prepareStatement("insert into sensor_temp(id,temp) value (?,?)")
    updateState = connection.prepareStatement("update sensor_temp set temp=? where id=?")
  }

  override def invoke(value: SensorReading, context: SinkFunction.Context): Unit = {
    updateState.setDouble(1, value.temperature)
    updateState.setString(2, value.id)
    val i: Int = updateState.executeUpdate()
    println(i)
    // 当原表中没有数据时，就不能执行update语句，所以影响的行数==0，而是执行insert语句
    // 反之，当原表中有数据，就执行update语句，影响的行数为1
    if (i == 0) {
      insertState.setString(1, value.id)
      insertState.setDouble(2, value.temperature)
      insertState.execute()
    }
  }

  override def close(): Unit = {
    insertState.close()
    updateState.close()
    connection.close()
  }
}

kafka生产消息：

[root@ant168 opt]# kafka-console-producer.sh --topic sensor --broker-list ant168:9092
>sensor_1,1684201947,36.8
>sensor_1,1684201947,36.10            
>sensor_2,1684202068,35.8

Mysql数据库：

4.加载kafka中topic的数据，处理后传入另一个topic

import source.SensorReading
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.{FlinkKafkaConsumer, FlinkKafkaProducer}
import org.apache.kafka.clients.consumer.ConsumerConfig

import java.util.Properties

/**
 * 将flink处理kafka后的数据传入kafka中
 */
object KafkaToKafkaSinkTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) // 设置并行度

    // TODO 从kafka中读取数据
    val properties = new Properties()
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "ant168:9092")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "sensorgroup1")

    // TODO 订阅topic
    val stream1: DataStream[String] = env.addSource(new FlinkKafkaConsumer[String]("sensor", new SimpleStringSchema(), properties))

    // TODO 处理topic数据
    val dataStream: DataStream[String] = stream1.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble).toString()
    })

    // TODO 处理后的topic数据存入另一个topic中
    dataStream.addSink(
      new FlinkKafkaProducer[String]("ant168:9092","sensorsinkout",new SimpleStringSchema())
    )
    env.execute("kafka sink test")
  }
}

        注意：这里默认是latest提交方式，如果程序中断，kafka生产者此时传入数据，重新开启该程序，后面传入的数据也会被消费。

5.加载kafka中topic的数据，处理后传入HBase中

HBase中创建表和列簇：

hbase(main):002:0> create_namespace 'ha' 

hbase(main):004:0> create 'ha:test','sensor'

hbase(main):006:0> list_namespace_tables 'ha'

Flink代码：

import source.SensorReading
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.apache.hadoop.conf
import org.apache.hadoop.hbase.client.{BufferedMutator, BufferedMutatorParams, ConnectionFactory, Put}
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.hbase.{HBaseConfiguration, HConstants, TableName, client}
import org.apache.kafka.clients.consumer.ConsumerConfig

import java.util.Properties
/**
 * 将数据流处理后写入到HBase中
 */
object KafkaToHBaseSinkTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) // 设置并行度

    // TODO 从kafka中读取数据
    val properties = new Properties()
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "ant168:9092")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "sensorgroup1")

    // TODO 订阅topic
    val stream1: DataStream[String] = env.addSource(new FlinkKafkaConsumer[String]("sensor", new SimpleStringSchema(), properties))

    // TODO 处理topic数据
    val dataStream: DataStream[SensorReading] = stream1.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
    })

    // TODO 处理后的topic数据存入HBase中
    dataStream.addSink(new MyHBaseSink)
    env.execute("HBase sink test")
  }
}

class MyHBaseSink extends RichSinkFunction[SensorReading] {
  var connection: client.Connection = _
  var mutator: BufferedMutator = _

  override def open(parameters: Configuration): Unit = {
    val configuration: conf.Configuration = HBaseConfiguration.create()
    configuration.set(HConstants.HBASE_DIR, "hdfs://lxm147:9000/hbase")
    configuration.set(HConstants.ZOOKEEPER_QUORUM, "lxm147")
    configuration.set(HConstants.CLIENT_PORT_STR, "2181")
    connection = ConnectionFactory.createConnection(configuration)

    val params = new BufferedMutatorParams(TableName.valueOf("ha:test"))
    params.writeBufferSize(10 * 1024 * 1024) // 达到缓存进行写入
    params.setWriteBufferPeriodicFlushTimeoutMs(5 * 1000L) // 达不到缓存但是达到时间也进行写入

    mutator = connection.getBufferedMutator(params)
  }

  override def invoke(value: SensorReading, context: SinkFunction.Context): Unit = {
    println(connection)
    println(mutator)
    println(value)
    val put = new Put(Bytes.toBytes(value.id + value.temperature + value.timestamp))
    put.addColumn("sensor".getBytes(), "id".getBytes(), value.id.getBytes())
    put.addColumn("sensor".getBytes(), "timestamp".getBytes(), value.timestamp.toString.getBytes)
    put.addColumn("sensor".getBytes(), "temperature".getBytes(), value.temperature.toString.getBytes())
    mutator.mutate(put)
    mutator.flush()
  }

  override def close(): Unit = {
    connection.close()
  }
}

kafka中传入数据：

[root@ant168 flink-1.13.2]# kafka-console-producer.sh --topic sensor --broker-list ant168:9092
>sensor_4 , 1684202064, 27.3                                                                                                                                                
>sensor_2,1684202068,  35.8

HBase中查看表数据：

hbase(main):010:0> scan 'ha:test'
ROW                                       COLUMN+CELL  
 sensor_235.81684202068                   column=sensor:id, timestamp=2023-05-17T09:44:41.123, value=sensor_2
 sensor_235.81684202068                   column=sensor:temperature, timestamp=2023-05-17T09:44:41.123, value=35.8
 sensor_235.81684202068                   column=sensor:timestamp, timestamp=2023-05-17T09:44:41.123, value=1684202068 
 sensor_427.31684202064                   column=sensor:id, timestamp=2023-05-17T09:21:41.475, value=sensor_4
 sensor_427.31684202064                   column=sensor:temperature, timestamp=2023-05-17T09:21:41.475, value=27.3 
 sensor_427.31684202064                   column=sensor:timestamp, timestamp=2023-05-17T09:21:41.475, value=1684202064

6. 加载kafka中topic的数据，处理后传入redis中

<dependency>
      <groupId>org.apache.bahir</groupId>
      <artifactId>flink-connector-redis_2.12</artifactId>
      <version>1.1.0</version>
    </dependency>
package nj.zb.kb21.sink

import nj.zb.kb21.source.SensorReading
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.streaming.connectors.redis.RedisSink
import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig
import org.apache.flink.streaming.connectors.redis.common.mapper.{RedisCommand, RedisCommandDescription, RedisMapper}

/**
 * 将flink处理后的数据传入redis中
 */
object RedisSinkTest {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1) // 设置并行度

    val inputStream: DataStream[String] = env.socketTextStream("192.168.180.141", 7777)

    val dataStream: DataStream[SensorReading] = inputStream.map(data => {
      val arr: Array[String] = data.split(",")
      SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
    })

    val redisConf: FlinkJedisPoolConfig = new FlinkJedisPoolConfig.Builder()
      .setHost("192.168.180.141")
      .setPort(6379)
      .setTimeout(30000)
      .build()

    dataStream.addSink(new RedisSink[SensorReading](redisConf,new MyRedisMapper))

    env.execute("redis sink test")
  }
}

class MyRedisMapper extends RedisMapper[SensorReading] {
  override def getCommandDescription: RedisCommandDescription = {
    new RedisCommandDescription(RedisCommand.HSET, "sensor")
  }

  override def getKeyFromData(data: SensorReading): String = {
    data.id
  }

  override def getValueFromData(data: SensorReading): String = {
    data.timestamp+":"+data.temperature
  }
}

Redis Desktop

雷神乐乐
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink Connector
07-05 213
已迁移。
【Flink实战系列】Flink 如何实现多个 sink 输出
热门推荐
JasonLee实时计算
02-04 1万+
在实际的生产环境中,我们的Flink任务可能需要同时写入多个存储,也就说会有多个sink,当然Flink是支持多个Sink,而且多个sink之间是并行的关系,互相也没有影响,具体的实现代码如下: package flink.table import java.sql.Timestamp import java.util.TimeZone import flink.util.CommonUti...
flink-connector-redis_2.10-1.1.5-API文档-中英对照版.zip
07-14
赠送jar包：flink-connector-redis_2.10-1.1.5.jar； 赠送原API文档：flink-connector-redis_2.10-1.1.5-javadoc.jar； 赠送源代码：flink-connector-redis_2.10-1.1.5-sources.jar； 赠送Maven依赖信息文件：flink-connector-redis_2.10-1.1.5.pom； 包含翻译后的API文档：flink-connector-redis_2.10-1.1.5-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.apache.flink:flink-connector-redis_2.10:1.1.5； 标签：apache、flink、connector、redis、中英对照文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
Flink多sink输出
zxczb的博客
06-01 1万+
Flink多sink Flink单一流多sink 通过OutputTag侧输出多个计算结果(同一结果对象需要进行copy再设置至侧输出流, 暂不支持同对象多次输出)进行sink Flink多阶段sink 通过OutputTag侧输出第一次计算结果进行sink 主流继续计算, 最后再sink package com.gin.demo; import lombok.*; import org.apache.flink.api.common.functions.MapFunction; import org.a
Flink：配置多个数据源和多个数据源并行处理
程序员无羡的博客
04-16 1312
Flink：配置多个数据源和多个数据源并行处理
Flink输出算子Sink
Hardhen的博客
02-07 1134
滚动”的概念在日志文件的写入中经常遇到：因为文件会有内容持续不断地写入，所以我们应该给一个标准，到什么时候就开启新的文件，将之前的内容归档保存。StreamingFileSink 支持行编码（Row-encoded）和批量编码（Bulk-encoded，比如Parquet）格式。（basePath）和数据的编码逻辑（rowEncoder 或 bulkWriterFactory）。在创建行或批量编码Sink 时，我们需要传入两个参数，用来指定存储桶的基本路径。文件大小已达到1 GB。
基于Java的Flink流批一体数据处理快速集成开发框架设计源码
最新发布
03-29
这是一个基于Java的Flink流批一体数据处理快速集成开发框架设计，使用Java语言开发，包含203个文件。主要文件类型包括169个Java源文件、11个XML文件、7个gitignore文件、3个PNG图片文件、2个Markdown文档、2个...
剑指大数据——Flink学习精要_java版
04-21
* 都是大数据处理框架，但 Flink 更加注重实时数据处理和流处理。 * Flink 能够更好地处理大规模数据，具有更高的性能和可扩展性。 Flink 的特点包括： * 高性能：Flink 能够实时处理大规模数据，具有高性能和低...
Flink入门：读取Kafka实时数据流，实现WordCount
01-07
本文主要介绍Flink接收一个Kafka文本数据流，进行WordCount词频统计，然后输出到标准输出上。通过本文你可以了解如何编写和运行Flink程序。 代码拆解 首先要设置Flink的执行环境： // 创建Flink执行环境 ...
基于flink-cdc实现监控数据源的实时变更数据捕获
06-06
cdc技术分析文章，基于flink-cdc做监控数据源的实时变更数据捕获。该文从基础定义、使用场景、分析、实际使用流程、源码分析、常见问题及解决方式等几个方向讲解了这个技术栈。如果公司有要使用搜索方案，涉及到业务...
浅谈Flink分布式运行时和数据流图的并行化
01-07
关于Flink WordCount程序可以参考我之前的文章：读取Kafka实时数据流，实现Flink WordCount。阅读完本文后，读者可以对Flink的分布式运行时有一个全面的认识。 1 Flink数据流图简介 1.1 Flink作业的逻辑视图 在...
Flink Table 的三种 Sink 模式
secretWHD的博客
01-05 1855
作为计算引擎 Flink 应用的计算结果总要以某种方式输出，比如调试阶段的打印到控制台或者生产阶段的写到数据库。而对于本来就需要在 Flink 内存保存中间及最终计算结果的应用来说，比如进行聚合统计的应用，输出结果便是将内存中的结果同步到外部。 就 Flink Table/SQL API 而言，这里的同步会有三种模式，分别是 Append、Upsert 和 Retract。实际上这些输出计算结果的模式并不限于某个计算框架，比如 Storm、Spark 或者 Flink Da...
flink维表查询redis之flink-connector-redis
zilong00007的专栏
03-10 6699
相对bahir增加的内容有：Table API, 维表查询。参考了腾讯云与阿里云两家主流云产商的流计算产品，取两家之长，并增加了更丰富的功能。
Flink 流处理API
qq_70085330的博客
08-31 833
Flink流处理APl：1：从集合读取数据2：从文件读取数据 3：以Kafka消息队列的数据作为来源
flink连接redis工具类-简单好用
weixin_45399602的博客
05-07 3028
简单易容的flink redis 工具
Flink之输出算子 （Sink）
四维大脑的博客
04-24 4620
Flink 作为数据处理框架，最终还是要把计算处理的结果写入外部存储，为外部应用提供支持。我们已经了解了 Flink 程序如何对数据进行读取、转换等操作，最后一步当然就应该将结果数据保存或输出到外部系统了。
Flink之Sink
SuperBoy_Liang的博客
03-16 1637
Flink 的 DataStream API 专门提供了向外部写入数据的方法：addSink。与 addSource 类似，addSink 方法对应着一个“Sink”算子，主要就是用来实现与外部系统连接、并将数据提交写入的；Flink 程序中所有对外的输出操作，一般都是利用 Sink 算子完成的。
Flink流批一体计算（23）：Flink SQL之多流kafka写入多个mysql sink
victory0508的专栏
12-05 1326
WITH提供了一种编写辅助语句以用于更大的查询的方法。这些语句通常被称为公共表表达式（CTE），可以被视为定义仅针对一个查询存在的临时视图。json.fail-on-missing-field：在json缺失字段时是否报错。json.ignore-parse-errors：在解析json失败时是否报错。一般无法保证json格式，所以以上两个配置是比较重要的。注意：针对双流中的每条记录都发触发。mysql 建表语句。
Flink系列（二）-- Flink的数据源详解
xcvbxv01的博客
11-18 2083
原文地址（包含源码和图片）：http://note.youdao.com/noteshare?id=c91f71fd16bedf7dfaac3b6fa663a243&sub=B79A8354FB1D4CB5BE44A1513C4F7A6C 一、DataSource 1、Flink 做为一款流式计算框架，它可用来做批处理，即处理静态的数据集、历史的数据集；也可以用来做流处理，...
flink股票价格数据流处理
10-19
Flink是一个开源的分布式流处理框架，它提供了强大的数据流处理能力。在处理股票价格数据时，Flink可以帮助我们实现实时的数据分析、计算和预测。 首先，我们可以使用Flink连接并读取股票价格数据流，这可以通过从消息队列、Kafka主题或其他数据源中消费数据来实现。然后，我们可以应用Flink提供的数据转换和操作函数来进行数据处理，例如过滤、映射、聚合等。我们可以根据股票价格的要求，自定义相应的处理逻辑。 其次，Flink还支持窗口操作，这对于股票价格数据流处理非常有用。我们可以定义滚动窗口、滑动窗口或会话窗口，以便对一定时间范围内的股票价格数据进行计算和分析。例如，我们可以计算某个窗口内的平均股票价格、最高价或最低价等。 另外，Flink还提供了状态管理功能，这对于股票价格数据流处理非常重要。我们可以在处理过程中维护和更新状态，以便实时跟踪和分析股票价格的变化。例如，我们可以记录某只股票的历史价格、成交量等。 最后，Flink还支持与外部系统的连接和集成，例如数据库、存储、API等。这可以让我们将股票价格数据与其他数据源和服务进行集成，以便获取更全面的信息和进行更高级的分析。例如，我们可以将股票价格数据与交易量、新闻事件等数据进行关联分析，以便预测股票市场的趋势。 总而言之，Flink是一个非常适合处理股票价格数据流的框架。它提供了灵活且高效的数据处理能力，可以实现实时的数据分析、计算和预测。无论是数据提取、转换、窗口操作还是状态管理，Flink都能满足股票价格数据处理的需求，并且提供了与外部系统的连接和集成能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值