Java 如何从Kafka访问记录中的文件路径并从中创建数据集？

我正在使用Java

我正在通过Kafka消息接收文件路径。我需要将这个文件加载到spark RDD中，处理它，然后将它转储到HDFS中

我能够从Kafka消息中检索文件路径。我希望在这个文件上创建一个dataset/RDD

我无法在Kafka消息数据集上运行映射函数。它与NPE一起出错，因为

sparkContext

在worker上不可用

我无法在卡夫卡消息数据集上运行

foreach

。它会出错并显示以下消息：

Queries with streaming sources must be executed with writeStream.start();" 

我无法

收集

从卡夫卡消息数据集收到的数据，因为它与消息错误

Queries with streaming sources must be executed with writeStream.start();;

我猜这一定是一个非常通用的用例，必须在很多设置中运行

如何从Kafka消息中接收的路径将文件作为RDD加载

SparkSession spark = SparkSession.builder()
.appName("MyKafkaStreamReader")
    .master("local[4]")
.config("spark.executor.memory", "2g")
.getOrCreate();

// Create DataSet representing the stream of input lines from kafka
Dataset<String> kafkaValues = spark.readStream()
.format("kafka")
    .option("spark.streaming.receiver.writeAheadLog.enable", true)
    .option("kafka.bootstrap.servers", Configuration.KAFKA_BROKER)
    .option("subscribe", Configuration.KAFKA_TOPIC)
    .option("fetchOffset.retryIntervalMs", 100)
    .option("checkpointLocation", "file:///tmp/checkpoint")
.load()
    .selectExpr("CAST(value AS STRING)").as(Encoders.STRING());

Dataset<String> messages = kafkaValues.map(x -> {
  ObjectMapper mapper = new ObjectMapper();
  String m = mapper.readValue(x.getBytes(), String.class);
  return m;
}, Encoders.STRING() );

// ====================
// TEST 1 : FAILS
// ====================    
// CODE TRYING TO execute MAP on the received RDD 
// This fails with a Null pointer exception because "spark" is not available on worker node

/*
Dataset<String> statusRDD = messages.map(message -> {

  // BELOW STATEMENT FAILS
  Dataset<Row> fileDataset = spark.read().option("header", "true").csv(message); 
  Dataset<Row> dedupedFileDataset = fileDataset.dropDuplicates();
  dedupedFileDataset.rdd().saveAsTextFile(getHdfsLocation());
  return getHdfsLocation();

}, Encoders.STRING());

  StreamingQuery query2 = statusRDD.writeStream().outputMode("append").format("console").start();
  */

// ====================    
// TEST 2 : FAILS
// ====================    
// CODE BELOW FAILS WITH EXCEPTION 
// "Queries with streaming sources must be executed with writeStream.start();;"
// Hence, processing the deduplication on the worker side using
/*
JavaRDD<String> messageRDD = messages.toJavaRDD();

messageRDD.foreach( message -> {

  Dataset<Row> fileDataset = spark.read().option("header", "true").csv(message);
  Dataset<Row> dedupedFileDataset = fileDataset.dropDuplicates();
  dedupedFileDataset.rdd().saveAsTextFile(getHdfsLocation());

});
*/

// ====================    
// TEST 3 : FAILS
// ====================
// CODE TRYING TO COLLECT ALSO FAILS WITH EXCEPTION
// "Queries with streaming sources must be executed with writeStream.start();;"
// List<String> mess = messages.collectAsList();

