pass night

【大数据】Spark学习笔记

初识`Spark`

`Spark`和`Hadoop`

	Hadoop	Spark
起源时间	2005	2009
起源地	MapReduce	University of California Berkeley
数据处理引擎	Batch	Batch
编程模型	MapReduce	Resilient distributed Datesets
内存管理	Disk Based	JVM Managed
延迟	高	中
吞吐量	中	高
优化机制	手动	手动
API	Low level	high level
流处理	NA	Spark Streaming
SQL支持	Hive, Impala	SparkSQL
Graph支持	NA	GraphX
机器学习支持	NA	SparkML

`Spark`对比`Hadoop`特点

`Spark`优缺点

Spark将运算的中间数据存放在内存, 迭代计算效率更高; 而MapReduce的中间结果需要保存到磁盘
Spark容错性更高, 通过弹性分布式数据集RDD来实现高容错; 一部分数据丢失或戳错可以通过数据集的计算过程的血缘关系来实现重建; MapReduce发生错误只能重新计算
Spark相比于Hadoop提供了transformation和action这两大类的多功能api, 以及流式处理Spark Streaming模块, 图计算GraphX等等; MapReduce只提供了map和reduce两种操作
Spark框架和生态更加复杂, 首先有RDD, 血缘lineage, 执行时的有向无环图DAG/stage划分等, 很多时候都需要根据不同场景分别调优以达到性能要求; 而MapReduce框架及应用较为简单, 但运行较为稳定, 更适合长期稳定运行

`Hadoop`优缺点

优点:

高可靠性: hadoop可以按位存储和处理数据
高扩展性
高效性: Hadoop能够在节点之间动态的移动数据, 并保证各个节点的动态平衡
高容错性: Hadoop能够保存数据的多个副本, 并且能够自动将失败的任务重新分配

缺点:

不适合低延迟的数据访问
无法高效存储大量小文件
不支持多用户写入及任意文件的修改

基本概念

Application: 用户编写的Spark应用程序, 包含了driver程序以及集群上运行的程序代码, 物理机器上涉及了driver, master, worker三个节点
RDD(Resilient Distributed Dataset): 弹性分布式数据集是Spark中最基本的数据抽象, 代表了一个不可变, 可分区, 可并行计算的集合. RDD具有数据流模型的特点: 自动容错/位置感知性调度/和可伸缩性. RDD允许用户在执行多个查询时显示地将工作集缓存在内存中, 后续的查询能够重用工作机, 这极大地提升了查询速度. RDD包含:
1. 分片(Partition): 即苏聚集的基本组成功单位, 对于RDD来说, 每个分片都会被一个计算任务吹了, 并决定并行计算的粒度. 用户可以在创建RDD时指定RDD的分片个数, 如果没有指定, 则会采取默认值即分配到的CPUCore个数
2. 分区计算函数: Spark中RDD的计算是以分片为单位的, 每个RDD都会实现compute函数以达到这个目的. compute函数会对迭代器进行复合, 不需要保存每次计算结果
3. 重建: 在部分分区数据丢失时, Spark可以通过这个以来关系重新计算丢失的分区数据, 而不是对RDD的所有分区进行计算
4. Partitioner即RDD的分片函数: 当前Spark中实现了两种类型的分片函数, 一个是基于哈希的HashPartitioner, 另一个是基于范围的RangePartitioner. 只有对于key-value的RDD, 才会有Partitioner
5. 优先位置(preferedlocation): 对于一个HDFS文件来说, 这个列表保存的就是每个Partition所在的块的位置, 按住奥"移数据不如移动计算"的理念, Spark在记性任务调度的时候, 会尽可能地讲计算任务分配到其所要处理的块的位置
DAG: 有向无环图
Task: 被发送到executor上的工作单元, 每个Task负责一个分区的数据
ShuffleMapTask: 输出是shuffle所需的数据, stage的划分也以此为依据, shuffle之前的所有变换是一个stage, shuffle之后的操作是另个一个stage
resultTask: 输出是计算结果
Job: 一个Job包含多个RDD及作用于RDD上面的各种操作; 他包含多个task的并行计算, 可以理解为SparkRDD里面的action, 每个action的出发会生成一个job. 用户提交的job会提交给DAGSCheduler; job会被分解为Stage, Stage会被细化乘Task, Task就是每个Partition上的单个数据处理流程
Stage: 是job的基本调度单位, 一个Job会分为多组Task, 每组Task被称为一个Stage就行MapStage, ReduceStage,或者也被称为TaskSet, 代表一组关联的, 相互之间没有Shuffle依赖关系的组成的任务集
Partition: Partition类似hadoop的Split，计算是以partition为单位进行的
Cluster Manager: 指的是在集群上获取资源的外部服务。主要有三种类型:
1. Standalon : spark原生的资源管理，由Master负责资源的分配。
2. Apache Mesos:与hadoop MR兼容性良好的一种资源调度框架。
3. Hadoop Yarn: 主要是指Yarn中的Resource Manager。

Spark 组成

Spark Core: Spark核心, 所有核心功能均为Spark提供, Spark Core以RDD为数据抽象, 提供Api, 可以支持海量离线数据批处理计算
SparkSQL: 基于Spark Core之上, 提供结构化数据的处理模块, 支持以SQL语言对数据的处理, 本身针对离线的计算场景, 同时基于SparkSQL, Spark提供了StructuredStreaming模块, 可以进行数据的流式计算
SparkStream: 以SparkCore为基础, 提供数据的流式计算功能
MLLib: 以SparkCore为基础, 进行机器学习计算
GraphX: 以SparkCore为基础, 进行图计算, 提供了大量图计算相关的Api

Spark运行模式

本地模式(单机): 本地模式是以一个独立的进程, 通过多个线程来模拟整个Spark运行的环境
Standalone模式(集群): Spark中各个角色以独立进程的形式存在, 并组成Spark集群环境
Hadoop YARN模式(集群): Spark中的各个角色运行在YARN容器内部, 并组成Spark集群环境
Kubernetes模式(容器集群): Spark中的各个角色运行在Kubernetes容器内部, 并组成Spark环境

Spark架构

Yarn角色分配:
1. 以资源管理层面: ResoureManger, ResoureManager
2. 任务计算层面: ApplicationMaster, Task(容器内计算框架的工作角色)
Spark角色分配:
1. Master: 管理集群的资源
2. Worker: 集群中任何一个可以运行spark应用代码的节点. Worker是物理节点, 可以在上面启动Executor进程 分配节点资源
3. Driver: Spark中的Driveer是运行Application的main函数, 并且创建了SparkContext; 创建SparkContext的目的是为了准备Spark应用程序的运行环境. 在Spark中SparkContext负责与Cluster Manager通信, 进行资源申请/任务分配和监控等. 当Excutor部分运行完毕后, Driver同时负责将SparkContext关闭 单个任务的管理
4. Executor: 在每个Worker上为某应用启动的一个进程, 该进程负责运行Task, 并且负责将数据存在内存或磁盘上, 每个任务都有各独立的Executor. Executor是一个执行Task的容器 单个任务的执行

Standalone架构

Standalone模式Spark自带的一种集群模式, 集群由Master和Spark组成. 除了Master和Worker以外, 还可能由HistoryServer, 该进程会在Spark Application运行完成之后, 保存事件日志到HDFS, 启动HistoryServer可以查看应用相关的信息

基本使用

安装 `Spark`¹

wget https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz
tar -xvf spark-3.4.1-bin-hadoop3.tgz
sudo mv spark-3.4.1-bin-hadoop3 /usr/local/spark
vim ~/.bashrc
export SPARK_HOME="/usr/local/spark"
/usr/local/spark/bin/spark-shell

Spark shell - Spark Jobs (passnight.local)包含Spark访问界面

使用`Spark`实现`WordCount`

package com.passnight.bigdata.spark;

import lombok.Cleanup;
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 scala.Tuple2;

import java.util.Arrays;

public class WordCount {

    public static void main(String[] args) {
        SparkConf conf = new SparkConf()
                .setAppName("WordCount")
                .setMaster("local");

        @Cleanup JavaSparkContext context = new JavaSparkContext(conf);
        JavaRDD<String> data = context.textFile("hdfs://server.passnight.local/test/word list.txt", 10);

        JavaPairRDD<String, Integer> result = data.flatMap(line -> Arrays.stream(line.split(" ")).iterator())
                .mapToPair(word -> new Tuple2<>(word, 1)) // 映射成词频
                .reduceByKey(Integer::sum) // 聚合词频
                // 排序
                .mapToPair(Tuple2::swap)
                .sortByKey(false)
                .mapToPair(Tuple2::swap);

        System.out.println("-".repeat(100));
        System.out.println(result.collect());
        System.out.println("-".repeat(100));
    }
}

输出如下(省略了日志)

[(I,4), (like,2), (passnight,2), (love,2), (hadoop,2)]

RDD

RDD基本概念

