Flink学习系列之六 DataSetAPI

最新推荐文章于 2023-04-11 16:38:59 发布
最新推荐文章于 2023-04-11 16:38:59 发布
阅读量269 收藏
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GoSaint/article/details/102863595
版权

1 DataSet API之Data Sources

  • 基于文件 readTextFile(path)
  • 基于集合 fromCollection(Collection)

    上述的API之前都已经使用过，这里不在赘述。

2 Transformations部分详解

  • Map：输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作
  • FlatMap：输入一个元素，可以返回零个，一个或者多个元素
  • MapPartition：类似map，一次处理一个分区的数据【如果在进行map处理的时候需要获取第三方资源链接，建议使用MapPartition】
  • Filter：过滤函数，对传入的数据进行判断，符合条件的数据会被留下
  • Reduce：对数据进行聚合操作，结合当前元素和上一次reduce返回的值进行聚合操作，然后返回一个新的值
  • Aggregate：sum、max、min等
  • Distinct：返回一个数据集中去重之后的元素，data.distinct()
  • Join：内连接
  • OuterJoin：外链接
  • Cross：获取两个数据集的笛卡尔积
  • Union：返回两个数据集的总和，数据类型需要一致
  • First-n：获取集合中的前N个元素
  • Sort Partition：在本地对数据集的所有分区进行排序，通过sortPartition()的链接调用来完成对多个字段的排序

上述的API，我红色标注出来的就是我在这里演示的。其余的API在DataStream API里面基本学习过了。

2.1 MapPartition

package com.caozg.batch;

import org.apache.flink.api.common.functions.MapPartitionFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.util.Collector;

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

/**
 * MapPartition：类似map，一次处理一个分区的数据【如果在进行map处理的时候需要获取第三方资源链接，建议使用MapPartition】
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: MapPartitionHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午7:32
 * @UpdateDate: 19-11-1 下午7:32
 * @Version: 1.0
 */
public class MapPartitionHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment environment = ExecutionEnvironment.getExecutionEnvironment();
        List<String> data=new ArrayList<>();
        data.add("hello you");
        data.add("hello me");
        DataSource<String> dataSource = environment.fromCollection(data);

        DataSet<String> dataSet = dataSource.mapPartition(new MapPartitionFunction<String, String>() {
            @Override
            public void mapPartition(Iterable<String> values, Collector<String> out) throws Exception {
                //这里是获取一个分区的链接，只获取一次就可以完成处理，不像map,需要多次获取。

                for (Iterator<String> iterator = values.iterator(); iterator.hasNext(); ) {
                    String[] valueArray = iterator.next().split("\\W+");
                    for (String value : valueArray) {
                        out.collect(value);
                    }
                }
            }
        });

        dataSet.print();
        
    }
}

结果如下：

hello
you
hello
me

2.2 Distinct

package com.caozg.batch;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapPartitionFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.operators.FlatMapOperator;
import org.apache.flink.util.Collector;

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

/**
 * Distinct：返回一个数据集中去重之后的元素，data.distinct()
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: MapDistinctHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午7:32
 * @UpdateDate: 19-11-1 下午7:32
 * @Version: 1.0
 */
public class MapDistinctHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment environment = ExecutionEnvironment.getExecutionEnvironment();
        List<String> data = new ArrayList<>();
        data.add("hello you");
        data.add("hello me");
        DataSource<String> dataSource = environment.fromCollection(data);
        dataSource.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                String[] split = value.split("\\W+");
                for (String val : split) {
                    System.out.println("单词：" + val);
                    out.collect(val);
                }
                System.out.println("===============>");
            }
        }).distinct().print();


    }
}

结果如下：

单词：hello
单词：you
===============>
单词：hello
单词：me
===============>
you
me
hello

2.3 Join

package com.caozg.batch;

import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;

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

/**
 * 连接 类似于sql中的连接查询
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: MapJoinHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午7:32
 * @UpdateDate: 19-11-1 下午7:32
 * @Version: 1.0
 */
public class MapJoinHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();

        List<Tuple2<Integer, String>> data1 = new ArrayList<>();
        data1.add(new Tuple2<>(1, "小明"));
        data1.add(new Tuple2<>(2, "丽丽"));
        data1.add(new Tuple2<>(3, "陆瓷"));

        List<Tuple2<Integer, String>> data2 = new ArrayList<>();
        data2.add(new Tuple2<>(1, "江西"));
        data2.add(new Tuple2<>(2, "纽约"));
        data2.add(new Tuple2<>(3, "成都"));

        DataSource<Tuple2<Integer, String>> t1 = e.fromCollection(data1);
        DataSource<Tuple2<Integer, String>> t2 = e.fromCollection(data2);

        // where的条件是指定关联的字段，equalTO是关联字相等
        t1.join(t2).where(0)
                .equalTo(0)
                .with(new JoinFunction<Tuple2<Integer, String>, Tuple2<Integer, String>,
                        Tuple3<Integer, String, String>>() {
                    @Override
                    public Tuple3<Integer, String, String> join(Tuple2<Integer, String> first, Tuple2<Integer, String> second)
                            throws Exception {
                        return new Tuple3<>(first.f0, first.f1, second.f1);
                    }
                }).print();


    }
}

