安装Spark集群并求取工资中位数的步骤如下：

1. 安装Spark集群：

   • 确保有多个节点。
   • 在每个节点上安装Spark。
   • 配置spark-env.sh和slaves文件，设置主节点和从节点。
   • 启动集群 sbin/start-all.sh。
2. 准备工资数据文件，例如salaries.txt，每行一个工资数据。

3. 使用Spark提交应用程序计算中位数：

   
   
   
   import org.apache.spark.{SparkConf, SparkContext}
    
   object SalaryMedian {
     def main(args: Array[String]) {
       val conf = new SparkConf().setAppName("SalaryMedian")
       val sc = new SparkContext(conf)
    
       val salaries = sc.textFile("hdfs://namenode:8020/path/to/salaries.txt")
       val sortedSalaries = salaries.map(_.toDouble).sortBy(x => x)
    
       // 计算中位数
       val count = sortedSalaries.count()
       val median = if (count % 2 == 0) {
         (sortedSalaries.lookup(count / 2 - 1) ++ sortedSalaries.lookup(count / 2)).sum / 2
       } else {
         sortedSalaries.lookup(count / 2).head
       }
    
       println(s"Median salary is: $median")
    
       sc.stop()
     }
   }

4. 将Scala代码编译成JAR文件。

5. 使用spark-submit提交应用程序到集群运行：

   
   
   
   spark-submit --class SalaryMedian --master spark://master:7077 --deploy-mode cluster /path/to/SalaryMedian.jar

请注意，以上步骤假设您已经有Spark安装包和集群配置基础。具体细节（如配置文件的设置、HDFS路径等）可能需要根据实际环境进行调整。

Spark SQL 的用户自定义函数（UDF）允许你在Spark SQL中注册一个自定义函数，然后在Spark SQL查询中像使用内置函数一样使用它。

以下是如何在Spark SQL中创建和使用UDF的步骤：

1. 使用Scala或Java编写你的函数逻辑。
2. 在SparkSession中注册这个函数作为UDF。
3. 在Spark SQL查询中使用这个UDF。

以下是一个简单的例子，假设我们有一个字符串输入，我们想要返回其长度。

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions.udf
 
val spark = SparkSession.builder.appName("UDF Example").getOrCreate()
 
// 定义一个简单的UDF，返回字符串的长度
val stringLengthUDF = udf((s: String) => if (s != null) s.length else 0)
 
// 注册UDF
spark.udf.register("strLen", stringLengthUDF)
 
// 创建一个示例DataFrame
import spark.implicits._
val df = Seq("Hello", "World", null).toDF("word")
 
// 使用UDF
val result = df.selectExpr("word", "strLen(word) as length")
 
// 显示结果
result.show()

这个例子中，我们定义了一个名为stringLengthUDF的UDF，它接受一个字符串参数并返回其长度。然后我们使用spark.udf.register方法将其注册为名为strLen的UDF。在查询中，我们使用selectExpr方法来调用这个UDF，并将结果列命名为length。最后，我们使用show方法来显示查询结果。

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.streaming.OutputMode
 
object StructuredNetworkWordCount {
  def main(args: Array[String]) {
    // 创建SparkSession
    val spark = SparkSession
      .builder
      .appName("StructuredNetworkWordCount")
      .getOrCreate()
 
    // 设置日志级别
    spark.sparkContext.setLogLevel("ERROR")
 
    // 定义流数据读取来源和格式
    val lines = spark.readStream
      .format("socket")
      .option("host", "localhost")
      .option("port", 9999)
      .load()
 
    // 将文本行转换为单词，并对单词进行聚合
    val words = lines.as[String](spark.implicits.newStringEncoder)     .flatMap(_.split(" "))
      .groupBy("value")
      .count()
 
    // 设置输出模式和输出目标（控制台）
    words.writeStream
      .outputMode(OutputMode.Complete())
      .format("console")
      .start()
      .awaitTermination()
  }
}

这段代码使用Spark Structured Streaming来创建一个简单的网络单词计数程序。它从本地主机的9999端口上的socket读取数据，并统计接收到的文本中的单词频率。统计结果会输出到控制台。注意，在运行此代码之前，需要确保在本地主机的9999端口上有一个应用程序在发送数据。

在Spark on YARN模式下，Spark任务运行时的架构如下：

