inputdstream mysql_Stream的output操作以及foreachRDD详解

output操作OutputMeaningprint打印每个batch中的前10个元素，主要用于测试，或者是不需要执行什么output操作时，用于简单触发一下job。

saveAsTextFile(prefix, [suffix])将每个batch的数据保存到文件中。每个batch的文件的命名格式为：prefix-TIME_IN_MS[.suffix]

saveAsObjectFile同上，但是将每个batch的数据以序列化对象的方式，保存到SequenceFile中。

saveAsHadoopFile同上，将数据保存到Hadoop文件中

foreachRDD最常用的output操作，遍历DStream中的每个产生的RDD，进行处理。可以将每个RDD中的数据写入外部存储，比如文件、数据库、缓存等。通常在其中，是针对RDD执行action操作的，比如foreach。DStream中的所有计算，都是由output操作触发的，比如print()。如果没有任何output操作，那么，压根儿就不会执行定义的计算逻辑。

此外，即使你使用了foreachRDD output操作，也必须在里面对RDD执行action操作，才能触发对每一个batch的计算逻辑。否则，光有foreachRDD output操作，在里面没有对RDD执行action操作，也不会触发任何逻辑。

foreachRDD详解通常在foreachRDD中，都会创建一个Connection，比如JDBC Connection，然后通过Connection将数据写入外部存储。

误区一：在RDD的foreach操作外部，创建Connection

这种方式是错误的，因为它会导致Connection对象被序列化后传输到每个Task中。而这种Connection对象，实际上一般是不支持序列化的，也就无法被传输。dstream.foreachRDD { rdd =>

val connection = createNewConnection()

rdd.foreach { record => connection.send(record)

}

}

误区二：在RDD的foreach操作内部，创建Connection

这种方式是可以的，但是效率低下。因为它会导致对于RDD中的每一条数据，都创建一个Connection对象。而通常来说，Connection的创建，是很消耗性能的。dstream.foreachRDD { rdd =>

rdd.foreach { record =>

val connection = createNewConnection()

connection.send(record)

connection.close()

}

}合理方式一 ：使用RDD的foreachPartition操作，并且在该操作内部，创建Connection对象，这样就相当于是，为RDD的每个partition创建一个Connection对象，节省资源的多了。dstream.foreachRDD { rdd =>

rdd.foreachPartition { partitionOfRecords =>

val connection = createNewConnection()

partitionOfRecords.foreach(record => connection.send(record))

connection.close()

}

}合理方式二：自己手动封装一个静态连接池，使用RDD的foreachPartition操作，并且在该操作内部，从静态连接池中，通过静态方法，获取到一个连接，使用之后再还回去。这样的话，甚至在多个RDD的partition之间，也可以复用连接了。而且可以让连接池采取懒创建的策略，并且空闲一段时间后，将其释放掉。dstream.foreachRDD { rdd =>

rdd.foreachPartition { partitionOfRecords =>

val connection = ConnectionPool.getConnection()

partitionOfRecords.foreach(record => connection.send(record))

ConnectionPool.returnConnection(connection)

}

}

案例：改写UpdateStateByKeyWordCount，将每次统计出来的全局的单词计数，写入一份，到MySQL数据库中。

java实例代码package cn.spark.study.streaming;

import java.sql.Connection;

import java.sql.Statement;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import org.apache.spark.SparkConf;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.function.FlatMapFunction;

import org.apache.spark.api.java.function.Function;

import org.apache.spark.api.java.function.Function2;

import org.apache.spark.api.java.function.PairFunction;

import org.apache.spark.api.java.function.VoidFunction;

import org.apache.spark.streaming.Durations;

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

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

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

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

import com.google.common.base.Optional;

import scala.Tuple2;

/**

* 基于持久化机制的实时wordcount程序

* @author Administrator

*

*/

public class PersistWordCount {

public static void main(String[] args) {

SparkConf conf = new SparkConf()

.setMaster("local[2]")

.setAppName("PersistWordCount");

JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5));

jssc.checkpoint("hdfs://spark1:9000/wordcount_checkpoint");

JavaReceiverInputDStream lines = jssc.socketTextStream("spark1", 9999);

JavaDStream words = lines.flatMap(new FlatMapFunction() {

private static final long serialVersionUID = 1L;

@Override

public Iterable call(String line) throws Exception {

return Arrays.asList(line.split(" "));

}

});

JavaPairDStream pairs = words.mapToPair(

new PairFunction() {

private static final long serialVersionUID = 1L;

@Override

public Tuple2 call(String word)

throws Exception {

return new Tuple2(word, 1);

}

});

JavaPairDStream wordCounts = pairs.updateStateByKey(

new Function2, Optional, Optional>() {

private static final long serialVersionUID = 1L;

@Override

public Optional call(List values,

Optional state) throws Exception {

Integer newValue = 0;

if(state.isPresent()) {

newValue = state.get();

}

for(Integer value : values) {

newValue += value;

}

return Optional.of(newValue);

}

});