分布式计算需要的机制, RDD是提供这些机制的一个抽象
1. 分区控制
2. Shuffle控制
3. 数据存储/序列化/发送
4. 数据计算
RDD定义:
1. Resilient Distributed Dataset(弹性分布式数据集): 是Spark中最基本的数据抽象, 表示一个不可变/可分区/可并行计算的集合, 三个单词分别有以下含义:
2. Dataset: 一个数据集合, 用于存放数据
3. Distributed: RDD中的数据是分布式存储的, 可用于分布式计算
4. Resilient: RDD中的数据可以存储在内存中或者磁盘中
RDD的数据具有以下特性:
1. 不可变: RDD是不可变集合
2. 分区性: 数据集合被划分为多个部分, 每个部分被称为分区 对于KV型数据可以有分区器; 且数据读取会尽量靠近数据所在地(移动计算而非数据); 分区是RDD的最小存储单位
3. 并行性: 计算方法是并行的, 计算方法会作用在每个分区上
4. 依赖性: RDD之间具有相互依赖的关系 RDD有血缘关系
RDD在WordCount中的数据流:

RDD创建

RDD可以通过读取文件或集合创建rdd

package com.passnight.bigdata.spark;

import lombok.Cleanup;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;

import java.util.Arrays;

public class RDDCreation {

    public static void main(String[] args) {
        SparkConf conf = new SparkConf()
                .setAppName("WordCount")
                .setMaster("local[*]");

        @Cleanup JavaSparkContext context = new JavaSparkContext(conf);
        // 通过并行化的方式创建RDD, 默认分区数为核心数
        JavaRDD<Integer> rdd = context.parallelize(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9), 3);
        System.out.println("-".repeat(100));
        System.out.println(rdd.collect());
        System.out.println("-".repeat(100));

        // 也可以通过本地文件创建; 这里的最小分区数是参考值, 而非强制值
        JavaRDD<String> rdd1 = context.textFile("bigdata/src/main/resources/word list.txt", 100);
        System.out.println("-".repeat(100));
        System.out.println(rdd1.getNumPartitions());
        System.out.println("-".repeat(100));
        System.out.println(rdd1.collect());
        System.out.println("-".repeat(100));

        // 从hdfs读取文件
        JavaRDD<String> rdd2 = context.textFile("hdfs://server.passnight.local/test/word list.txt");
        System.out.println("-".repeat(100));
        System.out.println(rdd2.getNumPartitions());
        System.out.println("-".repeat(100));
        System.out.println(rdd2.collect());
        System.out.println("-".repeat(100));
    }
        // 读取多个小文件
        JavaPairRDD<String, String> rdd3 = context.wholeTextFiles("bigdata/src/main/resources");
        System.out.println("-".repeat(100));
        System.out.println(rdd3.getNumPartitions());
        System.out.println("-".repeat(100));
        System.out.println(rdd3.collect());
        System.out.println("-".repeat(100));
}

输出为:

# 这里省略了日志和分隔符
[1, 2, 3, 4, 5, 6, 7, 8, 9]
61
[I love passnight, I like passnight, I love hadoop, I like hadoop]
2
[I love passnight, I like passnight, I love hadoop, I like hadoop]
[(file:/************/bigdata/src/main/resources/word list.txt,I love passnight
I like passnight #......................

Transformation算子

Transformation算子: 返回值仍是一个RDD的算子 这类算子是lazy加载的, 如果没有action算子, 这类算子是不工作的; 如flatMap是一类典型的Transformation算子
Action算子: 返回值不是RDD的算子 例如collect

`map`算子

功能: map算子, 是将RDD中的数字逐条处理, 返回新的RDD

class Map {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Map")
                .setMaster("local[*]"));
        List<Integer> rdd = context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()), 3)
                .map(i -> i * 10)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出为:

计算结果:
 [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

`flatMap`算子

功能: 先对rdd进行map操作, 再摊平嵌套

class FlatMap {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("FlatMap")
                .setMaster("local[*]"));
        List<String> rdd = context.parallelize(Arrays.asList("1 2 3", "4 5 6", "7 8 9"), 3)
                .flatMap(line -> Arrays.stream(line.split(" ")).iterator())
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出为:

计算结果:
 [1, 2, 3, 4, 5, 6, 7, 8, 9]

可以看到多个数组被摊平为一个数组

`reduceByKey`算子

功能: 针对KV型RDD, 先对key进行分组, 然后根据提供的聚合逻辑, 完成组内数据的聚合操作

class ReduceByKey {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("ReduceByKey")
                .setMaster("local[*]"));
        List<Tuple2<String, Integer>> rdd = context.parallelizePairs(Stream.of(1, 1, 1, 2, 2, 2, 3, 4, 4, 3, 10)
                        .map(i -> new Tuple2<>(String.format("值: %d", i), i))
                        .collect(Collectors.toList()), 3)
                .reduceByKey(Integer::sum)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [(值: 4,8), (值: 1,3), (值: 2,6), (值: 10,10), (值: 3,6)]

可以看到不同值被分组, 然后进行求和

`mapToValues`算子

功能: 针对二元元组RDD, 对其内部的Value进行map操作

class MapToValues {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("MapToValues")
                .setMaster("local[*]"));
        List<Tuple2<String, Integer>> rdd = context.parallelizePairs(Stream.of(1, 1, 1, 2, 2, 2, 3, 4, 4, 3, 10)
                        .map(i -> new Tuple2<>(String.format("值: %d", i), i))
                        .collect(Collectors.toList()), 3)
                .mapValues(i -> i * 10)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [(值: 1,10), (值: 1,10), (值: 1,10), (值: 2,20), (值: 2,20), (值: 2,20), (值: 3,30), (值: 4,40), (值: 4,40), (值: 3,30), (值: 10,100)]

可以看到只有值发生了变化, 且变为了原来的10倍

`groupBy`算子

功能: 将RDD的数据进行分组

class GroupBy {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("GroupBy")
                .setMaster("local[*]"));
        List<Tuple2<String, Iterable<Tuple2<String, Integer>>>> rdd = context.parallelizePairs(Arrays.asList(
                        Tuple2.apply("a", 1), Tuple2.apply("b", 2), Tuple2.apply("b", 1), Tuple2.apply("a", 3), Tuple2.apply("c", 1)
                ), 3)
                .groupBy(Tuple2::_1)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [(c,[(c,1)]), (a,[(a,1), (a,3)]), (b,[(b,2), (b,1)])]

可以看到已经根据key分组了

`ffilter`算子

功能: 过滤符合条件的数据

class Filter {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Filter")
                .setMaster("local[*]"));
        List<Integer> rdd = context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()), 3)
                .filter(i -> i % 2 == 0)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [0, 2, 4, 6, 8]

可以看到已将偶数都过滤出来了

`distinct`算子

功能: 将rdd数据去重

class Distinct {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Distinct")
                .setMaster("local[*]"));
        List<Integer> rdd = context.parallelize(Arrays.asList(1, 1, 1, 2, 2, 2, 3, 3, 3), 3)
                .distinct(2)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
        
        List<Tuple2<String, Integer>> rdd2 = context.parallelizePairs(Arrays.asList(Tuple2.apply("a", 1),
                        Tuple2.apply("b", 1), Tuple2.apply("b", 1),
                        Tuple2.apply("a", 3), Tuple2.apply("a", 1)), 3)
                .distinct(2)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd2);
    }
}

输出结果为:

计算结果:
 [2, 1, 3]
计算结果:
 [(a,1), (a,3), (b,1)]

可以看到无论是KV型数据还是普通的数据, 都已经去重了

`union`算子

功能: 将两个rdd合并成一个rdd

class Union {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Union")
                .setMaster("local[*]"));
        JavaRDD<Object> rdd1 = context.parallelize(IntStream.range(0, 4).boxed().collect(Collectors.toList()), 3);
        JavaRDD<Object> rdd2 = context.parallelize(IntStream.range(2, 7).boxed().collect(Collectors.toList()), 3);
        JavaRDD<Object> rdd3 = context.parallelize(IntStream.range(7, 10).boxed().map(String::valueOf).collect(Collectors.toList()), 3);
        List<Object> rdd = rdd1.union(rdd2)
                .union(rdd2)
                .union(rdd3)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [0, 1, 2, 3, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7, 8, 9]

可以看到可以合并数据类型, 合并也不会进行去重操作

`join`算子

功能: 对两个RDD执行join操作, 可以实现SQL的内连接/外连接

class Join {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Join")
                .setMaster("local[*]"));
        JavaPairRDD<Integer, String> rdd1 = context.parallelizePairs(Arrays.asList(
                Tuple2.apply(1, "张三"), Tuple2.apply(2, "李四"),
                Tuple2.apply(3, "王五"), Tuple2.apply(4, "赵六")
        ), 3);
        JavaPairRDD<Integer, String> rdd2 = context.parallelizePairs(Arrays.asList(
                Tuple2.apply(1, "生产部"), Tuple2.apply(2, "销售部")
        ), 3);
        // 默认按照两个rdd的key进行关联, 不像sql无需用on添加条件
        List<Tuple2<Integer, Tuple2<String, String>>> join = rdd1.join(rdd2)
                .collect();
        List<Tuple2<Integer, Tuple2<String, Optional<String>>>> leftOuterJoin = rdd1.leftOuterJoin(rdd2)
                .collect();
        System.out.printf("计算结果(join):%n %s%n", join);
        System.out.printf("计算结果(leftOuterJoin):%n %s%n", leftOuterJoin);
    }
}

