FlinkSQL的读入和写出数据

最新推荐文章于 2024-04-30 17:01:14 发布
最新推荐文章于 2024-04-30 17:01:14 发布
阅读量1.3k 收藏 4
点赞数
文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45150724/article/details/114407059
版权

文章目录

读取数据

file类型的source

package day06;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.FileSystem;
import org.apache.flink.table.descriptors.OldCsv;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.table.types.DataType;
import org.apache.flink.types.Row;

public class FlinkSQL03_Source_File {

    public static void main(String[] args) throws Exception {

        //1、创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2、构建文件的连接器
        //这里的path是指的是文件名
        //从文件sensor中读取数据数据，然后将数据放到一张零时表中。
        tableEnv.connect(new FileSystem().path("sensor"))
                .withFormat(new OldCsv())
                .withSchema(new Schema()
                .field("id", DataTypes.STRING())
                .field("ts",DataTypes.BIGINT())
                .field("temp",DataTypes.DOUBLE())
                )
                .createTemporaryTable("sensorTable");
           //source是追加流，因为是一条一条的进来的。

        
        //---------下面的部分相当于不属于source。往外对接的时候，往一些地方写的时候，作为输入流，是支持撤回流的。

         //3、读取数据创建表，通过 TableAPI 查询算子，得到一张表。
        Table sensortable = tableEnv.from("sensorTable");

        //4、TableAPI，然后通过继续查询得到想要的表。
        Table  tableResult = sensortable.select("id,temp").where("id='sensor_1'");

        //5、SQL方式
        Table sqlResult = tableEnv.sqlQuery("select id,ts from sensorTable where id ='sensor_7'");

        //6、转换成流打印输出
        
        //从文件章中读取的数据，不能使用聚合函数，也就是最后的输出流是追加流。
       tableEnv.toAppendStream(tableResult, Row.class).print("Table");
       tableEnv.toAppendStream(sqlResult,Row.class).print("SQL");

        //7、执行
        env.execute();
    }

}

kafka类型的source

package day06;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Csv;
import org.apache.flink.table.descriptors.Json;
import org.apache.flink.table.descriptors.Kafka;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;
import org.apache.kafka.clients.consumer.ConsumerConfig;

public class FlinkSQL04_Source_Kafka {

    public static void main(String[] args) throws Exception {

        //1.创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.创建Kafka的连接器
        tableEnv.connect(new Kafka()
                .version("0.11")
                .topic("test")
                .property(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092")
                .property(ConsumerConfig.GROUP_ID_CONFIG, "BigData0720"))
                //.withFormat(new Csv())
                .withFormat(new Json())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("ts", DataTypes.BIGINT())
                        .field("temp", DataTypes.DOUBLE()))
                .createTemporaryTable("kafka");

        //这里说的是进来的source，是source，将数据读取到一张临时表中.

        
        
//---------------------------------------------------------------------        
        
       //---Table API的做法 
        //3.创建表
        Table table = tableEnv.from("kafka");

        //4.TableAPI
        Table tableResult = table.groupBy("id").select("id,temp.max");
//---------------------------------------------------------------------       
        
        //--SQL
        //5.SQL的做法
        Table sqlResult = tableEnv.sqlQuery("select id,min(temp) from kafka group by id");

        //6.转换为流进行输出
        
        //上面用了聚合函数，所以这里用的是可撤回流。
        tableEnv.toRetractStream(tableResult, Row.class).print("Table");
        tableEnv.toRetractStream(sqlResult, Row.class).print("SQL");

        //7.执行
        env.execute();


        // bin/kafka-console-producer.sh  --broker-list hadoop102:9092 --topic test
        //   {"id":"sensor_1","ts":"15477112198","temp":"46.8"}

    }

}

输出数据

file类型的sink

package day06;

import bean.SensorReading;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.FileSystem;
import org.apache.flink.table.descriptors.OldCsv;
import org.apache.flink.table.descriptors.Schema;

