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 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();
        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);
  } 
}
  1. 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 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();
  } 
}

还可以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)
})

你可能感兴趣的:(大数据,Spark)