输出结果为:

计算结果(join):
 [(1,(张三,生产部)), (2,(李四,销售部))]
计算结果(leftOuterJoin):
 [(3,(王五,Optional.empty)), (4,(赵六,Optional.empty)), (1,(张三,Optional[生产部])), (2,(李四,Optional[销售部]))]

可以看到两个元组集合根据key关联在一起了, 左外连接保留了在右侧没有对应key的元组

`intersection`算子

功能: 求两个rdd的交集, 并返回一个rdd

class Intersection {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Intersection")
                .setMaster("local[*]"));
        JavaRDD<Integer> rdd1 = context.parallelize(IntStream.range(0, 8).boxed().collect(Collectors.toList()), 3);
        JavaRDD<Integer> rdd2 = context.parallelize(IntStream.range(5, 7).boxed().collect(Collectors.toList()), 3);
        List<Integer> rdd = rdd1.intersection(rdd2)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为

计算结果:
 [6, 5]

可以看到只有在两个集合中都存在的才被输出

`glom`算子

功能: 将RDD的数据按照分区加上嵌套

class Glom {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Glom")
                .setMaster("local[*]"));
        List<List<Integer>> rdd1 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd1);

        List<List<Integer>> rdd2 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 2)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd2);
    }
}

输出结果为:

计算结果:
 [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
计算结果:
 [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]

可以看到分区数和numSlices参数相对应

`groupByKey`算子

功能: 针对KV型RDD, 自动按照Key分组

class GroupByKey {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("GroupByKey")
                .setMaster("local[*]"));
        List<Tuple2<String, Iterable<Integer>>> rdd = context.parallelizePairs(Stream.of(1, 1, 1, 2, 2, 2, 3, 4, 4, 3, 10)
                        .map(i -> new Tuple2<>(String.format("值: %d", i), i))
                        .collect(Collectors.toList()), 3)
                .groupByKey()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为

计算结果:
 [(值: 4,[4, 4]), (值: 1,[1, 1, 1]), (值: 2,[2, 2, 2]), (值: 10,[10]), (值: 3,[3, 3])]

可以看到已经根据key进行分组了

`sortBy`算子

功能: 根据输入的函数, 对RDD进行排序

class SortBy {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("SortBy")
                .setMaster("local[*]"));
        List<Tuple2<String, Integer>> rdd = context.parallelize(new Random().ints(1, 100)
                        .boxed()
                        .map(integer -> Tuple2.apply(String.format("值(%d)",integer), integer))
                        .limit(10)
                        .collect(Collectors.toList()), 3)
                // 若要全局有序, Partition只能设置为1, 否则只能保证分区内局部有序
                .sortBy(Tuple2::_2, true, 1)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [(值(13),13), (值(15),15), (值(21),21), (值(46),46), (值(52),52), (值(55),55), (值(55),55), (值(66),66), (值(87),87), (值(90),90)]

可以看到已经根据元组的第二个元素排序了

`sortByKey`算子

功能: 针对KV型RDD, 按照Key进行排序

class SortByKey {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("SortByKey")
                .setMaster("local[*]"));
        List<Tuple2<String, Integer>> rdd = context.parallelizePairs(new Random().ints(1, 100)
                        .boxed()
                        .map(integer -> Tuple2.apply(String.format("值(%d)", integer), integer))
                        .limit(10)
                        .collect(Collectors.toList()), 3)
                .sortByKey(true, 1)
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [(值(11),11), (值(25),25), (值(45),45), (值(63),63), (值(64),64), (值(65),65), (值(71),71), (值(77),77), (值(79),79), (值(98),98)]

可以看到结果已经根据key排序了

Action算子

`countByKey`算子

功能: 统计key出现的次数, 这个算子是

class CountByKey {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("CountByKey")
                .setMaster("local[*]"));
        java.util.Map rdd = context.parallelizePairs(Stream.of(1, 1, 1, 2, 2, 2, 3, 4, 4, 3, 10)
                        .map(i -> new Tuple2<>(String.format("值: %d", i), i))
                        .collect(Collectors.toList()))
                .countByKey();

        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 {值: 2=3, 值: 4=2, 值: 3=2, 值: 10=1, 值: 1=3}

可以看到已经根据Key进行计数了

`collect`算子

功能: 将RDD各个分区内的数据, 统一手机到一个Driver中, 形成一个List对象

class Collect {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Collect")
                .setMaster("local[*]"));
        List<Integer> rdd = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .collect(); // 注意使用这个算子, 要确认结果集不会太大, 否则可能会导致Driver OOM
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

`reduce`算子:

功能: 根据传入的逻辑进行聚合

class Reduce {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Reduce")
                .setMaster("local[*]"));
        Integer result = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .reduce(Integer::sum);
        System.out.printf("计算结果:%n %s%n", result);
    }
}

输出结果值为:

计算结果:
 45

可以看到成功实现求和

`flod`算子

功能: 相当于有初始值的聚合, 每个分区内都会有一个初始值, 且分区间聚合也有该初始值

class Fold {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Collect")
                .setMaster("local[*]"));
        Integer result = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .reduce(Integer::sum);
        System.out.printf("计算结果:%n %s%n", result);
    }
}

输出结果为:

计算结果:
 85

三个分区聚合引入三个初始值, 因此三个分区聚合后的结果为[16, 25, 34], 它们再聚合, 并添加10作为初始值, 最后的结果为 $10 + 16 + 25 + 34 = 85$

`first`算子

功能: 取出rd的第一个元素

class First {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("First")
                .setMaster("local[*]"));
        Integer result = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .first();
        System.out.printf("计算结果:%n %s%n", result);
    }
}

输出结果为:

计算结果:
 0

可以看到去除第一个元素

`top`算子

功能: 对RDD结果集降序排序, 取前N个

class Top {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Top")
                .setMaster("local[*]"));
        List<Integer> top3 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.collectingAndThen(Collectors.toList(), (list) -> {
                            Collections.shuffle(list);
                            return list;
                        })), 3)
                .top(3);
        System.out.printf("计算结果:%n %s%n", top3);
    }
}

输出结果为:

计算结果:
 [9, 8, 7]

`count`算子

功能: 返回RDD的数据数

class Count {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Count")
                .setMaster("local[*]"));
        long count = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .count();
        System.out.printf("计算结果:%n %s%n", count);
    }
}

输出结果为:

计算结果:
 10

`takeSample`算子

功能: 随机抽样RDD的数据

class TakeSample {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("TakeSample")
                .setMaster("local[*]"));
        List<Integer> sample = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .takeSample(true, 3);
        System.out.printf("计算结果:%n %s%n", sample);
    }
}

输出结果为:

计算结果:
 [5, 4, 9]

可以看到随机取了三个rd中的元素

`takeOrderd`算子

功能: 对RDD进行排序后取前N个 相比于top, 可以制定排序方法

class TakeOrdered {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("TakeOrdered")
                .setMaster("local[*]"));
        List<Integer> sample = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.collectingAndThen(Collectors.toList(), list -> {
                            Collections.shuffle(list);
                            return list;
                        })), 3)
                .takeOrdered(3);
        System.out.printf("计算结果:%n %s%n", sample);
    }
}

输出结果为:

计算结果:
 [0, 1, 2]

`forEach`算子

功能: 对rdd的每个元素执行所提供的操作, 但相比于map, 没有返回值 注意forEach是直接由executor执行的, 其他的算子是由Driver输出的

class ForEach {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("ForEach")
                .setMaster("local[*]"));
        context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()), 3)
                .foreach(System.out::println);
    }
}

输出结果为:

值: 0|值: 3|值: 6|值: 7|值: 4|值: 5|值: 1|值: 2|值: 8|值: 9|

`saveAsTextFile`算子

功能: 将数据结果写入到文件当中, 这个任务是由Executor执行的 支持本地文件系统, 也支持hdfs; 因为是由Executor执行的, 所以每个分区都会写一部分

class SaveAsTextFile implements Serializable {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("SaveAsTextFile")
                .setMaster("local[*]"));
        context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .saveAsTextFile("result");
    }
}

可以看到结果成功写入到文件当中了 , 且结果的文件数量和分区数量相同

passnight@passnight-s600:~/project/note/spring/result$ ll
total 36
drwxr-xr-x  2 passnight passnight 4096 11月  4 14:34 ./
drwxrwxr-x 15 passnight passnight 4096 11月  4 14:34 ../
-rw-r--r--  1 passnight passnight    6 11月  4 14:34 part-00000
-rw-r--r--  1 passnight passnight   12 11月  4 14:34 .part-00000.crc
-rw-r--r--  1 passnight passnight    6 11月  4 14:34 part-00001
-rw-r--r--  1 passnight passnight   12 11月  4 14:34 .part-00001.crc
-rw-r--r--  1 passnight passnight    8 11月  4 14:34 part-00002
-rw-r--r--  1 passnight passnight   12 11月  4 14:34 .part-00002.crc
-rw-r--r--  1 passnight passnight    0 11月  4 14:34 _SUCCESS
-rw-r--r--  1 passnight passnight    8 11月  4 14:34 ._SUCCESS.crc

