packageorg.scala.opt

importjava.io.{PrintWriter,  IOException}
importjava.net.{Socket, SocketException, ServerSocket}

case classServerThread(socket : Socket) extendsThread("ServerThread") {
  override defrun(): Unit = {
    valptWriter = newPrintWriter(socket.getOutputStream)
    try{
      varcount = 0
      vartotalCount = 0
      varisThreadRunning : Boolean = true
      valbatchCount = 1
      valwords = List("Java Scala C C++ C# Python JavaScript",
      "Hadoop Spark Ngix MFC Net Mahout Hive")
      while(isThreadRunning) {
        words.foreach(ptWriter.println)
        count += 1
        if(count >= batchCount) {
          totalCount += count
          count = 0
          println("batch "+ batchCount + " totalCount => "+ totalCount)
          Thread.sleep(1000)
        }
        //out.println此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用 checkError() 是否出现错误。
        if(ptWriter.checkError()) {
          isThreadRunning = false
          println("ptWriter error then close socket")
        }
      }
    }
    catch{
      casee : SocketException =>
        println("SocketException : ", e)
      casee : IOException =>
        e.printStackTrace();
    } finally{
      if(ptWriter != null) ptWriter.close()
      println("Client "+ socket.getInetAddress + " disconnected")
      if(socket != null) socket.close()
    }
    println(Thread.currentThread().getName + " Exit")
  }
}
objectSocketServer {
  defmain(args : Array[String]) : Unit = {
    try{
      vallistener = newServerSocket(9999)
      println("Server is started, waiting for client connect...")
      while(true) {
        valsocket = listener.accept()
        println("Client : "+ socket.getLocalAddress + " connected")
        newServerThread(socket).start()
      }
      listener.close()
    }
    catch{
      casee: IOException =>
        System.err.println("Could not listen on port: 9999.")
        System.exit(-1)
    }
  }
}

packagecom.dt.spark.streaming_scala

importorg.apache.spark.streaming.{Seconds, StreamingContext}
importorg.apache.spark.{SparkConf, Accumulator}
importorg.apache.spark.broadcast.Broadcast

/**
 * 第103课：  动手实战联合使用Spark Streaming、Broadcast、Accumulator实现在线黑名单过滤和计数
 * 本期内容：
1，Spark Streaming与Broadcast、Accumulator联合
2，在线黑名单过滤和计算实战
 */
object_103SparkStreamingBroadcastAccumulator {

  @volatile private varbroadcastList : Broadcast[List[String]] = null
  @volatile private varaccumulator : Accumulator[Int] = null

  defmain(args : Array[String]) : Unit = {
    valconf = newSparkConf().setMaster("local[5]").setAppName("_103SparkStreamingBroadcastAccumulator")
    valssc = newStreamingContext(conf, Seconds(5))
    ssc.sparkContext.setLogLevel("WARN")

    /**
     * 使用Broadcast广播黑名单到每个Executor中
     */
    broadcastList = ssc.sparkContext.broadcast(Array("Hadoop", "Mahout", "Hive").toList)

    /**
     * 全局计数器，用于通知在线过滤了多少各黑名单
     */
    accumulator = ssc.sparkContext.accumulator(0, "OnlineBlackListCounter")

    ssc.socketTextStream("localhost", 9999).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).foreachRDD {rdd =>{
      if(!rdd.isEmpty()) {
        rdd.filter(wordPair => {
          if(broadcastList.value.contains(wordPair._1)) {

            println("BlackList word %s appeared".formatted(wordPair._1))
            accumulator.add(wordPair._2)
            false
          } else{
            true
          }
        }).collect()
        println("BlackList appeared : %d times".format(accumulator.value))
      }
    }}
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}