flink01--------1.flink简介 2.flink安装 3. flink提交任务的2种方式 4. 4flink的快速入门 5.source 6 常用算子（keyBy，max/min，maxBy/minBy，connect，union，split+select）

1. flink简介

1.1 什么是flink

Apache Flink是一个分布式大数据处理引擎，可以对有限数据流（如离线数据）和无限流数据及逆行有状态计算（不太懂）。可以部署在各种集群环境，对各种大小的数据规模进行快速计算。

1.2 flink的架构体系

　　具体见文档

2. flink的安装

修改flink-conf.yaml

jobmanager.rpc.address: feng05   // 注意，此处冒号后需要空一格，并且参数要顶行写（yaml文件格式的规定，否则会报错）

taskmanager.numberOfTaskSlots: 2

将配置好的Flink安装包拷⻉贝到其他节点

for i in {4..7}; do scp -r flink-1.10.1/ feng05:$PWD; done

启动集群（standalone模式）

bin/start-cluster.sh

查看Java进程（jps）

StandaloneSessionClusterEntrypoint (JobManager，即Master)

TaskManagerRunner (TaskManager，即Worker)

访问JobManager的web管理界面

feng05:8081

3. flink提交任务的两种方式

第一种：通过web页面提交

第二种：通过命令行提交

./flink run -m feng05:8081 -p 4 -c cn._51doit.flink.day1.HelloFlink  /root/flink-in-action-1.0-SNAPSHOT.jar --hostname feng05 --port 8888

4.flink快速入门

4.0 创建flink工程

java形式（window上）

mvn archetype:generate -DarchetypeGroupId=org.apache.flink -DarchetypeArtifactId=flink-quickstart-java -DarchetypeVersion=1.10.1 -DgroupId=cn._51doit.flink -DartifactId=flink-java -Dversion=1.0 -Dpackage=cn._51doit.flink -DinteractiveMode=false

scala形式

　　同理

也可以直接在IDEA上创建相应的maven项目，导入pom文件（这里jar的版本不好弄，所以直接用上面的命令更方便）

4.1 wordCount案例

StreamWordCount（匿名内部类的形式）

package cn._51doit.flink.day01;

import org.apache.flink.api.common.functions.FlatMapFunction;

import org.apache.flink.api.common.functions.MapFunction;

import org.apache.flink.api.java.tuple.Tuple;

import org.apache.flink.api.java.tuple.Tuple2;

import org.apache.flink.streaming.api.datastream.DataStream;

import org.apache.flink.streaming.api.datastream.DataStreamSource;

import org.apache.flink.streaming.api.datastream.KeyedStream;

import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import org.apache.flink.util.Collector;

public class StreamWordCount {

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

        // 创建一个Stream计算执行环境

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 调用Source创建DataStream

        DataStreamSource<String> lines = env.socketTextStream(args[0], Integer.parseInt(args[1]));

        int parallelism = lines.getParallelism();

//        DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

//            @Override

//            public void flatMap(String line, Collector<String> out) throws Exception {

//                String[] words = line.split(" ");

//                for (String word : words) {

//                    out.collect(word);

//                }

//            }

//        });

//        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() {

//            @Override

//            public Tuple2<String, Integer> map(String word) throws Exception {

//                return Tuple2.of(word, 1);

//            }

//        });

        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = lines.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {

            @Override

            public void flatMap(String line, Collector<Tuple2<String, Integer>> out) throws Exception {

                String[] words = line.split(" ");

                for (String word : words) {

                    out.collect(Tuple2.of(word, 1));

                }

            }

        });

        KeyedStream<Tuple2<String, Integer>, Tuple> keyed = wordAndOne.keyBy(0);

        SingleOutputStreamOperator<Tuple2<String, Integer>> summed = keyed.sum(1);

        //Transformation 结束

        //调用Sink

        summed.print();

        //执行程序

        env.execute("StreamWordCount");

    }

}

LambdaStreamWordCount（lambda的形式）

package cn._51doit.flink.day01;

import org.apache.flink.api.common.typeinfo.Types;

import org.apache.flink.api.java.tuple.Tuple2;

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.util.Collector;

import java.util.Arrays;

public class LambdaStreamWordCount {

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

        // 创建一个stream计算的执行环境

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> lines = env.socketTextStream("feng05", 8888);

//        SingleOutputStreamOperator<String> words = lines

//                .flatMap((String line, Collector<String> out) -> Arrays.asList(line.split(" ")).forEach(out::collect))

//                .returns(Types.STRING);

//

//        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = words

//                .map(word -> Tuple2.of(word, 1))

//                .returns(Types.TUPLE(Types.STRING, Types.INT));

        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = lines.flatMap((String line, Collector<Tuple2<String, Integer>> out)->{

            Arrays.stream(line.split(" ")).forEach(w -> out.collect(Tuple2.of(w, 1)));

        }).returns(Types.TUPLE(Types.STRING, Types.INT));

