spark基本工作原理
画图讲解Spark的基本工作原理
1、分布式
2、主要基于内存（少数情况基于磁盘）
3、迭代式计算
RDD以及其特点
1、RDD是Spark提供的核心抽象，全称为Resillient Distributed Dataset，即弹性分布式数据集。
2、RDD在抽象上来说是一种元素集合，包含了数据。它是被分区的，分为多个分区，每个分区分布在集群中的不同节点上，从而让RDD中的数据可以被并行操作。（分布式数据集）
3、RDD通常通过Hadoop上的文件，即HDFS文件或者Hive表，来进行创建；有时也可以通过应用程序中的集合来创建。
4、RDD最重要的特性就是，提供了容错性，可以自动从节点失败中恢复过来。即如果某个节点上的RDD partition，因为节点故障，导致数据丢了，那么RDD会自动通过自己的数据来源重新计算该partition。这一切对使用者是透明的。
5、RDD的数据默认情况下存放在内存中的，但是在内存资源不足时，Spark会自动将RDD数据写入磁盘。（弹性）
什么是spark开发
1、核心开发：离线批处理 / 延迟性的交互式数据处理
2、SQL查询：底层都是RDD和计算操作
3、实时计算：底层都是RDD和计算操作
使用Java、Scala和spark-shell开发word count程序
开发word count程序
1、用Java开发wordcount程序
1.1 配置maven环境
1.2 如何进行本地测试
1.3 如何使用spark-submit提交到spark集群进行执行（spark-submit常用参数说明，spark-submit其实就类似于hadoop的hadoop jar命令）
2、用Scala开发wordcount程序
2.1 下载scala ide for eclipse
2.2 在Java Build Path中，添加spark依赖包（如果与scala ide for eclipse原生的scala版本发生冲突，则移除原生的scala / 重新配置scala compiler）
2.3 用export导出scala spark工程
3、用spark-shell开发wordcount程序
3.1 常用于简单的测试
word count程序深度剖析
val conf = new SparkConf().setAppName("WordCount")
val sc = new JavaSparkContext(conf)
val lines = sc.textFile("hdfs://spark1:9000/spark.txt")
val words = lines.flatMap(line => line.split(" "))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
wordCounts.foreach(wordCount => println(wordCount._1 + " appears " + wordCount._2 + " times."))
spark架构原理
1、Driver
2、Master
3、Worker
4、Executor
5、Task
创建RDD
进行Spark核心编程时，首先要做的第一件事，就是创建一个初始的RDD。该RDD中，通常就代表和包含了Spark应用程序的输入源数据。然后在创建了初始的RDD之后，才可以通过Spark Core提供的transformation算子，对该RDD进行转换，来获取其他的RDD。
Spark Core提供了三种创建RDD的方式，包括：使用程序中的集合创建RDD；使用本地文件创建RDD；使用HDFS文件创建RDD。
个人经验认为：
1、使用程序中的集合创建RDD，主要用于进行测试，可以在实际部署到集群运行之前，自己使用集合构造测试数据，来测试后面的spark应用的流程。
2、使用本地文件创建RDD，主要用于临时性地处理一些存储了大量数据的文件。
3、使用HDFS文件创建RDD，应该是最常用的生产环境处理方式，主要可以针对HDFS上存储的大数据，进行离线批处理操作。
并行化集合创建RDD
如果要通过并行化集合来创建RDD，需要针对程序中的集合，调用SparkContext的parallelize()方法。Spark会将集合中的数据拷贝到集群上去，形成一个分布式的数据集合，也就是一个RDD。相当于是，集合中的部分数据会到一个节点上，而另一部分数据会到其他节点上。然后就可以用并行的方式来操作这个分布式数据集合，即RDD。
// 案例：1到10累加求和
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val rdd = sc.parallelize(arr)
val sum = rdd.reduce(_ + _)
调用parallelize()时，有一个重要的参数可以指定，就是要将集合切分成多少个partition。Spark会为每一个partition运行一个task来进行处理。Spark官方的建议是，为集群中的每个CPU创建2~4个partition。Spark默认会根据集群的情况来设置partition的数量。但是也可以在调用parallelize()方法时，传入第二个参数，来设置RDD的partition数量。比如parallelize(arr, 10)
使用本地文件和HDFS创建RDD
Spark是支持使用任何Hadoop支持的存储系统上的文件创建RDD的，比如说HDFS、Cassandra、HBase以及本地文件。通过调用SparkContext的textFile()方法，可以针对本地文件或HDFS文件创建RDD。
有几个事项是需要注意的：
1、如果是针对本地文件的话，如果是在windows上本地测试，windows上有一份文件即可；如果是在spark集群上针对linux本地文件，那么需要将文件拷贝到所有worker节点上。
2、Spark的textFile()方法支持针对目录、压缩文件以及通配符进行RDD创建。
3、Spark默认会为hdfs文件的每一个block创建一个partition，但是也可以通过textFile()的第二个参数手动设置分区数量，只能比block数量多，不能比block数量少。
// 案例：文件字数统计
val rdd = sc.textFile(“data.txt”)
val wordCount = rdd.map(line => line.length).reduce(_ + _)
transformation和action介绍
Spark支持两种RDD操作：transformation和action。transformation操作会针对已有的RDD创建一个新的RDD；而action则主要是对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并可以返回结果给Driver程序。
例如，map就是一种transformation操作，它用于将已有RDD的每个元素传入一个自定义的函数，并获取一个新的元素，然后将所有的新元素组成一个新的RDD。而reduce就是一种action操作，它用于对RDD中的所有元素进行聚合操作，并获取一个最终的结果，然后返回给Driver程序。
transformation的特点就是lazy特性。lazy特性指的是，如果一个spark应用中只定义了transformation操作，那么即使你执行该应用，这些操作也不会执行。也就是说，transformation是不会触发spark程序的执行的，它们只是记录了对RDD所做的操作，但是不会自发的执行。只有当transformation之后，接着执行了一个action操作，那么所有的transformation才会执行。Spark通过这种lazy特性，来进行底层的spark应用执行的优化，避免产生过多中间结果。
action操作执行，会触发一个spark job的运行，从而触发这个action之前所有的transformation的执行。这是action的特性。
案例：统计文件字数
这里通过一个之前学习过的案例，统计文件字数，来讲解transformation和action。
// 这里通过textFile()方法，针对外部文件创建了一个RDD，lines，但是实际上，程序执行到这里为止，spark.txt文件的数据是不会加载到内存中的。lines，只是代表了一个指向spark.txt文件的引用。
val lines = sc.textFile(“spark.txt”)
// 这里对lines RDD进行了map算子，获取了一个转换后的lineLengths RDD。但是这里连数据都没有，当然也不会做任何操作。lineLengths RDD也只是一个概念上的东西而已。
val lineLengths = lines.map(line => line.length)
// 之后，执行了一个action操作，reduce。此时就会触发之前所有transformation操作的执行，Spark会将操作拆分成多个task到多个机器上并行执行，每个task会在本地执行map操作，并且进行本地的reduce聚合。最后会进行一个全局的reduce聚合，然后将结果返回给Driver程序。
val totalLength = lineLengths.reduce(_ + _)
案例：统计文件每行出现的次数
Spark有些特殊的算子，也就是特殊的transformation操作。比如groupByKey、sortByKey、reduceByKey等，其实只是针对特殊的RDD的。即包含key-value对的RDD。而这种RDD中的元素，实际上是scala中的一种类型，即Tuple2，也就是包含两个值的Tuple。
在scala中，需要手动导入Spark的相关隐式转换，import org.apache.spark.SparkContext._。然后，对应包含Tuple2的RDD，会自动隐式转换为PairRDDFunction，并提供reduceByKey等方法。
val lines = sc.textFile(“hello.txt”)
val linePairs = lines.map(line => (line, 1))
val lineCounts = linePairs.reduceByKey(_ + _)
lineCounts.foreach(lineCount => println(lineCount._1 + " appears " + llineCount._2 + " times."))
常用transformation介绍
常用action介绍
案例
**
1、map：将集合中每个元素乘以2
2、filter算子函数：过滤集合总的偶数
3、flapMap案例：将文本拆分成多个单词
4、groupByKey案例：安装班级对成绩进行分类
5、reduceByKey:统计每个班级的总分
6、sourtByKey:安装学生分数降序排
7、join与cogroup:打印学生的成绩
**
package cn.spark.study.core;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class Transfromation_7 {
public static void main(String[] args) {
// myMap();
//myFilter();
//myFlatMap();
// myGroupByKey();
//myReduceByKey();
//mySortByKey();
myJoinAndCogroup();
}
/**
* map算子：对每一个元素*2
*/
private static void myMap(){
SparkConf conf = new SparkConf()
.setAppName("map")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//构建集合
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
//并行化集合，初始RDD
JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
//使用map算子，将集合中的每个元素*2
// map算子，是对任何算数据类型的RDD都可以调用的
// 在java中，map算子接收的参数是Function对象
// 创建的Function对象，一定会让你设置第二个参数，这个泛型参数，就是返回新元素的类型
// 同时call()方法的返回类型，也必须与第二个个泛型类型同步
// 在call()可以对原始数据进行各种操作，并返回一组新的元素组成一个新的RDD
JavaRDD<Integer> map = numberRDD.map(new Function<Integer, Integer>() {
@Override
public Integer call(Integer integer) throws Exception {
return integer * 2;
}
});
// 打印新的RDD中的内容
map.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println(integer);
}
});
sc.close();
}
/**
* filter算子函数：过滤集合总的偶数
*/
private static void myFilter(){
SparkConf conf = new SparkConf()
.setAppName("map")
.setMaster("local");
//创建SparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
//模拟结合
List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
//并行化集合，初始化RDD
JavaRDD<Integer> numberRDD = sc.parallelize(numbers);
//对初始RDD执行filter算子，将其中的偶数过滤出来
//filter传入的也是faction，其他的输赢注意点，实际和map是一样的
//每一个RDD初始化中的元素，都会传入call()方法，此时你可以执行各种自定义的计算逻辑
//莱帕胺段这个元素石佛营是你想要的
//如果你想要在新的RDD中保留这个元素，那么就返回true；否则，不想保留这个元素，返回false
JavaRDD<Integer> filter = numberRDD.filter(new Function<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) throws Exception {
return integer % 2 == 0;
}
});
filter.foreach(new VoidFunction<Integer>() {
@Override
public void call(Integer integer) throws Exception {
System.out.println(integer);
}
});
sc.close();
}
/**
* flapMap案例：将文本拆分成多个单词
*/
private static void myFlatMap(){
SparkConf conf = new SparkConf()
.setAppName("myFlatMap")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
//模拟结合
List<String> lineList = Arrays.asList("hello me" , "hello you" , "hello world");
JavaRDD<String> lines = sc.parallelize(lineList);
// 对RDD执行flatMap算子，将每一行文本，拆分成多个单词
// flatMap算子，在java中，接受的参数是flatMapFunction
// 我们需要自己定义FlatMapFunction的第二个泛型类型，即，代表了返回的新元素的类型
// call()方法，返回类型，不是Object。而是Iterable<Object>,这里的Object也与第二个泛型类型相同
// flatMap其实就是，接受原始RDD中的每个元素，并进行各种逻辑计算和处理。返回多个元素
// 多个元素，即封装在Iterable中，可以使用ArrayList等集合
JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterable<String> call(String s) throws Exception {
return Arrays.asList(s.split(" "));
}
});
words.foreach(new VoidFunction<String>() {
@Override
public void call(String s) throws Exception {
System.out.println(s);
}
});
sc.close();
}
/**
* groupByKey案例：安装班级对成绩进行分类
*/
private static void myGroupByKey(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("myGroupByKey");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<String,Integer>> scoreList = Arrays.asList(
new Tuple2<String, Integer>("class1",70),
new Tuple2<String, Integer>("class2", 75),
new Tuple2<String,Integer>("class1",67),
new Tuple2<String, Integer>("class2", 87)
);
//JavaRDD<Tuple2<String, Integer>> scores = sc.parallelize(scoreList);
JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList);
JavaPairRDD<String, Iterable<Integer>> groupedScore = scores.groupByKey();
groupedScore.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() {
@Override
public void call(Tuple2<String, Iterable<Integer>> tuple2) throws Exception {
System.out.println("班级：" + tuple2._1);
Iterator<Integer> scores = tuple2._2.iterator();
while (scores.hasNext()){
System.out.println(scores.next());
}
System.out.println("======================");
}
});
sc.close();
}
/**
* reduceByKey:统计每个班级的总分
*/
private static void myReduceByKey(){
SparkConf conf = new SparkConf()
.setAppName("myReduceByKey")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<String,Integer>> scoreClass = Arrays.asList(
new Tuple2<String, Integer>("class3",22),
new Tuple2<String, Integer>("class5", 12),
new Tuple2<String, Integer>("class3", 34),
new Tuple2<String, Integer>("class5", 56)
);
JavaPairRDD<String, Integer> scoreClassPRDD = sc.parallelizePairs(scoreClass);
// 针对scores DRR 执行reduceByKey
// reduceByKey，接受的参数是Function2类型，他有三个参数，实际上代表三个值
// 第一个泛型类型和第二个泛型类型，代表原始RDD中的元素value的类型
// 因此对每个key进行redce，都会一次将第一个，第二个value传入，将值在与第三个value传入
// 因此此处，也会自动定义两个泛型类型，代表call()方法的两个传入参数的类型
// 第三个泛型类型，代表了每次reduce操作返回值的类型，默认也是与原始RDD的value类型相同的
//reduceByKey算子返回的RDD，还是JavaPairRDD<key,value>
JavaPairRDD<String, Integer> scoreReduced = scoreClassPRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
@Override
// 对每个key，都会将其value，依次传入call方法
// 从而聚合出每一个key对应的一个value
// 然后，将每一个key对应的一个value，组合称一个Tuple2，做为新的RDD的元素
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
scoreReduced.foreach(new VoidFunction<Tuple2<String, Integer>>() {
@Override
public void call(Tuple2<String, Integer> tuple2) throws Exception {
System.out.println( tuple2._1 + ":" + tuple2._2);
}
});
sc.close();
}
/**
* sourtByKey:安装学生分数降序排
*/
private static void mySortByKey(){
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("mySortByKey");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<Double,String>> stuScore = Arrays.asList(
new Tuple2<Double,String>(59.9,"lixiaoguang"),
new Tuple2<Double,String>(59.99,"wangzhiqiang"),
new Tuple2<Double,String>(101.0,"duanxiaolei"),
new Tuple2<Double,String>(102.0,"zhaojiajia")
);
JavaPairRDD<Double,String> stuScorePRDD = sc.parallelizePairs(stuScore);
// 对scores DRR执行sortByKey算子
// 如果参数是false，是降序；默认是升序
// sortByKey 其实就是根据key进行排序，可以手动制定升序或者降序
// 返回的，还是JavaPairRDD，其中的元素内容，都是和原始的RDD一摸一样的
// 但是就是RDD中的元素顺序不同了
JavaPairRDD<Double,String> rdd = stuScorePRDD.sortByKey(false);
rdd.foreach(new VoidFunction<Tuple2<Double,String>>() {
@Override
public void call(Tuple2<Double,String> tuple2) throws Exception {
System.out.println(tuple2._1 +":"+tuple2._2);
}
});
sc.close();
}
/**
* join与cogroup:打印学生的成绩
*
*/
private static void myJoinAndCogroup() {
SparkConf conf = new SparkConf()
.setAppName("myJoinAndCogroup")
.setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
List<Tuple2<Integer, String>> stuList = Arrays.asList(
new Tuple2<Integer, String>(1, "zhansan"),
new Tuple2<Integer, String>(2, "lisi"),
new Tuple2<Integer, String>(3, "wangwu")
);
List<Tuple2<Integer, Integer>> scoreOneList = Arrays.asList(
new Tuple2<Integer, Integer>(1, 100),
new Tuple2<Integer, Integer>(2, 90),
new Tuple2<Integer, Integer>(3, 60)
);
List<Tuple2<Integer, Integer>> scoreTwoList = Arrays.asList(
new Tuple2<Integer, Integer>(1, 100),
new Tuple2<Integer, Integer>(2, 90),
new Tuple2<Integer, Integer>(3, 60),
new Tuple2<Integer, Integer>(1, 70),
new Tuple2<Integer, Integer>(2, 80),
new Tuple2<Integer, Integer>(3, 50)
);
// 并行化两个RDD
JavaPairRDD<Integer, String> students = sc.parallelizePairs(stuList);
final JavaPairRDD<Integer, Integer> scoreOne = sc.parallelizePairs(scoreOneList);
JavaPairRDD<Integer, Integer> scoreTwo = sc.parallelizePairs(scoreTwoList);
// 使用join关联两个RDD
// join后，还是会根据key进行join，并返回JavaPairRDD
// 但是JavaPairRDD的第一个泛型类型，之前两个JavaPairRDD的key的类型，因为是通过key进行join的
// 第二个泛型类型，是Tuple2<v1,v2>的类型，Tuple2的两个泛型分别是原始RDD的value类型
// join，就返回的RDD的每一个元素，就是通过key join上的一个pair
// 例如：(1,1) (1,2) (1,3)的一个RDD
//还有一个(1,4) (2,1) (2,2)的一个RDD
//join以后，实际上会得到(1,(1,4)) (1,(2,4)) (1,(3,4))
JavaPairRDD<Integer, Tuple2<String, Integer>> studentsJoinScoreOne = students.join(scoreOne);
studentsJoinScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<String, Integer>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<String, Integer>> tuple2) throws Exception {
System.out.println(tuple2._1 + ":" + tuple2._2._1 + ":" + tuple2._2._2);
}
});
System.out.println("=========================");
// cogroup与join不同
// 相当于，一个key join上的所有value，都放到一个Iterable里
JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> studentsCogroupScoreOne = students.cogroup(scoreTwo);
studentsCogroupScoreOne.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {
@Override
public void call(Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> tuple2) throws Exception {
System.out.println(tuple2._1 +":"+ tuple2._2._1+":"+tuple2._2._2);
}
});
sc.close();
}
}
HDFS 案例：统计文本文件字数
package cn.spark.study.core;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.hadoop.io.Text;
/**
* 使用HDFS文件创建RDD
* * 案例：统计文本文件字数
*/
public class HdfsFile_5 {
public static void main(String[] args) {
SparkConf conf = new SparkConf()
.setMaster("local")
.setAppName("HdfsFile_5");
JavaSparkContext sc = new JavaSparkContext(conf);
// 使用SparkContext以及其子类的textFile()方法，针对HDFS文件创建RDD
// 只要把textFile()内的路径修改为hdfs文件路径即可
JavaRDD<String> lines = sc.textFile("hdfs://hadoop1:9000/spark.txt");
JavaRDD<Integer> lineLength = lines.map(new Function<String, Integer>() {
@Override
public Integer call(String s) throws Exception {
return s.length();
}
});
Integer count = lineLength.reduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
});
System.out.println("文件中出现单词的总数：" + count);
sc.close();
}
}
本地文件创建初始的RDD
统计spark.txt文件一共有多少个单词
package cn.spark.study.core;
import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.rdd.RDD;
/**
* 本地文件创建初始的RDD
* 统计spark.txt文件一共有多少个单词
*/
public class LocalFile_5 {
public static void main(String[] args) {
// 创建SparkConf
SparkConf conf = new SparkConf()
.setAppName("LocalFile_5")
.setMaster("local");
// 创建JavaSparkContext
JavaSparkContext sc = new JavaSparkContext(conf);
// 使用SparkContext以及其子类的textFile()方法，针对本地文件创建RDD
JavaRDD<String> lines = sc.textFile(args[0]);
// 统计文本文件内的字数Array(123,12,45,24)
JavaRDD<Integer> lineLength = lines.map(new Function<String, Integer>() {
@Override
public Integer call(String line) throws Exception {
return line.length();
}
});
Integer count = lineLength.reduce(new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
System.out.println("文件中出现单词的总数：" + count);
sc.close();
}
}
7765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
