Stuuctured Streaming基础--学习笔记

Structured streaming介绍

spark进行实时数据流计算时有两个工具：

• Spark Streaming：编写rdd代码处理数据流,可以解决非结构化的流式数据
• Structured Streaming：编写df代码处理数据流,可以解决结构化和半结构化的流式数据

1，数据相关介绍

有界数据和无界数据

①有界数据：

• 有起始位置，有结束位置。比如文件数据 有起始行，有结束行
• 有明确的数据容量大小。处理数据时就能知道处理的数据大小
• 在处理数据时，按批次处理。数据处理完成程序就结束
• 离线计算时处理的都是有界数据

②无界数据

• 有起始位置，没有结束位置，知道数据的起始位置在哪里，但是数据到哪结束不知道（因为数据在不断产生，什么时候结束不知道）
• 流式数据都是无界数据
• 无界数据的总量是不确定的
• 数据是不断产生的
• 数据有时效性 （有效期）
• 处理无界数据时，程序是持续运行的
• 实时计算时处理的都是无界数据
• 近期实时计算处理的微批数据

离线计算：

• 离线计算就是在计算开始前已知所有输入数据，输入数据不会产生变化，且在解决一个问题后就要立即得出结果的前提下进行的计算。
• 数据处理时间大于1个小时，一般离线计算的处理时间都是t+1天
• mapreduce框架/spark框架

近实时计算：

• 近实时计算就是在计算开始前将多条数据（流数据）放在一起处理，同时处理的是几条数据
• 数据处理时间在5分钟到1小时范围内
• spark框架

实时计算：

• 实时计算就是一条一条的处理数据，处理的时间延迟很低
• 数据处理时间小于5分钟
• flink框架

2，Structured streaming基本使用

没有ncat服务的话，在线安装或离线导入

命令:yum install nc

执行前需要先启动ncat服务

命令：ncat -lk 8888

from pyspark.sql import SparkSession

ss = SparkSession.builder.getOrCreate()

#读取socket工具中的流数据


options = {
    #指定ip地址
    'host':'192.168.88.100',
    #指定socket的端口号
    'port':'8888'
}

df1 = ss.readStream.load(format='socket',**options)
#查看里面的数据不能通过show()方法查看
df1.printSchema()
#展示数据
#start：启动流计算
#awaitTermiantion():使应用程序一直运行
df1.writeStream.start(format='console',outputMode='append').awaitTermination()

3，Structured Streaming编程模型

1、Input Table 输入数据表 无界表

2、Query 对数据进行查询计算

3、Result Table 保存计算结果

4、Output 输出结果

变成模型遵循ETL处理流程：
①E->读取流数据，转换成无界表
②T->使用sparkSql处理流数据，流计算，查询计算
③L->存储E的结果

from pyspark.sql import SparkSession,functions as F

ss = SparkSession.builder.getOrCreate()

options = {
    # 指定ip地址
    'host': '192.168.88.100',
    # 指定socket的端口号
    'port': '8888'
}

df1 = ss.readStream.load(format='socket',**options)
df_split = df1.select(F.split('value',',')[0].astype('int').alias('id'),
                      F.split('value', ',')[1].alias('name'),
                      F.split('value', ',')[2].astype('int').alias('age'),
                      F.split('value', ',')[3].alias('gender'))


df_split.printSchema()

df2 = df_split.select('name','age')
#终端展示结果
# df2.writeStream.start(format='console',outputMode='append').awaitTermination()
df_split.writeStream.start(format='console',outputMode='append').awaitTermination()

4，数据处理流程

读取数据

Structured streaming支持读取的数据源包括文件数据，kafka数据，socket数据和rate数据

• 文件数据
  • 从文件中读取数据 csv文件 json文件 txt文件等
• Kafka数据
  • 从kafka中读取数据，常用的读取数据方式
• Socket数据
  • 从网络端口读取数据
• Rate数据
  • 读取框架自己产生的数据，测试性能，优化参数

from pyspark.sql import SparkSession


ss = SparkSession.builder.master('local[*]').appName('stream_file').getOrCreate()
print('--------------------text格式文件----------------')

#注意点：路径只能是文件夹的绝对路径
df_text = ss.readStream.text(path='/a')
df_text.writeStream.start(format='console', outputMode='append').awaitTermination()


print('--------------------csv格式文件----------------')
#path：文件路径
#sep：分隔符，默认时逗号
# schema：表结构，列名，类型
# header:加载第一行列名信息
#inferSchema：自动解析表结构

# ss.readStream.csv()
df_csv = ss.readStream.load(path='/b', format='csv', schema='name string,age int,gender string,phone string,email string,city string,address string', sep=',')
df_csv.printSchema()

df_csv.writeStream.start(format='console', outputMode='append').awaitTermination()

5，数据处理

structured streaming的数据处理操作支持DSL方式和SQL方式

from pyspark.sql import SparkSession

ss = SparkSession.builder.master('local[*]').appName('local_demo').getOrCreate()

#读取文件流数据
df1 = ss.readStream.csv(path='/b',sep=',',schema='name string,age int,gender string,phone string,email string,city string,address string')

