《初级》Flink API练习

最新推荐文章于 2024-08-24 10:12:47 发布
最新推荐文章于 2024-08-24 10:12:47 发布
阅读量346 收藏
点赞数
文章标签： flink 基础api flink 入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huzechen/article/details/100140768
版权

加微信拉微信交流群

微信：weixin605405145

Fliter

import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


public class TestFilter {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Long> input=env.generateSequence(-5,5);

        input.filter(new FilterFunction<Long>() {
            @Override
            public boolean filter(Long value) throws Exception {
                return value>0;
            }
        }).print();

        env.execute();
    }
}

IntervalJoin

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple5;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.functions.timestamps.AscendingTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;


public class TestIntervalJoin {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        DataStream<Transcript> input1=env.fromElements(TRANSCRIPTS).assignTimestampsAndWatermarks(new AscendingTimestampExtractor<Transcript>() {
            @Override
            public long extractAscendingTimestamp(Transcript element) {
                return element.time;
            }
        });


        DataStream<Student> input2=env.fromElements(STUDENTS).assignTimestampsAndWatermarks(new AscendingTimestampExtractor<Student>() {
            @Override
            public long extractAscendingTimestamp(Student element) {
                return element.time;
            }
        });

        KeyedStream<Transcript,String>  keyedStream=input1.keyBy(new KeySelector<Transcript, String>() {
            @Override
            public String getKey(Transcript value) throws Exception {
                return value.id;
            }
        });

        KeyedStream<Student,String>  otherKeyedStream=input2.keyBy(new KeySelector<Student, String>() {
            @Override
            public String getKey(Student value) throws Exception {
                return value.id;
            }
        });

        //e1.timestamp + lowerBound <= e2.timestamp <= e1.timestamp + upperBound

        // key1 == key2 && leftTs - 2 < rightTs < leftTs + 2

        keyedStream.intervalJoin(otherKeyedStream)
                .between(Time.milliseconds(-2), Time.milliseconds(2))
                .upperBoundExclusive()
                .lowerBoundExclusive()
                .process(new ProcessJoinFunction<Transcript, Student, Tuple5<String,String,String,String,Integer>>() {

                    @Override
                    public void processElement(Transcript transcript, Student student, Context ctx, Collector<Tuple5<String, String, String, String, Integer>> out) throws Exception {
                        out.collect(Tuple5.of(transcript.id,transcript.name,student.class_,transcript.subject,transcript.score));
                    }

                }).print();

