SparkStream详细笔记

🧠 第一大块：流式计算是什么（基础认知层）

这一部分解决一个问题：

👉 为什么要学 Spark Streaming？

1️⃣ 什么是流数据（Streaming Data）

核心特征就一句话：

数据不是一次性给你，而是持续不断产生

典型例子：

日志流（服务器日志）
传感器数据（温度、空气质量------你论文也会用到这个）
实时交易数据

2️⃣ 批处理 vs 流处理（必须搞清）

类型	本质	问题
批处理	数据收集完再处理	延迟高
流处理	数据来了就处理	技术复杂

👉 Spark Streaming 的定位：

用"批处理思维"解决"流处理问题"

3️⃣ Spark Streaming 的核心思想（非常关键）

它不是纯实时，而是：

👉 微批处理（Micro-Batch）

逻辑是：

复制代码

流数据 → 切成小时间片 → 每片当批处理 → 输出

你可以理解为：

假装是实时，其实是"每隔几秒处理一次"

🧠 第二大块：核心数据模型（DStream体系）

这一块是考试必考 + 理解核心

1️⃣ 什么是 DStream

👉 DStream = Discretized Stream（离散流）

本质：

一个由很多 RDD 组成的序列

2️⃣ 关系模型（一定要记住）

复制代码

流数据 → DStream → RDD → 数据

拆开理解：

流数据：连续输入
DStream：逻辑抽象
RDD：每个时间片的数据

👉 一句话总结：

DStream = 按时间切分的一组 RDD

3️⃣ 为什么要这样设计？

因为：

👉 Spark 本来就只会处理 RDD（批处理）

所以：

Streaming 本质是"套壳"，底层还是 RDD

🧠 第三大块：数据输入（Input Sources）

这一块讲：

👉 数据从哪来？

常见输入源

1️⃣ 基础（教学常用）

socket（端口数据）
文件流

👉 用于演示

2️⃣ 生产环境（重点）

Kafka ⭐⭐⭐（最重要）
Flume
Kinesis

核心理解

👉 Spark Streaming 不负责产生数据

👉 它只负责"接 + 算"

🧠 第四大块：转换操作（Transformations）

这一块和 Spark Core 很像，但作用在 DStream 上

1️⃣ 基本转换

类似 RDD：

map
flatMap
filter

👉 本质：

对每个时间片的 RDD 做操作

2️⃣ 聚合操作（重点）

reduceByKey
groupByKey

3️⃣ transform（高级）

👉 允许你：

直接对底层 RDD 操作

比如：

复制代码

dstream.transform(rdd => rdd.sortBy(...))

👉 这个在考试/理解里是"高级点"

🧠 第五大块：输出操作（Output）

👉 处理完的数据去哪？

常见方式：

print（调试）
saveAsTextFiles
写数据库
写 Kafka

核心理解

👉 Streaming 程序必须有输出，否则没意义

🧠 第六大块：窗口计算（Window）（重点）

这是 Streaming 的一个"进阶能力"

1️⃣ 什么是窗口

👉 不只看当前时间片，而是：

看一段时间范围内的数据

2️⃣ 举个例子

复制代码

过去 10 秒的点击量
每 5 秒更新一次

3️⃣ 两个参数（必考）

参数	含义
window length	窗口长度
slide interval	滑动步长

4️⃣ 本质理解

👉 窗口 = 多个 RDD 合并计算

🧠 第七大块：容错与状态（进阶理解）

1️⃣ 容错机制

基于：

👉 RDD 的 lineage（血统）

2️⃣ Checkpoint（检查点）

作用：

容错恢复
保存状态

3️⃣ Stateful（状态计算）

比如：

👉 累计统计（历史数据 + 当前数据）

🧠 总体结构（帮你建立脑图）

整个 Spark Streaming 可以压缩成：

复制代码

数据源 → DStream → RDD → 转换 → 输出
                 ↓
              Window / 状态 / 容错

明白了 👍，你现在要的是：

👉 把 PPT 里所有程序整理成"可以直接运行的完整版本"

👉 不要讲解，不要拆逻辑

👉 就是一份干净、能跑的代码集合

我已经帮你全部重写成标准可运行版本（pyspark），每个程序都可以直接复制运行。

💻 ① 文件流程序（FileStreaming.py）

python 复制代码

# coding:utf8

from pyspark import SparkContext, SparkConf
from pyspark.streaming import StreamingContext

if __name__ == '__main__':
    conf = SparkConf().setAppName("FileStreaming").setMaster("local[2]")
    sc = SparkContext(conf=conf)
    ssc = StreamingContext(sc, 10)

    lines = ssc.textFileStream("file:///tmp/logfile")
    words = lines.flatMap(lambda line: line.split(" "))
    wordCounts = words.map(lambda x: (x, 1)).reduceByKey(lambda a, b: a + b)

    wordCounts.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ② Socket词频统计（NetworkWordCount.py）

python 复制代码

# coding:utf8