结果如下：

(3,陆瓷,成都)
(1,小明,江西)
(2,丽丽,纽约)

2.4 Outer

这个和sql中的连接查询基本也是一致的。包括左外连接，右外连接，全连接等。demo如下：

import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;

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

/**
 * outer
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: OuterHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午9:07
 * @UpdateDate: 19-11-1 下午9:07
 * @Version: 1.0
 */
public class OuterHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();
        List<Tuple2<Integer, String>> data1 = new ArrayList<>();
        data1.add(new Tuple2<>(1, "小明"));
        data1.add(new Tuple2<>(2, "丽丽"));
        data1.add(new Tuple2<>(3, "陆瓷"));

        List<Tuple2<Integer, String>> data2 = new ArrayList<>();
        data2.add(new Tuple2<>(1, "江西"));
        data2.add(new Tuple2<>(2, "纽约"));
        data2.add(new Tuple2<>(4, "兰州"));

        DataSource<Tuple2<Integer, String>> t1 = e.fromCollection(data1);
        DataSource<Tuple2<Integer, String>> t2 = e.fromCollection(data2);

        t1.leftOuterJoin(t2).where(0).equalTo(0).with(new JoinFunction<Tuple2<Integer, String>, Tuple2<Integer, String>, Tuple3<Integer, String, String>>() {
            @Override
            public Tuple3<Integer, String, String> join(Tuple2<Integer, String> first, Tuple2<Integer, String> second) throws Exception {
                if (second == null) {
                    return new Tuple3<>(first.f0, first.f1, "null");
                }

                return new Tuple3<>(first.f0, first.f1, second.f1);
            }
        }).print();

        System.out.println("======left join is end=========");


        t1.rightOuterJoin(t2).where(0).equalTo(0).with(new JoinFunction<Tuple2<Integer, String>, Tuple2<Integer, String>, Tuple3<Integer, String, String>>() {
            @Override
            public Tuple3<Integer, String, String> join(Tuple2<Integer, String> first, Tuple2<Integer, String> second) throws Exception {
                if (first == null) {
                    return new Tuple3<>(second.f0, "null", second.f1);
                }

                return new Tuple3<>(first.f0, first.f1, second.f1);
            }
        }).print();

        System.out.println("======right join is end=========");


        t1.fullOuterJoin(t2).where(0).equalTo(0).with(new JoinFunction<Tuple2<Integer, String>, Tuple2<Integer, String>, Tuple3<Integer, String, String>>() {
            @Override
            public Tuple3<Integer, String, String> join(Tuple2<Integer, String> first, Tuple2<Integer, String> second) throws Exception {
                if (first == null) {
                    return new Tuple3<>(second.f0, "null", second.f1);
                } else if (second == null) {
                    return new Tuple3<>(first.f0, first.f1, "null");
                }

                return new Tuple3<>(first.f0, first.f1, second.f1);
            }
        }).print();

        System.out.println("======full join is end=========");


    }
}

结果如下：

(3,陆瓷,null)
(1,小明,江西)
(2,丽丽,纽约)
======left join is end=========
(1,小明,江西)
(2,丽丽,纽约)
(4,null,兰州)
======right join is end=========
(3,陆瓷,null)
(1,小明,江西)
(2,丽丽,纽约)
(4,null,兰州)
======full join is end=========

2.5 Cross(笛卡尔积)

import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;

import java.util.Arrays;
import java.util.List;

/**
 * outer
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: CrossHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午9:07
 * @UpdateDate: 19-11-1 下午9:07
 * @Version: 1.0
 */
public class CrossHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();
        List<Integer> s1 = Arrays.asList(10, 20);
        List<String> s2 = Arrays.asList("hello", "flink");
        DataSource<Integer> data1 = e.fromCollection(s1);
        DataSource<String> data2 = e.fromCollection(s2);
        data1.cross(data2).print();
    }
}

结果如下：

(10,hello)
(10,flink)
(20,hello)
(20,flink)

2.6 Union

