Spark入门实战系列--7.Spark Streaming（下）--实时流计算Spark Streaming实战

【注】该系列文章以及使用到安装包/测试数据 可以在《倾情大奉送--Spark入门实战系列》获取

1、实例演示

1.1 流数据模拟器

1.1.1 流数据说明

在实例演示中模拟实际情况，需要源源不断地接入流数据，为了在演示过程中更接近真实环境将定义流数据模拟器。该模拟器主要功能：通过Socket方式监听指定的端口号，当外部程序通过该端口连接并请求数据时，模拟器将定时将指定的文件数据随机获取发送给外部程序。

1.1.2 模拟器代码

import java.io.{PrintWriter}

import java.net.ServerSocket

import scala.io.Source

 

object StreamingSimulation {

  // 定义随机获取整数的方法

  def index(length: Int) = {

    import java.util.Random

    val rdm = new Random

    rdm.nextInt(length)

  }

 

  def main(args: Array[String]) {

    // 调用该模拟器需要三个参数，分为为文件路径、端口号和间隔时间（单位：毫秒）

    if (args.length != 3) {

      System.err.println("Usage: <filename> <port> <millisecond>")

      System.exit(1)

    }

 

    // 获取指定文件总的行数

    val filename = args(0)

    val lines = Source.fromFile(filename).getLines.toList

    val filerow = lines.length

 

    // 指定监听某端口，当外部程序请求时建立连接

    val listener = new ServerSocket(args(1).toInt)

    while (true) {

      val socket = listener.accept()

      new Thread() {

        override def run = {

          println("Got client connected from: " + socket.getInetAddress)

          val out = new PrintWriter(socket.getOutputStream(), true)

          while (true) {

            Thread.sleep(args(2).toLong)

            // 当该端口接受请求时，随机获取某行数据发送给对方

            val content = lines(index(filerow))

            println(content)

            out.write(content + ‘\n‘)

            out.flush()

          }

          socket.close()

        }

      }.start()

    }

  }

}

1.1.3 生成打包文件

【注】可以参见第3课《Spark编程模型（下）--IDEA搭建及实战》进行打包

在打包配置界面中，需要在Class Path加入：/app/scala-2.10.4/lib/scala-swing.jar /app/scala-2.10.4/lib/scala-library.jar /app/scala-2.10.4/lib/scala-actors.jar ，各个jar包之间用空格分开，

点击菜单Build->Build Artifacts，弹出选择动作，选择Build或者Rebuild动作，使用如下命令复制打包文件到Spark根目录下

cd /home/hadoop/IdeaProjects/out/artifacts/LearnSpark_jar

cp LearnSpark.jar /app/hadoop/spark-1.1.0/

ll /app/hadoop/spark-1.1.0/

1.2 实例1：读取文件演示

1.2.1 演示说明

在该实例中Spark Streaming将监控某目录中的文件，获取在间隔时间段内变化的数据，然后通过Spark Streaming计算出改时间段内单词统计数。

1.2.2 演示代码

import org.apache.spark.SparkConf

import org.apache.spark.streaming.{Seconds, StreamingContext}

import org.apache.spark.streaming.StreamingContext._

 

object FileWordCount {

  def main(args: Array[String]) {

    val sparkConf = new SparkConf().setAppName("FileWordCount").setMaster("local[2]")

 

    // 创建Streaming的上下文，包括Spark的配置和时间间隔，这里时间为间隔20秒

    val ssc = new StreamingContext(sparkConf, Seconds(20))

 

    // 指定监控的目录，在这里为/home/hadoop/temp/

    val lines = ssc.textFileStream("/home/hadoop/temp/")

 

    // 对指定文件夹变化的数据进行单词统计并且打印

    val words = lines.flatMap(_.split(" "))

    val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)

    wordCounts.print()

 

       // 启动Streaming

    ssc.start()

    ssc.awaitTermination()

  }

}

1.2.3 运行代码

第一步   创建Streaming监控目录

创建/home/hadoop/temp为Spark Streaming监控的目录，通过在该目录中定时添加文件内容，然后由Spark Streaming统计出单词个数

第二步   使用如下命令启动Spark集群

$cd /app/hadoop/spark-1.1.0

$sbin/start-all.sh

第三步   在IDEA中运行Streaming程序

在IDEA中运行该实例，由于该实例没有输入参数故不需要配置参数，在运行日志中将定时打印时间戳。如果在监控目录中加入文件内容，将输出时间戳的同时将输出单词统计个数。

1.2.4 添加文本及内容

1.2.5 查看结果