分区操作算子

`mapPartitions`算子

功能: 同map一样, 但一次操作一整个分区的数据 这样可以极大减少网络io次数

class MapPartitions {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("MapPartitions")
                .setMaster("local[*]"));
        List<Integer> rdd = context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()), 3)
                .mapPartitions(integerIterator -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(integerIterator, 0), false)
                        .map(integer -> integer * 10)
                        .iterator())
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

可以看到所有元素的值都变为了原来的10倍

`foreachPartitions`算子

功能: 同forEach一样, 但一次操作整个分区的数据

class ForeachPartitions {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("ForeachPartitions")
                .setMaster("local[*]"));
        context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()), 3)
                .mapPartitions(integerIterator -> Stream.generate(integerIterator::next)
                        .map(integer -> integer * 10)
                        .iterator())
                .foreachPartition(it -> System.out.printf("值: %s|", it));
    }
}

输出结果为:

值: java.util.Spliterators$1Adapter@8c66b7c|值: java.util.Spliterators$1Adapter@6e74b18e|值: java.util.Spliterators$1Adapter@6cb5e424|

`partitionBy`算子

功能: 对RDD进行自定义分区操作

class PartitionBy {
    public static void main(String[] args) {
        @Cleanup
        JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("PartitionBy")
                .setMaster("local[*]"));
        List<List<Tuple2<Integer, String>>> rdd = context.parallelizePairs(Stream.of(1, 1, 1, 2, 2, 2, 3, 4, 4, 3, 10)
                        .map(i -> new Tuple2<>(i, String.format("值: %d", i)))
                        .collect(Collectors.toList()))
                .partitionBy(new Partitioner() {
                    @Override
                    public int numPartitions() {
                        return 2;
                    }

                    @Override
                    public int getPartition(Object key) {
                        assert key instanceof Integer;
                        Integer k = (Integer) key;
                        return k > 3 ? 1 : 0;
                    }
                }).glom()
                .collect();

        System.out.printf("计算结果:%n %s%n", rdd);
    }
}

输出结果为:

计算结果:
 [[(1,值: 1), (1,值: 1), (1,值: 1), (2,值: 2), (2,值: 2), (2,值: 2), (3,值: 3), (3,值: 3)], [(4,值: 4), (4,值: 4), (10,值: 10)]]

可以看到大于3和小于3的分为了两组

`repartition`算子

功能: 改变分区的数量 注意添加分区可能会导致shuffle, 进而影响到性能, 因此尽量不要改变分区大小, 更不要增大分区

class Repartition {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Repartition")
                .setMaster("local[*]"));
        List<List<Integer>> rdd1 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd1);

        List<List<Integer>> rdd2 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 2)
                .repartition(5)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd2);

        List<List<Integer>> rdd3 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 2)
                .repartition(1)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd3);
    }
}

输出结果为:

计算结果:
 [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
 计算结果:
 [[1, 6], [2, 7], [3, 8], [4, 9], [0, 5]]
 计算结果:
 [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]

`colalesce`算子

功能: 修改分区大小 同repartition相比, 它有一个安全机制, 需要打开shuffle才能增加分区

class Coalesce {
    public static void main(String[] args) {

        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Coalesce")
                .setMaster("local[*]"));
        List<List<Integer>> rdd1 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 3)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd1);

        List<List<Integer>> rdd2 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 2)
                .coalesce(5)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd2);

        List<List<Integer>> rdd3 = context.parallelize(IntStream.range(0, 10)
                        .boxed()
                        .collect(Collectors.toList()), 2)
                .coalesce(1)
                .glom()
                .collect();
        System.out.printf("计算结果:%n %s%n", rdd3);
    }
}

输出结果为:

计算结果:
 [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
计算结果:
 [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
计算结果:
 [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]

RDD持久化

缓存

rdd之间的血缘关系
1. rdd之间相互迭代计算, 通过老的rdd计算生成rdd, 新的rdd生成之后老的rdd会被释放以节约内存空间
rdd持久化技术
1. 新的rdd生成后老的rdd会被释放, 而倘若一个rdd会被使用多次, 这样就要重新计算, 此时可以通过将其持久化到磁盘上来节约计算资源
2. Spark中可以通过cache方法将其缓存到内存中, 和persist将其持久化到磁盘上 persist也可以只持久化到内存或多个内存副本中
3. 可以通过unpresisit来主动清理缓存

下面是一个例子, rdd1和rdd2会被使用两次

public class RddCache {
    @SneakyThrows
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Distinct")
                .setMaster("local[*]"));

        JavaRDD<Integer> rdd1 = context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()));

        JavaRDD<Integer> rdd2 = rdd1.map(x -> x * 10);
        rdd2.cache(); // 将rdd保存下来
        JavaRDD<String> rdd3 = rdd2.map(String::valueOf);

        Integer sum = rdd2.reduce(Integer::sum);
        String expression = rdd3.reduce(String::concat);
        System.out.printf("计算结果:%n %s%n", sum);
        System.out.printf("计算结果:%n %s%n", expression);

        TimeUnit.DAYS.sleep(1);
    }
}

在管理界面, 可以看到DAG图:

由图可知rdd1和rdd2被计算了2次; 在将rdd缓存下来之后, rdd1和rdd2就只被计算了1次

CheckPoint

CheckPoint技术类似cache一样, 也是将RDD的数据保存起来, 但只支持硬盘存储.
CheckPoint 在设计上被认为是安全的, 因此不会保留血缘关系 保留血缘关系在丢失后可以重新计算
CheckPoint存储RDD是集中存储的, 不像Cache是分散存储的 例如将CheckPoint存储到HDFS, 并由HDFS保证其完整性

class CheckPoint {
    @SneakyThrows
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("CheckPoint")
                .setMaster("local[*]"));

        context.setCheckpointDir("checkpoint");

        JavaRDD<Integer> rdd1 = context.parallelize(IntStream.range(0, 10).boxed().collect(Collectors.toList()));

        JavaRDD<Integer> rdd2 = rdd1.map(x -> x * 10);
        rdd2.checkpoint();
        JavaRDD<String> rdd3 = rdd2.map(String::valueOf);

        Integer sum = rdd2.reduce(Integer::sum);
        String expression = rdd3.reduce(String::concat);
        System.out.printf("计算结果:%n %s%n", sum);
        System.out.printf("计算结果:%n %s%n", expression);
        TimeUnit.DAYS.sleep(1);
    }
}

可以看到rdd2被缓存下来了

并且任务2直接从CheckPoint开始执行

共享变量

广播变量

假设一个变量需要被多个分区使用, 可以将该变量标记为广播变量
若两个分区处于同一个进程, 分区二在请求共享变量的时候, 会被通知可以从同进程的其他线程中获取

广播变量的使用

class Broadcast {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Distinct")
                .setMaster("local[*]"));
        Map<Integer, String> nameMap = Map.of(3, "张三", 4, "李四", 5, "王五", 6, "赵六");


        List<Tuple3<Integer, String, Integer>> scoreMap = Arrays.asList(
                Tuple3.apply(3, "语文", 100),
                Tuple3.apply(3, "数学", 100),
                Tuple3.apply(4, "语文", 100),
                Tuple3.apply(4, "数学", 100),
                Tuple3.apply(5, "语文", 100),
                Tuple3.apply(5, "数学", 100),
                Tuple3.apply(5, "英语", 100),
                Tuple3.apply(4, "英语", 100),
                Tuple3.apply(3, "英语", 100)
        );
        org.apache.spark.broadcast.Broadcast<Map<Integer, String>> broadcastNameMap = context.broadcast(nameMap);


        System.out.printf("计算结果:%n %s%n", context.parallelize(scoreMap)
                .map(tuple -> Tuple3.apply(nameMap.get(tuple._1()), tuple._2(), tuple._3()))
                .collect());

        System.out.printf("计算结果:%n %s%n", context.parallelize(scoreMap)
                .map(tuple -> Tuple3.apply(broadcastNameMap.getValue().get(tuple._1()), tuple._2(), tuple._3()))
                .collect());
    }
}

以上面的例子为例, broadcast可以将变量封装为广播变量; 这样就可以节约部分情况下变量的传播
使用广播变量而不使用RDD的原因在于: 使用RDD可能会导致shuffle, 进而使得性能降低 上例中, 假设不是Map而是遍历list找到到对应的key的话, 遍历过程rdd的每个元素都要一次网络io; 广播变量可以一次性传输全量io

累加器

假设要累加分布式对象的数量, 若没有变量共享, 每个分区都会有一个累加器, 进而导致累加的数量少于实际的数量, 下面是一个累加器的例子

