spark官方文档之——Spark Streaming Programming Guid spark streaming编程指南

概述

spark streaming是core spark api的扩展，能够进行可伸缩的、高通量、容错的实时流处理。数据可来源于kafka，flume，twitter，zeromq，kinesis或tcp sockets，基于这些数据的复杂算法可用高层次函数，像map，reduce，join和window进行处理。最后，处理过的数据可被存储到文件系统，数据库和实时仪表盘上。实际上，你可以在数据流上进行spark的machine learning和graph processing。

它如下图工作。spark streaming接收到实时输入数据流，并把数据分批次，这些数据会被spark引擎分批次处理得到最后的结果。

spark streaming提供了一个高层次的抽象概念，称为分布式流或DStream，它代表一个源源不断的数据流。DStreams可以从像kafka，flume和kinesis的数据源创建得到，也可以在其他DStreams进行操作得到。DStream内部是一系列RDDs。

本指南向你展示了怎样用DStream来编写spark streaming程序。你可以用scala，java或python（spark 1.2引入）写spark streaming程序。（官方所有语言都有，但这里只翻译java版本）

一个例子

在怎样写你自己的spark streaming程序之前，让我们先看一下简单的spark streaming程序都长啥样。我们要计算监听一个tcp socket得到的文本数据的单词数，如下进行：

java：

首先，我们创建JavaStreamingContext对象，它是所有流处理函数的主要入口点。我们创建一个本地StreamingContext，两个线程运行，并间隔1s一个处理批次（接受1s的数据处理一次）。

import org.apache.spark.*;
import org.apache.spark.api.java.function.*;
import org.apache.spark.streaming.*;
import org.apache.spark.streaming.api.java.*;
import scala.Tuple2;

// Create a local StreamingContext with two working thread and batch interval of 1 second
SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(1))

使用这个context，我们可以创建一个数据流DStream，它来自于tcp source，并指定了主机名（例如localhost）和端口（例如9999）。

// Create a DStream that will connect to hostname:port, like localhost:9999
JavaReceiverInputDStream<String> lines = jssc.socketTextStream("localhost", 9999);

lines代表接收自数据服务器的数据流。这个流中的每个记录是一个文本行。然后，我们想把这行文本分离成单词。

// Split each line into words
JavaDStream<String> words = lines.flatMap(
  new FlatMapFunction<String, String>() {
    @Override public Iterable<String> call(String x) {
      return Arrays.asList(x.split(" "));
    }
  });

flatMap是创建一个新的DStream的DStream操作，它从源DStream的每个记录生成多个新的记录。在这种情况下，每行会被分成多个单词，由words表示。注意我们用FlatMapFunction对象定义了此转换过程。java api中还有很多这种类来帮助定义DStream transformtions。

接下来，我们想要计算单词数。

// Count each word in each batch
JavaPairDStream<String, Integer> pairs = words.mapToPair(
  new PairFunction<String, String, Integer>() {
    @Override public Tuple2<String, Integer> call(String s) {
      return new Tuple2<String, Integer>(s, 1);
    }
  });
JavaPairDStream<String, Integer> wordCounts = pairs.reduceByKey(
  new Function2<Integer, Integer, Integer>() {
    @Override public Integer call(Integer i1, Integer i2) {
      return i1 + i2;
    }
  });

// Print the first ten elements of each RDD generated in this DStream to the console
wordCounts.print();

words通过使用PairFunction对象，被映射（one-to-one的转换）为（word，1）键值对DStream。然后，使用Function2对象计算每个数据批次的单词数。最后，wordCounts.print（）会每秒打印一些单词数。

注意，spark streaming start之后这些代码行才执行。为了所有被建立的转换被执行，我们最后要调用start方法。

jssc.start();              // Start the computation
jssc.awaitTermination();   // Wait for the computation to terminate

完整的代码可在https://github.com/apache/spark/blob/master/examples/src/main/java/org/apache/spark/examples/streaming/JavaNetworkWordCount.java找到。

如果你已经下载并搭建了spark，你可以如下运行例程。你要首先运行Netcat（多数unix-like系统中有的小工具）作为数据服务器：

$ nc -lk 9999

然后，另一个终端中，如下开始例程：

$ ./bin/run-example streaming.JavaNetworkWordCount localhost 9999

然后，运行netcat服务的终端输入的行都会每秒被计算一次并打印在屏幕上，如下：

基本概念

接下来，详细讨论spark streaming的基础。

Linking

写spark streaming程序时，你要添加如下依赖库到你的SBT或Maven工程。

maven：

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.10</artifactId>
    <version>1.4.0</version>
</dependency>

sbt：

libraryDependencies += "org.apache.spark" % "spark-streaming_2.10" % "1.4.0"

若想使用来源于像kafka，flume，kinesis这些不存在于spark streaming api中的数据，你需要增加一些依赖库，例如如下一些：

Source	Artifact
Kafka	spark-streaming-kafka_2.10
Flume	spark-streaming-flume_2.10
Kinesis	spark-streaming-kinesis-asl_2.10 [Amazon Software License]
Twitter	spark-streaming-twitter_2.10
ZeroMQ	spark-streaming-zeromq_2.10
MQTT	spark-streaming-mqtt_2.10

初始化StreamingContext

初始化一个spark streaming程序，必须创建StreamingContext对象，它是所有spark streaming函数功能的主要入口点。

java：

JavaStreamingContext对象能够从一个SparkConf对象创建而来。

import org.apache.spark.*;
import org.apache.spark.streaming.api.java.*;

SparkConf conf = new SparkConf().setAppName(appName).setMaster(master);
JavaStreamingContext ssc = new JavaStreamingContext(conf, Duration(1000));

appName是显示在集群UI上的程序名。master是一个spark，mesos或yarn集群URL，或“local[n]”字符串（运行在本地模式）。实际上，当在一个集群上运行时，你不会想要把master硬编码到程序中，而是spark-submit指定。但是，对于本地测试和单元测试，你可以通过“local[n]”在一个进程中运行spark streaming（多个线程模拟集群）。注意，ssc.sparkContext可访问JavaSparkContext（所有spark功能函数的入口点）。

batch间隔要根据你的应用的延迟需要和可获得的集群资源来设置。更多请参考performance tuning章节。

JavaStreamingContext可从一个存在的JavaSparkContext对象创建。

import org.apache.spark.streaming.api.java.*;

JavaSparkContext sc = ...   //existing JavaSparkContext
JavaStreamingContext ssc = new JavaStreamingContext(sc, Durations.seconds(1));

在context创建之后，你要如下进行：

1.通过创建输入DStreams定义输入数据源。

2.

未完待续········