        SingleOutputStreamOperator<Tuple2<String, Integer>> result = wordAndOne.keyBy(0).sum(1);

        result.print();

        env.execute();

    }

}

自己运行时遇到的小问题

5.source

单并行source

　　只有一个source来产生数据，如fromCollection、socketTextStream

双并行source

　　有多个source实例来产生数据

6 常用算子

6.1 keyBy

分组的对象是元组中的数据，可以直接指定角标，而且可以是多个

package cn._51doit.flink.day01;

import org.apache.flink.api.common.functions.MapFunction;

import org.apache.flink.api.java.tuple.Tuple;

import org.apache.flink.api.java.tuple.Tuple3;

import org.apache.flink.streaming.api.datastream.DataStreamSource;

import org.apache.flink.streaming.api.datastream.KeyedStream;

import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class KeyByDemo1 {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);

        //辽宁省,沈阳市,1000

        SingleOutputStreamOperator<Tuple3<String, String, Double>> provinceCityAndMoney = lines.map(new MapFunction<String, Tuple3<String, String, Double>>() {

            @Override

            public Tuple3<String, String, Double> map(String line) throws Exception {

                String[] fields = line.split(",");

                String province = fields[0];

                String city = fields[1];

                double money = Double.parseDouble(fields[2]);

                return Tuple3.of(province, city, money);

            }

        });

        KeyedStream<Tuple3<String, String, Double>, Tuple> keyed = provinceCityAndMoney.keyBy(0, 1);

        SingleOutputStreamOperator<Tuple3<String, String, Double>> summed = keyed.sum(2);

        summed.print();

        env.execute();

    }

}

分组的对象不是元组中的元素，比如javabean中定义的字段，这个时候只能按照一个字段分组

package cn._51doit.flink.day01;

import org.apache.flink.api.common.functions.MapFunction;

import org.apache.flink.api.java.tuple.Tuple;

import org.apache.flink.api.java.tuple.Tuple3;

import org.apache.flink.streaming.api.datastream.DataStreamSource;

import org.apache.flink.streaming.api.datastream.KeyedStream;

import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class KeyByDemo2 {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);

        //辽宁省,沈阳市,1000

        SingleOutputStreamOperator<OrderBean> provinceCityAndMoney = lines.map(new MapFunction<String, OrderBean>() {

            @Override

            public OrderBean map(String line) throws Exception {

                String[] fields = line.split(",");

                String province = fields[0];

                String city = fields[1];

                double money = Double.parseDouble(fields[2]);

                return new OrderBean(province, city, money);

            }

        });

        KeyedStream<OrderBean, Tuple> keyed = provinceCityAndMoney.keyBy("province", "city");

        SingleOutputStreamOperator<OrderBean> res = keyed.sum("money");

        //provinceCityAndMoney.keyBy(OrderBean::getProvince) 只能按照一个字段分组

        res.print();

        env.execute();

    }

}

6.2 max和min

　min、max返回分组的字段和参与比较的数据，如果有多个字段，其他字段的返回值是第一次出现的数据。

package cn._51doit.flink.day01;

import org.apache.flink.api.common.typeinfo.Types;

import org.apache.flink.api.java.tuple.Tuple;

import org.apache.flink.api.java.tuple.Tuple3;

import org.apache.flink.streaming.api.datastream.DataStreamSource;

import org.apache.flink.streaming.api.datastream.KeyedStream;

import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class MinMaxDemo {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);

        //省份,城市,人数

        SingleOutputStreamOperator<Tuple3<String, String, Integer>> provinceCityAmount = lines.map(line -> {

            String[] fields = line.split(",");

            String province = fields[0];

            String city = fields[1];

            Integer amount = Integer.parseInt(fields[2]);

            return Tuple3.of(province, city, amount);

        }).returns(Types.TUPLE(Types.STRING, Types.STRING, Types.INT));

        KeyedStream<Tuple3<String, String, Integer>, Tuple> keyed = provinceCityAmount.keyBy(0);

        //min、max返回分组的字段和参与比较的数据，如果有多个字段，其他字段的返回值是第一次出现的数据。

        SingleOutputStreamOperator<Tuple3<String, String, Integer>> max = keyed.max(2);

        max.print();

        env.execute();

    }

}

比如

江西,鹰潭,1000   //先输入此数据，max后得到本身

江西,南昌,2000　 //输入该数据，max后得到的是江西,鹰潭,2000  并不能得到南昌字段

解决办法=====>使用maxBy和minBy

6.3 maxBy和minBy

package cn._51doit.flink.day01;

