Flink05：Flink核心API之DataSet：DataSource、Transformation、Sink
一、DataSet API
DataSet API主要可以分为3块来分析：DataSource、Transformation、Sink。
DataSource是程序的数据源输入。
Transformation是具体的操作，它对一个或多个输入数据源进行计算处理，例如map、flatMap、filter等操作。
DataSink是程序的输出，它可以把Transformation处理之后的数据输出到指定的存储介质中。
二、DataSet API之DataSource
针对DataSet批处理而言，其实最多的就是读取HDFS中的文件数据，所以在这里我们主要介绍两个DataSource组件。
1、基于集合
fromCollection(Collection)，主要是为了方便测试使用。它的用法和DataStreamAPI中的用法一样，我们已经用过很多次了。
2、基于文件
readTextFile(path)，读取hdfs中的数据文件。这个前面我们也使用过了。
三、DataSet API之Transformation
这里面的算子我们都是比较熟悉的，在前面DatatreamAPI中都用过，用法都是一样的，所以在这就不再演示了。
mapPartition这个算子我们在Flink中还没用过，不过在Spark 中是用过的，用法也是一样的。
其实mapPartition就是一次处理一批数据，如果在处理数据的时候想要获取第三方资源连接，建议使用mapPartition，这样可以一批数据获取一次连接，提高性能。
下面来演示一下Flink中mapPartition的使用。
1、Flink中mapPartition的使用
scala代码如下：
package com.imooc.scala.batch.transformation
import org.apache.flink.api.scala.ExecutionEnvironment
import scala.collection.mutable.ListBuffer
/**
* MapPartition的使用：一次处理一个分区的数据
*
*/
object BatchMapPartitionScala {
def main(args: Array[String]): Unit = {
val env = ExecutionEnvironment.getExecutionEnvironment
import org.apache.flink.api.scala._
//生成数据源数据
val text = env.fromCollection(Array("hello you", "hello me"))
//每次处理一个分区的数据
text.mapPartition(it=>{
//可以在此处创建数据库连接，建议把这块代码放到try-catch代码块中
//注意：此时是每个分区获取一个数据库连接，不需要每处理一条数据就获取一次连接，性能较高
val res = ListBuffer[String]()
it.foreach(line=>{
val words = line.split(" ")
for(word <- words){
res.append(word)
}
})
res
//关闭数据库连接
}).print()
//No new data sinks have been defined since the last execution.
//The last execution refers to the latest call to 'execute()', 'count()', 'collect()', or 'print()'.
//注意：针对DataSetAPI，如果在后面调用的是count、collect、print，则最后不需要指定execute即可。
//env.execute("BatchMapPartitionScala")
}
}
java代码如下：
package com.imooc.java.batch.transformation;
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.util.Collector;
import java.util.Arrays;
import java.util.Iterator;
/**
* MapPartition的使用：一次处理一个分区的数据
*
*/
public class BatchMapPartitionJava {
public static void main(String[] args) throws Exception{
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
//生成数据源数据
DataSource text = env.fromCollection(Arrays.asList("hello you", "hello me"));
//每次处理一个分区的数据
text.mapPartition(new MapPartitionFunction() {
@Override
public void mapPartition(Iterable iterable, Collector out)
throws Exception {
//可以在此处创建数据库连接，建议把这块代码放到try-catch代码块中
Iterator it = iterable.iterator();
while(it.hasNext()){
String line = it.next();
String[] words = line.split(" ");
for(String word: words){
out.collect(word);
}
}
//关闭数据库连接
}
}).print();
}
}
下面还有一些transformation算子。
distinct算子比较简单，就是对数据进行全局去重。
join：内连接，可以连接两份数据集。
2、join的用法
scala代码如下：
package com.imooc.scala.batch.transformation
import org.apache.flink.api.scala.ExecutionEnvironment
/**
* join：内连接
*
*/
object BatchJoinScala {
def main(args: Array[String]): Unit = {
val env = ExecutionEnvironment.getExecutionEnvironment
import org.apache.flink.api.scala._
//初始化第一份数据 Tuple2<用户id,用户姓名>
val text1 = env.fromCollection(Array((1, "jack"), (2, "tom"), (3, "mick")))
//初始化第二份数据 Tuple2<用户id,用户所在城市>
val text2 = env.fromCollection(Array((1, "bj"), (2, "sh"), (4, "gz")))
//对两份数据集执行join操作
text1.join(text2)
//注意：这里的where和equalTo实现了类似于on fieldA=fieldB的效果
//where：指定左边数据集中参与比较的元素角标
.where(0)
//equalTo指定右边数据集中参与比较的元素角标
.equalTo(0){(first,second)=>{
(first._1,first._2,second._2)
}}.print()
}
}
java代码如下：
package com.imooc.java.batch.transformation;
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.Arrays;
/**
* join：内连接
*
*/
public class BatchJoinJava {
public static void main(String[] args) throws Exception{
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
//初始化第一份数据 Tuple2<用户id,用户姓名>
ArrayList> data1 = new ArrayList<>();
data1.add(new Tuple2(1,"jack"));
data1.add(new Tuple2(2,"tom"));
data1.add(new Tuple2(3,"mick"));
DataSource> text1 = env.fromCollection(data1);
//初始化第二份数据 Tuple2<用户id,用户所在城市>
ArrayList> data2 = new ArrayList<>();
data2.add(new Tuple2(1,"bj"));
data2.add(new Tuple2(2,"sh"));
data2.add(new Tuple2(4,"gz"));
DataSource> text2 = env.fromCollection(data2);
//对两份数据集执行join操作
text1.join(text2)
.where(0)
.equalTo(0)
//三个输入参数：
//第一个tuple2是左边数据集的类型，
//第二个tuple2是右边数据集的类型，
//第三个tuple3是此函数返回的数据集类型
.with(new JoinFunction, Tuple2, Tuple3>() {
@Override
public Tuple3 join(Tuple2 first, Tuple2 second)
throws Exception {
return new Tuple3(first.f0,first.f1,second.f1);
}
}).print();
}
}
3、outerJoin：外连接
scala代码如下：
package com.imooc.scala.batch.transformation
import org.apache.flink.api.scala.ExecutionEnvironment
/**
* outerJoin：外连接
* 一共有三种情况
* 1：leftOuterJoin
* 2：rightOuterJoin
* 3：fullOuterJoin
*
*/
object BatchOuterJoinScala {
def main(args: Array[String]): Unit = {
val env = ExecutionEnvironment.getExecutionEnvironment
import org.apache.flink.api.scala._
//初始化第一份数据 Tuple2<用户id,用户姓名>
val text1 = env.fromCollection(Array((1, "jack"), (2, "tom"), (3, "mick")))
//初始化第二份数据 Tuple2<用户id,用户所在城市>
val text2 = env.fromCollection(Array((1, "bj"), (2, "sh"), (4, "gz")))
//对两份数据集执行leftOuterJoin操作
text1.leftOuterJoin(text2)
.where(0)
.equalTo(0){
(first,second)=>{
//注意：second中的元素可能为null
if(second==null){
(first._1,first._2,"null")
}else{
(first._1,first._2,second._2)
}
}
}.print()
println("========================================")
//对两份数据集执行rightOuterJoin操作
text1.rightOuterJoin(text2)
.where(0)
.equalTo(0){
(first,second)=>{
//注意：first中的元素可能为null
if(first==null){
(second._1,"null",second._2)
}else{
(first._1,first._2,second._2)
}
}
}.print()
println("========================================")
//对两份数据集执行rightOuterJoin操作
text1.fullOuterJoin(text2)
.where(0)
.equalTo(0){
(first,second)=>{
//注意：first和second中的元素都有可能为null
if(first==null){
(second._1,"null",second._2)
}else if(second==null){
(first._1,first._2,"null")
}else{
(first._1,first._2,second._2)
}
}
}.print()
}
}
java代码如下：
package com.imooc.java.batch.transformation;
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;
/**
* outerJoin：外连接
* 一共有三种情况
* 1：leftOuterJoin
* 2：rightOuterJoin
* 3：fullOuterJoin
*
*/
public class BatchOuterJoinJava {
public static void main(String[] args) throws Exception{
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
//初始化第一份数据 Tuple2<用户id,用户姓名>
ArrayList> data1 = new ArrayList<>();
data1.add(new Tuple2(1,"jack"));
data1.add(new Tuple2(2,"tom"));
data1.add(new Tuple2(3,"mick"));
DataSource> text1 = env.fromCollection(data1);
//初始化第二份数据 Tuple2<用户id,用户所在城市>
ArrayList> data2 = new ArrayList<>();
data2.add(new Tuple2(1,"bj"));
data2.add(new Tuple2(2,"sh"));
data2.add(new Tuple2(4,"gz"));
DataSource> text2 = env.fromCollection(data2);
//对两份数据集执行leftOuterJoin操作
text1.leftOuterJoin(text2)
.where(0)
.equalTo(0)
.with(new JoinFunction, Tuple2, Tuple3>() {
@Override
public Tuple3 join(Tuple2 first, Tuple2 second)
throws Exception {
if(second==null){
return new Tuple3(first.f0,first.f1,"null");
}else{
return new Tuple3(first.f0,first.f1,second.f1);
}
}
}).print();
System.out.println("==============================================");
//对两份数据集执行rightOuterJoin操作
text1.rightOuterJoin(text2)
.where(0)
.equalTo(0)
.with(new JoinFunction, Tuple2, Tuple3>() {
@Override
public Tuple3 join(Tuple2 first, Tuple2 second)
throws Exception {
if(first==null){
return new Tuple3(second.f0,"null",second.f1);
}else{
return new Tuple3(first.f0,first.f1,second.f1);
}
}
}).print();
System.out.println("==============================================");
//对两份数据集执行rightOuterJoin操作
text1.fullOuterJoin(text2)
.where(0)
.equalTo(0)
.with(new JoinFunction, Tuple2, Tuple3>() {
@Override
public Tuple3 join(Tuple2 first, Tuple2 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");
}else{
return new Tuple3(first.f0,first.f1,second.f1);
}
}
}).print();
}
}
4、cross：获取两个数据集的笛卡尔积
scala代码如下：
package com.imooc.scala.batch.transformation
import org.apache.flink.api.scala.ExecutionEnvironment
/**
* cross：获取两个数据集的笛卡尔积
*
*/
object BatchCrossScala {
def main(args: Array[String]): Unit = {
val env = ExecutionEnvironment.getExecutionEnvironment
import org.apache.flink.api.scala._
//初始化第一份数据
val text1 = env.fromCollection(Array(1, 2))
//初始化第二份数据
val text2 = env.fromCollection(Array("a", "b"))
//执行cross操作
text1.cross(text2).print()
}
}
java代码如下：
package com.imooc.java.batch.transformation;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import java.util.Arrays;
/**
* cross：获取两个数据集的笛卡尔积
*
*/
public class BatchCrossJava {
public static void main(String[] args) throws Exception{
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
//初始化第一份数据
DataSource text1 = env.fromCollection(Arrays.asList(1, 2));
//初始化第二份数据
DataSource text2 = env.fromCollection(Arrays.asList("a", "b"));
//执行cross操作
text1.cross(text2).print();
}
}
union：返回两个数据集的总和，数据类型需要一致。
和DataStreamAPI中的union操作功能一样。
5、first-n：获取集合中的前N个元素
scala代码如下：
package com.imooc.scala.batch.transformation
import org.apache.flink.api.common.operators.Order
import org.apache.flink.api.scala.ExecutionEnvironment
import scala.collection.mutable.ListBuffer
/**
* first-n：获取集合中的前N个元素
* */
object BatchFirstNScala {
def main(args: Array[String]): Unit = {
val env = ExecutionEnvironment.getExecutionEnvironment
val data = ListBuffer[Tuple2[Int,String]]()
data.append((2,"zs"))
data.append((4,"ls"))
data.append((3,"ww"))
data.append((1,"aw"))
data.append((1,"xw"))
data.append((1,"mw"))
import org.apache.flink.api.scala._
//初始化数据
val text = env.fromCollection(data)
//获取前3条数据，按照数据插入的顺序
text.first(3).print()
println("==================================")
//根据数据中的第一列进行分组，获取每组的前2个元素
text.groupBy(0).first(2).print()
println("==================================")
//根据数据中的第一列分组，再根据第二列进行组内排序[倒序],获取每组的前2个元素
//分组排序取TopN
text.groupBy(0).sortGroup(1,Order.DESCENDING).first(2).print()
}
}
java代码如下：
package com.imooc.java.batch.transformation;
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;
/**
* first-n：获取集合中的前N个元素
*
*/
public class BatchFirstNJava {
public static void main(String[] args) throws Exception{
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
ArrayList> data = new ArrayList<>();
data.add(new Tuple2(2,"zs"));
data.add(new Tuple2(4,"ls"));
data.add(new Tuple2(3,"ww"));
data.add(new Tuple2(1,"aw"));
data.add(new Tuple2(1,"xw"));
data.add(new Tuple2(1,"mw"));
//初始化数据
DataSource> text = env.fromCollection(data);
//获取前3条数据，按照数据插入的顺序
text.first(3).print();
System.out.println("====================================");
//根据数据中的第一列进行分组，获取每组的前2个元素
text.groupBy(0).first(2).print();
System.out.println("====================================");
//根据数据中的第一列分组，再根据第二列进行组内排序[倒序],获取每组的前2个元素
//分组排序取TopN
text.groupBy(0).sortGroup(1, Order.DESCENDING).first(2).print();
}
}
四、DataSet API之DataSink
Flink针对DataSet提供了一些已经实现好的数据目的地
其中最常见的是向HDFS中写入数据
writeAsText()：将元素以字符串形式逐行写入，这些字符串通过调用每个元素的toString()方法来获取
writeAsCsv()：将元组以逗号分隔写入文件中，行及字段之间的分隔是可配置的，每个字段的值来自对象的toString()方法
还有一个是print：打印每个元素的toString()方法的值
这个print是测试的时候使用的。