第一步   查看IDEA中运行情况

在IDEA的运行日志窗口中，可以观察到输出时间戳的同时将输出单词统计个数

第二步   通过webUI监控运行情况

在http://hadoop1:4040监控Spark Streaming运行情况，可以观察到每20秒运行一次作业

并且与其他运行作业相比在监控菜单增加了"Streaming"项目，点击可以看到监控内容：

1.3 实例2：网络数据演示

1.3.1 演示说明

在该实例中将由4.1流数据模拟以1秒的频度发送模拟数据，Spark Streaming通过Socket接收流数据并每20秒运行一次用来处理接收到数据，处理完毕后打印该时间段内数据出现的频度，即在各处理段时间之间状态并无关系。

1.3.2 演示代码

import org.apache.spark.{SparkContext, SparkConf}

import org.apache.spark.streaming.{Milliseconds, Seconds, StreamingContext}

import org.apache.spark.streaming.StreamingContext._

import org.apache.spark.storage.StorageLevel

 

object NetworkWordCount {

  def main(args: Array[String]) {

    val conf = new SparkConf().setAppName("NetworkWordCount").setMaster("local[2]")

    val sc = new SparkContext(conf)

    val ssc = new StreamingContext(sc, Seconds(20))

 

    // 通过Socket获取数据，该处需要提供Socket的主机名和端口号，数据保存在内存和硬盘中

    val lines = ssc.socketTextStream(args(0), args(1).toInt, StorageLevel.MEMORY_AND_DISK_SER)

 

    // 对读入的数据进行分割、计数

    val words = lines.flatMap(_.split(","))

    val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)

 

    wordCounts.print()

    ssc.start()

    ssc.awaitTermination()

  }

}

1.3.3 运行代码

第一步   启动流数据模拟器

启动4.1打包好的流数据模拟器，在该实例中将定时发送/home/hadoop/upload/class7目录下的people.txt数据文件（该文件可以在本系列配套资源目录/data/class7中找到），其中people.txt数据内容如下：

模拟器Socket端口号为9999，频度为1秒，

$cd /app/hadoop/spark-1.1.0

$java -cp LearnSpark.jar class7.StreamingSimulation /home/hadoop/upload/class7/people.txt 9999 1000

在没有程序连接时，该程序处于阻塞状态

第二步   在IDEA中运行Streaming程序

在IDEA中运行该实例，该实例需要配置连接Socket主机名和端口号，在这里配置参数机器名为hadoop1和端口号为9999

1.3.4 查看结果

第一步   观察模拟器发送情况

IDEA中的Spark Streaming程序运行与模拟器建立连接，当模拟器检测到外部连接时开始发送测试数据，数据是随机的在指定的文件中获取一行数据并发送，时间间隔为1秒

第二步   在监控页面观察执行情况

在webUI上监控作业运行情况，可以观察到每20秒运行一次作业

第三步   IDEA运行情况

在IDEA的运行窗口中，可以观测到的统计结果，通过分析在Spark Streaming每段时间内单词数为20，正好是20秒内每秒发送总数。

1.4 实例3：销售数据统计演示

1.4.1 演示说明

在该实例中将由4.1流数据模拟器以1秒的频度发送模拟数据（销售数据），Spark Streaming通过Socket接收流数据并每5秒运行一次用来处理接收到数据，处理完毕后打印该时间段内销售数据总和，需要注意的是各处理段时间之间状态并无关系。

1.4.2 演示代码

import org.apache.log4j.{Level, Logger}

import org.apache.spark.{SparkContext, SparkConf}

import org.apache.spark.streaming.{Milliseconds, Seconds, StreamingContext}

import org.apache.spark.streaming.StreamingContext._

import org.apache.spark.storage.StorageLevel

 

object SaleAmount {

  def main(args: Array[String]) {

    if (args.length != 2) {

      System.err.println("Usage: SaleAmount <hostname> <port> ")

      System.exit(1)

    }

    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)

    Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)

 

    val conf = new SparkConf().setAppName("SaleAmount").setMaster("local[2]")

    val sc = new SparkContext(conf)

    val ssc = new StreamingContext(sc, Seconds(5))

 

   // 通过Socket获取数据，该处需要提供Socket的主机名和端口号，数据保存在内存和硬盘中

    val lines = ssc.socketTextStream(args(0), args(1).toInt, StorageLevel.MEMORY_AND_DISK_SER)

    val words = lines.map(_.split(",")).filter(_.length == 6)

    val wordCounts = words.map(x=>(1, x(5).toDouble)).reduceByKey(_ + _)

 

    wordCounts.print()

    ssc.start()

    ssc.awaitTermination()

  }

}