public class FlinkSQL05_Sink_File {

    public static void main(String[] args) throws Exception {

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.读取端口数据转换为JavaBean
        SingleOutputStreamOperator<SensorReading> sensorDS = env.socketTextStream("hadoop102", 9999)
                .map(line -> {
                    String[] fields = line.split(",");
                    return new SensorReading(fields[0],
                            Long.parseLong(fields[1]),
                            Double.parseDouble(fields[2]));
                });

    //-----------常规套路部分。

   //因为我们要做的是sink，所以还没有collect，我们collect的输出端，所以不能创建临时表。
   
       //对于用tableAPI的方式，先是将流转换为表，然后从这张表中查询，得到一张表。
	   //对于sql的这种方式，是用流创建一个临时视图，然后从临时视图中查询，得到一张表。
	   //这两张表将起到中介的作用，将来临时表通过这里的表进行传输到外部的文件。
	   

        //3.对流进行注册，从流中创建表。
        Table table = tableEnv.fromDataStream(sensorDS);

        //4.TableAPI
        Table tableResult = table.select("id,temp");   //将查询的数据放到tableresult这张表中。

        //5.SQL
        tableEnv.createTemporaryView("sensor", sensorDS);                      //将流的数据给了临时视图sensor。这里的视图相当于是一张临时表。
        Table sqlResult = tableEnv.sqlQuery("select id,temp from sensor");    //然后用SQL查询时查询这个视图中的数据，放到sqlResult表中。

   //-----------------写入到文件系统中

        //6.创建文件连接器
		
		//输出路径:tableOut,这是一个文件，在idea上可以看到它的位置。
		//输出的表名:outTable1，临时表，在idea上看不到，因为时临时的。
		
		
		//创建文件连接器，只有collect之后才能创建临时表。
        
        //对于输出到的是文件来说
        //发现，只有collect后面的new xxx() 之后的那个path才是正在的文件的路径。
        tableEnv.connect(new FileSystem().path("tableOut"))
                .withFormat(new OldCsv())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("temp", DataTypes.DOUBLE()))
                .createTemporaryTable("outTable1");


        tableEnv.connect(new FileSystem().path("sqlOut"))
                .withFormat(new OldCsv())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("temp", DataTypes.DOUBLE()))
                .createTemporaryTable("outTable2");


        //7.将数据写入文件系统
		
		//tableResult中的数据通过临时表，将数据放到tableOut这个文件中。
        tableEnv.insertInto("outTable1", tableResult);
		//sqlResult中的数据通过临时表，将数据放到sqlOut这个文件中。
        tableEnv.insertInto("outTable2", sqlResult);

        
        //8.执行
        env.execute();

    }

}

kafka类型的sink

package day06;

import bean.SensorReading;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.*;
import org.apache.kafka.clients.producer.ProducerConfig;

public class FlinkSQL06_Sink_Kafka {

    public static void main(String[] args) throws Exception {

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.读取端口数据转换为JavaBean
        SingleOutputStreamOperator<SensorReading> sensorDS = env.socketTextStream("hadoop102", 9999)
                .map(line -> {
                    String[] fields = line.split(",");
                    return new SensorReading(fields[0],
                            Long.parseLong(fields[1]),
                            Double.parseDouble(fields[2]));
                });

  //对传过来的数据进行处理，最后发给Kafka，也就是sink连接至Kafka。是写出的方式，这里用到的是一个insertinto方法。表明直接写出。
  //Kafka也在官网上规定了，只能直接输出，不能用撤回流或者修改的那中方式。      
        
        //3.对流进行注册
        Table table = tableEnv.fromDataStream(sensorDS);

        //4.TableAPI
        Table tableResult = table.select("id,temp");

        //5.SQL
        tableEnv.createTemporaryView("sensor", sensorDS);
        Table sqlResult = tableEnv.sqlQuery("select id,temp from sensor");

        //6.创建Kafka连接器
        tableEnv.connect(new Kafka()
                .topic("test")
                .version("0.11")
                .property(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092"))
                //.withFormat(new Json())
                .withFormat(new Csv())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("temp", DataTypes.DOUBLE()))
                .createTemporaryTable("kafkaOut");

        
        //7.将数据写入文件系统
        tableEnv.insertInto("kafkaOut", tableResult);  //临时表kafkaOut通过tableResult，写到Kafka。
        tableEnv.insertInto("kafkaOut", sqlResult);    //临时表kafkaOut通过tableResult，写到Kafka。

        //8.执行
        env.execute();

    }

}
kafka到kafka
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Csv;
import org.apache.flink.table.descriptors.Kafka;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;

public class FlinkSQL_Test06 {