class Accumulator {
    public static void main(String[] args) {
        @Cleanup JavaSparkContext context = new JavaSparkContext(new SparkConf()
                .setAppName("Accumulator")
                .setMaster("local[*]"));
        AtomicLong count = new AtomicLong(0); // 不适用累加器


        context.parallelize(IntStream.range(0, 10).boxed()
                        .collect(Collectors.toList()), 3)
                .map(x -> {
                    count.incrementAndGet();
                    System.out.println("计算过程: " + count.get());
                    return x;
                }).collect();
        System.out.printf("计算结果:%n %s%n", count.get());

        LongAccumulator countAccumulator = context.sc().longAccumulator();// 累加器
        context.parallelize(IntStream.range(0, 10).boxed()
                        .collect(Collectors.toList()), 3)
                .map(x -> {
                    countAccumulator.add(1);
                    System.out.println("累加器计算过程: " + countAccumulator.value());
                    return x;
                }).collect();
        System.out.printf("累加器计算结果:%n %s%n", countAccumulator.value());
    }
}

输出结果为:

计算过程: 1
计算过程: 1
计算过程: 1
计算过程: 2
计算过程: 2
计算过程: 3
计算过程: 2
计算过程: 3
计算过程: 3
计算过程: 4
计算结果:
 0
 
 累加器计算过程: 1
累加器计算过程: 2
累加器计算过程: 3
累加器计算过程: 1
累加器计算过程: 2
累加器计算过程: 3
累加器计算过程: 4
累加器计算过程: 1
累加器计算过程: 2
累加器计算过程: 3
累加器计算结果:
 10

可以看到每个分区都有一份累加器的拷贝(Executor的拷贝), 并且结算结果是单独的一份拷贝(Driver的拷贝) 传递是值传递, 而非引用传递, 分布式环境下也无法实现引用传递; 但是如果使用Accumulator的话, 尽管各个分区都是值传递, 但是最后累加的结果会作用在Drive的父拷贝上 注意, 多一个rdd被创创建多次, 会导致accumulator被执行多次, 可以使用cache解决这个问题

Spark Scheduler

Spark的计算调度是Spark Scheduler完成的, 而任务的调度又先后关系, 基于这些关系形成的DAG划分Stage, 调度中Spark Scheduler将每个任务发到指定的节点运行
基本概念
1. Action: 流水线的开关, 只有执行了Action算子, 前面的Transformation算子才会开始执行
2. Job: 任务, 一个Action会产生一个job
3. DAG: 有向无环图, 这里特指RDD间血缘关系形成的有向无环图 在运行时, 会生成带有分区关系的DAG
4. 宽依赖: 父RDD的一个分区, 将数据发给子RDD的多个分区此过程也被成为shuffle
5. 窄依赖: 父RDD的一份分区, 全部将数据发送给子RDD的一个分区
6. 如下图所示,所有都是窄依赖 子节点接受多个父节点也属于窄依赖
7. 该图所有的情况都是宽依赖 可以看到所有的RDD都存在分叉
8. Stage: stage是通过宽依赖划分的, 一个宽依赖会划分出一个新的Stage, 因此Stage内部一定是窄依赖

内存迭代计算

Spark调度器会根据DAG, 按照宽窄以来划分DAG阶段
Spark调度器会尽量将窄依赖划分为一个任务, 这样可以减少网络交互IO
如下图, Task1-Task3都可以在一个分区上完成计算, 因此Spark可以将这些算子调度在同一个内存计算管道
倘若Task3-Task6都在Executor上, 他们之间的数据交互也是通过内存 底层是本地回环网络

Spark并行度

定义: 同一时间内, 同时运行的Task数量
全局并行度可以通过spark.default.parallelism配置 可以在启动参数/配置文件/SparkConf对象中配置

Spark任务调度

DAG Scheduler: 处理逻辑的DAG图, 最后得到逻辑上的Task划分
Task Scheduler: 基于DAG Scheduler调度处的逻辑划分, 决定任务实际在那些物理Executor上执行, 以及监控管理他们的运行

Spark SQL

基本使用

SparkSQL是Spark的一个模块, 用于处理海量的结构化数据
SparkSQL特点
1. 融合性: SQL可以无缝集成在代码中, 随时用SQL处理数据
2. 统一数据访问: 一套标准API课读写不同数据源
3. Hive兼容: 可以使用SparkSQL直接计算并生成Hive数据表
4. 标准化连接: 支持标准化JDBC/ODBC连接, 方便和各种数据库进行交互
SparkSQL和Hive的异同点
1. 相同点:
  1. Spark和Hive都是分布式SQL计算引擎
  2. 都可以运行在YARN之上
2. SparkSQL特点
  1. 内存计算; 底层基于SparkRDD
  2. 无元数据管理
3. Hive特点
  1. 磁盘计算, 底层基于MapReduce
  2. 元数据管理基于MetaStore
SparkSQL中的数据抽象:
1. DataFrame, 是以二维表数据结构存储 类似于Pandas, 但是是分布式存储
2. SchemaRDD对象: 类似于RDD, 对RDD修改使其支持SQL
3. DataSet对象: 用于Java/Scala语言, 带有泛型特性
SparkSession: 类似于SparkContext, 是Spark的入口对象
1. 可以用作SparkSQL入口对象
2. 也可以用于SparkCore编程, 因为可以通过SparkSession获取SparkContext对象

读取csv

对于订单数据

id,user_id,commodity_code,count,money
2,user1,00001,2,200
3,user1,00001,2,200
4,user1,00001,2,200
9,user1,00001,2,200
10,user1,00001,2,200
11,user1,00001,2,200
12,user1,00001,2,200
13,user1,00001,2,200
15,user1,00001,2,200
18,user1,00001,20,200

可以通过spark读取

public class SparkSQLBase {
    public static void main(String[] args) throws AnalysisException {
        // 创建SparkSession对象
        SparkSession spark = SparkSession.builder()
                .appName("test")
                .master("local[*]")
                .getOrCreate();
        // 通过SparkSession获取SparkContext
        SparkContext context = spark.sparkContext();
        Dataset<Row> df = spark.read().csv("bigdata/src/main/resources/order.csv")
                .toDF("id", "user_id", "commodity_code", "count", "money");
        df.printSchema();
        df.show();

        // 创建表
        df.createTempView("order");

        // 写sql
        spark.sql("SELECT * FROM order limit 3;").show();
        // 使用dsl风格写sql
        df.where("count=20").show();
    }
}

输出为

root
 |-- id: string (nullable = true)
 |-- user_id: string (nullable = true)
 |-- commodity_code: string (nullable = true)
 |-- count: string (nullable = true)
 |-- money: string (nullable = true)

+---+-------+--------------+-----+-----+
| id|user_id|commodity_code|count|money|
+---+-------+--------------+-----+-----+
| id|user_id|commodity_code|count|money|
|  2|  user1|         00001|    2|  200|
|  3|  user1|         00001|    2|  200|
|  4|  user1|         00001|    2|  200|
|  9|  user1|         00001|    2|  200|
| 10|  user1|         00001|    2|  200|
| 11|  user1|         00001|    2|  200|
| 12|  user1|         00001|    2|  200|
| 13|  user1|         00001|    2|  200|
| 15|  user1|         00001|    2|  200|
| 18|  user1|         00001|   20|  200|
+---+-------+--------------+-----+-----+

+---+-------+--------------+-----+-----+
| id|user_id|commodity_code|count|money|
+---+-------+--------------+-----+-----+
| id|user_id|commodity_code|count|money|
|  2|  user1|         00001|    2|  200|
|  3|  user1|         00001|    2|  200|
+---+-------+--------------+-----+-----+

+---+-------+--------------+-----+-----+
| id|user_id|commodity_code|count|money|
+---+-------+--------------+-----+-----+
| 18|  user1|         00001|   20|  200|
+---+-------+--------------+-----+-----+

DataFrame

DataFrame是一个二维表结构, 因此由以下三点构成:
1. 行: 数据行
2. 列: 记录一个列的数据, 并且描述一个列的信息
3. 表结构: 描述表的结构
DataFrame具体组成
1. StructType: 描述整个DataFrame的表结构
2. StructField: 描述一个列的信息
数据层面组成:
1. Row: 记录一整行的数据
2. Column: 记录一个列的数据, 并且包含列的信息

通过StructType构建DataSet

    @Test
    public void buildFromRdd() throws AnalysisException {
        @Cleanup JavaSparkContext context = JavaSparkContext.fromSparkContext(spark.sparkContext());

        JavaRDD<Row> rdd = context.textFile("src/main/resources/traffic.txt", 10)
                .map(line -> line.split("\t"))
                .map(words -> RowFactory.create(Long.parseLong(words[0]), words[1]));


        Dataset<Row> df = spark.createDataFrame(rdd, DataTypes.createStructType(Arrays.asList(
                DataTypes.createStructField("phone_number", DataTypes.LongType, true),
                DataTypes.createStructField("ip", DataTypes.StringType, true)
        )));

        df.printSchema();
        // 展示数据
        // 展示前20条数据, 并且不截断数据
        df.show(20, false);

        // 将DataSet注册为临时表; 这样就可以查询了
        df.createTempView("traffic");
        spark.sql("SELECT * FROM traffic where phone_number < 14589530085").show();
    }