1.4.3 运行代码

第一步   启动流数据模拟器

启动4.1打包好的流数据模拟器，在该实例中将定时发送第五课/home/hadoop/upload/class5/saledata目录下的tbStockDetail.txt数据文件（参见第五课《5.Hive（下）--Hive实战》中2.1.2数据描述，该文件可以在本系列配套资源目录/data/class5/saledata中找到），其中表tbStockDetail字段分别为订单号、行号、货品、数量、金额，数据内容如下：

模拟器Socket端口号为9999，频度为1秒

$cd /app/hadoop/spark-1.1.0

$java -cp LearnSpark.jar class7.StreamingSimulation /home/hadoop/upload/class5/saledata/tbStockDetail.txt 9999 1000

在IDEA中运行该实例，该实例需要配置连接Socket主机名和端口号，在这里配置参数机器名为hadoop1和端口号为9999

1.4.4 查看结果

第一步   观察模拟器发送情况

IDEA中的Spark Streaming程序运行与模拟器建立连接，当模拟器检测到外部连接时开始发送销售数据，时间间隔为1秒

第二步   IDEA运行情况

在IDEA的运行窗口中，可以观察到每5秒运行一次作业（两次运行间隔为5000毫秒），运行完毕后打印该时间段内销售数据总和。

第三步   在监控页面观察执行情况

在webUI上监控作业运行情况，可以观察到每5秒运行一次作业

1.5 实例4：Stateful演示

1.5.1 演示说明

该实例为Spark Streaming状态操作，模拟数据由4.1流数据模拟以1秒的频度发送，Spark Streaming通过Socket接收流数据并每5秒运行一次用来处理接收到数据，处理完毕后打印程序启动后单词出现的频度，相比较前面4.3实例在该实例中各时间段之间状态是相关的。

1.5.2 演示代码

import org.apache.log4j.{Level, Logger}

import org.apache.spark.{SparkContext, SparkConf}

import org.apache.spark.streaming.{Seconds, StreamingContext}

import org.apache.spark.streaming.StreamingContext._

 

object StatefulWordCount {

  def main(args: Array[String]) {

    if (args.length != 2) {

      System.err.println("Usage: StatefulWordCount <filename> <port> ")

      System.exit(1)

    }

    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)

    Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)

 

    // 定义更新状态方法，参数values为当前批次单词频度，state为以往批次单词频度

    val updateFunc = (values: Seq[Int], state: Option[Int]) => {

      val currentCount = values.foldLeft(0)(_ + _)

      val previousCount = state.getOrElse(0)

      Some(currentCount + previousCount)

    }

 

    val conf = new SparkConf().setAppName("StatefulWordCount").setMaster("local[2]")

    val sc = new SparkContext(conf)

 

    // 创建StreamingContext，Spark Steaming运行时间间隔为5秒

    val ssc = new StreamingContext(sc, Seconds(5))

    // 定义checkpoint目录为当前目录

    ssc.checkpoint(".")

 

    // 获取从Socket发送过来数据

    val lines = ssc.socketTextStream(args(0), args(1).toInt)

    val words = lines.flatMap(_.split(","))

    val wordCounts = words.map(x => (x, 1))

 

    // 使用updateStateByKey来更新状态，统计从运行开始以来单词总的次数

    val stateDstream = wordCounts.updateStateByKey[Int](updateFunc)

    stateDstream.print()

    ssc.start()

    ssc.awaitTermination()

  }

}

1.5.3 运行代码

第一步   启动流数据模拟器

启动4.1打包好的流数据模拟器，在该实例中将定时发送/home/hadoop/upload/class7目录下的people.txt数据文件（该文件可以在本系列配套资源目录/data/class7中找到），其中people.txt数据内容如下：

模拟器Socket端口号为9999，频度为1秒

$cd /app/hadoop/spark-1.1.0

$java -cp LearnSpark.jar class7.StreamingSimulation /home/hadoop/upload/class7/people.txt 9999 1000

在没有程序连接时，该程序处于阻塞状态，在IDEA中运行Streaming程序

在IDEA中运行该实例，该实例需要配置连接Socket主机名和端口号，在这里配置参数机器名为hadoop1和端口号为9999

1.5.4 查看结果

第一步   IDEA运行情况

在IDEA的运行窗口中，可以观察到第一次运行统计单词总数为1，第二次为6，第N次为5(N-1)+1，即统计单词的总数为程序运行单词数总和。

第二步   在监控页面观察执行情况