    public static void main(String[] args) throws Exception {

        //1.创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.定义Kafka输入描述器,创建临时表.
        tableEnv.connect(new Kafka()
                .version("0.11")
                .topic("test")   //主题。
                .property("bootstrap.servers", "hadoop102:9092")) 
                .withFormat(new Csv())
                .withSchema(
                new Schema()
                .field("id", DataTypes.STRING())
                .field("ts", DataTypes.BIGINT())
                .field("temp", DataTypes.DOUBLE()) 
                 )
                .createTemporaryTable("KafkaInput");  //创建临时表。


        //4.执行SQL查询数据
        Table table = tableEnv.sqlQuery("select id,temp from KafkaInput where id='sensor_1'");

        //5.定义Kafka输出连接器,创建临时表。
       tableEnv.connect(new Kafka()
                .version("0.11")
                .topic("sinkTest")   //主题。
                .property("bootstrap.servers", "hadoop102:9092")) 
                .withFormat(new Csv())
                .withSchema(
                 new Schema()
                .field("id", DataTypes.STRING())  //我们select的时候就选择了这连个字段，最后查询出来就是这两个字段。
               .field("temp", DataTypes.DOUBLE())
                )            
                .createTemporaryTable("KafkaOutPut"); //创建临时表。

        //6.将数据输出到Kafka的另一个主题
        tableEnv.insertInto("KafkaOutPut", table);

        //7.执行任务
        env.execute();

    }

}

ES类型的Sink

ES知识点回顾
PUT stu
{
  "mappings": {
    "_doc":{
      "properties":{
        "id":{
          "type":"keyword"
        },
        "name":{
          "type":"text"
        },
        "sex":{
          "type":"integer"
        },
        "birth":{
          "type":"date"
        }
      }
    }
  }
}

—————————————华丽分割符————————————————
###############对上面命令做个简单解释
PUT stu （stu类似于MySQL中的数据库名）
{
  "mappings": {	（"mappings"可以理解为建表语句 create table关键字）
    "_doc":{		（"_doc"相当于MySQL中表名）
      "properties":{	（"properties"相当于建表语句中要指定字段及字段类型的关键字）"id":{           （" id "相当于具体某个字段）
          "type":"keyword"（"type"相当于要指定字段类型的关键字，"keyword "相当于字段的具体类型）

        },
        "name":{
          "type":"text"
        },
        "sex":{
          "type":"integer"
        },
        "birth":{
          "type":"date"
        }
      }
    }
  }
}

//---创建文档

PUT stu/_doc/1001
{
  "id":"001",
  "name":"红红",
  "sex":0,
  "birth":"1999-01-01"
}

—————————————华丽分割符————————————————
###############对上面命令做个简单解释
PUT stu/_doc/1001  （相当于指定要插入到哪个库的哪个表的哪个id中，类似于hbase的rowkey）
{
  "id":"001",		（字段具体的值）
  "name":"红红",
  "sex":0,
  "birth":"1999-01-01"
}


//----
GET stu/_search
输出结果如下：
{
  "took" : 9,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,  （切片总数）
    "successful" : 
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {   （命中）
    "total" : 1, （命中总数一条）
    "max_score" : 1.0, （数据在里面存储的时候是有一个评分，这个评分是按照搜索的关键字跟文章的匹配度得来的，如果这个关键字在文章中出现频率较高，这个分数也相应的较大）
    "hits" : [
      {
        "_index" : "stu",
        "_type" : "_doc",
        "_id" : "1001",   //在表中的位置。
        "_score" : 1.0,
        "_source" : {  （具体的数据）
          "id" : "001",
          "name" : "红红",
          "sex" : 0,
          "birth" : "1999-01-01"
                   }
      }
    ]
  }
}

package day06;

import bean.SensorReading;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.*;
import org.apache.kafka.clients.producer.ProducerConfig;

public class FlinkSQL07_Sink_ES {