public class UnionHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();
        List<Integer> s1 = Arrays.asList(10, 20);
        List<Integer> s2 = Arrays.asList(30, 40);
        DataSource<Integer> data1 = e.fromCollection(s1);
        DataSource<Integer> data2 = e.fromCollection(s2);
        data1.union(data2).print();
    }
}

将两块数据源汇聚成一块。

2.7 First-N以及Sort Partition

import org.apache.flink.api.common.operators.Order;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;

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

/**
 * outer
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: UnionHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午9:07
 * @UpdateDate: 19-11-1 下午9:07
 * @Version: 1.0
 */
public class UnionHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();
        List<Tuple2<Integer,String>> data=new ArrayList<>();
        data.add(new Tuple2<>(1,"xa"));
        data.add(new Tuple2<>(3,"aa"));
        data.add(new Tuple2<>(4,"pa"));
        data.add(new Tuple2<>(2,"oa"));
        data.add(new Tuple2<>(2,"na"));
        data.add(new Tuple2<>(2,"ma"));
        data.add(new Tuple2<>(7,"ba"));
        DataSource<Tuple2<Integer, String>> source = e.fromCollection(data);
        //获取前3个元素
        source.first(3).print();
        /* 结果如下：
            (1,xa)
            (3,aa)
            (4,pa)
        */
        System.out.println("=====================");
        //先分组，然后获取每个分组的前2条数据
        source.groupBy(0).first(2).print();
        /*
            结果如下：
            (3,aa)
            (7,ba)
            (1,xa)
            (2,oa)
            (2,na)
            (4,pa)
        */
        System.out.println("=====================");
        //根据第一列分组，第二列排序，获取每组前2个
        source.groupBy(0).sortGroup(1, Order.ASCENDING).first(2).print();
        /*
            结果如下：
            (3,aa)
            (7,ba)
            (1,xa)
            (2,ma)
            (2,na)
            (4,pa)
        */
        System.out.println("=====================");
        //全局排序 在本地会对所有的数据进行排序
        source.sortPartition(0,Order.ASCENDING).sortPartition(1,Order.DESCENDING).first(3).print();
        /*
            结果如下：
            (1,xa)
            (2,oa)
            (2,na)
        */
    }
}

3 DataSet API之partition

  • Rebalance：对数据集进行再平衡，重分区，消除数据倾斜
  • Hash-Partition：根据指定key的哈希值对数据集进行分区 partitionByHash()
  • Range-Partition：根据指定的key对数据集进行范围分区 .partitionByRange()
  • Custom Partitioning：自定义分区规则 自定义分区需要实现Partitioner接口 partitionCustom(partitioner, "someKey") 或者partitionCustom(partitioner, 0)

下面演示hash和range的分区策略：

import org.apache.flink.api.common.functions.MapPartitionFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;

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

/**
 * outer
 *
 * @ProjectName: FlinkLearning
 * @Package: com.caozg.batch
 * @ClassName: PartionHandler
 * @Author: GoSaint
 * @CreateDate: 19-11-1 下午9:07
 * @UpdateDate: 19-11-1 下午9:07
 * @Version: 1.0
 */