在webUI上监控作业运行情况，可以观察到每5秒运行一次作业

第三步   查看CheckPoint情况

在项目根目录下可以看到checkpoint文件

1.6 实例5：Window演示

1.6.1 演示说明

该实例为Spark Streaming窗口操作，模拟数据由4.1流数据模拟以1秒的频度发送，Spark Streaming通过Socket接收流数据并每10秒运行一次用来处理接收到数据，处理完毕后打印程序启动后单词出现的频度。相比前面的实例，Spark Streaming窗口统计是通过reduceByKeyAndWindow()方法实现的，在该方法中需要指定窗口时间长度和滑动时间间隔。

1.6.2 演示代码

import org.apache.log4j.{Level, Logger}

import org.apache.spark.{SparkContext, SparkConf}

import org.apache.spark.storage.StorageLevel

import org.apache.spark.streaming._

import org.apache.spark.streaming.StreamingContext._

 

object WindowWordCount {

  def main(args: Array[String]) {

    if (args.length != 4) {

      System.err.println("Usage: WindowWorldCount <filename> <port> <windowDuration> <slideDuration>")

      System.exit(1)

    }

    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)

    Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)

 

    val conf = new SparkConf().setAppName("WindowWordCount").setMaster("local[2]")

    val sc = new SparkContext(conf)

 

     // 创建StreamingContext

    val ssc = new StreamingContext(sc, Seconds(5))

     // 定义checkpoint目录为当前目录

    ssc.checkpoint(".")

 

    // 通过Socket获取数据，该处需要提供Socket的主机名和端口号，数据保存在内存和硬盘中

    val lines = ssc.socketTextStream(args(0), args(1).toInt, StorageLevel.MEMORY_ONLY_SER)

    val words = lines.flatMap(_.split(","))

 

    // windows操作，第一种方式为叠加处理，第二种方式为增量处理

    val wordCounts = words.map(x => (x , 1)).reduceByKeyAndWindow((a:Int,b:Int) => (a + b), Seconds(args(2).toInt), Seconds(args(3).toInt))

//val wordCounts = words.map(x => (x , 1)).reduceByKeyAndWindow(_+_, _-_,Seconds(args(2).toInt), Seconds(args(3).toInt))

 

    wordCounts.print()

    ssc.start()

    ssc.awaitTermination()

  }

}

1.6.3 运行代码

第一步   启动流数据模拟器

启动4.1打包好的流数据模拟器，在该实例中将定时发送/home/hadoop/upload/class7目录下的people.txt数据文件（该文件可以在本系列配套资源目录/data/class7中找到），其中people.txt数据内容如下：

模拟器Socket端口号为9999，频度为1秒

$cd /app/hadoop/spark-1.1.0

$java -cp LearnSpark.jar class7.StreamingSimulation /home/hadoop/upload/class7/people.txt 9999 1000

在没有程序连接时，该程序处于阻塞状态，在IDEA中运行Streaming程序

在IDEA中运行该实例，该实例需要配置连接Socket主机名和端口号，在这里配置参数机器名为hadoop1、端口号为9999、时间窗口为30秒和滑动时间间隔10秒

1.6.4 查看结果

第一步   IDEA运行情况

在IDEA的运行窗口中，可以观察到第一次运行统计单词总数为4，第二次为14，第N次为10(N-1)+4，即统计单词的总数为程序运行单词数总和。

第二步   在监控页面观察执行情况

在webUI上监控作业运行情况，可以观察到每10秒运行一次作业

时间： 2024-10-12 04:00:01

Spark入门实战系列--7.Spark Streaming（下）--实时流计算Spark Streaming实战的相关文章

.Spark Streaming（上）--实时流计算Spark Streaming原理介

Spark入门实战系列--7.Spark Streaming(上)--实时流计算Spark Streaming原理介绍 http://www.cnblogs.com/shishanyuan/p/4747735.html 1.Spark Streaming简介 1.1 概述 Spark Streaming 是Spark核心API的一个扩展,可以实现高吞吐量的.具备容错机制的实时流数据的处理.支持从多种数据源获取数据,包括Kafk.Flume.Twitter.ZeroMQ.Kinesis 以及TCP

Spark入门实战系列--7.Spark Streaming（上）--实时流计算Spark Streaming介绍

[注]该系列文章以及使用到安装包/测试数据 可以在<倾情大奉送–Spark入门实战系列>获取 1 Spark Streaming简介 1.1 概述 Spark Streaming 是Spark核心API的一个扩展,可以实现高吞吐量的.具备容错机制的实时流数据的处理.支持从多种数据源获取数据,包括Kafk.Flume.Twitter.ZeroMQ.Kinesis 以及TCP sockets,从数据源获取数据之后,可以使用诸如map.reduce.join和window等高级函数进行复杂算法的处理

