Flink---各种输出（Sink）

最新推荐文章于 2023-12-05 16:07:29 发布
最新推荐文章于 2023-12-05 16:07:29 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： flink 文章标签： flink kafka mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43288259/article/details/118310037
版权

文章目录

一、kafka

Java

import Flink.beans.SensorReading;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSink;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer09;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class sink1_kafka {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		
		// 配置 kafka
        Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.159.100:9092");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"gro1");
        properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");	// 读取最新消息

		// 创建 FlinkKafkaConsumer (主题,SimpleStringSchema,kafka配置)
        DataStreamSource<String> dss = env.addSource(new FlinkKafkaConsumer011<String>("flinkKafka", new SimpleStringSchema(), properties));

		// 转换操作
        SingleOutputStreamOperator<String> result = dss.map(line -> {
            String[] split = line.split(",");
            SensorReading sr = new SensorReading(split[0], Long.valueOf(split[1]), Double.valueOf(split[2]));
            return sr.toString();
        });

		// sink ： 利用生产者再写入到新的主题中
        DataStreamSink<String> flinkKafka = result.addSink(new FlinkKafkaProducer09<String>(
                "192.168.159.100:9092","sensorOut",new SimpleStringSchema()));
        
        try {
            env.execute("kafka-sink");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Scala

import java.util.Properties

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.datastream.DataStreamSink
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.{FlinkKafkaConsumer011, FlinkKafkaProducer010}
import org.apache.kafka.clients.consumer.ConsumerConfig

object Sink1_Kafka {
  def main(args: Array[String]): Unit = {
	// 导入隐式类
    import org.apache.flink.api.scala._
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val properties = new Properties
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.159.100:9092")
    properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "group-3")
    properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest")

    val kafkaSource = new FlinkKafkaConsumer011[String]("flinkKafka",new SimpleStringSchema(),properties)

    val value: DataStream[String] = env.addSource(kafkaSource)

    val sinkStream: DataStreamSink[String] = value.addSink(new FlinkKafkaProducer010[String]("192.168.159.100:9092","sensorOut",new SimpleStringSchema()))

    env.execute("kafka-sink")
  }
}

二、MySQL

Java
【从kafka中读取，在写入到MySQL中】

import Flink.beans.SensorReading;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Properties;

public class sink2_Mysql {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
		
		// 配置 kafka
        Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.159.100:9092");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"gro2");
        properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");

		// 创建消费者...
        DataStreamSource<String> dss = env.addSource(new FlinkKafkaConsumer011<String>("flinkKafka", new SimpleStringSchema(), properties));

        SingleOutputStreamOperator<SensorReading> result = dss.map(line -> {
            String[] split = line.split(",");
            SensorReading sr = new SensorReading(split[0], Long.valueOf(split[1]), Double.valueOf(split[2]));
            return sr;
        });
		
		// 使用自定义方式处理
        result.addSink(new MyJDBCSink());

        try {
            env.execute("sink-mysql");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

	// 自定义类 extends RichSinkFunction,本来是应该继承SinkFunction，
	// 但是RichSinkFunction是其子类，拥有更多大方法
    private static class MyJDBCSink extends RichSinkFunction<SensorReading> {
        Connection conn = null;

        @Override
        // open: 配置连接数据库等信息
        public void open(Configuration parameters) throws Exception {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(
              "jdbc:mysql://192.168.159.100:3306/flinkDemo",
              "root",
              "root"
            );
        }

        @Override
        // invoke: sql 处理
        public void invoke(SensorReading value, Context context) throws Exception {
            String sql = "insert into sensor_temp values (?,?)";
            PreparedStatement prep = conn.prepareStatement(sql);
            PreparedStatement upprep = conn.prepareStatement("update sensor_temp set temp = ? where id =?");
            upprep.setDouble(1,value.getTemperature());
            upprep.setString(2,value.getId());
            upprep.execute();
            if(upprep.getUpdateCount()==0){
                prep.setString(1,value.getId());
                prep.setDouble(2,value.getTemperature());
                prep.execute();
            }
        }

        @Override
        // close: 关闭资源
        public void close() throws Exception {
            conn.close();
        }
    }
}

Scala

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

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.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011
import org.apache.kafka.clients.consumer.ConsumerConfig

case class Sensors(id:String,timestamp:Long,tempature:Double)  // 设置样例类用于存储

/*
*   从Kafka中读取消息，flink处理完后，并存放到Mysql
* */

object Sink2_Mysql {
  def main(args: Array[String]): Unit = {
    import org.apache.flink.api.scala._

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val properties = new Properties
    properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.159.100:9092")
    properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "group-3")
    properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")

    val kafkaSource = new FlinkKafkaConsumer011[String]("flinkKafka",new SimpleStringSchema(),properties)

    val kafkaStream: DataStream[String] = env.addSource(kafkaSource)

    val value: DataStream[Sensors] = kafkaStream.map(line => {
      val strs: Array[String] = line.split(",")
      val sensors = new Sensors(strs(0), strs(1).toLong, strs(2).toDouble)
      sensors
    })

    value.addSink(new MySinkFunction())
    env.execute("Sink-Mysql")
  }

  class MySinkFunction extends RichSinkFunction[Sensors]{
    var conn:sql.Connection = null;
    override def open(parameters: Configuration): Unit = {
      Class.forName("com.mysql.jdbc.Driver")
      conn = DriverManager.getConnection("jdbc:mysql://192.168.159.100:3306/flinkDemo", "root", "root")
    }

	// 在 invoke 函数中进行sql 处理
    override def invoke(value: Sensors, context: SinkFunction.Context[_]): Unit = {
      val sql = "insert into sensor1_temp values (?,?)"
      val prep: PreparedStatement = conn.prepareStatement(sql)
      val upprep: PreparedStatement = conn.prepareStatement("update sensor1_temp set temp = ? where id =?")
      upprep.setDouble(1, value.tempature)
      upprep.setString(2, value.id)
      upprep.execute
      if (upprep.getUpdateCount == 0) {
        prep.setString(1, value.id)
        prep.setDouble(2, value.tempature)
        prep.execute
      }
    }

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

三、Redis

package Flink.sink;

import Flink.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.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;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommandDescription;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisMapper;

public class sink3_Redis {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        
        // 读取文件
        String filePath = "D:\\peixun\\soft\\projects\\Flink\\resource\\b.txt";
        DataStreamSource<String> dataStreamSource = env.readTextFile(filePath);
		
		// 转换操作
        SingleOutputStreamOperator<SensorReading> map = dataStreamSource.map(line -> {
            String[] splits = line.split(",");
            return new SensorReading(splits[0], Long.valueOf(splits[1]), Double.valueOf(splits[2]));
        });

        // 配置redis
        FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder()
                .setHost("192.168.184.156")
                .setPort(6379)
                .setDatabase(0)
                .build();

        // 放入addSink(config,RedisMapper)
        map.addSink(new RedisSink<>(config, new RedisMapper<SensorReading>() {
            @Override
            public RedisCommandDescription getCommandDescription() {
                return new RedisCommandDescription(RedisCommand.HSET,"sensor");
            }

            @Override
            public String getKeyFromData(SensorReading sensorReading) {
                return sensorReading.getId();
            }

            @Override
            public String getValueFromData(SensorReading sensorReading) {
                return sensorReading.getTemperature().toString();
            }
        }));
        
        try {
            env.execute("redis-sink");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Shall潇
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【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-1.13.6_cdc
07-07
flink-1.13.6_cdc 部署资源包
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-clickhouse-sink:Flink水槽的Clickhouse
05-17
Flink-ClickHouse-Sink 描述 用于数据库的器。 由。 用于将数据加载到ClickHouse的高性能库。 它有两个触发器来加载数据：超时和缓冲区大小。 版本图 闪烁 flink-clickhouse-sink 1.3。* 1.0.0 1.9。* 1.3.1 安装 Maven中央 < dependency> < groupId>ru.ivi.opensource</ groupId> < artifactId>flink-clickhouse-sink</ artifactId> < version>1.3.1</ version> </ dependency> 用法 特性 flink-clickhouse-sink使用配置属性的两个部分：common和操作员链中的每个接收器。 共同的部分（像全局一样使用）： clickhouse
(11) flink中的sink数据输出
张不帅
09-11 1896
文章目录基于kafka的sink基于redis的sink 基于kafka的sink kafkaUtil中 def getProducer(topic: String): FlinkKafkaProducer011[String] = { new FlinkKafkaProducer011[String]("note01:9092,note02:9092,note03:9092",top...
Flink学习10---DataStream之Sink简介及RichSinkFunction
zhuzuwei的博客
07-05 6457
功能就是负责把 Flink 处理后的数据输出到外部系统中。 一、Flink针对DataStream提供了大量的已经实现的数据下沉（sink）方式，具体有： 1. writeAsText(): 将元素以字符串形式逐行写入，这些字符串通过调用每个元素的toString()方法来获取。 2. print() / printToErr(): 打印每个元素的toString()方法的值到标准输出或者标准错误输出流中。 3. 自定义输出：addSink可以实现把数据输出到第三方存储介质中。 Flink通过内置
Flink之输出算子 （Sink）
四维大脑的博客
04-24 4533
Flink 作为数据处理框架，最终还是要把计算处理的结果写入外部存储，为外部应用提供支持。我们已经了解了 Flink 程序如何对数据进行读取、转换等操作，最后一步当然就应该将结果数据保存或输出到外部系统了。
Flink输出算子Sink
Hardhen的博客
02-07 1072
滚动”的概念在日志文件的写入中经常遇到：因为文件会有内容持续不断地写入，所以我们应该给一个标准，到什么时候就开启新的文件，将之前的内容归档保存。StreamingFileSink 支持行编码（Row-encoded）和批量编码（Bulk-encoded，比如Parquet）格式。（basePath）和数据的编码逻辑（rowEncoder 或 bulkWriterFactory）。在创建行或批量编码Sink 时，我们需要传入两个参数，用来指定存储桶的基本路径。文件大小已达到1 GB。
Flink流批一体计算（23）：Flink SQL之多流kafka写入多个mysql sink
最新发布
victory0508的专栏
12-05 1204
WITH提供了一种编写辅助语句以用于更大的查询的方法。这些语句通常被称为公共表表达式（CTE），可以被视为定义仅针对一个查询存在的临时视图。json.fail-on-missing-field：在json缺失字段时是否报错。json.ignore-parse-errors：在解析json失败时是否报错。一般无法保证json格式，所以以上两个配置是比较重要的。注意：针对双流中的每条记录都发触发。mysql 建表语句。
Flink-输出算子(Sink)使用
m0_46507516的博客
11-18 2790
flink输出到kafka，elasticsearch，redis
Flink Table API/SQL 多分支sink
desmond的专栏
08-22 857
在某个场景中，需要从Kafka中获取数据，经过转换处理后，需要同时sink到多个输出源中(kafka、mysql、hologres)等。
apache-doris-flink-connector-1.14_2.12-1.0.3
05-05
Flink Doris Connector（apache-doris-flink-connector-1.14_2.12-1.0.3-incubating-src.tar.gz） Flink Doris Connector Version：1.0.3 Flink Version：1.14 Scala Version：2.12 Apache Doris是一个现代MPP...
flink-1.14.0-bin-scala_2.11.tgz
07-18
flink-1.14.0-bin-scala_2.11.tgz
apache-doris-flink-connector-1.13_2.12-1.0.3
05-05
Flink Doris Connector 源码（apache-doris-flink-connector-1.13_2.12-1.0.3-incubating-src.tar.gz） Flink Doris Connector Version：1.0.3 Flink Version：1.13 Scala Version：2.12 Apache Doris是一个现代...
FlinkSql（二）API使用-sink
星星的博客
08-09 1536
表的输出，是通过将数据写入 TableSink 来实现的。TableSink 是一个通用接口，可以支持不同的文件格式、存储数据库和消息队列。 具体实现，输出表最直接的方法，就是通过 Table.insertInto() 方法将一个 Table 写入注册过的 TableSink 中。
Flink 获取kafka数据 批量sinkHbase
wudonglianga的专栏
12-09 1937
1. 处理流程： 通过flink 从kafka 中获取到数据， 然后在sink 到hbase 中 数据结构 {"address":"深圳","age":20,"createTime":"2021-12-08 22:30","id":1,"name":"hdfs"} 2.Hbase 建表 hbase(main):002:0> create 'wudluser','cf', { NUMREGIONS => 15, SPLITALGO =>'HexStringSplit'} Created
FlinkKafkaProducer两阶段提交-TwoPhaseCommitSinkFunction过程简述
m0_47444428的博客
01-20 1073
两阶段提交 1 FlinkKafkaProducer继承了TwoPhaseCommitSinkFunction 类 2 TwoPhaseCommitSinkFunction类继承了RichSinkFunction类且实现了CheckPointedFunction接口以及CheckPointListener接口 3 FlinkKafkaProducer重写了TwoPhaseCommitSinkFunction类...
Flink实操 : Sink操作
张伯毅的专栏
03-03 2923
.一 .前言二 .类型2.1. 基于本地集合的sink2.2. 基于文件的sink2.2.1.将数据写入本地文件2.2.2.将数据写入HDFS2.3. Kafka Sink2.4. MySQL Sink 一 .前言 二 .类型 2.1. 基于本地集合的sink 目标: 基于下列数据,分别 进行打印输出,error输出,collect() (19, "zhangsan", 178.8), (17, "lisi", 168.8), (18, "wangwu", 184.8), (21, "zhaoliu", 1
Flink学习——处理不同数据源的流数据，存入不同的Sink端
Helen_1997_1997的博客
05-17 984
Flink学习——处理不同数据源的流数据，存入不同的Sink端 mysql、kafka、hbase、redis
flink实战--flinksql使用Streaming Sink将数据流写入文件系统
07-27
您需要定义一个输入表和一个输出表，以便在Flink SQL中引用它们。 ```java tableEnv.executeSql("CREATE TABLE inputTable (field1 INT, field2 STRING) WITH (...)"); tableEnv.executeSql("CREATE TABLE ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值