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--& ...

随机推荐

跳台阶牛客网剑指Offer
跳台阶牛客网剑指Offer 题目描述一只青蛙一次可以跳上1级台阶,也可以跳上2级.求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果). class Solution: #ru ...
『学了就忘』Linux基础命令 — 25、文件基本权限的管理
目录 1.文件和目录的默认权限 2.umask默认权限 (1)查看系统的umask权限 (2)用八进制数值显示umask权限 (3)umask权限的计算方法 (4)注意:umask默认权限的计算绝不是 ...
交换机 & 路由基础
以太网帧结构 Ethernet II帧结构 Ethernet_II帧类型值大于等于1536(0×0600) 以太网帧结构的长度在64-1518字节之间帧各字段说明目的MAC地址(DMAC):接收方 ...
Django笔记&教程 4-3 模型（models）主键外键
Django 自学笔记兼学习教程第4章第3节--模型(models)主键外键点击查看教程总目录参考:https://docs.djangoproject.com/en/2.2/ref/models ...
php 递推递归
思想:如何利用数学模式,来解决对应的需求问题,然后利用代码实现对应的数据模型(逻辑) 算法:使用代码实现对应的数学模型,从而解决对应的业务问题递推算法是一种简单的算法,级通过已知条件,利用特定关系得 ...
Jetpack架构组件学习(1)——LifeCycle的使用
原文地址:Jetpack架构组件学习(1)--LifeCycle的使用 | Stars-One的杂货小窝要看本系列其他文章,可访问此链接Jetpack架构学习 | Stars-One的杂货小窝最近 ...
[cf1361E]James and the Chase
称一个点是"好点",当且仅当其到其余所有点恰存在一条简单路径结论1:$x$为好点当且仅当以$x$为根的dfs树包含所有点且非树边均为返祖边若不包含所有点,那么$x$到不被包含的 ...
[bzoj1077]天平
先考虑如何求出任意两数的最大差值和最小差值,直接差分约束建图跑floyd求最短路和最长路即可然后枚举i和j,考虑dA+dB和di+dj的关系,分两种情况移项,转化成dA-di和dj-dB的关系或dA- ...
[bzoj3170]松鼠聚会
这个距离就是切比雪夫距离,有一个神奇的东西是说将(x,y)变成(x+y,x-y),然后就是曼哈顿距离,因此转化后对x坐标和y坐标分别统计排序和求和(求前缀和预处理+二分) 1 #include< ...
【NetWork】-- 网络原理
2019-07-18 21:00:25 by冲冲 1. 网络拓扑把网络中的计算机和通信设备抽象为一个点,把传输介质抽象为一条线,由点和线组成的几何图形就是计算机网络的拓扑结构(Network T ...

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）的更多相关文章

随机推荐

热门专题