1. Client提交应用：用户提交应用的入口是Client，它负责向YARN提交应用，包括Application Master。
2. RM Scheduler：YARN的资源管理器（ResourceManager, RM）负责调度整个集群的资源，Application Master向RM申请资源，Container由RM分配给Application Master。
3. Node Manager：YARN的节点管理器（NodeManager, NM）负责管理集群中每个节点的资源和任务。
4. Application Master：每个应用程序在YARN中都有一个Application Master，它负责与RM协商资源，与NM通信来启动/停止任务，任务监控等。
5. Executors：Application Master向RM申请足够的容器，一旦得到容器，就在对应的NM上启动Executor进程，Spark任务就在这些Executor上运行。
6. Driver：Driver在Client端启动，如果是集群模式，Driver会运行在Application Master所在的节点。
7. Exeuctor Backend：每个Executor运行在一个JVM中，它负责与Driver进行通信，并管理自己的线程池运行任务。

以下是一个简化的Spark on YARN提交过程的伪代码：

// 用户代码，提交Spark作业
val conf = new SparkConf()
conf.setMaster("yarn")
conf.setAppName("My Spark Application")
 
val sc = new SparkContext(conf)
 
// 运行Spark作业
sc.textFile("hdfs://path/to/input/data").count()
 
sc.stop()

在这个例子中，SparkContext负责与YARN集群通信，请求资源，并启动作业。这个过程在Spark源代码中的org.apache.spark.deploy.yarn.Client类中实现，它负责与YARN资源管理器（ResourceManager）通信，并且与节点管理器（NodeManager）通信以启动Executor。Driver在Application Master中运行，而Executor在YARN容器内运行。

import org.apache.spark.sql.SparkSession
 
// 创建SparkSession
val spark = SparkSession.builder()
  .appName("SparkSQL初体验")
  .config("spark.some.config.option", "some-value")
  .getOrCreate()
 
// 引入隐式转换
import spark.implicits._
 
// 创建DataFrame
val dataFrame = Seq(
  (1, "张三", "北京"),
  (2, "李四", "上海"),
  (3, "王五", "广州")
).toDF("id", "name", "city")
 
// 注册临时视图
dataFrame.createOrReplaceTempView("people")
 
// 执行SQL查询
val sqlDF = spark.sql("SELECT * FROM people")
 
// 显示查询结果
sqlDF.show()
 
// 停止SparkSession
spark.stop()

这段代码首先创建了一个SparkSession，并启动了一个简单的交互式Spark SQL会话。它创建了一个DataFrame，将其注册为一个临时视图，并执行了一个SQL查询。最后，它显示了查询结果并清理了SparkSession。这个过程是学习Spark SQL的一个很好的起点。

Spark Core的核心调度机制主要涉及到任务的提交、分配以及执行等过程。由于Spark的调度是一个复杂的过程，涉及到各种不同的调度策略和策略的组合，因此我们不能在一个简短的回答中全部解释清楚。但是，我们可以提供一个概览和一些核心概念的代码示例。

Spark的调度器是TaskScheduler，它负责初始化和维护任务的调度。Spark的调度策略包括FIFO、FAIR和FIFO with priorities。

以下是一个简化的TaskScheduler初始化的伪代码：

val scheduler = new TaskSchedulerImpl(sc)
val schedulableBuilder = new SchedulableBuilder(rootPool, scheduler)
 
// 对于FIFO策略
schedulableBuilder.addTaskSetManager(manager, "FIFO")
 
// 对于FAIR策略
schedulableBuilder.addTaskSetManager(manager, "FAIR")
 
// 对于带优先级的FIFO策略
schedulableBuilder.addTaskSetManager(manager, "FIFO with priorities")
 
scheduler.start()

在这个例子中，我们创建了一个TaskSchedulerImpl实例，并且通过SchedulableBuilder将TaskSetManagers添加到调度池中。然后我们启动了调度器。

这只是一个简化的示例，实际的Spark调度器要复杂得多，包含了更多的细节和策略。如果你想要深入了解，我建议你查看Spark的官方文档或源代码。

import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
 