从不同数据源读取数据(以CSV为例)

    @Test
    public void buildFromSparkSql() throws AnalysisException {
        Dataset<Row> df = spark.read()
                .format("csv")
                .option("header", false)
                .option("sep", "\t")
                .option("encoding", StandardCharsets.UTF_8.name())
                .schema(DataTypes.createStructType(Arrays.asList(
                        DataTypes.createStructField("phone_number", DataTypes.LongType, true),
                        DataTypes.createStructField("ip", DataTypes.StringType, true)
                )))
                .load("src/main/resources/traffic.txt");
        df.printSchema();
        df.createTempView("traffic");
        spark.sql("SELECT * FROM traffic where phone_number < 14589530085").show();
    }

DataFrame操作

数据准备

    private final static SparkSession spark = SparkSession.builder()
            .appName("test")
            .master("local[*]")
            .getOrCreate();
    private final static Dataset<Row> df = spark.read()
            .format("csv")
            .option("header", false)
            .option("sep", "\t")
            .option("encoding", StandardCharsets.UTF_8.name())
            .schema(DataTypes.createStructType(Arrays.asList(
                    DataTypes.createStructField("phone_number", DataTypes.LongType, true),
                    DataTypes.createStructField("ip", DataTypes.StringType, true),
                    DataTypes.createStructField("host", DataTypes.StringType, true),
                    DataTypes.createStructField("up", DataTypes.LongType, false),
                    DataTypes.createStructField("down", DataTypes.LongType, false),
                    DataTypes.createStructField("code", DataTypes.IntegerType, false)
            )))
            .load("src/main/resources/traffic.txt");

通过DSL语法操作

    @Test
    public void dslStyleQuery() {
        df.select("ip", "code")
                .filter(df.col("phone_number").lt(14589530085L))
                .limit(10)
                .show();
    }

输出为

+--------------+----+
|            ip|code|
+--------------+----+
| 110.11.174.29| 200|
| 21.234.130.14| 200|
| 90.242.200.96| 404|
|  68.99.109.14| 200|
|148.227.226.79| 404|
|153.178.25.132| 200|
| 191.49.192.31| 500|
| 10.60.145.193| 500|
|  52.122.13.63| 500|
| 203.82.225.65| 500|
+--------------+----+

通过SQL操作

    @Test
    public void sqlStyleQuery() throws AnalysisException {
//        // 创建全局临时试图, 可以跨session共享
//        df.createGlobalTempView()
//        // 同createTempView, 但是视图存在则替换;
//        df.createOrReplaceGlobalTempView();
        df.createTempView("traffic");
        spark.sql("SELECT code, count(*) FROM traffic group by code").show();
    }

输出为

+----+--------+
|code|count(1)|
+----+--------+
| 500|      38|
| 404|      25|
| 200|      37|
+----+--------+

SparkSQL实现WordCount

通过rdd分词

    @Test
    public void wordCount_buildFromRDD() throws AnalysisException {
        @Cleanup JavaSparkContext context = JavaSparkContext.fromSparkContext(spark.sparkContext());
        JavaRDD<Row> rdd = context.textFile("hdfs://server.passnight.local/test/word list.txt", 10)
                .flatMap(line -> Arrays.stream(line.split(" ")).iterator())
                .map(RowFactory::create);

        Dataset<Row> df = spark.createDataFrame(rdd, DataTypes.createStructType(List.of(
                DataTypes.createStructField("word", DataTypes.StringType, false)
        )));
        df.createTempView("words");
        spark.sql("SELECT word, count(*) AS cnt FROM words GROUP BY word ORDER BY cnt DESC")
                .show();
    }

输出为

+---------+---+
|     word|cnt|
+---------+---+
|        I|  4|
|     love|  2|
|passnight|  2|
|     like|  2|
|   hadoop|  2|
+---------+---+

通过functions分词

    @Test
    public void wordCount_buildFromSparkSql() throws AnalysisException {
        Dataset<Row> words = spark.read()
                .text("hdfs://server.passnight.local/test/word list.txt");

        words.printSchema();
        Dataset<Row> df2 = words.withColumn("value", functions.explode(functions.split(words.col("value"), " ")));
        df2.createTempView("words");
        df2.groupBy("value")
                .count()
                .orderBy("count")
                .show();
    }

输出为

+---------+-----+
|    value|count|
+---------+-----+
|     love|    2|
|passnight|    2|
|     like|    2|
|   hadoop|    2|
|        I|    4|
+---------+-----+

写api

@Test
    public void writeText() {
        // text只能写出一列数据, 因此要将df转化为一列
        df.select(functions.concat_ws("---",
                        functions.col("ip"),
                        functions.col("up"),
                        functions.col("down")))
                .write()
                .mode("overwrite")
                .format("text")
                .save("data.txt");
    }

    @Test
    public void writeCsv() {
        df.select(functions.col("ip"),
                        functions.col("up"),
                        functions.col("down"))
                .write()
                .mode("overwrite")
                .option("sep", ",")
                .option("header", true)
                .format("csv")
                .save("data.csv");
    }

    @Test
    public void writeJson() {
        df.select(functions.col("ip"),
                        functions.col("up"),
                        functions.col("down"))
                .write()
                .mode("overwrite")
                .format("json")
                .save("data.json");
    }

    @Test
    public void writeParquet() {
        df.select(functions.col("ip"),
                        functions.col("up"),
                        functions.col("down"))
                .write()
                .mode("overwrite")
                .format("parquet")
                .save("data.parquet");
    }

UDF

在SparkSQL分析处理数据时, 往往需要使用到函数; 而SparkSQL自带的函数可能无法覆盖全部的需求, 因此SparkSQL可以通过自定义UDF来实现自定义函数
在Hive中, UDF分为以下三类
1. UDF(User Defined Function)函数:
  1. 1对1关系, 输入一个值, 经过函数输出后输出一个值
  2. 在Hive中集成UDF类, 方法名称为evaluate, 返回值不能为void; 本质上是一个方法
2. UDAF(User Defined Aggregation Function)聚合函数
  1. 多对1关系, 输入多个值输出一个值, 通常与groupBy一起使用
3. UDTF(User Defined Table-Generating Function)函数
  1. 1对多的关系, 输入一个值, 输出多个值 类似flatMap

基本UDF

UDF的使用有以下三种方式
1. 调用spark.udf().register()后, 通过funcions.callUDF调用
2. 通过funcitons.udf的返回值调用
3. 调用spark.udf().register()后, 直接在SQL中调用

    @Test
    public void basicUdf() throws AnalysisException {
        Dataset<Row> df = spark.createDataFrame(IntStream.range(0, 10)
                        .boxed()
                        .map(RowFactory::create)
                        .collect(Collectors.toList()),
                DataTypes.createStructType(List.of(DataTypes.createStructField("value", DataTypes.IntegerType, false))));

        // 注册一个udf, 名称为`timeTen`
        // `timeTen`名称可以可以用于SQL风格调用
        // dsl风格通过`functions.callUDF()`调用
        // 也可以通过functions.udf注册, 这样可以直接通过返回的方法调用
        spark.udf().register("timeTen", (UDF1<Integer, Integer>) x -> 10 * x, DataTypes.IntegerType);

        // dsl风格, 使用`functions.callUDF()`调用
        UserDefinedFunction timeTen = functions.udf((UDF1<Integer, Integer>) x -> x * 10, DataTypes.IntegerType);
        df.withColumn("value", functions.callUDF("timeTen", functions.col("value")))
                .show();
        // dsl风格, 使用`functions.udf()`返回值
        df.withColumn("value", timeTen.apply(functions.col("value")))
                .show();
        // SQL风格, 直接在SQL中调用
        df.createTempView("values");
        spark.sql("select timeTen(value) from values").show();
    }

输出为

+-----+
|value|
+-----+
|    0|
|   10|
|   20|
|   30|
|   40|
|   50|
|   60|
|   70|
|   80|
|   90|
+-----+

+-----+
|value|
+-----+
|    0|
|   10|
|   20|
|   30|
|   40|
|   50|
|   60|
|   70|
|   80|
|   90|
+-----+

+--------------+
|timeTen(value)|
+--------------+
|             0|
|            10|
|            20|
|            30|
|            40|
|            50|
|            60|
|            70|
|            80|
|            90|
+--------------+

返回数组的UDF

    @Test
    public void arrayUdf() {
        Dataset<Row> df = spark.createDataFrame(IntStream.range(0, 10)
                        .boxed()
                        .map(RowFactory::create)
                        .collect(Collectors.toList()),
                DataTypes.createStructType(List.of(DataTypes.createStructField("value", DataTypes.IntegerType, false))));

        UserDefinedFunction toArray = functions.udf((UDF1<Integer, List<Integer>>) x -> Arrays.asList(x, x, x, x, x), DataTypes.createArrayType(DataTypes.IntegerType));

        df.withColumn("value", toArray.apply(functions.col("value"))).show();
    }

