package StreamingDemo

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * 實時黑名單過濾
 */
object TransformDemo {
 def main(args: Array[String]): Unit = {
  //設置日志級別
  Logger.getLogger("org").setLevel(Level.WARN)
  val conf = new SparkConf()
   .setAppName(this.getClass.getSimpleName)
   .setMaster("local[2]")
  val ssc = new StreamingContext(conf, Seconds(2))

  //創(chuàng)建一個黑名單的RDD
  val blackRDD =
   ssc.sparkContext.parallelize(Array(("zs", true), ("lisi", true)))

  //通過socket從nc中獲取數據
  val linesDStream = ssc.socketTextStream("Hadoop01", 6666)

  /**
   * 過濾黑名單用戶發(fā)言
   * zs sb sb sb sb
   * lisi fuck fuck fuck
   * jack hello
   */
  linesDStream
   .map(x => {
    val info = x.split(" ")
    (info(0), info.toList.tail.mkString(" "))
   })
   .transform(rdd => { //transform是一個RDD->RDD的操作，所以返回值必須是RDD
    /**
     * 經過leftouterjoin操作之后，產生的結果如下：
     * (zs,(sb sb sb sb),Some(true)))
     * (lisi,(fuck fuck fuck),some(true)))
     * (jack,(hello,None))
     */
    val joinRDD = rdd.leftOuterJoin(blackRDD)

    //如果是Some(true)的，說明就是黑名單用戶，如果是None的，說明不在黑名單內，把非黑名單的用戶保留下來
    val filterRDD = joinRDD.filter(x => x._2._2.isEmpty)

    filterRDD
   })
   .map(x=>(x._1,x._2._1)).print()

  ssc.start()
  ssc.awaitTermination()
 }
}

package StreamingDemo

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * 基于緩存的實時WordCount，在全局范圍內統(tǒng)計單詞出現次數
 */
object UpdateStateByKeyDemo {
 def main(args: Array[String]): Unit = {
  //設置日志級別
  Logger.getLogger("org").setLevel(Level.WARN)

  /**
   * 如果沒有啟用安全認證或者從Kerberos獲取的用戶為null，那么獲取HADOOP_USER_NAME環(huán)境變量，
   * 并將它的值作為Hadoop執(zhí)行用戶設置hadoop username
   * 這里實驗了一下在沒有啟用安全認證的情況下，就算不顯式添加，也會自動獲取我的用戶名
   */
  //System.setProperty("HADOOP_USER_NAME","Setsuna")

  val conf = new SparkConf()
   .setAppName(this.getClass.getSimpleName)
   .setMaster("local[2]")
  val ssc = new StreamingContext(conf, Seconds(2))

  //設置Checkpoint存放的路徑
  ssc.checkpoint("hdfs://Hadoop01:9000/checkpoint")

  //創(chuàng)建輸入DStream
  val lineDStream = ssc.socketTextStream("Hadoop01", 6666)
  val wordDStream = lineDStream.flatMap(_.split(" "))
  val pairsDStream = wordDStream.map((_, 1))

  /**
   * state:代表之前的狀態(tài)值
   * values：代表當前batch中key對應的values值
   */
  val resultDStream =
   pairsDStream.updateStateByKey((values: Seq[Int], state: Option[Int]) => {

    //當state為none，表示沒有對這個單詞做統(tǒng)計，則返回0值給計數器count
    var count = state.getOrElse(0)

    //遍歷values，累加新出現的單詞的value值
    for (value <- values) {
     count += value
    }

    //返回key對應的新state，即單詞的出現次數
    Option(count)
   })

  //在控制臺輸出
  resultDStream.print()

  ssc.start()
  ssc.awaitTermination()
 }
}

package StreamingDemo

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * 需求：每隔2秒鐘，統(tǒng)計最近5秒鐘的搜索詞中排名最靠前的3個搜索詞以及出現次數
 */