    public static void main(String[] args) throws Exception {

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.读取端口数据转换为JavaBean
        SingleOutputStreamOperator<SensorReading> sensorDS = env.socketTextStream("hadoop102", 9999)
                .map(line -> {
                    String[] fields = line.split(",");
                    return new SensorReading(fields[0],
                            Long.parseLong(fields[1]),
                            Double.parseDouble(fields[2]));
                });

        //3.对流进行注册
        Table table = tableEnv.fromDataStream(sensorDS);

        //4.TableAPI
        Table tableResult = table.select("id,temp");

        //5.SQL，从输入的流中创建临时表。
        tableEnv.createTemporaryView("sensor", sensorDS);
        Table sqlResult = tableEnv.sqlQuery("select id,temp from sensor");

        //6.创建ES连接器
        tableEnv.connect(new Elasticsearch()
                .version("6")  //es的版本
                .host("hadoop102", 9200, "http")
                .index("sensor1")        //索引(也就是数据库)
                .documentType("_doc")    //文档所属类型名,相当于MySQL中的表名。
                .bulkFlushMaxActions(1))  //来一条刷写一次
                .withFormat(new Json())   //json格式
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("temp", DataTypes.DOUBLE()))
                .inAppendMode()              //用的追加模式,es中的id是随机给的。
                .createTemporaryTable("Es");

        //7.将数据写入文件系统，这里的insert只是一个方法，不是流。
       tableEnv.insertInto("Es", tableResult);//临时表Es中的数据，经过表tableResult发送到Elasticsearch。
       tableEnv.insertInto("Es", sqlResult);//临时表Es中的数据，经过表sqlResult发送到Elasticsearch。

        //8.执行
        env.execute();

    }

}
kafka写到ES当中
package day06;

import bean.SensorReading;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.*;
import org.apache.kafka.clients.producer.ProducerConfig;

public class FlinkSQL07_Sink_ES {

    public static void main(String[] args) throws Exception {

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);


        //2.定义Kafka输入描述器,创建临时表.
        tableEnv.connect(new Kafka()
                .version("0.11")
                .topic("test")   //主题。
                .property("bootstrap.servers", "hadoop102:9092")) 
                .withFormat(new Csv())
                .withSchema(
                new Schema()
                .field("id", DataTypes.STRING())
                .field("ts", DataTypes.BIGINT())
                .field("temp", DataTypes.DOUBLE()) 
                 )
                .createTemporaryTable("KafkaInput");  //创建临时表。


        //5.SQL
        Table sqlResult = tableEnv.sqlQuery("select id,temp from KafkaInput");

        //6.创建ES连接器
        tableEnv.connect(new Elasticsearch()
                .version("6")
                .host("hadoop102", 9200, "http")
                .index("sensor1")
                .documentType("_doc")
                .bulkFlushMaxActions(1))
                .withFormat(new Json())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("temp", DataTypes.DOUBLE()))
                .inAppendMode()              //用的追加模式,es中的id是随机给的。
                .createTemporaryTable("Es"); //创建临时表。

        //7.将数据写入文件系统，这里的insert只是一个方法，不是流。
       tableEnv.insertInto("Es", sqlResult);//临时表Es中的数据，经过表sqlResult发送到Elasticsearch。

        //8.执行
        env.execute();

    }

}
例子