// 每次得到当前所有单词的统计次数之后，将其写入mysql存储，进行持久化，以便于后续的J2EE应用程序

// 进行显示

wordCounts.foreachRDD(new Function, Void>() {

private static final long serialVersionUID = 1L;

@Override

public Void call(JavaPairRDD wordCountsRDD) throws Exception {

// 调用RDD的foreachPartition()方法

wordCountsRDD.foreachPartition(new VoidFunction>>() {

private static final long serialVersionUID = 1L;

@Override

public void call(Iterator> wordCounts) throws Exception {

// 给每个partition，获取一个连接

Connection conn = ConnectionPool.getConnection();

// 遍历partition中的数据，使用一个连接，插入数据库

Tuple2 wordCount = null;

while(wordCounts.hasNext()) {

wordCount = wordCounts.next();

String sql = "insert into wordcount(word,count) "

+ "values('" + wordCount._1 + "'," + wordCount._2 + ")";

Statement stmt = conn.createStatement();

stmt.executeUpdate(sql);

}

// 用完以后，将连接还回去

ConnectionPool.returnConnection(conn);

}

});

return null;

}

});

jssc.start();

jssc.awaitTermination();

jssc.close();

}

}建表语句create table wordcount (

id integer auto_increment primary key,

updated_time timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP,

word varchar(255),

count integer

);

与Spark SQL结合使用Spark Streaming最强大的地方在于，可以与Spark Core、Spark SQL整合使用，之前已经通过transform、foreachRDD等算子看到，如何将DStream中的RDD使用Spark Core执行批处理操作。现在就来看看，如何将DStream中的RDD与Spark SQL结合起来使用。

案例：每隔10秒，统计最近60秒的，每个种类的每个商品的点击次数，然后统计出每个种类top3热门的商品。

Java版本实例代码package cn.spark.study.streaming;

import java.util.ArrayList;

import java.util.List;

import org.apache.spark.SparkConf;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.JavaRDD;

import org.apache.spark.api.java.function.Function;

import org.apache.spark.api.java.function.Function2;

import org.apache.spark.api.java.function.PairFunction;

import org.apache.spark.sql.DataFrame;

import org.apache.spark.sql.Row;

import org.apache.spark.sql.RowFactory;

import org.apache.spark.sql.hive.HiveContext;

import org.apache.spark.sql.types.DataTypes;

import org.apache.spark.sql.types.StructField;

import org.apache.spark.sql.types.StructType;

import org.apache.spark.streaming.Durations;

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

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

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

import scala.Tuple2;

/**

* 与Spark SQL整合使用，top3热门商品实时统计

* @author Administrator

*

*/

