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

随机推荐

Qt char * 转QString
1.QString转char * 先将QString转换为QByteArray,再将QByteArray转换为char *. 注意:不能用char *mm = str.toLatin1().data( ...
更优于 Shellinabox 的 web shell 工具 -- ttyd
ttyd 是一个运行在服务端,客户端通过web浏览器访问从而连接后台 tty (pts伪终端)接口的程序,把 shell 终端搬到 web 浏览器中. WebSocket WebSocket 是 HT ...
了解一下Git的常用语句
简单学习了一下Git,整理了一点常用语句 http连接 git clone https://仓库地址连接githup cd shop 进入文件夹 git config --global user.n ...
MnogoDB唯一索引，稀疏索引
1,单个字段唯一索引 db.collection.createIndex({name:1},{unique:true} 2,多个字段联合索引示例 db.collection.createIndex({ ...
Oracle Error while trying to retrieve text for error ORA-01804
我在Linux上编译C++程序,有这个错误. 本机情况: Linux上Oracle的安装情况,服务器上有两个Client版本.我在Makefile中使用了高版本的动态库. 原因: 1.首先排查下 tn ...
filter筛选数组
和map()类似,array的filter也接收一个函数和map()不同的是,filter把传入的函数依次作用于每个函数,然后根据返回TRUE还是FALSE来做决定保留还是舍弃该元素例如,删除一个 ...
关于JAVA中顺序IO的基本操作
关于JAVA中顺序IO的基本操作写在前面最近研究一下JAVA中的顺序IO,在网络上找了一会儿,发现少有详细的介绍,顾此在此处说说顺序IO,才学疏浅,如有不对,望赐教. 什么是顺序IO 事实上JAV ...
[hdu7065]Yinyang
将一个格子看作一个节点,相邻(有公共边)的同色格子之间连边,那么由前两个条件即要求图恰被分为两个非空连通块(由于$n,m\ge 3$,显然不能不使用某种颜色) 下面,来分析图中的简单环,其对应于网格图 ...
mybatis新增账号并且返回主键id
<insert id="save" useGeneratedKeys="true" keyPropert ...
springboot默认Thymeleaf模板引擎js的解决方案
<script th:inline="javascript"> var btnexam=[[${btnexam}]]; console.log(btnexam); va ...

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

随机推荐

热门专题