spark几种不同版本的WordCount

1、spark streaming消费netcat的数据

代码：
消费netcat的数据到spark streaming原理图：

package com.murphy.WC

import org.apache.hadoop.hdfs.server.common.Storage
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, Durations, Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 实现一个简单的WordCount
  * 数据需要从netcat中获取 ：模拟实时数据
  */
object StreamingWC {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("streamingwc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    // 创建streaming的上下文
    // Durations.seconds(5) == Seconds(5)
    val ssc = new StreamingContext(sc, Seconds(5))

    // 获取netcat的数据。这种获取方式，streaming会把获取的数据以缓存的方式放到指定缓存级别的地方
    val dStream: ReceiverInputDStream[String] = ssc.socketTextStream("node1", 8888, StorageLevel.MEMORY_AND_DISK)

    // 开始分析数据
    val res: DStream[(String, Int)] = dStream.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_)

    // 打印到控制台
    res.print()

    // 开始提交任务到集群
    ssc.start()
    // 线程等待，等待处理下一批次任务
    ssc.awaitTermination()
  }
}

2.使用updateStateByKey原语实现批次累加(WordCount)

**思路：**在用历史结果应用到当前批次的需求时，可以用updateStateByKey原语实现实现历史批次累加功能也可以借助数据库来实现updateStateByKey只有获取历史批次结果应用到当前批次中的功能，该原语是没有存储历史批次结果的功能的 所以，实现批次累加必须要进行checkpoint----streaming中，checkpoint具有存储历史结果的功能

代码：

package com.murphy.WC

import org.apache.spark.{HashPartitioner, SparkConf}
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * 在用历史结果应用到当前批次的需求时，可以用updateStateByKey原语实现
  * 实现历史批次累加功能也可以借助数据库来实现
  * updateStateByKey只有获取历史批次结果应用到当前批次中的功能，该原语是没有存储历史批次结果的功能的
  * 所以，实现批次累加必须要进行checkpoint----streaming中，checkpoint具有存储历史结果的功能
  */
object AccSparkStreamingWC {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("AccSparkStreamingWC").setMaster("local[2]")
    val ssc = new StreamingContext(conf, Seconds(5))

    // 做checkpoint
    ssc.checkpoint("hdfs://node1:8020/cp-20190110-1")

    // 获取数据
    val dStream = ssc.socketTextStream("node1", 8888)

    // 开始统计 map没变里一个单词，记一次（key,value） -> (a,1)
    val tups: DStream[(String, Int)] = dStream.flatMap(_.split(" ")).map((_, 1))
    // 调用updateStateByKey原语进行批次累加
    val result: DStream[(String, Int)] = tups.updateStateByKey(func, new HashPartitioner(ssc.sparkContext.defaultParallelism), true)

    result.print()

    ssc.start()
    ssc.awaitTermination()
  }

  /**
    * 迭代器中，
    * 第一个参数：数据中的key
    * 第二个参数：当前批次中相同key对应的value  Seq(1,1,1,1,1)
    * 第三个参数：历史结果中相同key对应的value  Some(2)
    */
  val func = (it: Iterator[(String, Seq[Int], Option[Int])]) => {
    it.map(x => {
      (x._1, x._2.sum + x._3.getOrElse(0))
    })
  }
}

3、从kafka的topic中加载数据(WordCount)

首先：是模板代码
然后：设置一个检查点
其次: 请求kafka的配置信息
再之: topics封装到map,并通过调用kafka工具类获取到topic的信息
最后: 过滤掉offset,只留下数据，通过updateStateByKey进行批次累加，其中包括定义一个迭代器函数作为该原语的参数

package com.qf.gp15.day09

import org.apache.spark.{HashPartitioner, SparkConf}
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}

object LoadTopicDataWC {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("LoadTopicDataWC").setMaster("local[2]")
    val ssc = new StreamingContext(conf, Seconds(2))

    // 设置检查点
    ssc.checkpoint("hdfs://node1:8020/out-20190110-2")

    // 设置请求kafka的配置信息
    val Array(zkQuorum, group, topics, numThread) = args

    // 将topic封装到map里
    val topicMap: Map[String, Int] = topics.split(",").map((_, numThread.toInt)).toMap

    // 开始调用kafka工具类获取topic的信息
    val dstream: ReceiverInputDStream[(String, String)] =
      KafkaUtils.createStream(ssc, zkQuorum, group, topicMap, StorageLevel.MEMORY_AND_DISK)

    // 因为获取到kafka的数据中是key，value的，其中key为offset，在实际统计中不需要，可以过滤掉
    val lines: DStream[String] = dstream.map(_._2) //只需要数据(value)，不需要offset(key)

    // 开始统计 map没遍历到一个单词就加1，（a,1）并使用updateStateByKey原语实现批次累加
    val tups: DStream[(String, Int)] = lines.flatMap(_.split(" ")).map((_, 1))
    val res = tups.updateStateByKey(func, new HashPartitioner(ssc.sparkContext.defaultMinPartitions), true)

    res.print

    ssc.start()
    ssc.awaitTermination()
  }
  
	//编写一个函数：实现数据的迭代
  val func = (it: Iterator[(String, Seq[Int], Option[Int])]) => {
    it.map {
      case (x, y, z) => {
        (x, y.sum + z.getOrElse(0))
      }
    }
  }
}