使用FlinkSQL实现从Kafka读取数据计算WordCount并将数据写入ES中

package practice;

import bean.word;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
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.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.*;
import org.apache.flink.types.Row;
import org.apache.flink.util.Collector;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;



/**
 * @author zb
 * @create 2020-12-18 8:32
 */
//输入数据如下:
//hello,atguigu,hello
//hello,spark
//hello,flink
//
//使用FlinkSQL实现从Kafka读取数据计算WordCount并将数据写入ES中




public class Flink08 {
    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.从Kafka读取数据创建流
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "Bigdata");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");

        DataStreamSource<String> sensorDS = env.addSource(new FlinkKafkaConsumer011<String>(
                "test",
                new SimpleStringSchema(),
                properties));


        SingleOutputStreamOperator<word> wordDS = sensorDS.flatMap(new FlatMapFunction<String, word>() {
            @Override
            public void flatMap(String value, Collector<word> out) throws Exception {
                String[] fields = value.split(",");
                for (String field : fields) {
                    out.collect(new word(field, 1L));
                }
            }
        });


        //5.SQL
        tableEnv.createTemporaryView("wordDS", wordDS);
        Table sqlResult = tableEnv.sqlQuery("select id,count(id) ct from wordDS group by id");

        //6.创建ES连接器
        tableEnv.connect(new Elasticsearch()
                .version("6")
                .host("hadoop102", 9200, "http")
                .index("wordcount")
                .documentType("_doc")
                .bulkFlushMaxActions(1))
                .withFormat(new Json())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("ct", DataTypes.BIGINT()))
                .inUpsertMode()
                .createTemporaryTable("Es");

        tableEnv.toRetractStream(sqlResult, Row.class).print();
        tableEnv.insertInto("Es", sqlResult);

        //7.执行
        env.execute();
    }
}

//开窗，事件时间只看WeaterMark


package bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zb
 * @create 2020-12-11 10:47
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
public class word {
    private String id;
    private Long count;

}

Sink_ES_Upsert

package day06;

import bean.SensorReading;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.java.StreamTableEnvironment;
import org.apache.flink.table.descriptors.Elasticsearch;
import org.apache.flink.table.descriptors.Json;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;

public class FlinkSQL08_Sink_ES_Upsert {

    public static void main(String[] args) throws Exception {

        //1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //获取TableAPI执行环境
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        //2.定义Kafka输入描述器,创建临时表.
        tableEnv.connect(new Kafka()
                .version("0.11") //Kafka的版本。
                .topic("test")   //主题。
                .property("bootstrap.servers", "hadoop102:9092")) 
                .withFormat(new Csv())
                .withSchema(
                new Schema()
                .field("id", DataTypes.STRING())
                .field("ts", DataTypes.BIGINT())
                .field("temp", DataTypes.DOUBLE()) 
                 )
                .createTemporaryTable("KafkaInput");  //创建临时表。


        //5.SQL
        Table sqlResult = tableEnv.sqlQuery("select id,min(temp) from KafkaInput group by id");

        //6.创建ES连接器
        tableEnv.connect(new Elasticsearch()
                .version("6")   //es的版本。
                .host("hadoop102", 9200, "http")
                .index("sensor4")
                .documentType("_doc")
                .bulkFlushMaxActions(1))
                .withFormat(new Json())
                .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("ts", DataTypes.BIGINT())
                        .field("temp", DataTypes.DOUBLE()))
                .inUpsertMode()  //用的是upsert模式。
                .createTemporaryTable("Es");

        //7.将数据写入文件系统
        tableEnv.insertInto("Es", sqlResult);

        //8.执行
        env.execute();

    }

}

需要注意的地方:

//-----TableApi-需要注意的一点是:

 Table table = tableEnv.fromDataStream(sensorDS);
 Table tableResult = table.groupBy("id,ts").select("id,ts,temp.min");


  我们要添加字段的时候，在ES中添加之外，也就是这里添加field的时候
      .withSchema(new Schema()
                        .field("id", DataTypes.STRING())
                        .field("ts", DataTypes.BIGINT())
                        .field("temp", DataTypes.DOUBLE()))

要注意的是，查询语句中，这些字段都是会出现的，如果一个是出现在group by之后，那么其他的肯定出现在聚合函数里面。

group by后面字段，作为ES中的doc_id。

两个流进行测试的时候，第一个流进行写入到ES之后，注释掉之后，换成另一个流的时候，因为是一条新的流，流中没有进行可以比较的数据，它的布尔值是一个true，那么就会写到ES里面，那么同一个id下的数据就会被覆盖掉。因为系统里面已经有数据了，没有办法和其他的流之前写入的数据进行比较，所以会覆盖掉。
Null is Null
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++使用htslib库读入和写出bam文件的实例
08-28
下面小编就为大家分享一篇C++使用htslib库读入和写出bam文件的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
易语言进度读入写出
07-23
易语言进度读入写出源码,进度读入写出
【Flink SQL】Flink SQL 基础概念（三）：SQL 动态表 & 连续查询
书山有路，学海无涯。记录成长，追逐梦想
03-14 1344
物化视图其实就是一条 SQL 查询，就像常规的虚拟视图 VIEW 一样。但与虚拟视图不同的是，物化视图会缓存查询的结果，因此在请求访问视图时不需要对查询进行重新计算，可以直接获取物化视图的结果，小伙伴萌可以认为物化视图其实就是把结果缓存了下来。
flink从数据库读数据
weixin_46054799的博客
03-22 4377
package com.example.flink; import org.apache.flink.api.common.typeinfo.BasicTypeInfo; import org.apache.flink.api.common.typeinfo.TypeInformation; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataSourc.
Flink1.12 SQL连接器之JDBC Connector介绍与使用总结
俩只猴的博客
02-08 5048
前言 与DataStream同样，官方在Flink SQL上也提供了很多连接器，今天来学习总结一下JDBC连接器 环境准备 如果使用编码，需要引入两个依赖包，Flink提供的jdbc连接器依赖和和对应的mysql驱动包， 以下为1.12.0 提供的jdbc连接器依赖 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-jdbc_2.11</art
Flink各类关键数据格式读取/SQL支持
立志宜思真品格，读书须尽苦功夫。
05-04 1832
目前事件归并分为两种，一种为实时的归并，即基于Kafka内的数据进行归并和事件生成；一种是周期性的归并，即基于Hive中的数据进行数据的归并和事件生成。 基于SQL归并时Spark Streaming支持的输入/输出数据如下： 数据类型 Flink支持情况 Kafka 需要定义schema HDFS(parquet/csv/textfile) 读取parquet需要使用Avr...
Flink通过读取sql语句，执行代码
qq_31866793的博客
10-09 2722
参考：http://wuchong.me/blog/2019/09/02/flink-sql-1-9-read-from-kafka-write-into-mysql/ 参考：https://github.com/wuchong/flink-sql-submit 1）做一个最简单的sql配置文件 -- -- 开启 mini-batch -- SET table.exec.mini-batch.enabled=true; -- -- mini-batch的时间间隔，即作业需要额外忍受的延迟 -.
flink读取MySQL维表,3、flinksql 表（读取外部文件）
weixin_30991735的博客
03-19 426
1、TableEnvironment 可以注册目录 Catalog， 可以基于catalog 注册表2、表 是由一个标识符 来指定的， 由三部分组成：catalog、 数据库名、对象名3、表可以是常规的，也可以是虚拟的(视图)4、常规表一般可以用来描述外部数据， 比如文件、数据库或消息队列的数据，也可以直接从datastream转换过来5、视图可以从现有的表中创建，通常是table api 或者 ...
flink 1.10.1 java版本jdbc source从mysql读取数据
liaomingwu的专栏
02-09 1644
flink 1.10.1 java版本jdbc source从mysql读取数据
flink数据源读取方式
qq_36213530的博客
08-15 463
package apiTest import java.util.{Properties, Random} import org.apache.flink.api.common.serialization.SimpleStringSchema import org.apache.flink.streaming.api.functions.source.SourceFunction import org.apache.flink.streaming.api.scala._ import org.apac.
易语言源码易语言进度读入写出.rar
02-22
易语言源码易语言进度读入写出.rar 易语言源码易语言进度读入写出.rar 易语言源码易语言进度读入写出.rar 易语言源码易语言进度读入写出.rar 易语言源码易语言进度读入写出.rar 易语言源码易语言进度读入写出....
AD,DA模拟量的读入和写出.zip三菱PLC编程案例源码资料编程控制器应用通讯通信例子程序实例
04-23
AD,DA模拟量的读入和写出.zip三菱PLC编程案例源码资料编程控制器应用通讯通信例子程序实例AD,DA模拟量的读入和写出.zip三菱PLC编程案例源码资料编程控制器应用通讯通信例子程序实例AD,DA模拟量的读入和写出.zip三菱...
AD,DA模拟量的读入和写出.rar
05-02
三菱PLC例程_本资料仅供个人供学习与参考
Flink checkpoint 源码分析- Flink Checkpoint 触发流程分析
TONIYH的博客
04-29 782
Flink的checkpoint的过程依赖于异步屏障快照算法，该算法在《Lightweight Asynchronous Snapshots for Distributed Dataflows》这篇paper中被提出。理解了这篇paper也就明白了flink的chekpoint机制。paper整体来说比较简单易懂，这篇博文主要是介绍flink中checkpoint触发流程。持续分析学习~
Flink checkpoint 源码分析- Checkpoint barrier 传递源码分析
TONIYH的博客
04-30 834
在上一篇的博客里，大致介绍了flink checkpoint中的触发的大体流程，现在介绍一下触发之后下游的算子是如何做snapshot。
7、Flink 自定义 WaterMarkGenerator 案例
猫猫爱吃小鱼粮
04-29 717
Flink 自定义 WaterMarkGenerator 案例
infrared-remote-candroid studiodemo
最新发布
05-05
android studio下载
flink sql客户端 接收数据
07-28
Flink SQL 客户端可以通过不同的方式接收数据，包括从文件、Kafka、Socket 等源获取数据。下面是一些常用的接收数据的方法： 1. 从文件读取数据：可以使用 `CREATE TABLE` 语句创建表，并通过 `INSERT INTO` 语句将文件中的数据插入到表中。例如： ```sql CREATE TABLE myTable ( id INT, name STRING ) WITH ( 'connector' = 'filesystem', 'path' = '/path/to/file.csv', 'format' = 'csv' ); INSERT INTO myTable SELECT * FROM file; ``` 2. 从 Kafka 读取数据：使用 Kafka connector 可以方便地从 Kafka 主题中读取数据。首先需要在 Flink 中添加 Kafka connector 的依赖，然后可以通过以下方式将 Kafka 主题中的数据读入表中： ```sql CREATE TABLE myTable ( id INT, name STRING ) WITH ( 'connector' = 'kafka', 'topic' = 'myTopic', 'properties.bootstrap.servers' = 'localhost:9092', 'format' = 'csv' ); ``` 3. 通过 Socket 接收数据：可以使用 Socket connector 在指定的端口监听来自外部系统的数据。以下是一个接收字符串数据并将其插入到表中的示例： ```sql CREATE TABLE myTable ( content STRING ) WITH ( 'connector' = 'socket', 'hostname' = 'localhost', 'port' = '9999', 'format' = 'csv' ); ``` 这些只是 Flink SQL 客户端接收数据的几种常见方式，具体的使用方法可以根据实际需求进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值