【Spark床头书系列】Spark SparkSession由来方法示例源码分析-优快云博客

Spark SparkSession由来方法示例源码分析点击这里免费看全文

文章目录

由来

SparkSession是由Apache Spark项目引入的一个概念。在Spark 2.0中，它取代了旧版本中的SQLContext和HiveContext，并成为与Spark集群交互的主要入口点。

在之前的版本中，SQLContext用于执行SQL查询和操作DataFrame，而HiveContext则提供了对Hive功能的支持。然而，这种分离导致了API的冗余和不一致性。

为了解决这些问题并提供更好的用户体验，SparkSession应运而生。它将SQLContext和HiveContext的功能合并到一个统一的接口中，并提供了更多的功能和便利性。

SparkSession的目标是为用户提供一个统一且一致的编程接口，无论是进行交互式数据探索、批处理作业还是流式处理任务，都能使用相同的代码模型和API。

通过SparkSession，用户可以创建DataFrame、执行SQL查询、读写数据、注册表、管理配置等。它还提供了更多的集成选项和功能扩展，例如对结构化流处理的支持。

总之，SparkSession是Apache Spark中用于与Spark集群交互的主要入口点，提供了统一的编程接口和丰富的功能，使得数据处理更加方便和高效。

方法示例

元数据管理：

catalog: Catalog：用于访问Spark会话的元数据信息，如数据库、表等。

val catalog: Catalog = spark.catalog

配置管理：

conf: RuntimeConfig：用于获取和设置Spark会话的运行时配置。

val conf: RuntimeConfig = spark.conf

SQLConf.setSQLConfGetter(() => { ... })：设置自定义的SQL配置获取器。

SQLConf.setSQLConfGetter(() => spark.conf)

构建和配置：

Builder：用于构建和配置SparkSession对象。

val builder: SparkSession.Builder = SparkSession.builder()
val newSparkSession: SparkSession = builder.getOrCreate()

会话管理：

active: SparkSession：获取当前活动的Spark会话。
clearActiveSession(): Unit：清除当前活动的Spark会话。
clearDefaultSession(): Unit：清除默认的Spark会话。
newSession(): SparkSession：创建一个新的Spark会话。
getActiveSession: Option[SparkSession]：获取当前活动的Spark会话（以Option形式返回）。
getDefaultSession: Option[SparkSession]：获取默认的Spark会话（以Option形式返回）。
setActiveSession(session: SparkSession): Unit：设置当前活动的Spark会话。
setDefaultSession(session: SparkSession): Unit：设置默认的Spark会话。

val activeSession: SparkSession = SparkSession.active
SparkSession.clearActiveSession()
SparkSession.clearDefaultSession()
val newSession: SparkSession = SparkSession.newSession()
val activeSessionOption: Option[SparkSession] = SparkSession.getActiveSession
val defaultSessionOption: Option[SparkSession] = SparkSession.getDefaultSession
SparkSession.setActiveSession(spark)
SparkSession.setDefaultSession(spark)

数据转换和操作：

createDataFrame(data: java.util.List[_], beanClass: Class[_]): DataFrame：根据Java列表和指定的Bean类创建DataFrame。
createDataFrame(rdd: JavaRDD[_], beanClass: Class[_]): DataFrame：根据Java RDD和指定的Bean类创建DataFrame。
createDataFrame(rdd: RDD[_], beanClass: Class[_]): DataFrame：根据RDD和指定的Bean类创建DataFrame。
createDataFrame(rowRDD: JavaRDD[Row], schema: StructType): DataFrame：根据Java RDD和结构类型创建DataFrame。
createDataFrame(rowRDD: RDD[Row], schema: StructType): DataFrame：根据RDD和结构类型创建DataFrame。
createDataFrame(rows: java.util.List[Row], schema: StructType): DataFrame：根据Java列表和结构类型创建DataFrame。
createDataFrame[A <: Product : TypeTag](data: Seq[A]): DataFrame：根据序列数据创建DataFrame。
createDataFrame[A <: Product : TypeTag](rdd: RDD[A]): DataFrame：根据RDD数据创建DataFrame。
createDataset[T : Encoder](data: RDD[T]): Dataset[T]：根据RDD创建Dataset。
createDataset[T : Encoder](data: Seq[T]): Dataset[T]：根据序列创建Dataset。
createDataset[T : Encoder](data: java.util.List[T]): Dataset[T]：根据Java列表创建Dataset。
emptyDataset[T: Encoder]: Dataset[T]：创建一个空的Dataset。