import org.apache.flink.api.common.typeinfo.Types;

import org.apache.flink.api.java.tuple.Tuple;

import org.apache.flink.api.java.tuple.Tuple3;

import org.apache.flink.streaming.api.datastream.DataStreamSource;

import org.apache.flink.streaming.api.datastream.KeyedStream;

import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class MinByMaxByDemo {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> lines = env.socketTextStream("localhost", 8888);

        //省份,城市,人数

        江西,鹰潭,1000

        江西,南昌,2000

        SingleOutputStreamOperator<Tuple3<String, String, Integer>> provinceCityAmount = lines.map(line -> {

            String[] fields = line.split(",");

            String province = fields[0];

            String city = fields[1];

            Integer amount = Integer.parseInt(fields[2]);

            return Tuple3.of(province, city, amount);

        }).returns(Types.TUPLE(Types.STRING, Types.STRING, Types.INT));

        KeyedStream<Tuple3<String, String, Integer>, Tuple> keyed = provinceCityAmount.keyBy(0);

        //minBy、maxBy返回最大值或最小值数据本身（全部字段都返回）。

        SingleOutputStreamOperator<Tuple3<String, String, Integer>> max = keyed.maxBy(2);

        max.print();

        env.execute();

    }

}

这种形式又会出现另外一个难点，就是当按照key进行分组后，比较大小的值一样时，其它字段返回的值又是第一次出现的数据，解决办法===>加一个参数（可以从源码中得出此结论），如下：加上false

SingleOutputStreamOperator<Tuple3<String, String, Integer>> max = keyed.maxBy(2, false);

此时其它字段返回的值就是最后依次出现的字段了。

6.4 connect

　　DataStream转换成ConnectedStreams：连接两个保持他们类型的数据流，两个数据流被Connect之后，只是被放在了同一个流中，内部依然保持各自的数据和形式不不发生任何变化，两个流相互独?立。

ConnectDemo

package cn._51doit.flink.day02;

import org.apache.flink.streaming.api.datastream.ConnectedStreams;

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.co.CoMapFunction;

public class ConnectDemo2 {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> words = env.fromElements("a", "b", "c", "d", "e");

        DataStreamSource<Integer> nums = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8);

        ConnectedStreams<Integer, String> connected = nums.connect(words);

        SingleOutputStreamOperator<String> res = connected.map(new CoMapFunction<Integer, String, String>() {

            @Override

            public String map1(Integer value) throws Exception {

                return value * 10 + "";

            }

            @Override

            public String map2(String value) throws Exception {

                return value.toUpperCase();

            }

        });

        res.print();

        env.execute();

    }

}

6.5 union

　　DataStream转换成DataStream，对两个或者两个以上的DataStream进行union操作，产生一个包含所有DataStream元素的新DataStream

　　注意：unoin要求两个流的数据类型必须一致，并且不去重

UnionDemo

package cn._51doit.flink.day02;

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 UnionDemo {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<Integer> num1 = env.fromElements(1, 2, 3, 4, 5, 6, 7, 8, 9);

        DataStreamSource<Integer> num2 = env.fromElements( 10, 11, 12);

        //unoin要求两个流的数据类型必须一致

        DataStream<Integer> union = num1.union(num2);

        union.print();

        env.execute();

    }

}

6.6 split+select

　　DataStream转换成SplitStrram，根据某些特征把一个DataStream拆分成两个或者多个DataStream。split一般是结合select使用的，若是将一个数据划分成多个类，split+select的效率会更高，若只是筛选出一个类型的数据，则用filter效率高些。

flink01--------1.flink简介 2.flink安装 3. flink提交任务的2种方式 4. 4flink的快速入门 5.source 6 常用算子（keyBy，max/min，maxBy/minBy，connect，union，split+select）的更多相关文章