public class PartionHandler {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment e = ExecutionEnvironment.getExecutionEnvironment();
        List<Tuple2<Integer,String>> data=new ArrayList<>();
        data.add(new Tuple2<>(1,"xa"));
        data.add(new Tuple2<>(2,"aa"));
        data.add(new Tuple2<>(3,"pa"));
        data.add(new Tuple2<>(3,"oa"));
        data.add(new Tuple2<>(3,"na"));
        data.add(new Tuple2<>(3,"ma"));
        data.add(new Tuple2<>(4,"ba"));
        data.add(new Tuple2<>(4,"ba"));
        data.add(new Tuple2<>(4,"ba"));
        data.add(new Tuple2<>(4,"ba"));
        data.add(new Tuple2<>(5,"ba"));
        data.add(new Tuple2<>(5,"ba"));
        data.add(new Tuple2<>(5,"ba"));
        data.add(new Tuple2<>(5,"ba"));
        data.add(new Tuple2<>(5,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        data.add(new Tuple2<>(6,"ba"));
        DataSource<Tuple2<Integer, String>> source = e.fromCollection(data);
        /*source.partitionByHash(0).mapPartition(new MapPartitionFunction<Tuple2<Integer, String>, Tuple2<Integer, String>>() {
            @Override
            public void mapPartition(Iterable<Tuple2<Integer, String>> values, Collector<Tuple2<Integer, String>> out) throws Exception {
                Iterator<Tuple2<Integer, String>> iterator = values.iterator();
                while (iterator.hasNext()){
                    Tuple2<Integer, String> next = iterator.next();
                    System.out.println("当前线程ID是："+Thread.currentThread().getId()+" value is "+next);
                }
            }
        }).print();*/

      /*  结果如下：
        当前线程ID是：61 value is (3,pa)
        当前线程ID是：61 value is (3,oa)
        当前线程ID是：61 value is (3,na)
        当前线程ID是：61 value is (3,ma)
        当前线程ID是：62 value is (1,xa)
        当前线程ID是：62 value is (5,ba)
        当前线程ID是：62 value is (5,ba)
        当前线程ID是：62 value is (5,ba)
        当前线程ID是：62 value is (5,ba)
        当前线程ID是：62 value is (5,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：62 value is (6,ba)
        当前线程ID是：63 value is (2,aa)
        当前线程ID是：63 value is (4,ba)
        当前线程ID是：63 value is (4,ba)
        当前线程ID是：63 value is (4,ba)
        当前线程ID是：63 value is (4,ba)*/

        source.partitionByRange(0).mapPartition(new MapPartitionFunction<Tuple2<Integer, String>, Tuple2<Integer, String>>() {
            @Override
            public void mapPartition(Iterable<Tuple2<Integer, String>> values, Collector<Tuple2<Integer, String>> out) throws Exception {
                Iterator<Tuple2<Integer, String>> iterator = values.iterator();
                while (iterator.hasNext()){
                    Tuple2<Integer, String> next = iterator.next();
                    System.out.println("当前线程ID是："+Thread.currentThread().getId()+" value is "+next);
                }
            }
        }).print();

        /*结果如下：
        当前线程ID是：64 value is (1,xa)
        当前线程ID是：64 value is (2,aa)
        当前线程ID是：64 value is (3,pa)
        当前线程ID是：64 value is (3,oa)
        当前线程ID是：64 value is (3,na)
        当前线程ID是：64 value is (3,ma)
        当前线程ID是：65 value is (4,ba)
        当前线程ID是：65 value is (4,ba)
        当前线程ID是：65 value is (4,ba)
        当前线程ID是：65 value is (4,ba)
        当前线程ID是：65 value is (5,ba)
        当前线程ID是：65 value is (5,ba)
        当前线程ID是：65 value is (5,ba)
        当前线程ID是：65 value is (5,ba)
        当前线程ID是：65 value is (5,ba)
        当前线程ID是：66 value is (6,ba)
        当前线程ID是：66 value is (6,ba)
        当前线程ID是：66 value is (6,ba)
        当前线程ID是：66 value is (6,ba)
        当前线程ID是：66 value is (6,ba)
        当前线程ID是：66 value is (6,ba)
*/

    }
}

 

大佛拈花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink系列：Tuples作为Key的使用方法
NIO4444
06-07 2172
DataSet Reduce, GroupReduce, Aggregate, Windows DataSet<...> input = // [...] DataSet<...> reduced = input .groupBy(/*define key here*/) .reduceGroup(/*do something*/); DataStream join, coGroup, keyBy, groupBy DataStream<......
flink学习教程，flink学习案例
05-15
3. "FlinkTutorial" - 这可能是另一个Flink教程的文件，可能包含一系列的步骤、示例代码或实验，帮助用户动手实践Flink的用法。 **详细知识点：** 1. **Flink基础**：了解Flink的核心概念，如DataStream API、...
Flink学习笔记（七）：flink聚合函数
小白的专栏
08-10 4131
Flink的AggregateFunction是一个基于中间计算结果状态进行增量计算的函数，可以用在多种场景的实时计算中，而且采用迭代方式，运行效率比较高。 一、接口 我们查看AggregateFunction接口可以看到它有三个参数 输入类型(IN) 累加器类型(ACC) 输出类型(OUT) @PublicEvolving public interface AggregateFunction<IN, ACC, OUT> extends Function, Serializable {
Flink-dataSource的种类和基本使用
Zong_0915的博客
08-01 733
Flink-dataSource的种类和基本使用并行的dataSource无界集并行dataSourcesocketTextStream()有界集并行dataSourcefromCollection()fromElements()非并行的dataSourcefromParallelCollection()generateSequence()readTextFile() 前言： 对于一个flink任务，我们拿java的API层面来解释： 一个任务基本上我们分为3种 名称 作用 dataSour
Flink流处理之迭代案例
VinoYang的专栏
11-29 1万+
当前Flink将迭代的重心集中在批处理上，之前我们谈及了批量迭代和增量迭代主要是针对批处理（DataSet）API而言的，并且Flink为批处理中的迭代提供了针对性的优化。但是对于流处理（DataStream），Flink同样提供了对迭代的支持，这一节我们主要来分析流处理中的迭代，我们将会看到流处理中的迭代相较于批处理有相似之处，但差异也是十分之明显。
Flink04: Flink核心API之DataSet
anglemanyi的博客
02-22 1242
DataSet API主要可以分为3块来分析：DataSource、Transformation、Sink。
剑指大数据——Flink学习精要_java版
04-21
"Flink学习精要_java版" Flink 是一个由 Apache 软件基金会旗下的开源大数据处理框架，当前已经成为各大公司大数据实时处理的发力重点。Flink 起源于一个叫作 Stratosphere 的项目，由柏林理工大学的教授沃克尔·...
Flink学习笔记.docx
05-07
Flink 学习笔记 Apache Flink 是近年来越来越流行的一款开源大数据计算引擎，它同时支持了批处理和流处理。Flink 的主要特点是它可以实时处理大规模数据，并且可以与其他大数据处理工具集成，例如 Hadoop、Spark 等...
spark，flink学习
05-23
学习Spark和Flink，你需要掌握如何设置和运行这些框架，理解其背后的计算模型，以及如何利用它们提供的API编写处理任务。同时，熟悉Hadoop生态系统（如HDFS、YARN）和数据源（如Kafka、HBase）也是必要的，因为它们...
Flink学习资料.zip
07-16
通过尚硅谷大数据之flink教程.docx和尚学堂大数据技术之Flink教案.pdf，可以系统性地学习Flink的基本概念和技术；而FlinkLearn可能包含了更多的实践项目和进阶内容，以巩固理论知识并提升实际操作能力。
Flink的基本DataSource与自定义DataSource
weixin_45316851的博客
05-14 686
DataSource DataSource指定了流计算的输入，用户可以通过StreamExecutionEnvironment.addSource(sourceFunction),Flink已经预先实现了一些DataSource的实现，如果用户需要自定义自己的实现可以通过实现SourceFunction接口（非并行Source）或者ParallelSourceFunction 接口（实现并行Source）或者继承RichParallelSourceFunction . File Based readText
Flink 系例 之 FlatMap
不会飞的小龙人的博客
11-03 2397
FlatMap算子：将数据流一行按逻辑或规则拆分成0行或多行输出 示例环境 java.version: 1.8.x flink.version: 1.11.1 示例数据源（项目码云下载） Flink 系例 之 搭建开发环境与数据 FlatMap.java import com.flink.demo.DataSource; import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.fli..
Flink系列-5、Flink DataSet API介绍
最新发布
不积跬步无以至千里，不积小流无以成江河
04-11 795
Flink DataSet API介绍
快速入门Flink(4)——Flink的DataSource你都会了？(常用的操作还不快收藏起来？)
大数据记录
09-08 7604
1
Flink（9）：Flink的各种创建执行环境的方法
yang_shibiao的博客
07-01 1632
0. 相关文章链接 1. 创建DataSet的执行环境以及WordCount程序 package cn.itcast.hello; import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.common.operators.Order; import org.apa
Flink DataSet获取变量的4种方式
tom_fans的博客
06-11 975
1. 通过广播变量获取 import org.apache.flink.api.common.functions.RichFlatMapFunction; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.configuration.Configuration; import org.apache.flink.u
Flink1.8实时数仓项目实战
08-26
《Flink1.8实时数仓项目实战》课程主要基于Flink**稳定版本进行讲解，课程包含Flink DataSet、容错、Connector、Flink SQL以及实时数仓项目。希望通过本课程的学习，大家能快速掌握Flink 批处理和Flink SQL，并通过实时数仓项目快速积累项目经验。
java搭建flink读取数据库 简单Demo实例
热门推荐
为什么简介是必填项？
07-02 1万+
一、搭建环境使用工具 idea 、gradle、jdk1.8、mysql数据库 具体idea 搭建gradle和项目环境略··········下边直接上代码 二、gradle依赖包设置 dependencies { implementation 'org.apache.flink:flink-java:1.8.0' implementation 'org.apache.flin......
Flink DataSet API 使用示范
coderlaw's study
11-30 5918
DataSet API 编程示范 package com.dtwave.flink.example import org.apache.flink.api.common.functions._ import org.apache.flink.api.common.operators.Order import org.apache.flink.api.common.operators.base.
Apache Flink学习之旅：开启大数据处理新篇章
2. 低延迟：Flink的设计目标之一是实现亚秒级的延迟，这使得它在实时数据处理场景中具有显著优势，如在线推荐系统、实时交易监控等。 3. 状态管理和容错机制：Flink提供了强大的状态管理和容错机制，确保在分布式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值