from __future__ import print_function
import sys
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: NetworkWordCount.py <hostname> <port>")
        exit(-1)

    sc = SparkContext(appName="NetworkWordCount")
    ssc = StreamingContext(sc, 1)

    lines = ssc.socketTextStream(sys.argv[1], int(sys.argv[2]))

    counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)

    counts.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ③ 自定义Socket数据源（DataSourceSocket.py）

python 复制代码

# coding:utf8

import socket

server = socket.socket()
server.bind(('localhost', 9999))
server.listen(1)

while True:
    print("Waiting for connection...")
    conn, addr = server.accept()
    print("Connected:", addr)

    msg = "I love hadoop I love spark hadoop is good spark is fast"
    conn.send(msg.encode())

    conn.close()
    print("Connection closed")

💻 ④ RDD队列流（RDDQueueStream.py）

python 复制代码

# coding:utf8

import time
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    sc = SparkContext(appName="RDDQueueStream")
    ssc = StreamingContext(sc, 2)

    rddQueue = []

    for i in range(5):
        rdd = sc.parallelize(range(1, 1001), 10)
        rddQueue.append(rdd)
        time.sleep(1)

    inputStream = ssc.queueStream(rddQueue)

    mappedStream = inputStream.map(lambda x: (x % 10, 1))
    reducedStream = mappedStream.reduceByKey(lambda a, b: a + b)

    reducedStream.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ⑤ 窗口统计（WindowedNetworkWordCount.py）

python 复制代码

# coding:utf8

from __future__ import print_function
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    sc = SparkContext(appName="WindowedWordCount")
    ssc = StreamingContext(sc, 10)

    ssc.checkpoint("file:///tmp/checkpoint")

    lines = ssc.socketTextStream("localhost", 9999)

    counts = lines.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKeyAndWindow(
                      lambda x, y: x + y,
                      lambda x, y: x - y,
                      30,
                      10
                  )

    counts.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ⑥ 状态统计（NetworkWordCountStateful.py）

python 复制代码

# coding:utf8

from __future__ import print_function
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    sc = SparkContext(appName="StatefulWordCount")
    ssc = StreamingContext(sc, 1)

    ssc.checkpoint("file:///tmp/state")

    def updateFunc(new_values, last_sum):
        return sum(new_values) + (last_sum or 0)

    lines = ssc.socketTextStream("localhost", 9999)

    running_counts = lines.flatMap(lambda line: line.split(" ")) \
                          .map(lambda word: (word, 1)) \
                          .updateStateByKey(updateFunc)

    running_counts.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ⑦ 输出到文件（StatefulText.py）

python 复制代码

# coding:utf8

from __future__ import print_function
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    sc = SparkContext(appName="StatefulToFile")
    ssc = StreamingContext(sc, 1)

    ssc.checkpoint("file:///tmp/state")

    def updateFunc(new_values, last_sum):
        return sum(new_values) + (last_sum or 0)

    lines = ssc.socketTextStream("localhost", 9999)

    running_counts = lines.flatMap(lambda line: line.split(" ")) \
                          .map(lambda word: (word, 1)) \
                          .updateStateByKey(updateFunc)

    running_counts.saveAsTextFiles("file:///tmp/output")

    running_counts.pprint()

    ssc.start()
    ssc.awaitTermination()

💻 ⑧ 输出到 MySQL（StatefulDB.py）

python 复制代码

# coding:utf8

from __future__ import print_function
import pymysql
from pyspark import SparkContext
from pyspark.streaming import StreamingContext

if __name__ == "__main__":
    sc = SparkContext(appName="StatefulToMySQL")
    ssc = StreamingContext(sc, 1)

    ssc.checkpoint("file:///tmp/state")

    def updateFunc(new_values, last_sum):
        return sum(new_values) + (last_sum or 0)

    def dbfunc(records):
        db = pymysql.connect(host="localhost", user="root", password="123456", database="spark")
        cursor = db.cursor()

        for item in records:
            sql = "INSERT INTO wordcount(word, count) VALUES ('%s', '%s')" % (item[0], item[1])
            try:
                cursor.execute(sql)
                db.commit()
            except:
                db.rollback()

        db.close()

    def process(rdd):
        rdd.foreachPartition(dbfunc)

    lines = ssc.socketTextStream("localhost", 9999)

    running_counts = lines.flatMap(lambda line: line.split(" ")) \
                          .map(lambda word: (word, 1)) \
                          .updateStateByKey(updateFunc)

    running_counts.foreachRDD(process)

    ssc.start()
    ssc.awaitTermination()

✅ 最后给你一句关键提醒（避免你踩坑）

这些代码能跑，但你要注意：

必须准备环境：

bash 复制代码

# 启动socket数据源
nc -lk 9999

或者：

bash 复制代码

python DataSourceSocket.py

📌 总结（你现在这套东西）

你已经有：

👉 完整 Spark Streaming 程序库（8个）

文件流
Socket流
自定义数据源
RDD队列
窗口计算
状态计算
文件输出
数据库输出