#进行数据处理，流计算
df2 = df1.groupby('gender').avg('age').toDF('gender','avg_age')
df2.printSchema()
df1.createTempView('stu')
df_sql = ss.sql("select gender,avg(age) from stu group by gender")
df_sql.printSchema()

df2.writeStream.start(format='console',outputMode='complete').awaitTermination()

6，数据输出

outputMode 指定输出模式

输出模式有三种：append、complete和update

①append模式

append模式，默认的模式，每次只能看到新增的行的内容，不支持聚合操作，一般在进行查询展示时使用

②complete模式

每次都是对所有数据进行处理，必须进行聚合操作

后续生成多条数据时，都是对所有数据进行聚合操作

③update模式

支持select和聚合操作 不支持聚合后的排序操作

在没有聚合时和append模式一样，只会显示新增的数据

在进行聚合计算时，以新增数据的分组类别为分组依据，获取所有数据中的当前分组类别数据，进行聚合

"""
通过outputMode参数设置输出模式
append:默认模式, 每次流计算只展示新增的行数据, 不支持聚合和排序操作的df, 只支持普通查询过滤操作的df
complete:支持聚合操作和聚合后排序操作的df
update:支持查询过滤操作,等同于append模式; 支持聚合操作
"""
"""
complete和update支持聚合操作区别:
complete: 对历史所有数据进行聚合操作
update: 对有更新的数据进行聚合操作进行展示
"""
from pyspark.sql import SparkSession

# 创建ss对象
ss = SparkSession.builder.getOrCreate()

# 读取流数据
df1 = ss.readStream.load(path='/b', format='csv', sep=',',
                         schema='name string,age int,gender string,phone string,email string,city string,address string')

# 查询操作  支持append update模式
# df_select = df1.select('id', 'name', 'age')
# 过滤操作  支持append update模式
# df_where = df1.where(df1['gender']=='女')
# 分组聚合操作 支持complete update模式
df_group = df1.groupBy('gender').avg('age').toDF('gender','avg_age')
# 分组聚合排序操作 支持complete模式
# df_group_order = df1.groupBy('gender').avg('age').toDF('gender', 'avg_age').orderBy('avg_age')
# 排序操作  流计算中不支持排序操作
# df_order = df1.sort('age', ascending=False)


# 展示数据
df_group.writeStream.start(format='console', outputMode='complete').awaitTermination()

7，指定数据位置

File Sink 把结果输出到文件中，仅支持追加 append模式

Kafka Sink 把结果输出到kafka的topic中，append complete update都支持

Foreach Sink/ForeachBatch Sink 可以接收函数/对象，其中可以定义复杂的计算逻辑，对数据进行处理。数据最终输出到哪里，自己决定，append complete update都支持

Foreach 允许在每一行上执行自定义写逻辑，而ForeachBatch 允许在每个微批的输出上执行任意操作和自定义逻辑。

Console Sink 直接在终端中显示，append complete update都支持

Memory Sink 把数据输出到内存中，以表的形式存在，可以使用SparkSQL进行查询，支持append complete模式

from pyspark.sql import SparkSession

ss =SparkSession.builder.getOrCreate()

df1 = ss.readStream.load(path='/b', format='csv', sep=',',
                         schema='name string,age int,gender string,phone string,email string,city string,address string')

#过滤查询操作
df2 = df1.where('gender=="男"').select('name','age','gender')
#分组聚合操作(不支持)
# df_group = df1.groupby('gender').avg('age').toDF('gender','avg_age')

#设置checkpointLocation参数
options = {
    'checkpointLocation':'/pydata_checkpoint'
}
df2.writeStream.start(path='/pydata_csv',outputMode='append',format='csv',sep=',',**options).awaitTermination()

8，指定输出位置

"""
foreach:方法中可以传入自定义函数，函数中的代码逻辑可以自定义(排序，聚合，保存到问价按中，……)
将流数据转换成批数据进行处理->自定义函数中是离线计算
自定义函数中接受的实参值是流数据df中的一行数据
"""

from pyspark.sql import SparkSession,functions as F
from pyspark.sql import DataFrame

ss =SparkSession.builder.getOrCreate()

# df1 = ss.readStream.load(path='/b', format='csv', sep=',',
#                          schema='name string,age int,gender string,phone string,email string,city string,address string')
df1= ss.readStream.load(path='/b',format='csv',sep=',',schema='id int ,name string,age int,gender string')
#过滤查询操作
df2 = df1.select('id','name','age','gender')
def func(df:DataFrame,batch_id):
    #x是df2中的一行一行数据
    #df就是流数据的df对象
    print('df的值为',df)
    df.show()
    #batch_id是流计算的批次编号
    print('batch_id的值',batch_id)
    df_group = df.groupby('gender').agg(F.avg('age').alias('avg_age'))
    df_group.write.csv(path='/test/data_csv',sep=',',mode='append')
    df.write.jdbc(url='jdbc:mysql://node1:3306/BI_db?characterEncoding=utf-8',
                  table='test3',
                  mode='append',
                  properties={'user':'root','password':'123456','driver':'com.mysql.jdbc.Driver'})


df2.writeStream.foreachBatch(func).start(outputMode='append').awaitTermination()