Aprendizaje del marco de computación en tiempo real de Spark Streaming 01

Explorando Spark Streaming

Acepte una o más líneas de contenido de texto del puerto 8888 de hadoop102 y separe el contenido recibido con espacios para calcular el número de ocurrencias de cada palabra

package Spark_Streaming
import org.apache.log4j.{
    
    Level,Logger}
import org.apache.spark.{
    
    SparkContext,SparkConf}
import org.apache.spark.streaming._
object demo01 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //设置日志级别
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf=new SparkConf().setAppName("demo01").setMaster("local[2]")
    val sc=new SparkContext(conf)
    //从SparkConf创建SteamingContext并指定10s的批处理大小
    val ssc=new StreamingContext(sc,Seconds(10))
    //启动连接到hadoop102 8888端口上，使用收到的数据创建DAtream
    val lines=ssc.socketTextStream("hadoop102",8888)
    val words=lines.flatMap(_.split(" "))
    val wordCounts=words.map(x=>(x,1)).reduceByKey(_+_)
    wordCounts.print()
    //启动流计算环境StreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

Escuche el directorio HDFS de hadoop102 /opt/datafiles, una vez que se agrega un nuevo archivo a este directorio, Spark
Streaming calculará las estadísticas de palabras dentro del tiempo

package Spark_Streaming
import org.apache.log4j.{
    
    Level,Logger}
import org.apache.spark.{
    
    SparkContext,SparkConf}
import org.apache.spark.streaming._
object demo02 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //设置日志级别
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf=new SparkConf().setAppName("demo02").setMaster("local[2]")
    val sc=new SparkContext(conf)
    //从SparkConf创建SteamingContext并指定10s的批处理大小
    val ssc=new StreamingContext(sc,Seconds(10))
    //启动连接到hadoop102 hdfs目录/opt/datafiles上
    val lines=ssc.textFileStream("hdfs://hadoop102:8020/opt/datafiles")
    val words=lines.flatMap(_.split(" "))
    val wordCounts=words.map(x=>(x,1)).reduceByKey(_+_)
    wordCounts.print()
    //启动流计算环境StreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

Domina el modelo de programación DStream

Operación de conversión de DStream

Use transform para dividir una línea de declaraciones en palabras

package Spark_Streaming
import org.apache.log4j.{
    
    Level,Logger}
import org.apache.spark.{
    
    SparkContext,SparkConf}
import org.apache.spark.streaming._
object demo03 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //设置日志级别
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf=new SparkConf().setAppName("demo03").setMaster("local[2]")
    val sc=new SparkContext(conf)
    //从SparkConf创建SteamingContext并指定10s的批处理大小
    val ssc=new StreamingContext(sc,Seconds(10))
    //启动连接到hadoop102 8888端口上
    val lines=ssc.socketTextStream("hadoop102",8888)
    val words=lines.transform(rdd=>rdd.flatMap(_.split(" ")))
    words.print()
    //启动流计算环境StreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

Operación de la ventana DStream

La operación de ventana se basa en un cálculo por lotes de ventana de un DStream de origen para obtener un nuevo DStream.
Por ejemplo, establezca la duración de la ventana en 3 s y el intervalo de tiempo deslizante en 1 s. Interceptar elementos en el DStream de origen para formar un nuevo DStream.

package Spark_Streaming
import org.apache.log4j.{
    
    Level,Logger}
import org.apache.spark.{
    
    SparkContext,SparkConf}
import org.apache.spark.streaming._
object demo04 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //设置日志级别
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf=new SparkConf().setAppName("demo04").setMaster("local[2]")
    val sc=new SparkContext(conf)
    val ssc=new StreamingContext(sc,Seconds(1))
    val lines=ssc.socketTextStream("localhost",8888)
    val words=lines.flatMap(_.split(" "))
    val windowWords=words.window(Seconds(3),Seconds(1))
    windowWords.print()
    //启动流计算环境StreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

Básicamente, ingrese una letra cada segundo, saque todos los elementos en la longitud de 3s en el momento actual e imprímalos. En la cuarta vez, a ya no es visible, lo que indica que a ya no está en la ventana actual

Operaciones de salida DStream

package Spark_Streaming
import org.apache.log4j.{
    
    Level,Logger}
import org.apache.spark.streaming.{
    
    Seconds,StreamingContext}
import org.apache.spark.{
    
    SparkContext,SparkConf}
object demo06 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //设置日志级别
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf=new SparkConf().setAppName("demo06").setMaster("local[2]")
    val sc=new SparkContext(conf)
    val ssc=new StreamingContext(sc,Seconds(10))
    val lines=ssc.socketTextStream("hadoop102",8888)
    lines.saveAsTextFiles("hdfs://hadoop102:8020/opt/datafiles/sahf","txt")
    ssc.start()
    ssc.awaitTermination()
  }
}

Si el error muestra que el permiso es insuficiente y no se puede escribir
Ejecutar

hdfs dfs -chmod a+w /opt/datafiles

[xwk@hadoop102 ~]$ nc -l -p 8888
this is 1th line
this is 2th line
this is 3th line
this is 4 th line

Las 4 líneas de texto se guardan en los primeros 4 directorios respectivamente

Use foreachPartition para escribir los resultados del procesamiento en la base de datos MySQL

mysql> create database spark;
Query OK, 1 row affected (0.07 sec)

mysql> use spark;
Database changed
mysql> create table searchKeyWord(insert_time date,keyword varchar(30),search_count integer);
Query OK, 0 rows affected (0.66 sec)

Establezca la longitud de la ventana en 60 s, el intervalo de tiempo deslizante de la ventana en 10 s, calcule la cantidad de ocurrencias de cada palabra dentro de 10 s y ordene las palabras en orden descendente según la cantidad de ocurrencias

package Spark_Streaming

import org.apache.spark.SparkConf
import org.apache.spark.streaming._
import java.sql.DriverManager
import org.apache.log4j.{
    
    Level, Logger}

object demo07 {
    
    
  def main(args: Array[String]): Unit = {
    
    
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf = new SparkConf().setMaster("local[3]").setAppName("WriteDataToMySQL")
    val ssc = new StreamingContext(conf, Seconds(5))
    val ItemsStream = ssc.socketTextStream("hadoop102", 8888)
    val ItemPairs = ItemsStream.map(line => (line.split(",")(0), 1))
    val ItemCount = ItemPairs.reduceByKeyAndWindow((v1:Int,v2:Int)=>v1+v2,Seconds (60),Seconds(10))
    val hottestWord = ItemCount.transform(itemRDD => {
    
    
      val top3 = itemRDD.map(pair => (pair._2, pair._1)).sortByKey(false).map(pair => (pair._2, pair._1)).take(3)
      ssc.sparkContext.makeRDD(top3)
    })
    hottestWord.foreachRDD(rdd => {
    
    
      rdd.foreachPartition(partitionOfRecords => {
    
    
        val url = "jdbc:mysql://hadoop102:3306/spark"
        val user = "root"
        val password = "root"
        Class.forName("com.mysql.cj.jdbc.Driver")
        val conn = DriverManager.getConnection(url, user, password)
        conn.prepareStatement("delete from searchKeyWord where 1=1").executeUpdate()
        conn.setAutoCommit(false)
        val stmt = conn.createStatement()
        partitionOfRecords.foreach(record => {
    
    
          stmt.addBatch("insert into searchKeyWord (insert_time,keyword,search_count) values (now(),'" + record._1 + "','" + record._2 + "')")
        })
        stmt.executeBatch()
        conn.commit()
      })
    })
    ItemsStream.print()
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}

nc -l -p 8888

select * from searchKeyWord;