在单文件组件中，引入安装模块里的css的2种方式：script中引入、style中引入
在单文件组件中,引入安装模块里的css的2种方式:script中引入.style中引入 1.script中引入 <script> import 'bulma/css/bulma.css' ...
基础知识：编程语言介绍、Python介绍、Python解释器安装、运行Python解释器的两种方式、变量、数据类型基本使用
2018年3月19日今日学习内容: 1.编程语言的介绍 2.Python介绍 3.安装Python解释器(多版本共存) 4.运行Python解释器程序两种方式.(交互式与命令行式)(♥♥♥♥♥) 5 ...
PythonDay02——编程语言、python介绍以及安装解释器、运行程序的两种方式、变量
一.编程语言 1.1 机器语言:直接用计算机能理解的二进制指令编写程序,直接控制硬件 1.2 汇编语言:用英文标签取代二进制指令去编写程序,本质也是直接控制硬件 1.3 高级语言:用人能理解的表达方式 ...
编程语言、Python介绍及其解释器安装、运行Python解释器的两种方式、变量、内存管理
一.编程语言介绍 1.1 机器语言:直接用计算机能理解的二进制指令来编写程序,直接控制硬件. 1.2 汇编语言:在机器语言的基础上,用英文标签取代二进制指令来编写程序,本质上也是直接控制硬件. 以上2 ...
Linux（CentOS）安装Node.JS和npm的两种方式（yum安装和源码安装）
yum安装 yum安装是将yum源中的rpm包下载到本地,安装这个rpm包.这个rpm包是别人编译安装好的二进制包.这种方式方便快捷,特别是不用考虑包依赖. 0.了解linux版本通过 uname ...
MAC下安装多版本JDK和切换几种方式
环境: MAC AIR,OS X 10.10,64位历史: 过去 Mac 上的 Java 都是由 Apple 自己提供,只支持到 Java 6,并且OS X 10.7 开始系统并不自带(而是可选 ...
LAMP(七)之编译安装php（模块化和fpm两种方式）
安装前说明: 安装环境: CentOS6 安装应用程序:httpd2.4 + mariadb + php 安装次序: 先编译安装 httpd2.4和mariadb,最后安装php 编译安装 httpd ...
Eclipse中安装插件的三种方式
转载自:http://www.cnblogs.com/lcgustc/archive/2013/01/03/2843496.html Eclipse也用了很久,但是都没有怎么去研究过怎么安装插件,今天 ...
Flink简介及使用
一.Flink概述官网:https://flink.apache.org/ mapreduce-->maxcompute HBase-->部门 quickBI DataV Hive--& ...

随机推荐

configure: error: invalid variable name: `'
今天在交叉编译一个编解码库的时候,出现一个莫名其妙的报错,一直找不到原因,后来无意中删除了一个空格,才发现就是这个空格造成的错误. ./configure --host=arm-linux LDFLA ...
Python 字符串的encode与decode
python的str,unicode对象的encode和decode方法 python中的str对象其实就是"8-bit string" ,字节字符串,本质上类似java中的byt ...
namespace之cgroup
Linux Namespace,但是Namespace解决的问题主要是环境隔离的问题,这只是虚拟化中最最基础的一步,我们还需要解决对计算机资源使用上的隔离.也就是说,虽然你通过Namespace把我J ...
elasticsearch7.x配置文件
前言: 以下配置文件基于elasticsearch-7.13.4版本,当然也适用于其它7.x版本集群环境: 部署3个节点的集群,各个节点不做角色区分,既是master,也是data,在性能上这种方 ...
Apache Kyuubi 在 T3 出行的深度实践
支撑了80%的离线作业,日作业量在1W+ 大多数场景比 Hive 性能提升了3-6倍多租户.并发的场景更加高效稳定 T3出行是一家基于车联网驱动的智慧出行平台,拥有海量且丰富的数据源.因为车联网数据 ...
那一天，我被Redis主从架构支配的恐惧
面试官:要不你来讲讲你最近在看的点呗?可以拉出来一起讨论下(今天我也不知道要问什么) 候选者:最近在看「Redis」相关的内容面试官:嗯,我记得已经问过Redis的基础和持久化了面试官:要不你来讲 ...
[cf1326F]Wise Men
对答案序列求一个高维后缀和,再通过差分将其解出,后者复杂度为$o(n2^{n})$ 对于求后缀和后的结果,即01序列仅要求1处有边(不要求0处没有边),那么也即要求将原图划分为若干条长度给定且没有公共 ...
[bzoj1711]吃饭
由于无法直接将果汁和饮料连边,所以将人放在中间,果汁和饮料放在两侧,然后分别向对应的人连边.同时,为了保证每一个人只被算一次,对每一个人裂点,两个点中间连一条流量为1的边. 1 #include< ...
[loj3274]变色龙之恋
首先有一个暴力的做法,将任意两个点判断,可以得到与之相关的1或3只变色龙:1只是两只变色龙相互喜欢,那么剩下那只就是颜色相同:3只从3只选2只并和自己判断一次,结果为1的那次剩下的那个就是他喜欢的,然 ...
spring-整合es
spring-整合es 导入pom <?xml version="1.0" encoding="UTF-8"?> <project xmln ...

flink01--------1.flink简介 2.flink安装 3. flink提交任务的2种方式 4. 4flink的快速入门 5.source 6 常用算子（keyBy，max/min，maxBy/minBy，connect，union，split+select）

flink01--------1.flink简介 2.flink安装 3. flink提交任务的2种方式 4. 4flink的快速入门 5.source 6 常用算子（keyBy，max/min，maxBy/minBy，connect，union，split+select）的更多相关文章

随机推荐

热门专题