SparkStreamin-DStream的输出操作以及foreachRDD详解

输出操作概览

在Spark应用中，外部系统经常需要使用到SparkStreaming处理后的数据，因此，需要采用输出操作把DStream的数据输出到数据库或者文件系统中。

Output	Meaning
print	打印每个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将数据写入外部存储。
我们可以采用以下两种方式来建立连接：
(1) 使用RDD的foreachPartition操作
使用RDD的foreachPartition操作，并且在该操作内部，创建Connection对象，这样就相当于是，为RDD的每个partition创建一个Connection对象，好处是节省资源。

dstream.foreachRDD { rdd =>
  rdd.foreachPartition { partitionOfRecords =>
    val connection = createNewConnection()
    partitionOfRecords.foreach(record => connection.send(record))
    connection.close()
  }
}

(2) 使用连接池
封装一个静态连接池，使用RDD的foreachPartition操作，并且在该操作内部，从静态连接池中，通过静态方法，获取到一个连接，使用之后再还回去。这样的话，甚至在多个RDD的partition之间，也可以复用连接了。而且可以让连接池采取懒创建的策略，并且空闲一段时间后，将其释放掉。

这里我就第二种方法写一个连接MySQL数据库的代码实例：

1. 手动实现一个静态连接池

public class ConnectionPool { 
  // 静态的Connection队列
  private static LinkedList<Connection> connectionQueue;
 
//加载驱动
  static {
    try {
      Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
 
  // 获取连接，多线程访问并发控制
  public synchronized static Connection getConnection() {
    try {
      if (connectionQueue == null) {
        connectionQueue = new LinkedList<Connection>();
        for (int i = 0; i < 10; i++) {
          Connection conn = DriverManager.getConnection("jdbc:mysql://spark1:3306/testdb", "", "");
          connectionQueue.push(conn);
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return connectionQueue.poll();
  }
 
  // 还回去一个连接
  public static void returnConnection(Connection conn) {
    connectionQueue.push(conn);
  } 
}

2. foreachRDD操作实例

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)); 
    // 开启checkpoint机制
    jssc.checkpoint("hdfs://spark1:9000/wordcount_checkpoint"); 
    JavaReceiverInputDStream<String> lines = jssc.socketTextStream("spark1", 9999); 
    JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() { 
      private static final long serialVersionUID = 1L; 
      @Override
      public Iterable<String> call(String line) throws Exception {
        return Arrays.asList(line.split(" "));
      } 
    });
 
    JavaPairDStream<String, Integer> pairs = words.mapToPair( 
        new PairFunction<String, String, Integer>() { 
          private static final long serialVersionUID = 1L; 
          @Override
          public Tuple2<String, Integer> call(String word) throws Exception {
            return new Tuple2<String, Integer>(word, 1);
          } 
        });
 
    JavaPairDStream<String, Integer> wordCounts = pairs.updateStateByKey( 
        new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() { 
          private static final long serialVersionUID = 1L; 
          @Override
          public Optional<Integer> call(List<Integer> values, Optional<Integer> 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<JavaPairRDD<String, Integer>, Void>() { 
      private static final long serialVersionUID = 1L;
       @Override
      public Void call(JavaPairRDD<String, Integer> wordCountsRDD) throws Exception {
        // 调用RDD的foreachPartition()方法
        wordCountsRDD.foreachPartition(new VoidFunction<Iterator<Tuple2<String, Integer>>>() {
           private static final long serialVersionUID = 1L; 
          @Override
          public void call(Iterator<Tuple2<String, Integer>> wordCounts) throws Exception {
            // 给每个partition，获取一个连接
            Connection conn = ConnectionPool.getConnection(); 
            // 遍历partition中的数据，使用一个连接，插入数据库
            Tuple2<String, Integer> 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();
  } 
}

还可以scala编写数据库连接，主要代码如下所示：

stateDstream.foreachRDD(rdd => {
      //内部函数
      def func(records: Iterator[(String,Int)]) {
        var conn: Connection = null
        var stmt: PreparedStatement = null
        try {
          val url = "jdbc:mysql://localhost:3306/spark"
          val user = "root"
          val password = "hadoop"
          conn = DriverManager.getConnection(url, user, password)
          records.foreach(p => {
            val sql = "insert into wordcount(word,count) values (?,?)"
            stmt = conn.prepareStatement(sql)
            stmt.setString(1, p._1.trim)
            stmt.setInt(2,p._2.toInt)
            stmt.executeUpdate()
          })
        } catch {
          case e: Exception => e.printStackTrace()
        } finally {
          if (stmt != null) {
            stmt.close()
          }
          if (conn != null) {
            conn.close()
          }
        }
      }
      val repartitionedRDD = rdd.repartition(3)
      repartitionedRDD.foreachPartition(func)
})