public class Top3HotProduct {

public static void main(String[] args) {

SparkConf conf = new SparkConf()

.setMaster("local[2]")

.setAppName("Top3HotProduct");

@SuppressWarnings("resource")

JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(1));

// 首先看一下，输入日志的格式

// leo iphone mobile_phone

// 首先，获取输入数据流

// 这里顺带提一句，之前没有讲过，就是说，我们的Spark Streaming的案例为什么都是基于socket的呢？

// 因为方便啊。。。

// 其实，企业里面，真正最常用的，都是基于Kafka这种数据源

// 但是我觉得我们的练习，用socket也无妨，比较方便，而且一点也不影响学习

// 因为不同的输入来源的，不同之处，只是在创建输入DStream的那一点点代码

// 所以，核心是在于之后的Spark Streaming的实时计算

// 所以只要我们掌握了各个案例和功能的使用

// 在企业里，切换到Kafka，易如反掌把，因为我们之前都详细讲过，而且实验过，实战编码过，将Kafka作为

// 数据源的两种方式了

// 获取输入数据流

JavaReceiverInputDStream productClickLogsDStream = jssc.socketTextStream("spark1", 9999);

// 然后，应该是做一个映射，将每个种类的每个商品，映射为(category_product, 1)的这种格式

// 从而在后面可以使用window操作，对窗口中的这种格式的数据，进行reduceByKey操作

// 从而统计出来，一个窗口中的每个种类的每个商品的，点击次数

JavaPairDStream categoryProductPairsDStream = productClickLogsDStream

.mapToPair(new PairFunction() {

private static final long serialVersionUID = 1L;

@Override

public Tuple2 call(String productClickLog)

throws Exception {

String[] productClickLogSplited = productClickLog.split(" ");

return new Tuple2(productClickLogSplited[2] + "_" +

productClickLogSplited[1], 1);

}

});

// 然后执行window操作

// 到这里，就可以做到，每隔10秒钟，对最近60秒的数据，执行reduceByKey操作

// 计算出来这60秒内，每个种类的每个商品的点击次数

JavaPairDStream categoryProductCountsDStream =

categoryProductPairsDStream.reduceByKeyAndWindow(

new Function2() {

private static final long serialVersionUID = 1L;

@Override

public Integer call(Integer v1, Integer v2) throws Exception {

return v1 + v2;

}

}, Durations.seconds(60), Durations.seconds(10));

// 然后针对60秒内的每个种类的每个商品的点击次数

// foreachRDD，在内部，使用Spark SQL执行top3热门商品的统计

categoryProductCountsDStream.foreachRDD(new Function, Void>() {

private static final long serialVersionUID = 1L;

@Override

public Void call(JavaPairRDD categoryProductCountsRDD) throws Exception {

// 将该RDD，转换为JavaRDD的格式

JavaRDD categoryProductCountRowRDD = categoryProductCountsRDD.map(

new Function, Row>() {

private static final long serialVersionUID = 1L;

@Override

public Row call(Tuple2 categoryProductCount)

throws Exception {

String category = categoryProductCount._1.split("_")[0];

String product = categoryProductCount._1.split("_")[1];

Integer count = categoryProductCount._2;

return RowFactory.create(category, product, count);

}

});

// 然后，执行DataFrame转换

List structFields = new ArrayList();

structFields.add(DataTypes.createStructField("category", DataTypes.StringType, true));

structFields.add(DataTypes.createStructField("product", DataTypes.StringType, true));

structFields.add(DataTypes.createStructField("click_count", DataTypes.IntegerType, true));

StructType structType = DataTypes.createStructType(structFields);

HiveContext hiveContext = new HiveContext(categoryProductCountsRDD.context());

DataFrame categoryProductCountDF = hiveContext.createDataFrame(

categoryProductCountRowRDD, structType);

// 将60秒内的每个种类的每个商品的点击次数的数据，注册为一个临时表

categoryProductCountDF.registerTempTable("product_click_log");

// 执行SQL语句，针对临时表，统计出来每个种类下，点击次数排名前3的热门商品

DataFrame top3ProductDF = hiveContext.sql(

"SELECT category,product,click_count "

+ "FROM ("

+ "SELECT "

+ "category,"

+ "product,"

+ "click_count,"

+ "row_number() OVER (PARTITION BY category ORDER BY click_count DESC) rank "

+ "FROM product_click_log"

+ ") tmp "

+ "WHERE rank<=3");

// 这里说明一下，其实在企业场景中，可以不是打印的

// 案例说，应该将数据保存到redis缓存、或者是mysql db中

// 然后，应该配合一个J2EE系统，进行数据的展示和查询、图形报表

top3ProductDF.show();

return null;

}

});

jssc.start();

jssc.awaitTermination();

jssc.close();

}

}

Scala版本实例代码package cn.spark.study.streaming

import org.apache.spark.SparkConf

import org.apache.spark.streaming.StreamingContext

import org.apache.spark.streaming.Seconds

import org.apache.spark.sql.Row

import org.apache.spark.sql.types.StructType

import org.apache.spark.sql.types.StructField

import org.apache.spark.sql.types.StringType

import org.apache.spark.sql.types.IntegerType

import org.apache.spark.sql.hive.HiveContext

/**

* @author Administrator

*/

object Top3HotProduct {

def main(args: Array[String]): Unit = {

val conf = new SparkConf()

.setMaster("local[2]")

.setAppName("Top3HotProduct")

val ssc = new StreamingContext(conf, Seconds(1))

val productClickLogsDStream = ssc.socketTextStream("spark1", 9999)

val categoryProductPairsDStream = productClickLogsDStream

.map { productClickLog => (productClickLog.split(" ")(2) + "_" + productClickLog.split(" ")(1), 1)}

val categoryProductCountsDStream = categoryProductPairsDStream.reduceByKeyAndWindow(

(v1: Int, v2: Int) => v1 + v2,

Seconds(60),

Seconds(10))

categoryProductCountsDStream.foreachRDD(categoryProductCountsRDD => {

val categoryProductCountRowRDD = categoryProductCountsRDD.map(tuple => {

val category = tuple._1.split("_")(0)

val product = tuple._1.split("_")(1)

val count = tuple._2

Row(category, product, count)

})

val structType = StructType(Array(

StructField("category", StringType, true),

StructField("product", StringType, true),

StructField("click_count", IntegerType, true)))

val hiveContext = new HiveContext(categoryProductCountsRDD.context)

val categoryProductCountDF = hiveContext.createDataFrame(categoryProductCountRowRDD, structType)

categoryProductCountDF.registerTempTable("product_click_log")

val top3ProductDF = hiveContext.sql(

"SELECT category,product,click_count "

+ "FROM ("

+ "SELECT "

+ "category,"

+ "product,"

+ "click_count,"

+ "row_number() OVER (PARTITION BY category ORDER BY click_count DESC) rank "

+ "FROM product_click_log"

+ ") tmp "

+ "WHERE rank<=3")

top3ProductDF.show()

})

ssc.start()

ssc.awaitTermination()

}

}