        env.execute();

    }

    public static final Transcript[] TRANSCRIPTS = new Transcript[] {
            new Transcript("1","张三","语文",100,System.currentTimeMillis()),
            new Transcript("2","李四","语文",78,System.currentTimeMillis()),
            new Transcript("3","王五","语文",99,System.currentTimeMillis()),
            new Transcript("4","赵六","语文",81,System.currentTimeMillis()),
            new Transcript("5","钱七","语文",59,System.currentTimeMillis()),
            new Transcript("6","马二","语文",97,System.currentTimeMillis())
    };

    public static final Student[] STUDENTS = new Student[] {
            new Student("1","张三","class1",System.currentTimeMillis()),
            new Student("2","李四","class1",System.currentTimeMillis()),
            new Student("3","王五","class1",System.currentTimeMillis()),
            new Student("4","赵六","class2",System.currentTimeMillis()),
            new Student("5","钱七","class2",System.currentTimeMillis()),
            new Student("6","马二","class2",System.currentTimeMillis())
    };

    private static class Transcript{
        private String id;
        private String name;
        private String subject;
        private int score;
        private long time;

        public Transcript(String id, String name, String subject, int score, long time) {
            this.id = id;
            this.name = name;
            this.subject = subject;
            this.score = score;
            this.time = time;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getSubject() {
            return subject;
        }

        public void setSubject(String subject) {
            this.subject = subject;
        }

        public int getScore() {
            return score;
        }

        public void setScore(int score) {
            this.score = score;
        }

        public long getTime() {
            return time;
        }

        public void setTime(long time) {
            this.time = time;
        }
    }

    private static class Student{
        private String id;
        private String name;
        private String class_;
        private long time;

        public Student(String id, String name, String class_, long time) {
            this.id = id;
            this.name = name;
            this.class_ = class_;
            this.time = time;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getClass_() {
            return class_;
        }

        public void setClass_(String class_) {
            this.class_ = class_;
        }

        public long getTime() {
            return time;
        }

        public void setTime(long time) {
            this.time = time;
        }
    }
}

Connect

import org.apache.flink.streaming.api.datastream.ConnectedStreams;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoFlatMapFunction;
import org.apache.flink.util.Collector;


public class TestConnect {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Long> someStream = env.generateSequence(0,10);
        DataStream<String> otherStream = env.fromElements(WORDS);

        ConnectedStreams<Long, String> connectedStreams = someStream.connect(otherStream);

        DataStream<String> result=connectedStreams.flatMap(new CoFlatMapFunction<Long, String, String>() {

            @Override
            public void flatMap1(Long value, Collector<String> out) throws Exception {
                out.collect(value.toString());
            }

            @Override
            public void flatMap2(String value, Collector<String> out) {
                for (String word: value.split("\\W+")) {
                    out.collect(word);
                }
            }
        });

        result.print();

        env.execute();
    }

    public static final String[] WORDS = new String[] {
            "And thus the native hue of resolution",
            "Is sicklied o'er with the pale cast of thought;",
            "And enterprises of great pith and moment,",
            "With this regard, their currents turn awry,",
            "And lose the name of action.--Soft you now!",
            "The fair Ophelia!--Nymph, in thy orisons",
            "Be all my sins remember'd."
    };
}

 

KeyBy

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.datastream.*;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;


public class TestKeyBy {
    public static void main(String[] args) throws Exception {
        //统计各班语文成绩最高分是谁
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Tuple4<String,String,String,Integer>> input=env.fromElements(TRANSCRIPT);
//        System.out.println("-----------"+input.getParallelism());
        //input.print();

        KeyedStream<Tuple4<String,String,String,Integer>,Tuple> keyedStream = input.keyBy("f0");


//        KeyedStream<Tuple4<String,String,String,Integer>,String> keyedStream = input.keyBy(new KeySelector<Tuple4<String, String, String, Integer>, String>() {
//
//            @Override
//            public String getKey(Tuple4<String, String, String, Integer> value) throws Exception {
//                return value.f0;
//            }
//        });


//        keyedStream.process(new KeyedProcessFunction<Tuple, Tuple4<String,String,String,Integer>, Object>() {
//
//            @Override
//            public void processElement(Tuple4<String, String, String, Integer> value, Context ctx, Collector<Object> out) throws Exception {
//                System.out.println(ctx.getCurrentKey());
//            }
//        });
        //System.out.println("***********"+keyedStream.getParallelism());

//        System.out.println("---------444444---"+keyedStream.max(3).getParallelism());
        keyedStream.maxBy("f3").print();

        env.execute();

//        SingleOutputStreamOperator<Tuple4<String,String,String,Integer>> sumed=keyed.min(3);
//
//        //使用了DataStreamUtils就不需要env.execute()
//        Iterator<Tuple4<String,String,String,Integer>> it=DataStreamUtils.collect(sumed);
//
//        while (it.hasNext()){
//            System.out.println(it.next());
//        }

    }

    public static final Tuple4[] TRANSCRIPT = new Tuple4[] {
            Tuple4.of("class1","张三","语文",100),
            Tuple4.of("class1","李四","语文",78),
            Tuple4.of("class1","王五","语文",99),
            Tuple4.of("class2","赵六","语文",81),
            Tuple4.of("class2","钱七","语文",59),
            Tuple4.of("class2","马二","语文",97)
    };
}

Map

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


public class TestMap {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Long> input=env.generateSequence(0,10);