SparkSession spark=SparkSession.builder（）
.appName（“MyKafkaStreamReader”）
.master（“本地[4]”）
.config（“spark.executor.memory”，“2g”）
.getOrCreate（）；
//创建表示kafka输入行流的数据集
数据集kafkaValues=spark.readStream（）
.格式（“卡夫卡”）
.option（“spark.streaming.receiver.writeahedlog.enable”，true）
.option（“kafka.bootstrap.servers”，Configuration.kafka\u BROKER）
.option（“订阅”，配置.KAFKA_主题）
.option（“fetchOffset.retryIntervalMs”，100）
.选项（“检查点位置”file:///tmp/checkpoint")
.load（）
.selectExpr（“转换（值为字符串）”）.AS（Encoders.STRING（））；
数据集消息=kafkaValues.map（x->{
ObjectMapper mapper=新的ObjectMapper（）；
String m=mapper.readValue（x.getBytes（），String.class）；
返回m；
}，Encoders.STRING（））；
// ====================
//测试1：失败
// ====================    
//试图在收到的RDD上执行MAP的代码
//此操作失败，出现空指针异常，因为“spark”在工作节点上不可用
/*
数据集状态RDD=messages.map（message->{
//下面的语句失败
Dataset fileDataset=spark.read（）.option（“header”，“true”）.csv（消息）；
Dataset DuplicatedFileDataSet=fileDataset.dropDuplicates（）；
duplicatedFileDataSet.rdd（）.saveAsTextFile（getHdfsLocation（））；
返回getHdfsLocation（）；
}，Encoders.STRING（））；
StreamingQuery query2=statusRDD.writeStream（）.outputMode（“追加”）.format（“控制台”）.start（）；
*/
// ====================    
//测试2：失败
// ====================    
//下面的代码异常失败
//“必须使用writeStream.start（）；；执行具有流媒体源的查询”
//因此，在工作端使用
/*
JavaRDD messageRDD=messages.toJavaRDD（）；
messageRDD.foreach（消息->{
Dataset fileDataset=spark.read（）.option（“header”，“true”）.csv（消息）；
Dataset DuplicatedFileDataSet=fileDataset.dropDuplicates（）；
duplicatedFileDataSet.rdd（）.saveAsTextFile（getHdfsLocation（））；
});
*/
// ====================    
//测试3：失败
// ====================
//尝试收集的代码也失败，出现异常
//“必须使用writeStream.start（）；；执行具有流媒体源的查询”
//List mess=messages.collectAsList（）；

---

有没有关于如何读取、创建文件路径和在文件上创建RDD的想法？

在结构化流媒体中，我认为没有一种方法可以具体化一个流中的数据，将其用作数据集操作的参数

在Spark生态系统中，这可以通过结合Spark流和Spark SQL（数据集）实现。我们可以使用Spark Streaming来使用Kafka主题，然后使用Spark SQL加载相应的数据并应用所需的过程

这样的工作大致如下：（这是在Scala中，Java代码将遵循相同的结构。只是实际的代码更详细一些）

---

我不认为您可以使用结构化流来实现这个用例。将Spark Streaming与

Direct

kafka消费者一起使用。您可以在常规的

foreachRDD

操作中实现自定义文件加载逻辑。我有一个类似的问题，这个问题在这段时间内发生了变化，还是解决方案直到今天仍然坚持这样做？@Stefn在结构化流媒体中实现流的具体化是不可能的。您可以使用新的

foreachBatch

函数以类似的方式加载数据，如图所示，然后将数据放入一个中间主题，您可以从另一份工作中使用，我必须实现类似于此问题的功能。使用

foreachBatch

为我解决了这个问题，我还检查了伸缩性，它在每个微批次上的伸缩性都非常好！

// configure and create spark Session

val spark = SparkSession
    .builder
    .config(...)
    .getOrCreate()

// create streaming context with a 30-second interval - adjust as required
val streamingContext = new StreamingContext(spark.sparkContext, Seconds(30))

// this uses Kafka080 client. Kafka010 has some subscription differences

val kafkaParams = Map[String, String](
  "metadata.broker.list" -> kafkaBootstrapServer,
  "group.id" -> "job-group-id",
  "auto.offset.reset" -> "largest",
  "enable.auto.commit" -> (false: java.lang.Boolean).toString
)

// create a kafka direct stream
val topics = Set("topic")
val stream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
     streamingContext, kafkaParams, topics)

// extract the values from the kafka message
val dataStream = stream.map{case (id, data) => data}     

// process the data
dataStream.foreachRDD { dataRDD => 
  // get all data received in the current interval
  // We are assuming that this data fits in memory. 
  // We're not processing a million files per second, are we?
  val files = dataRDD.collect()
  files.foreach{ file => 
    // this is the process proposed in the question --
    // notice how we have access to the spark session in the context of the foreachRDD
    val fileDataset = spark.read().option("header", "true").csv(file) 
    val dedupedFileDataset = fileDataset.dropDuplicates()
    // this can probably be written in terms of the dataset api
    //dedupedFileDataset.rdd().saveAsTextFile(getHdfsLocation());
    dedupedFileDataset.write.format("text").mode("overwrite").save(getHdfsLocation())
  }
}

// start the streaming process
streamingContext.start()
streamingContext.awaitTermination()