输出为

+---------------+
|          value|
+---------------+
|[0, 0, 0, 0, 0]|
|[1, 1, 1, 1, 1]|
|[2, 2, 2, 2, 2]|
|[3, 3, 3, 3, 3]|
|[4, 4, 4, 4, 4]|
|[5, 5, 5, 5, 5]|
|[6, 6, 6, 6, 6]|
|[7, 7, 7, 7, 7]|
|[8, 8, 8, 8, 8]|
|[9, 9, 9, 9, 9]|
+---------------+

返回Map类型的UDF

    @Test
    public void mapUdf() {
        Dataset<Row> df = spark.createDataFrame(IntStream.range(0, 10)
                        .boxed()
                        .map(RowFactory::create)
                        .collect(Collectors.toList()),
                DataTypes.createStructType(List.of(DataTypes.createStructField("value", DataTypes.IntegerType, false))));

        UserDefinedFunction toArray = functions.udf((UDF1<Integer, Map<Integer, String>>) x -> Map.of(x, String.valueOf(x)), DataTypes.createMapType(DataTypes.IntegerType, DataTypes.StringType));

        df.withColumn("value", toArray.apply(functions.col("value"))).show();
    }

输出为

+--------+
|   value|
+--------+
|{0 -> 0}|
|{1 -> 1}|
|{2 -> 2}|
|{3 -> 3}|
|{4 -> 4}|
|{5 -> 5}|
|{6 -> 6}|
|{7 -> 7}|
|{8 -> 8}|
|{9 -> 9}|
+--------+

窗口函数

窗口函数: 窗口函数既显示聚合前的数据又显示聚合后的数据 即显示每一行都显示聚合结果

public class WindowTest {
    private final static SparkSession spark = SparkSession.builder()
            .appName("test")
            .master("local[*]")
            .getOrCreate();
    private final static Dataset<Row> df = spark.read()
            .format("csv")
            .option("header", false)
            .option("sep", "\t")
            .option("encoding", StandardCharsets.UTF_8.name())
            .schema(DataTypes.createStructType(Arrays.asList(
                    DataTypes.createStructField("phone_number", DataTypes.LongType, true),
                    DataTypes.createStructField("ip", DataTypes.StringType, true),
                    DataTypes.createStructField("host", DataTypes.StringType, true),
                    DataTypes.createStructField("up", DataTypes.LongType, false),
                    DataTypes.createStructField("down", DataTypes.LongType, false),
                    DataTypes.createStructField("code", DataTypes.IntegerType, false)
            ))).load("src/main/resources/traffic.txt");

    @BeforeClass
    public static void setUpClass() throws AnalysisException {
        df.createTempView("traffic");
    }

    @Test
    public void aggregationWindow() {
        spark.sql("SELECT *, AVG(down) OVER() AS avg_down FROM traffic").show();
    }

    @Test
    public void orderWindow() {
        spark.sql("SELECT *, RANK() OVER(ORDER BY down DESC) AS rank_down," +
                "DENSE_RANK() OVER(PARTITION BY code ORDER BY down DESC) AS dense_rank_down," +
                "ROW_NUMBER() OVER(ORDER BY down) AS row_number_down FROM traffic").show();
    }
}

输出结果为

+------------+---------------+--------------------+----+----+----+--------+
|phone_number|             ip|                host|  up|down|code|avg_down|
+------------+---------------+--------------------+----+----+----+--------+
| 14591430480| 206.175.250.82|        web-49.28.cn|6652|4853| 200| 4597.34|
| 14576404331|  110.11.174.29|       lt-91.duxu.cn|3691|9180| 200| 4597.34|
| 14582487728|  21.234.130.14|    desktop-19.13.cn|2797|1428| 200| 4597.34|
| 14596521336| 149.125.91.187|    db-46.guiying.cn|4742|3870| 500| 4597.34|
| 15964887988|201.254.165.183|desktop-12.guiyin...|8266|8951| 500| 4597.34|
| 14582499209|  90.242.200.96|         db-36.05.cn|3686|1143| 404| 4597.34|
| 14505200322|   68.99.109.14|       web-94.40.org|6978|4684| 200| 4597.34|
| 15057102608|  73.31.103.153|desktop-77.zhongw...|1180| 785| 404| 4597.34|
| 15961211597| 159.244.71.102|       web-89.dh.net|8526|4965| 500| 4597.34|
| 15311413947|   60.85.30.231|  db-34.shenhuang.cn|1942|9698| 500| 4597.34|
| 13755692548| 148.227.226.79|   srv-89.fanggao.cn|3049|2243| 404| 4597.34|
| 15512665231| 172.147.244.20| lt-73.taoguiying.cn|9494| 151| 200| 4597.34|
| 13671972925| 153.178.25.132|        srv-73.31.cn|3311|1452| 200| 4597.34|
| 18142899590|  31.150.73.196|        web-49.nl.cn|2909| 277| 500| 4597.34|
| 15013760479|   94.26.117.22|      email-47.63.cn|5645|4756| 200| 4597.34|
| 15696235979|   80.73.193.75|        lt-91.lei.cn|9845|1267| 404| 4597.34|
| 15678423363| 171.44.202.193|         db-37.99.cn|7496|7354| 200| 4597.34|
| 13313631905|  191.49.192.31|     laptop-78.nd.cn|3037|3070| 500| 4597.34|
| 15911783755|   208.18.32.83|       db-48.yao.net|4846|4935| 404| 4597.34|
| 14589530086| 57.193.203.100|   srv-25.mingcao.cn|1861|3034| 200| 4597.34|
+------------+---------------+--------------------+----+----+----+--------+


+------------+---------------+--------------------+----+----+----+---------+---------------+---------------+
|phone_number|             ip|                host|  up|down|code|rank_down|dense_rank_down|row_number_down|
+------------+---------------+--------------------+----+----+----+---------+---------------+---------------+
| 14576404331|  110.11.174.29|       lt-91.duxu.cn|3691|9180| 200|        5|              1|             96|
| 15848614274|221.193.203.253|  web-81.duanxiao.cn|8474|8973| 200|        6|              2|             95|
| 15133313425|   3.41.203.203|    laptop-65.fan.cn|1979|8496| 200|       12|              3|             89|
| 14722781518|  41.33.230.230|laptop-66.zhangze...|3840|8161| 200|       15|              4|             86|
| 13985614323| 105.154.67.146|    laptop-67.jie.cn|5629|7876| 200|       18|              5|             83|
| 15025055835|   57.67.224.58|   web-46.weiliao.cn|1093|7830| 200|       19|              6|             82|
| 15708423956|   52.173.24.63|  web-36.yangchao.cn| 201|7774| 200|       20|              7|             81|
| 15550368967|  181.80.90.147|  laptop-44.yanli.cn|4669|7770| 200|       21|              8|             80|
| 15281538689| 173.204.178.87|    web-83.weimin.cn|7082|7718| 200|       23|              9|             78|
| 13618975336|   178.12.49.98|      srv-13.min.net|9290|7560| 200|       24|             10|             77|
| 14765852831|  121.98.240.15|   laptop-81.fang.cn|3595|7556| 200|       25|             11|             76|
| 15678423363| 171.44.202.193|         db-37.99.cn|7496|7354| 200|       27|             12|             74|
| 13434369051|   220.82.35.57| srv-03.longqian.org|2160|6650| 200|       30|             13|             71|
| 14554599007|    52.35.92.91| web-91.xiulanlai.cn|6098|5124| 200|       38|             14|             63|
| 14591430480| 206.175.250.82|        web-49.28.cn|6652|4853| 200|       42|             15|             59|
| 15013760479|   94.26.117.22|      email-47.63.cn|5645|4756| 200|       43|             16|             58|
| 14505200322|   68.99.109.14|       web-94.40.org|6978|4684| 200|       46|             17|             55|
| 13913021809| 190.111.163.19|        srv-83.jn.cn|8296|4349| 200|       48|             18|             53|
| 15108282222|   56.175.78.40|   laptop-17.mao.net|8846|3830| 200|       55|             19|             46|
| 18788825153|   61.76.43.152|        lt-48.81.net|8101|3812| 200|       56|             20|             45|
+------------+---------------+--------------------+----+----+----+---------+---------------+---------------+

SparkSQL执行流程

RDD的执行流程RDD->DAGScheduler->TaskSceduler->Worker
与RDD不同的是, SparkSQL会对写完的代码执行自动优化; 以提高代码执行效率
SparkSQL可以自动优化而RD不行的原因
1. RDD仅包含数据而不包含格式; DataFrame是有结构的二维表结构
2. SparkSQL的优化器为Catalyst优化器

Catalyst执行流程:

API

Catalyst

RDD

Cluster

2. API层接受SQL语句, Catalyst解析SQL并生对应的RDD执行计划, 并由集群执行

Catalyst优化器

具体流程

元数据

API

未解析的逻辑计划

逻辑计划

优化的逻辑计划

物理执行计划

RDD