        DataStream plusOne=input.map(new MapFunction<Long, Long>() {

            @Override
            public Long map(Long value) throws Exception {
                System.out.println("--------------------"+value);
                return value+1;
            }
        });

        plusOne.print();

        env.execute();
    }
}

 

Fold

import org.apache.flink.api.common.functions.FoldFunction;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


public class TestFold {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Tuple4<String,String,String,Integer>> input=env.fromElements(TRANSCRIPT);

        DataStream<String> result =input.keyBy(0).fold("Start", new FoldFunction<Tuple4<String,String,String,Integer>,String>() {

            @Override
            public String fold(String accumulator, Tuple4<String, String, String, Integer> value) throws Exception {
                return accumulator + "=" + value.f1;
            }
        });

        result.print();

        env.execute();
    }

    public static final Tuple4[] TRANSCRIPT = new Tuple4[] {
            Tuple4.of("class1","张三","语文",100),
            Tuple4.of("class1","李四","语文",78),
            Tuple4.of("class1","王五","语文",99),
            Tuple4.of("class2","赵六","语文",81),
            Tuple4.of("class2","钱七","语文",59),
            Tuple4.of("class2","马二","语文",97)
    };
}

 

Reduce

import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class TestReduce {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Tuple4<String,String,String,Integer>> input=env.fromElements(TRANSCRIPT);

        KeyedStream<Tuple4<String,String,String,Integer>,Tuple> keyedStream = input.keyBy(0);

        keyedStream.reduce(new ReduceFunction<Tuple4<String, String, String, Integer>>() {
            @Override
            public Tuple4<String, String, String, Integer> reduce(Tuple4<String, String, String, Integer> value1, Tuple4<String, String, String, Integer> value2) throws Exception {
                value1.f3+=value2.f3;
                return value1;
            }
        }).print();

        env.execute();
    }


    public static final Tuple4[] TRANSCRIPT = new Tuple4[] {
            Tuple4.of("class1","张三","语文",100),
            Tuple4.of("class1","李四","语文",78),
            Tuple4.of("class1","王五","语文",99),
            Tuple4.of("class2","赵六","语文",81),
            Tuple4.of("class2","钱七","语文",59),
            Tuple4.of("class2","马二","语文",97)
    };
}

 

Project

import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;


public class TestProject {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<Tuple4<String,String,String,Integer>> input=env.fromElements(TRANSCRIPT);

        DataStream<Tuple2<String, Integer>> out = input.project(1,3);

        out.print();

        env.execute();

    }

    public static final Tuple4[] TRANSCRIPT = new Tuple4[] {
            Tuple4.of("class1","张三","语文",100),
            Tuple4.of("class1","李四","语文",78),
            Tuple4.of("class1","王五","语文",99),
            Tuple4.of("class2","赵六","语文",81),
            Tuple4.of("class2","钱七","语文",59),
            Tuple4.of("class2","马二","语文",97)
    };
}

 

SplitAndSelect

import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SplitStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.ArrayList;
import java.util.List;


public class TestSplitAndSelect {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Long> input=env.generateSequence(0,10);

        SplitStream<Long> splitStream = input.split(new OutputSelector<Long>() {

            @Override
            public Iterable<String> select(Long value) {
                List<String> output = new ArrayList<String>();
                if (value % 2 == 0) {
                    output.add("even");
                }
                else {
                    output.add("odd");
                }
                return output;
            }

        });

        //splitStream.print();

        DataStream<Long> even = splitStream.select("even");
        DataStream<Long> odd = splitStream.select("odd");
        DataStream<Long> all = splitStream.select("even","odd");

        //even.print();

        odd.print();

        //all.print();

        env.execute();
    }
}

 

Flatmap

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;


public class TestFlatmap {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<String> input=env.fromElements(WORDS);

