Spark中DStream 输出
输出操作指定了对流数据经转化操作得到的数据所要执行的操作(例如把结果推入外部数据库或输出到屏幕上)。与 RDD 中的惰性求值类似，如果一个 DStream 及其派生出的 DStream 都没有被执行输出操作，那么这些 DStream 就都不会被求值。如果StreamingContext 中没有设定输出操作，整个 context 就都不会启动。
输出操作如下：
➢ print()：在运行流程序的驱动结点上打印 DStream 中每一批次数据的最开始 10 个元素。这用于开发和调试。在 Python API 中，同样的操作叫 print()。
➢ saveAsTextFiles(prefix, [suffix])：以 text 文件形式存储这个 DStream 的内容。每一批次的存储文件名基于参数中的 prefix 和 suffix。”prefix-Time_IN_MS[.suffix]”。
➢ saveAsObjectFiles(prefix, [suffix])：以 Java 对象序列化的方式将 Stream 中的数据保存为SequenceFiles . 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]". Python中目前不可用。
➢ saveAsHadoopFiles(prefix, [suffix])：将 Stream 中的数据保存为 Hadoop files. 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]"。Python API 中目前不可用。
➢ foreachRDD(func)：这是最通用的输出操作，即将函数 func 用于产生于 stream 的每一个RDD。其中参数传入的函数 func 应该实现将每一个 RDD 中数据推送到外部系统，如将RDD 存入文件或者通过网络将其写入数据库。
通用的输出操作 foreachRDD()，它用来对 DStream 中的 RDD 运行任意计算。这和 transform()有些类似，都可以让我们访问任意 RDD。在 foreachRDD()中，可以重用我们在 Spark 中实现的所有行动操作。比如，常见的用例之一是把数据写到诸如 MySQL 的外部数据库中。
注意：
1) 连接不能写在 driver 层面（序列化）
2) 如果写在 foreach 则每个 RDD 中的每一条数据都创建，得不偿失；
3) 增加 foreachPartition，在分区创建（获取）。
package com.ljpbd.bigdata.spark.streaming
import com.ljpbd.bigdata.spark.Util.JdbcUtil
import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import java.sql.{Connection, PreparedStatement, ResultSet}
import java.text.SimpleDateFormat
import java.util.Date
import scala.collection.mutable.ListBuffer
object SparkStreaming11_Req1BlockList {
def main(args: Array[String]): Unit = {
//1.创建 SparkConf
val sparkConf: SparkConf = new
SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
//2.创建 StreamingContext
val ssc = new StreamingContext(sparkConf, Seconds(3))
//3.定义 Kafka 参数
val kafkaPara: Map[String, Object] = Map[String, Object](
ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG ->
"linux1:9092,linux2:9092,linux3:9092",
ConsumerConfig.GROUP_ID_CONFIG -> "atguigu",
"key.deserializer" ->
"org.apache.kafka.common.serialization.StringDeserializer",
"value.deserializer" ->
"org.apache.kafka.common.serialization.StringDeserializer"
)
//4.读取 Kafka 数据创建 DStream
val kafkaDStream: InputDStream[ConsumerRecord[String, String]] =
KafkaUtils.createDirectStream[String, String](ssc,
LocationStrategies.PreferConsistent,
ConsumerStrategies.Subscribe[String, String](Set("atguigu"), kafkaPara))
//5.将每条消息的 KV 取出
val adClickData: DStream[AdClickData] = kafkaDStream.map(
kafkaData => {
val data: String = kafkaData.value()
val datas: Array[String] = data.split(" ")
AdClickData(datas(0), datas(1), datas(2), datas(3), datas(4))
}
)
//周期性获取黑名单数据
//判断点击用户是否在黑名单中
//如果用户不在黑名单中，那么进行统计数量(每个采集周期)
val ds: DStream[((String, String, String), Int)] = adClickData.transform(
rdd => {
//通过jdbc周期性获取黑名单数据
val blackList = ListBuffer[String]()
val connection: Connection = JdbcUtil.getConnection
val pstat: PreparedStatement = connection.prepareStatement("select userid from black_list")
val rs: ResultSet = pstat.executeQuery()
while (rs.next()) {
blackList.append(rs.getString(1))
}
rs.close()
pstat.close()
connection.close()
val filterRdd: RDD[AdClickData] = rdd.filter(
data => {
//判断点击用户是不是在黑名单中
!blackList.contains(data.user)
}
)
//如果用户不在黑名单中，那么进行统计数量(每个采集周期)
filterRdd.map(
data => {
val sdf = new SimpleDateFormat("yyyy-MM-dd")
val day = sdf.format(new Date(data.ts))
val user = data.user
val ad = data.ad
((day, user, ad), 1)
}
).reduceByKey(_ + _)
}
)
ds.foreachRDD(
rdd => {
//rdd.foreach会每一条数据创建连接
/*
foreach是rdd的算子，算子之外的代码是在driver端执行，算子之内的代码是在executor执行
，可以将对象从driver传输到executor，这样就会涉及到闭包操作，需要将数据序列化
但是数据库连接对象是不能序列化的
val conn: Connection = JdbcUtil.getConnection
rdd提供了一个算子可以有效提供效率，foreachPartition
可以一个分区创建一个连接对象，这样就可以大幅度减少连接对象的创建
*/
/* rdd.foreachPartition(
iter=>{
val conn: Connection = JdbcUtil.getConnection
conn.close()
}
)*/
rdd.foreach {
case ((day, user, ad), count) => {
println(s"${day} ${user} ${ad} ${count}")
if (count >= 30) {
//如果统计数量超过点击域值，那么将用户拉入到黑名单中
val conn: Connection = JdbcUtil.getConnection
var sql =
"""
|insert into black_list(userid) values(?)
|on DUPLICATE KEY
|UPDATE userid = ?
|""".stripMargin
JdbcUtil.executeUpdate(conn, sql, Array(user, user))
conn.close()
} else {
//如果没有超过域值，那么需要将当天的广告点击数量进行更新，
val conn: Connection = JdbcUtil.getConnection
val sql =
"""
|select * from user_ad_count where dt=? and userid=? and adid=?
|""".stripMargin
//查询统计表数据
var flag = JdbcUtil.isExist(conn, sql, Array(day, user, ad))
//如果存在数据，则更新
if (flag) {
val sql1 =
"""
|update user_ad_count
|set count=count+?
|where dt=? and userid=? and adid=?
|""".stripMargin
JdbcUtil.executeUpdate(conn, sql1, Array(count, day, user, ad))
//判断更新后的点击数量是否超过域值，如果超过，那么将用户拉入到黑名单中
val sql2 =
"""
|select * from user_ad_count
|where dt=? and userid=? and adid=? and count>=30
|""".stripMargin
var flag1 = JdbcUtil.isExist(conn, sql2, Array(day, user, ad))
if (flag1) {
val sql3 =
"""
|insert into black_list(userid) values(?)
|on DUPLICATE KEY
|UPDATE userid = ?
|""".stripMargin
JdbcUtil.executeUpdate(conn, sql3, Array(user, user))
}
} else {
//如果不存在数据，那么新增
val sql4 =
"""
|insert into user_ad_count(dt,userid,adid,count) values(?,?,?,?)
|""".stripMargin
JdbcUtil.executeUpdate(conn, sql4, Array(day, user, ad, count))
}
conn.close()
}
}
}
}
)
//7.开启任务
ssc.start()
ssc.awaitTermination()
}
//广告点击数据
case class AdClickData(ts: String, area: String, city: String, user: String, ad: String)
}