object ReduceByKeyAndWindowDemo {
 def main(args: Array[String]): Unit = {

  //設置日志級別
  Logger.getLogger("org").setLevel(Level.WARN)
  //基礎配置
  val conf = new SparkConf()
   .setAppName(this.getClass.getSimpleName)
   .setMaster("local[2]")

  //批處理間隔設置為1s
  val ssc = new StreamingContext(conf, Seconds(1))

  val linesDStream = ssc.socketTextStream("Hadoop01", 6666)
  linesDStream
   .flatMap(_.split(" ")) //根據空格來做分詞
   .map((_, 1)) //返回(word,1)
   .reduceByKeyAndWindow(
    //定義窗口如何計算的函數
    //x代表的是聚合后的結果，y代表的是這個Key對應的下一個需要聚合的值
    (x: Int, y: Int) => x + y,
    //窗口長度為5秒
    Seconds(5),
    //窗口時間間隔為2秒
    Seconds(2)
   )
   .transform(rdd => { //transform算子對rdd做處理，轉換為另一個rdd
    //根據Key的出現次數來進行排序，然后降序排列，獲取最靠前的3個搜索詞
    val info: Array[(String, Int)] = rdd.sortBy(_._2, false).take(3)
    //將Array轉換為resultRDD
    val resultRDD = ssc.sparkContext.parallelize(info)
    resultRDD
   })
   .map(x => s"${x._1}出現的次數是：${x._2}")
   .print()

  ssc.start()
  ssc.awaitTermination()

 }
}

dstream.foreachRDD { rdd =>
  val connection=createNewConnection()
  rdd.foreach { record => connection.send(record)
  }
}

dstream.foreachRDD { rdd =>
  rdd.foreach { record =>
    val connection = createNewConnection()
    connection.send(record)
    connection.close()
  }
}

CREATE TABLE wordcount (
  word varchar(100) CHARACTER SET utf8 NOT NULL,
  count int(10) NOT NULL,
  PRIMARY KEY (word)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

package StreamingDemo

import java.sql.{Connection, DriverManager, SQLException}
import java.util

object JDBCManager {
 var connectionQue: java.util.LinkedList[Connection] = null

 /**
  * 從數據庫連接池中獲取連接對象
  * @return
  */
 def getConnection(): Connection = {
  synchronized({
   try {
    //如果連接池是空的，那么就實例化一個Connection類型的鏈表
    if (connectionQue == null) {
     connectionQue = new util.LinkedList[Connection]()
     for (i <- 0 until (10)) {
      //生成10個連接，并配置相關信息
      val connection = DriverManager.getConnection(
       "jdbc:mysql://Hadoop01:3306/test?characterEncoding=utf-8",
       "root",
       "root")
      //將連接push進連接池
      connectionQue.push(connection)
     }
    }
   } catch {
    //捕獲異常并輸出
    case e: SQLException => e.printStackTrace()
   }
   //如果連接池不為空，則返回表頭元素，并將它在鏈表里刪除
   return connectionQue.poll()
  })
 }

 /**
  * 當連接對象用完后，需要調用這個方法歸還連接
  * @param connection
  */
 def returnConnection(connection: Connection) = {
  //插入元素
  connectionQue.push(connection)
 }

 def main(args: Array[String]): Unit = {
  //main方法測試
  getConnection()
  println(connectionQue.size())
 }
}

package StreamingDemo

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, streaming}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object ForeachRDDDemo {
 def main(args: Array[String]): Unit = {
  //設置日志級別，避免INFO信息過多
  Logger.getLogger("org").setLevel(Level.WARN)

  //設置Hadoop的用戶，不加也可以
  System.setProperty("HADOOP_USER_NAME", "Setsuna")

  //Spark基本配置
  val conf = new SparkConf()
   .setAppName(this.getClass.getSimpleName)
   .setMaster("local[2]")
  val ssc = new StreamingContext(conf, streaming.Seconds(2))

  //因為要使用updateStateByKey，所以需要使用checkpoint
  ssc.checkpoint("hdfs://Hadoop01:9000/checkpoint")

  //設置socket，跟nc配置的一樣
  val linesDStream = ssc.socketTextStream("Hadoop01", 6666)
  val wordCountDStream = linesDStream
   .flatMap(_.split(" "))   //根據空格做分詞
   .map((_, 1)) //生成(word,1)
   .updateStateByKey((values: Seq[Int], state: Option[Int]) => {
    //實時更新狀態(tài)信息
    var count = state.getOrElse(0)
    for (value <- values) {
     count += value
    }
    Option(count)
   })

  wordCountDStream.foreachRDD(rdd => {
   if (!rdd.isEmpty()) {
    rdd.foreachPartition(part => {
     //從連接池中獲取連接
     val connection = JDBCManager.getConnection()
     part.foreach(data => {
      val sql = //往wordcount表中插入wordcount信息，on duplicate key update子句是有則更新無則插入
       s"insert into wordcount (word,count) " +
        s"values ('${data._1}',${data._2}) on duplicate key update count=${data._2}"
      //使用prepareStatement來使用sql語句
      val pstmt = connection.prepareStatement(sql)
      pstmt.executeUpdate()
     })
     //在連接處提交完數據后，歸還連接到連接池
     JDBCManager.returnConnection(connection)
    })
   }
  })

  ssc.start()
  ssc.awaitTermination()
 }
}