        DataStream<String> wordStream=input.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {

                String[] tokens = value.toLowerCase().split("\\W+");

                for (String token : tokens) {
                    if (token.length() > 0) {
                        out.collect(token);
                    }
                }
            }
        });

        wordStream.print();

        env.execute();
    }

    public static final String[] WORDS = new String[] {
            "To be, or not to be,--that is the question:--",
            "Whether 'tis nobler in the mind to suffer",
            "The slings and arrows of outrageous fortune",
            "And by opposing end them?--To die,--to sleep,--",
            "Be all my sins remember'd."
    };
}

 

小晨说数据
关注
Flink API分层
蜗牛小将
10-13 1200
Flink API 分层介绍
flink api 简介
zxczb的博客
04-13 1450
1.1 不同级别的抽象 Flink API 最底层的抽象为有状态实时流处理。其抽象实现是 Process Function，并且 Process Function 被 Flink 框架集成到了 DataStream API 中来为我们使用。它允许用户在应用程序中自由地处理来自单流或多流的事件（数据），并提供具有全局一致性和容错保障的状态。此外，用户可以在此层抽象中注册事件时间（event time）和处理时间（processing time）回调方法，从而允许程序可以实现复杂计算。 Flink A
Flink编程练习（一）
crazy_scott的博客
12-11 1443
Flink编程练习，NYC出租车数据 环境配置 本项目参考这里，setup。 首先确保已经下载好flink依赖，并从Github下载代码。 下载依赖数据，这里依赖的是纽约出租车数据，可以使用命令行下载： wget http://training.data-artisans.com/trainingData/nycTaxiRides.gz wget http://training.da...
Flink练习
hsiehchou的博客
06-01 559
Flink练习 一、Flink开发IDEA环境搭建与测试 1、IDEA开发环境 先虚拟机联网，然后执行yum -y install nc nc是用来打开端口的工具 然后nc -l 9000 1.pom文件设置 <properties> <maven.compiler.source>1.8</maven.compiler.source> ...
Apache Flink 训练练习指南
最新发布
gitblog_00521的博客
08-24 935
Apache Flink 训练练习指南 flink-training-exercises项目地址:https://gitcode.com/gh_mirrors/fli/flink-training-exercises 1. 项目介绍 Apache Flink Training Exercises 是一个专为开发者设计的训练项目，旨在通过一系列的编程练习加深对Flink框架的理解。本项目与Apac...
Flink初次练习（Transformation）
曦玥Moonight的博客
11-08 194
Flink的官网：https://flink.apache.org/ 使用的软件：IntelliJ IDEA Community Edition 创建TransformationTest文件 练习一 将输入的数字均乘10 package cn.tedu.dataset; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.ExecutionEnvironment; import
Flink1.12-2021黑马 6-7Table&SQL +实战
紫蝶侠的博客
03-16 1387
7.Flink-Action综合练习 课程目标 掌握使用Flink实现模拟双十一实时大屏统计 掌握使用Flink实现订单自动好评 1. Flink模拟双十一实时大屏统计 1.1 需求 在大数据的实时处理中，实时的大屏展示已经成了一个很重要的展示项，比如最有名的双十一大屏实时销售总价展示。除了这个，还有一些其他场景的应用，比如我们在我们的后台系统实时的展示我们网站当前的pv、uv等等，其实做法都是类似的。 今天我们就做一个最简单的模拟电商统计大屏的小例子， 需求如下： 1.实时计算出当天零点截止到当前时
Flink初次练习（Source、Sink）
曦玥Moonight的博客
11-08 222
Flink的官网：https://flink.apache.org/ 使用的软件：IntelliJ IDEA Community Edition 第一个练习： 读取目录下的文件并打印输出 package cn.tedu.dataset; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataSource; import org.apache.flink.st
Flink JavaAPI开发
05-30
此案例使用的是IDEA开发工具，项目属于maven项目 ...使用Flink JavaAPI实现的流处理、批处理（其中还包括Table API的使用和SQL API的使用），主要针对（《Flink入门与实战》徐葳著）教材中的实验使用
flink-java-1.14.3-API文档-中文版.zip
06-06
包含翻译后的API文档：flink-java-1.14.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.flink:flink-java:1.14.3； 标签：apache、flink、java、中文文档、jar包； 使用方法：解压翻译后的API文档，用...
flink-table-api-java-bridge_2.11-1.12.7-API文档-中文版.zip
07-12
赠送jar包：flink-table-api-java-bridge_2.11-1.12.7.jar； 赠送原API文档：flink-table-api-java-bridge_2.11-1.12.7-javadoc.jar； 赠送源代码：flink-table-api-java-bridge_2.11-1.12.7-sources.jar； 赠送...
myflink：我的flink练习项目
02-22
myflink：我的flink练习项目
flink-training:Apache Flink培训练习
03-19
Apache Flink培训练习 练习以及文档中的培训内容。 目录 设置您的开发环境 以下说明将指导您完成设置开发环境的过程，以开发，调试和执行Flink开发人员培训练习和示例的解决方案。 软件需求 Flink支持Linux，OS X和Windows作为Flink程序和本地执行的开发环境。 Flink开发设置需要以下软件，并且应将其安装在系统上： Java 8或Java 11的JDK（JRE不够；不支持Java的其他版本） 吉特 具有Gradle支持的Java（和/或Scala）开发IDE。我们建议您使用IntelliJ，但是只要您坚持使用Java，也可以使用Eclipse或Visual Studio Code。对于Scala，您将需要使用IntelliJ（及其Scala插件）​​。 :information: Windows用户注意事项：培训说明中提供的Shell命令示例适用于UNIX系统。为了使事情变得
Flink热门电影实时统计（模仿双十一实时大屏统计）
qq_43521665的博客
04-03 693
本实验根据累计观影人数，判断电影的热门程度 实验要求： 实时计算出三天内截止到当前时间的观影人数 计算出电影观影人数的Top3，并输出对应电影 每秒钟更新一次统计结果 附加：实时计算出电影的平均评分，如果电影人数相同，则输出分数高的 实验过程： 数据源会源源不断地产生数据流，根据电影ID，对电影的观影人数进行累加，并对电影评分求平均。 每秒钟收集一次窗口结果数据，将聚合结果打包成对象，该对象中包含了打包时间，使用这个打包时间代替事件发生时间 按照时间分组，每1s更新截至当前时间的累计总人数和平均分，并
Flink批处理练习
影子
03-04 191
idea、Flink、maven <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:/..
flink 练习
xuwenxinxjzy的博客
06-11 126
111。
《初级》Flink 窗口函数练习
huzechen的博客
08-29 426
加微信拉微信交流群 微信：weixin605405145 ProcessWinFunOnWindow import org.apache.flink.api.java.tuple.Tuple; import org.apache.flink.api.java.tuple.Tuple3; import org.apache.flink.streaming.api.datastream.Dat...
《初级》Flink 异步io练习
huzechen的博客
08-29 196
加微信拉微信交流群 微信：weixin605405145 AsyncIO import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.api.java.utils.ParameterTo...
Flink Top N/连续性数据处理问题-练习记录
weixin_40503364的博客
08-11 608
5 自定义实现开窗函数 （第四步的累加器输出结果交给这里的开窗函数处理，包装成前面自定义的输出格式输出数据）2 根据UserBehavior类的itemId分类，类的timestamp位时间戳，统计pv值。4 自定义实现累加器，输出结果为后者的input:Iterable[Long]1 自定义类，定义数据的输入和输出格式，语言为scala。3 添加开窗函数聚合，做count聚合次数。6 添加 process 进行统计数据整理。7 自定义TopN逻辑。...
Flink Table API Java 1.12.7 中文API文档完整版
资源摘要信息: "flink-table-api-java-1.12.7-API文档-中文版.zip" 文件是一个压缩包，其中包含了Apache Flink的Table API的Java版本1.12.7的相关文件和资源。它提供了一个完整的Java API，用于关系型流处理和批处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值