import org.apache.spark.api.java.JavaRDD
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types.{
   
   IntegerType, StringType, StructField, StructType}
import org.apache.spark.sql.{
   
   DataFrame, Dataset, Row, SparkSession}

object SparkSessionTest extends App {
   
   
   val spark = SparkSession.builder
    .master("local[2]")
    .appName("appName").config("", true)
    .getOrCreate()
  import spark.implicits._
  import scala.collection.JavaConverters._

//  val dataList: java.util.List[String] = List("John", "Jane").asJava
//  val df1: DataFrame = spark.createDataFrame(dataList,classOf[String])
//  df1.show()

//  val rdd: JavaRDD[Int] = spark.sparkContext.parallelize(Seq(1, 2, 3)).toJavaRDD()
//  val df2: DataFrame = spark.createDataFrame(rdd, classOf[Int])
//  df2.show()

  val data: Seq[(String, Int)] = Seq(("Alice", 25), ("Bob", 30))
  val rdd2: RDD[(String, Int)] = spark.sparkContext.parallelize(data)
  val df3: DataFrame = spark.createDataFrame(rdd2)
  df3.show()

  val rowRDD: JavaRDD[Row] = spark.sparkContext.parallelize(Seq(Row("Alice", 25), Row("Bob", 30))).toJavaRDD()
  val schema: StructType = StructType(Seq(StructField("name", StringType), StructField("age", IntegerType)))
  val df4: DataFrame = spark.createDataFrame(rowRDD, schema)
  df4.show()

  val rows: java.util.List[Row] = List(Row("Alice", 25), Row("Bob", 30)).asJava
  val df5: DataFrame = spark.createDataFrame(rows, schema)
  df5.show()


  case class Person(name: String, age: Int)
  val personData: Seq[Person] = Seq(Person("Alice", 25), Person("Bob", 30))
  val df6: DataFrame = spark.createDataFrame(personData)
  df6.show()
  val rdd3: RDD[Person] = spark.sparkContext.parallelize(personData)
  val df7: DataFrame = spark.createDataFrame(rdd3)
  df7.show()

  val intRDD: RDD[Int] = spark.sparkContext.parallelize(Seq(1, 2, 3))
  val ds1: Dataset[Int] = spark.createDataset(intRDD)
  ds1.show()

  val stringSeq: Seq[String] = Seq("John", "Jane")
  val ds2: Dataset[String] = spark.createDataset(stringSeq)
  ds2.show()


  val longList: java.util.List[Long] = List(1L, 2L, 3L).asJava
  val ds3: Dataset[Long] = spark.createDataset(longList)
  ds3.show()


  val emptyDS: Dataset[String] = spark.emptyDataset[String]
  emptyDS.printSchema()
}

+-----+---+
|   _1| _2|
+-----+---+
|Alice| 25|
|  Bob| 30|
+-----+---+

+-----+---+
| name|age|
+-----+---+
|Alice| 25|
|  Bob| 30|
+-----+---+

+-----+---+
| name|age|
+-----+---+
|Alice| 25|
|  Bob| 30|
+-----+---+

+-----+---+
| name|age|
+-----+---+
|Alice| 25|
|  Bob| 30|
+-----+---+

+-----+---+
| name|age|
+-----+---+
|Alice|