解析SQL, 生成AST:
在AST中加入元数据信息, 便于后续优化 如score.id -> id#1#L; 表score.id的id为1, 类型为Long
进行优化, 主要的友发方式有谓词下推即列值裁剪
1. 谓词下推: 尽量下推谓词操作, 这样可以减少操作时候的数据量
2. 列值裁剪: 在断言下推后执行裁剪, 裁剪掉不需要的列, 进而减少需要处理的数据量
生成执行计划: 根据上述过程生成的优化后的AST, 生成物理计划, 从而生成RDD来执行

引用

Downloads | Apache Spark ↩︎

你可能感兴趣的:(学习笔记,java,spark,大数据,sql)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
MYSQL面试系列-04 king01299 面试 mysql 面试
MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
ES聚合分析原理与代码实例讲解光剑书架上的书大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解秋刀prince mysql mysql 数据库
提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
html 周华华 html
js 1，数组的排列 var arr=[1,4,234,43,52,]; for(var x=0;x<arr.length;x++){ for(var y=x-1;y<arr.length;y++){ if(arr[x]<arr[y]){ &
【Struts2 四】Struts2拦截器 bit1129 struts2拦截器
Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 Struts2中自定义拦截器的步骤是：
make:cc 命令未找到解决方法 daizj linux 命令未知 make cc
安装rz sz程序时，报下面错误： [root@slave2 src]# make posix cc -O -DPOSIX -DMD=2 rz.c -o rz make: cc：命令未找到 make: *** [posix] 错误 127 系统：centos 6.6 环境：虚拟机错误原因：系统未安装gcc，这个是由于在安
Oracle之Job应用周凡杨 oracle job
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。一：查看相关job信息 1、相关视图 dba_jobs all_jobs user_jobs dba_jobs_running 包含正在运行
多线程机制朱辉辉33 多线程
转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 程序、进程和线程：程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
web报表工具FineReport使用中遇到的常见报错及解决办法（一）老A不折腾 web报表 finereport java报表报表工具
FineReport使用中遇到的常见报错及解决办法（一）这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、address pool is full：含义：地址池满，连接数超过并发数上
mysql rpm安装后没有my.cnf 林鹤霄没有my.cnf
Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的，至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法，第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动，第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题 aigo root
原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ Step 4: Run ADB command from your PC On the PC, you need install Amazon Fire ADB driver and instal
javascript 中var提升的典型实例 alxw4616 JavaScript
// 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧 myname = 'global'; var fn = function () { console.log(myname); // undefined var myname = 'local'; console.log(myname); // local }; fn() // 上述代码实际上等同于以下代码 m
定时器和获取时间的使用百合不是茶时间的转换定时器
定时器:定时创建任务在游戏设计的时候用的比较多 Timer();定时器 TImerTask();Timer的子类由 Timer 安排为一次执行或重复执行的任务。定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
JDK1.5 Queue bijian1013 java thread java多线程 Queue
JDK1.5 Queue LinkedList： LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
http认证原理和https bijian1013 http https
一.基础介绍在URL前加https://前缀表明是用SSL加密的。你的电脑与服务器之间收发的信息传输将更加安全。 Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
【Java范型五】范型继承 bit1129 java
定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 package com.tom.lang.generics; public abstract class SuperGenerics<T1, T2> { private T1 t1; private T2 t2; public abstract void doIt(T
【Nginx六】nginx.conf常用指令(Directive) bit1129 Directive
1. worker_processes 8; 表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process
lua 遍历Header头部 ronin47 lua header 遍历　
local headers = ngx.req.get_headers() ngx.say("headers begin", "<br/>") ngx.say("Host : ", he
java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。 bylijinnan java
import java.util.Arrays; public class MinSumASumB { /** * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序. * * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 * 例如: * int[] a = {100,99,98,1,2,3
redis 开窍的石头 redis
在redis的redis.conf配置文件中找到# requirepass foobared 把它替换成requirepass 12356789 后边的12356789就是你的密码打开redis客户端输入config get requirepass 返回 redis 127.0.0.1:6379> config get requirepass 1) "require
[JAVA图像与图形]现有的GPU架构支持JAVA语言吗？ comsci java语言
无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情
安装ubuntu14.04登录后花屏了怎么办 cuiyadll ubuntu
这个情况，一般属于显卡驱动问题。可以先尝试安装显卡的官方闭源驱动。按键盘三个键：CTRL + ALT + F1 进入终端，输入用户名和密码登录终端：安装amd的显卡驱动 sudo apt-get install fglrx 安装nvidia显卡驱动 sudo ap
SSL 与数字证书的基本概念和工作原理 darrenzhu 加密 ssl 证书密钥签名
SSL 与数字证书的基本概念和工作原理 http://www.linuxde.net/2012/03/8301.html SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 http://www.ibm.com/developerworks/cn/webspher
Ubuntu设置ip的步骤 dcj3sjt126com ubuntu
在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。转载不是错： Ubuntu命令行修改网络配置方法 /etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 1. 以D
php包管理工具推荐 dcj3sjt126com PHP Composer
http://www.phpcomposer.com/ Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。中文文档入门指南下载安装包列表 Composer 中国镜像
Gson使用四（TypeAdapter） eksliang json gson Gson自定义转换器 gsonTypeAdapter
转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 Gson的TypeAapter可以理解成自定义序列化和返序列化二、应用场景举例例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
JQM控件之Navbar和Tabs gundumw100 html xml css
在JQM中使用导航栏Navbar是简单的。只需要将data-role="navbar"赋给div即可： <div data-role="navbar"> <ul> <li><a href="#" class="ui-btn-active&qu
利用归并排序算法对大文件进行排序 iwindyforest java 归并排序大文件分治法 Merge sort
归并排序算法介绍，请参照Wikipeida zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 基本思想：大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数低于限制行数的子文件直接排序两个排序好的子文件归并到父文件直到最后所有排序好的父文件归并到输入
iOS UIWebView URL拦截啸笑天 UIWebView
本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
索引的碎片整理SQL语句 macroli sql
SET NOCOUNT ON DECLARE @tablename VARCHAR (128) DECLARE @execstr VARCHAR (255) DECLARE @objectid INT DECLARE @indexid INT DECLARE @frag DECIMAL DECLARE @maxfrag DECIMAL --设置最大允许的碎片数量,超过则对索引进行碎片
Angularjs同步操作http请求with $promise qiaolevip 每天进步一点点学习永无止境 AngularJS 纵观千象
// Define a factory app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) { var deferred = $q.defer(); AccountService.getProfile().then(function(res) {
hibernate联合查询问题 sxj19881213 sql Hibernate HQL 联合查询
最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 1 几个常识：（1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。（2）hql的默认查询策略，在进行联合查询时，会产
struts2.xml wuai struts
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache

【大数据】Spark学习笔记

初识Spark

Spark和Hadoop

Spark对比Hadoop特点

Spark优缺点

Hadoop优缺点

基本概念

Spark 组成

Spark运行模式

Spark架构

Standalone架构

基本使用

安装 Spark1

使用Spark实现WordCount

RDD

RDD基本概念

RDD创建

Transformation算子

map算子

flatMap算子

reduceByKey算子

mapToValues算子

groupBy算子

ffilter算子

distinct算子

union算子

join算子

intersection算子

glom算子

groupByKey算子

sortBy算子

sortByKey算子

Action算子

countByKey算子

collect算子

reduce算子:

flod算子

first算子

top算子

count算子

takeSample算子

takeOrderd算子

forEach算子

saveAsTextFile算子

分区操作算子

mapPartitions算子

foreachPartitions算子

partitionBy算子

repartition算子

colalesce算子

RDD持久化

缓存

CheckPoint

共享变量

广播变量

广播变量的使用

累加器

Spark Scheduler

内存迭代计算

Spark并行度

Spark任务调度

Spark SQL

基本使用

读取csv

DataFrame

通过StructType构建DataSet

从不同数据源读取数据(以CSV为例)

DataFrame操作

通过DSL语法操作

通过SQL操作

SparkSQL实现WordCount

通过rdd分词

通过functions分词

写api

UDF

基本UDF

返回数组的UDF

返回Map类型的UDF

窗口函数

SparkSQL执行流程

初识`Spark`

`Spark`和`Hadoop`

`Spark`对比`Hadoop`特点

`Spark`优缺点

`Hadoop`优缺点

安装 `Spark`¹

使用`Spark`实现`WordCount`

`map`算子

`flatMap`算子

`reduceByKey`算子

`mapToValues`算子

`groupBy`算子

`ffilter`算子

`distinct`算子

`union`算子

`join`算子

`intersection`算子

`glom`算子

`groupByKey`算子

`sortBy`算子

`sortByKey`算子

`countByKey`算子

`collect`算子

`reduce`算子:

`flod`算子

`first`算子

`top`算子

`count`算子

`takeSample`算子

`takeOrderd`算子

`forEach`算子

`saveAsTextFile`算子

`mapPartitions`算子

`foreachPartitions`算子

`partitionBy`算子

`repartition`算子

`colalesce`算子