SparkStream：4)foreachRDD详解

转载自：http://blog.csdn.net/jiangpeng59/article/details/53318761

foreachRDD通常用来把SparkStream运行得到的结果保存到外部系统比如HDFS、Mysql、Redis等等。了解下面的知识可以帮助我们避免很多误区

误区1：实例化外部连接对象的位置不正确，比如下面代码

1. dstream.foreachRDD { rdd =>
2. val connection = createNewConnection()  // executed at the driver
3. rdd.foreach { record =>
4. connection.send(record) // executed at the worker
5. }
6. }  ​

其实例化的连接对象在driver中，然后通过序列化的方式发送到各个Worker，但实际上Connection的序列化通常是无法正确序列化的

误区2：为每条记录都创建一个连接对象

1. dstream.foreachRDD { rdd =>
2. rdd.foreach { record =>
3. val connection = createNewConnection()
4. connection.send(record)
5. connection.close()
6. }
7. }  ​

虽然误区1的问题得到了解决，但通常情况下，外部系统如mysql，其连接对象是非常可贵的，如果一条记录就申请一个连接资源，系统性能会非常糟糕

然后，给出了一个比较好的方法，为每一个分区创建一个连接对象，其具体代码如下

 

1. dstream.foreachRDD { rdd =>
2. rdd.foreachPartition { partitionOfRecords =>
3. val connection = createNewConnection()
4. partitionOfRecords.foreach(record => connection.send(record))
5. connection.close()
6. }
7. }  ​

最后给出一个较优的方案，使用一个连接池来维护连接对象

 

1. dstream.foreachRDD { rdd =>
2. rdd.foreachPartition { partitionOfRecords =>
3. // ConnectionPool is a static, lazily initialized pool of connections
4. val connection = ConnectionPool.getConnection()
5. partitionOfRecords.foreach(record => connection.send(record))
6. ConnectionPool.returnConnection(connection)  // return to the pool for future reuse
7. }
8. }  ​

正如上面代码阐述的，连接对象推荐是使用lazy关键字来修饰，用到的时候才去实例化

下面给出网上一段把SparkStream的结果保存到Mysql中的代码示例

1. package spark.examples.streaming
2. import java.sql.{PreparedStatement, Connection, DriverManager}
3. import java.util.concurrent.atomic.AtomicInteger
4. import org.apache.spark.SparkConf
5. import org.apache.spark.streaming.{Seconds, StreamingContext}
6. import org.apache.spark.streaming._
7. import org.apache.spark.streaming.StreamingContext._
8. object SparkStreamingForPartition {
9. def main(args: Array[String]) {
10. val conf = new SparkConf().setAppName("NetCatWordCount")
11. conf.setMaster("local[3]")
12. val ssc = new StreamingContext(conf, Seconds(5))
13. //The DStream is a collection of RDD, which makes the method foreachRDD reasonable
14. val dstream = ssc.socketTextStream("192.168.26.140", 9999)
15. dstream.foreachRDD(rdd => {
16. //embedded function
17. def func(records: Iterator[String]) {
18. var conn: Connection = null
19. var stmt: PreparedStatement = null
20. try {
21. val url = "jdbc:mysql://192.168.26.140:3306/person";
22. val user = "root";
23. val password = ""
24. conn = DriverManager.getConnection(url, user, password)
25. records.flatMap(_.split(" ")).foreach(word => {
26. val sql = "insert into TBL_WORDS(word) values (?)";
27. stmt = conn.prepareStatement(sql);
28. stmt.setString(1, word)
29. stmt.executeUpdate();
30. })
31. } catch {
32. case e: Exception => e.printStackTrace()
33. } finally {
34. if (stmt != null) {
35. stmt.close()
36. }
37. if (conn != null) {
38. conn.close()
39. }
40. }
41. }
42. val repartitionedRDD = rdd.repartition(3)
43. repartitionedRDD.foreachPartition(func)
44. })
45. ssc.start()
46. ssc.awaitTermination()
47. }
48. }  ​

注意的细节：

Dstream和RDD一样是延迟执行，只有遇到action操作才会真正去计算。因此在Dstream的内部RDD必须包含Action操作才能是接受到的数据得到处理。即使代码中包含foreachRDD,但在内部却没有action的RDD，SparkStream只会简单地接受数据数据而不进行处理