Scala Spark streaming-转换两个流并连接_Scala_Apache Spark_Spark Streaming_Scala Collections

Scala Spark streaming-转换两个流并连接

scala apache-spark

Scala Spark streaming-转换两个流并连接,scala,apache-spark,spark-streaming,scala-collections,Scala,Apache Spark,Spark Streaming,Scala Collections,我遇到了一个问题，我需要在加入之前转换两个从spark读取的流一旦我做了转换，我就不能再加入了，我猜类型不再是DStream[（String，String）]，而是DStream[Map[String，String]] val windowStream1 = act1Stream.window(Seconds(5)).transform{rdd => rdd.map(_._2).map(l =>(...toMap)} val windowStream2 = act2Stream.w

我遇到了一个问题，我需要在加入之前转换两个从spark读取的流

一旦我做了转换，我就不能再加入了，我猜类型不再是DStream[（String，String）]，而是DStream[Map[String，String]]

val windowStream1 = act1Stream.window(Seconds(5)).transform{rdd => rdd.map(_._2).map(l =>(...toMap)}
val windowStream2 = act2Stream.window(Seconds(5)).transform{rdd => rdd.map(_._2).map(l =>(...toMap)}

val joinedWindow = windowStream1.join(windowStream2)  //can't join

有什么想法吗？

这并不能解决你的问题，但会让你的问题更容易消化。通过使用预期类型定义时态val/def/var标识符，可以拆分方法链并记录每个步骤中预期的类型。通过这种方式，您可以很容易地发现类型不再符合您的期望

例如，我希望您的

act1Stream

和

act2Stream

实例属于

DStream[（String，String）]

类型，我现在将其称为

s1

和

s2

。如果不是这样，请评论我

def joinedWindow(
      s1: DStream[(String, String)], 
      s2: DStream[(String, String)]
    ): DStream[...] = {
  val w1 = windowedStream(s1)
  val w2 = windowedStream(s2)
  w1.join(w2)
}
def windowedStream(actStream: DStream[(String, String)]): DStream[Map[...]] = {
  val windowed: DStream[(String, String)] = actStream.window(Seconds(5))
  windowed.transform( myTransform )
}
def myTransform(rdd: RDD[(String, String)]): RDD[Map[...]] = {
  val mapped: RDD[String] = rdd.map(_._2)
  // not enough information to conclude 
  // the result type from given code
  mapped.map(l =>(...toMap)) 
}

从这里，您可以通过填写

…

部分来总结其余类型。逐行消除编译器错误，直到获得所需的结果。附

def窗口（windowDuration:Duration）：数据流[T]

def transform[U]（transformFunc:（RDD[T]）⇒ RDD[U]）（隐式arg0:ClassTag[U]）：数据流[U]

def join[W]（其他：数据流[（K，W）]）（隐式arg0:ClassTag[W]）：数据流[（K，（V，W））]

def映射[U]（f:（T）⇒ U） （隐式arg0:ClassTag[U]）：RDD[U]

至少通过这种方式，您可以确切地知道预期类型和生成的类型不匹配。

这并不能解决您的问题，但会使问题更易于理解。通过使用预期类型定义时态val/def/var标识符，可以拆分方法链并记录每个步骤中预期的类型。通过这种方式，您可以很容易地发现类型不再符合您的期望

例如，我希望您的

act1Stream

和

act2Stream

实例属于

DStream[（String，String）]

类型，我现在将其称为

s1

和

s2

。如果不是这样，请评论我

def joinedWindow(
      s1: DStream[(String, String)], 
      s2: DStream[(String, String)]
    ): DStream[...] = {
  val w1 = windowedStream(s1)
  val w2 = windowedStream(s2)
  w1.join(w2)
}
def windowedStream(actStream: DStream[(String, String)]): DStream[Map[...]] = {
  val windowed: DStream[(String, String)] = actStream.window(Seconds(5))
  windowed.transform( myTransform )
}
def myTransform(rdd: RDD[(String, String)]): RDD[Map[...]] = {
  val mapped: RDD[String] = rdd.map(_._2)
  // not enough information to conclude 
  // the result type from given code
  mapped.map(l =>(...toMap)) 
}

从这里，您可以通过填写

…

部分来总结其余类型。逐行消除编译器错误，直到获得所需的结果。附

def窗口（windowDuration:Duration）：数据流[T]

def transform[U]（transformFunc:（RDD[T]）⇒ RDD[U]）（隐式arg0:ClassTag[U]）：数据流[U]

def join[W]（其他：数据流[（K，W）]）（隐式arg0:ClassTag[W]）：数据流[（K，（V，W））]

def映射[U]（f:（T）⇒ U） （隐式arg0:ClassTag[U]）：RDD[U]

至少通过这种方式，您可以确切地知道预期类型和生成的类型不匹配。

是的，

act1Stream

和

act2Stream

属于

DStream[Map[String，String]]

类型，但让我在这里解释一下。我有两个不同类型的流

DStream[（String，String）]

，但是在加入之前，我需要对每个流进行转换，转换方法返回一个

DStream[Map[String，String]]

并且不能加入它…所以有没有办法加入两个流

DStream[Map[String，String]]

我不是火花专家，但是连接操作似乎只在

PairDStreamFunctions[K，V]

s上定义。签名告诉我，为了能够应用连接操作，您需要两个类型为

DStream[（K，V）]

的实例。也许你可以改变你的

转换

和内部

映射

s来返回

DStream[（String，map[String，String]）]

实例，如果这在你的用例中有意义的话……是的，

act1Stream

和

act2Stream

属于

DStream[map[String，String]]