object WordCount {
  def main(args: Array[String]) {
    // 检查输入参数
    if (args.length < 1) {
      System.err.println("Usage: WordCount <master> <hostname> <port>")
      System.exit(1)
    }
 
    // 初始化Spark配置和Streaming上下文
    val sparkConf = new SparkConf().setAppName("WordCount").setMaster(args(0))
    val ssc = new StreamingContext(sparkConf, Seconds(args(2).toInt))
 
    // 创建输入数据流
    val lines = ssc.socketTextStream(args(1), args(2).toInt)
 
    // 执行词频统计
    val words = lines.flatMap(_.split(" "))
                     .map(word => (word, 1))
    val wordCounts = words.reduceByKey(_ + _)
 
    // 打印结果并启动接收数据
    wordCounts.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

这段代码演示了如何使用Spark Streaming库来进行实时的词频统计。它接收一个主节点（master），主机名（hostname）和端口号（port）作为参数，并通过这个端口号从指定主机接收文本数据流。代码中的flatMap, map, reduceByKey是Spark Streaming操作的例子，它们用于将数据流转换为词频形式，并在控制台打印出来。

import org.apache.spark.sql.SparkSession
 
// 创建SparkSession
val spark = SparkSession.builder()
  .appName("Spark SQL Basic Example")
  .config("spark.some.config.option", "some-value")
  .getOrCreate()
 
// 引入隐式转换
import spark.implicits._
 
// 创建DataFrame
val data = Seq(
  (1, "John Doe", "M", 21),
  (2, "Jane Doe", "F", 19),
  (3, "Steve Smith", "M", 22)
)
val df = data.toDF("id", "name", "gender", "age")
 
// 创建视图
df.createOrReplaceTempView("people")
 
// 运行SQL查询
val sqlDF = spark.sql("SELECT * FROM people WHERE age >= 21")
 
// 显示查询结果
sqlDF.show()
 
// 停止SparkSession
spark.stop()

这段代码首先创建了一个SparkSession，并启动了一个简单的Spark SQL查询，查询选取了年龄大于等于21岁的所有人的信息。代码展示了如何创建DataFrame，将其转换为视图，并使用Spark SQL执行查询。最后，它停止了SparkSession。这个例子是学习Spark SQL的基础，并展示了如何在实际应用程序中使用它。

在Spark中，RDD的缓存是通过调用cache()方法或者persist(level: StorageLevel)方法来实现的。cache()方法是persist(StorageLevel.MEMORY_ONLY)的简写，表示将RDD以序列化的形式存储在JVM堆内存中。

persist()方法允许你指定存储级别，可以是以下几种：

• MEMORY_ONLY：仅在内存中存储。
• MEMORY_AND_DISK：内存中存储不下时存到磁盘。
• DISK_ONLY：仅在磁盘中存储。
• MEMORY_ONLY_SER：以序列化的形式仅在内存中存储。
• MEMORY_AND_DISK_SER：以序列化的形式内存存储不下时存到磁盘。

存储级别可以组合使用，例如MEMORY_AND_DISK和MEMORY_AND_DISK_SER。

以下是一个使用persist()方法的例子：

val conf = new SparkConf().setAppName("Persist Example").setMaster("local")
val sc = new SparkContext(conf)
 
val dataRDD = sc.parallelize(Seq(1, 2, 3, 4, 5))
val cachedRDD = dataRDD.persist(StorageLevel.MEMORY_AND_DISK_SER)
 
cachedRDD.collect().foreach(println)
 
sc.stop()

在这个例子中，dataRDD被转换成缓存的cachedRDD，并且指定了使用序列化的方式存储在内存和磁盘中。然后，通过collect方法将结果收集回驱动器程序并打印。

import org.apache.spark.SparkConf
import org.apache.spark.api.java.JavaSparkContext
import org.elasticsearch.spark.rdd.EsSpark
 
object SparkEsIntegration {
  def main(args: Array[String]): Unit = {
    // 初始化Spark配置
    val conf = new SparkConf().setAppName("SparkEsIntegration").setMaster("local")
    val jsc = new JavaSparkContext(conf)
 
    // 指定Elasticsearch索引和类型
    val index = "spark_test_index"
    val `type` = "spark_test_type"
 
    // 创建一个包含文档的RDD
    val data = jsc.parallelize(Seq("Spark", "Elasticsearch", "Integration"))
 
    // 将RDD保存到Elasticsearch
    EsSpark.saveJsonToEs(data, Seq(index, `type`))
 
    // 执行全文搜索
    val query = s"""{"query": {"match": {"_all": "Spark"}}}"""
    val searchResults = EsSpark.esJsonRDD(jsc, index, `type`, query)
 
    // 输出搜索结果
    searchResults.collect().foreach(println)
 
    // 关闭Spark上下文
    jsc.stop()
  }
}

这段代码展示了如何在Spark应用程序中使用Elasticsearch。首先，我们创建了一个Spark配置并初始化了一个JavaSparkContext。然后，我们指定了Elasticsearch索引和类型。接着，我们创建了一个包含文档的RDD，并使用EsSpark.saveJsonToEs方法将其保存到Elasticsearch。最后，我们执行了一个全文搜索，并输出了搜索结果。这个例子简单明了地展示了如何将Spark与Elasticsearch集成，并进行数据的索引和搜索操作。