Spark连接外部数据源解读

本文以连接HBase数据库为例，介绍Spark DataSource API的结构。项目源码：https://github.com/hortonworks-spark/shc 注：由于某些原因，尚无充裕时间进行更深入的解读，本文先着重数据源注册和写入两个流程，后续文章会继续跟进。本文原文出处: http://blog.csdn.net/bluishglc/article/details/52882250 严禁任何形式的转载，否则将委托CSDN官方维护权益！

注册流程

位置：org.apache.spark.sql.execution.datasources.hbase.examples.HBaseSource,Line：75

def withCatalog(cat: String): DataFrame = {  sqlContext    .read    .options(Map(HBaseTableCatalog.tableCatalog->cat))    .format("org.apache.spark.sql.execution.datasources.hbase")    .load()}

read方法会创建一个DataFrameReader实例并返回，后续的options和format是在为新创建的DataFrameReader实例注册相关信息，最终是通过load方法，在基于options和format传入的信息基础之上，初始化了一个DataFrame.

位置： org.apache.spark.sql.DataFrameReader#load， Line： 118

  def load(): DataFrame = {    val resolved = ResolvedDataSource(      sqlContext,      userSpecifiedSchema = userSpecifiedSchema,      partitionColumns = Array.empty[String],      provider = source,      options = extraOptions.toMap)    DataFrame(sqlContext, LogicalRelation(resolved.relation))  }

在创建DataFrame实例时，最重要的是需要传入一个LogicalRelation, 而LogicalRelation需要一个BaseRelation（对BaseRelation进行包裹），BaseRelation的主要用途是描述数据的Schema，这里的我们要传入的BaseRelation实例是通过ResolvedDataSource的apply方法创建的字段：relation, 这个relation的创建发生在：org.apache.spark.sql.execution.datasources.ResolvedDataSource#apply Line 153 - 158

      case None => clazz.newInstance() match {        case dataSource: RelationProvider =>          val caseInsensitiveOptions = new CaseInsensitiveMap(options)          if (caseInsensitiveOptions.contains("paths")) {            throw new AnalysisException(s"$className does not support paths option.")          }          dataSource.createRelation(sqlContext, caseInsensitiveOptions)

最终，这个Relation是通过org.apache.spark.sql.execution.datasources.hbase.DefaultSource#createRelation创建的(DefaultSource有两个createRelation方法，一个是for read, 一个是for write)，而这个Relation的实例是org.apache.spark.sql.execution.datasources.hbase.HBaseRelation.

到这里，我们可以简单小结一下：在Spark中注册和读取一个新的数据源，只需要我们给出数据源的Class路径和一些需要的参数，就像本例中options和format那样做就可以了。我们真正需要做的工作是提供RelationProvider和对应的Relation。

写入流程

位置：org.apache.spark.sql.execution.datasources.hbase.examples.HBaseSource#main Line： 85 - 91

val data = (0 to 255).map { i =>    HBaseRecord(i)}sc.parallelize(data).toDF.write.options(    Map(HBaseTableCatalog.tableCatalog -> cat, HBaseTableCatalog.newTable -> "5"))    .format("org.apache.spark.sql.execution.datasources.hbase")    .save()

有几处需要注意的地方：
- sc.parallelize(data)返回的是一个RDD，而toDF则是org.apache.spark.sql.DataFrameHolder的一个方法，很显然，这里发生了隐式转换。隐士转化是声明是发生在前面的一行代码里import sqlContext.implicits._ implicits是SQLContext类内部定义的一个object, 它本身并无过多的隐式转换定义，大量的隐式转换都定义在了它的父类org.apache.spark.sql.SQLImplicits里面，而我们上面的代码使用到的隐式转换正是org.apache.spark.sql.SQLImplicits#rddToDataFrameHolder,具体如下

implicit def rddToDataFrameHolder[A <: Product : TypeTag](rdd: RDD[A]): DataFrameHolder = {    DataFrameHolder(_sqlContext.createDataFrame(rdd))}

它将一个RDD隐式转化成为了DataFrameHolder，进而才能调用toDF方法去得到一个DataFrame。

从这个方法中我们可以看到这个DataFrame的创建最最终还是通过org.apache.spark.sql.SQLContext#createDataFrame方法实现的。看上去有些“绕”，这可能是版本在演化过程中的历史原因造成的。我们来具体看一下这个方法：

  def createDataFrame[A <: Product : TypeTag](rdd: RDD[A]): DataFrame = {    SQLContext.setActive(self)    val schema = ScalaReflection.schemaFor[A].dataType.asInstanceOf[StructType]    val attributeSeq = schema.toAttributes    val rowRDD = RDDConversions.productToRowRdd(rdd, schema.map(_.dataType))    DataFrame(self, LogicalRDD(attributeSeq, rowRDD)(self))  }

对于这个方法的一些细节我们先不做过多深入的探究，简单地总结起来就是：SQLContext提供了把RDD转换成DataFrame的方法，你只需要提供数据的Schema信息即可，如果你没有显示的提供Schema,SQLContext在进行parallelize操作把数据transform成RDD时会根据传入的数据类型参数[T]以反射的方式获取Schema信息，在本例中传入的数据类型是：org.apache.spark.sql.execution.datasources.hbase.examples.HBaseRecord

DataFrame实例创建出出来之后，通过write方法创建了一个org.apache.spark.sql.DataFrameWriter实例，然后通过options和format为新创建的DataFrameWriter实例注册相关信息，最后通过save方法将DataFrame实例中的数据时保存起来。实际的保存动作是发生是依赖org.apache.spark.sql.execution.datasources.ResolvedDataSource#apply完成的。注意: ResolvedDataSource有两个重载的apply的方法，一个为读取服务的（这个方法前文已经提及）一个是为写入服务的，我们具体看一下这个为写入提供的apply方法：

    val relation = clazz.newInstance() match {      case dataSource: CreatableRelationProvider =>        dataSource.createRelation(sqlContext, mode, options, data)    ......    }    ResolvedDataSource(clazz, relation)  }

和读取的流程很类似，这个apply方法也要创建一个Relation，这个Relation是通过org.apache.spark.sql.execution.datasources.hbase.DefaultSource#createRelation创建的(DefaultSource有两个createRelation方法，一个是for read, 一个是for write)，让我们来看一下这个实际执行写入的方法：

  override def createRelation(    sqlContext: SQLContext,    mode: SaveMode,    parameters: Map[String, String],    data: DataFrame): BaseRelation = {    val relation = HBaseRelation(parameters, Some(data.schema))(sqlContext)    relation.createTable()    relation.insert(data, false)    relation  }

在创建Relation的过程中，代码附带性的创建了Table，插入了数据。这一部分的设计不是很好，方法的目的不够单一，应该相应的改动一下。