Spark入门实战系列--6.SparkSQL（下）--Spark实战应用

[注]该系列文章以及使用到安装包/测试数据 可以在<倾情大奉送–Spark入门实战系列>获取 1 运行环境说明 1.1 硬软件环境 主机操作系统:Windows 64位,双核4线程,主频2.2G,10G内存 虚拟软件:VMware? Workstation 9.0.0 build-812388 虚拟机操作系统:CentOS 64位,单核 虚拟机运行环境: JDK:1.7.0_55 64位 Hadoop:2.2.0(需要编译为64位) Scala:2.10.4 Spark:1.1.0(需要编译)

Spark实时流计算Java案例

现在,网上基于spark的代码基本上都是Scala,很多书上也都是基于Scala,没办法,谁叫spark是Scala写出来的了,但是我现在还没系统的学习Scala,所以只能用java写spark程序了,spark支持java,而且Scala也基于JVM,不说了,直接上代码 这是官网上给出的例子,大数据学习中经典案例单词计数 在linux下一个终端 输入 $ nc -lk 9999 然后运行下面的代码 package com.tg.spark.stream; import java.util.Ar

倾情大奉送--Spark入门实战系列 (转自：http://www.cnblogs.com/shishanyuan/p/4699644.html）

这一两年Spark技术很火,自己也凑热闹,反复的试验.研究,有痛苦万分也有欣喜若狂,抽空把这些整理成文章共享给大家.这个系列基本上围绕了Spark生态圈进行介绍,从Spark的简介.编译.部署,再到编程模型.运行架构,最后介绍其组件SparkSQL.Spark Streaming.Spark MLib和Spark GraphX等.文章内容的整理一般是先介绍原理,随后是实战例子,由于面向的是入门读者,在实战中多截图,还请谅解.为了大家实验方便,在这里把实验相关的测试数据和安装包放在百度盘提供下载 

Spark入门实战系列--1.Spark及其生态圈简介

[注]该系列文章以及使用到安装包/测试数据 可以在<倾情大奉送--Spark入门实战系列>获取 1.简介 1.1 Spark简介 Spark是加州大学伯克利分校AMP实验室(Algorithms, Machines, and People Lab)开发通用内存并行计算框架.Spark在2013年6月进入Apache成为孵化项目,8个月后成为Apache顶级项目,速度之快足见过人之处,Spark以其先进的设计理念,迅速成为社区的热门项目,围绕着Spark推出了Spark SQL.Spark St

Spark 入门（Python、Scala 版）

本文中,我们将首先讨论如何在本地机器上利用Spark进行简单分析.然后,将在入门级水平探索Spark,了解Spark是什么以及它如何工作(希望可以激发更多探索).最后两节将开始通过命令行与Spark进行交互,然后演示如何用Python写Spark应用,并作为Spark作业提交到集群上.同时也会提供相应的 Scala 版本. 1.设置Spark环境 在本机设置和运行Spark非常简单.你只需要下载一个预构建的包,只要你安装了Java 6+和Python 2.6+,就可以在Windows.Mac O

Spark入门——什么是Hadoop，为什么是Spark?

#Spark入门#这个系列课程,是综合于我从2017年3月分到今年7月份为止学习并使用Spark的使用心得感悟,暂定于每周更新,以后可能会上传讲课视频和PPT,目前先在博客园把稿子打好.注意:这只是一个草稿,里面关于知识的误解还请各大网友监督,我们互相进步.总而言之,网络上的知识学会断舍离,学会带着辩证的眼光去学习就能进步. 谈到Spark,实际上从16年本科实习的时候就已经开始接触,那个时候是从Pig入门大数据Hadoop的,有兴趣的朋友可以看Hadoop家族之Pig入门:当时大家基本都在使用

Spark入门(Python)

Hadoop是对大数据集进行分布式计算的标准工具,这也是为什么当你穿过机场时能看到”大数据(Big Data)”广告的原因.它已经成为大数据的操作系统,提供了包括工具和技巧在内的丰富生态系统,允许使用相对便宜的商业硬件集群进行超级计算机级别的计算.2003和2004年,两个来自Google的观点使Hadoop成为可能:一个分布式存储框架(Google文件系统),在Hadoop中被实现为HDFS:一个分布式计算框架(MapReduce). 这两个观点成为过去十年规模分析(scaling analy