技术周总结 2024.07.01~07.07(Spark & Scala)
文章目录
- 一、07.01 周一
- 1.1）问题01：scala怎么实现 一个变量作为函数的入参以及返回值
- 1.2）问题02：park中DataFrame使用 createView的用法
- 1.3）问题03：scala中三元运算符
- 1.4) 问题04：伴生对象和伴生类
- 1.5）问题05：spark-shell的使用
- 1.6) 问题06：mybatis中 like语句怎么写
- 二、07.02 周二
- 2.1）问题01：常见的 spark DataFrame的算子有哪些？分类是怎样的
- 三、07.03 周三
- 3.1）问题01：scala中想把入参修改后，再返回，都有哪些实现方式？
- 1. 使用返回值
- 2. 使用可变对象（Mutable Objects）
- 3. 使用元组（Tuples）
- 4. 使用隐式类（Implicit Classes）
- 5. 使用辅助类或对象
- 6. 使用变长参数（Varargs）
- 总结
- 3.2）spark中的 DataFrame的操作有哪些优化措施
- 1. 使用 Spark SQL Catalyst Optimizer
- 2. 缓存和持久化
- 3. 使用列式存储格式
- 4. 谓词下推（Predicate Pushdown）
- 5. 列裁剪（Column Pruning）
- 6. 使用广播变量（Broadcast Variables）
- 7. 使用适当的分区（Partitioning）
- 8. 避免过度分区和少量分区
- 9. 合理使用 `coalesce` 和 `repartition`
- 10. 启用动态分区裁剪（Dynamic Partition Pruning）
- 11. 使用高效的 UDF（User-Defined Functions）
- 12. 调整并行度配置参数
- 13. 合理使用 window 函数
- 14. 避免重复计算
- 3.3）sparkUI怎么看
- 1. 启动 Spark 应用程序
- 2. 访问 Spark UI
- 3. Spark UI 的主要组件
- 4. 查看详细信息
- 5. 监控运行中的应用
- 6. 查看历史应用
- 3.4）SparkSession.sql()会实际触发查询操作
- 四、07.04 周四
- 4.1) 问题01：怎么设置log4j日志的格式中包含输出的代码所在的行号
- 五、07.06 周六
- 5.1） 问题01: 嵌入式处理器 PowerPC750 ，Cortex-M3，MIPS32 24K，帮忙介绍下吧
- 5.2）问题02: Python列表中的两个冒号的含义是什么
- 5.3）问题03: 那磁盘中的柱面，磁头，扇区都是什么
- 1. 柱面（Cylinder）
- 2. 磁头（Head）
- 3. 扇区（Sector）
- 磁盘的物理结构
- 数据访问过程
- 示例
一、07.01 周一
1.1）问题01：scala怎么实现 一个变量作为函数的入参以及返回值
要保持返回的结果变量名为myVariable，可以使用case class 来实现。示例如下：
case class MyVariable(myVariable: Int, result: Int) // 函数接受一个变量作为入参，并返回一个包含原始变量名和处理后的值的 case class 实例 def processVariable(input: Int): MyVariable = { val processedValue = input * 2 MyVariable(input, processedValue) } val myVariable = 10 val result = processVariable(myVariable) println(result.myVariable) // 输出：10 println(result.result) // 输出：20 1.2）问题02：park中DataFrame使用 createView的用法
要将DataFrame注册为临时视图，可以使用createOrReplaceTempView方法或createOrReplaceGlobalTempView方法。示例如下：
// 创建临时视图 dataFrame.createOrReplaceTempView("temp_view_name") // 创建全局临时视图 dataFrame.createOrReplaceGlobalTempView("global_temp_view_name") 这样就可以通过SQL语句或Spark SQL操作这些视图。
1.3）问题03：scala中三元运算符
在Scala中，没有类似于其他语言中的三元运算符（例如condition ? value1 : value2）。但是，可以使用if-else表达式来实现类似的功能。以下是一个示例：
val condition = true val result = if (condition) "value1" else "value2" println(result) 在这个示例中，如果condition为true，则result将被赋值为"value1"，否则为"value2"。
1.4) 问题04：伴生对象和伴生类
在 Scala 中，伴生对象和伴生类可以互相访问对方的私有成员。伴生对象和伴生类是同名且在同一文件中的类和对象。
实例
class CompanionExample { private val privateField: String = "I am private in class" } object CompanionExample { def accessPrivateField(example: CompanionExample): String = { example.privateField // 伴生对象可以访问类的 private 成员 } } object Main { def main(args: Array[String]): Unit = { val example = new CompanionExample println(CompanionExample.accessPrivateField(example)) } } 1.5）问题05：spark-shell的使用
https://www.hadoopdoc.com/spark/spark-shell
spark-shell 查看页面： http://localhost:4040/jobs/
1.6) 问题06：mybatis中 like语句怎么写
在 MyBatis 中，可以使用 ${} 占位符来直接拼接字符串，而不使用 CONCAT 函数。下面是一个示例：
在这个示例中，我们使用 || 运算符来直接拼接字符串，实现在 name 字段中进行模糊匹配，而无需使用 CONCAT 函数。
二、07.02 周二
2.1）问题01：常见的 spark DataFrame的算子有哪些？分类是怎样的
Spark DataFrame 的常见算子可以分为以下几类：
转换算子（Transformation）：
select(): 选择指定的列。filter(): 根据条件筛选行。groupBy(): 按列分组。agg(): 对分组后的数据进行聚合操作。join(): 连接两个 DataFrame。sort(): 对数据进行排序。withColumn(): 添加新列或替换现有列。drop(): 删除列。distinct(): 获取唯一值。
行动算子（Action）：
show(): 显示 DataFrame 的内容。collect(): 将 DataFrame 中的数据收集到本地。count(): 计算 DataFrame 中的行数。take(): 获取前几行数据。foreach(): 对每行数据执行指定操作。write(): 将 DataFrame 写入外部存储。
I/O 算子：
read(): 从外部数据源读取数据。write(): 将 DataFrame 写入外部存储。
窗口函数（Window Functions）：
over(): 定义窗口规范，用于在分组数据上执行聚合和排序操作。
这些算子可以帮助在 Spark DataFrame 上进行数据转换、操作和分析，实现复杂的数据处理任务。
三、07.03 周三
3.1）问题01：scala中想把入参修改后，再返回，都有哪些实现方式？
在 Scala 中，函数参数默认是不可变的。这意味着你不能直接在函数内部修改参数的值并返回它们。不过，你可以通过多种方式实现修改参数并返回的效果。以下是几种常见的方法：
1. 使用返回值
最直接的方法是通过返回一个新的值或对象。你可以创建一个新的对象或修改副本，然后返回它。
def modifyAndReturn(x: Int): Int = { val modifiedX = x + 1 modifiedX } val result = modifyAndReturn(5) // result = 6 对于更复杂的数据结构，比如集合或自定义对象，可以返回一个新的修改后的实例：
case class Person(name: String, age: Int) def modifyPerson(person: Person): Person = { person.copy(age = person.age + 1) } val person = Person("Alice", 25) val modifiedPerson = modifyPerson(person) // modifiedPerson = Person("Alice", 26) 2. 使用可变对象（Mutable Objects）
虽然 Scala 倾向于使用不可变对象，但你可以使用可变对象来实现参数修改。比如使用 var 或可变集合（如 ArrayBuffer）。
def modifyArray(arr: Array[Int]): Array[Int] = { arr(0) = arr(0) + 1 arr } val array = Array(1, 2, 3) val modifiedArray = modifyArray(array) // modifiedArray = Array(2, 2, 3) 3. 使用元组（Tuples）
你可以返回一个元组，包含多个修改后的参数值。
def modifyParams(x: Int, y: Int): (Int, Int) = { (x + 1, y + 1) } val (newX, newY) = modifyParams(5, 10) // newX = 6, newY = 11 4. 使用隐式类（Implicit Classes）
你可以使用隐式类来增强现有类型的功能，使其支持链式调用。
object IntOps { implicit class RichInt(val x: Int) extends AnyVal { def increment: Int = x + 1 } } import IntOps._ val newX = 5.increment // newX = 6 5. 使用辅助类或对象
如果你需要修改多个参数并返回它们，可以使用辅助类或对象来封装这些参数。
case class Params(x: Int, y: Int) def modifyParams(params: Params): Params = { params.copy(x = params.x + 1, y = params.y + 1) } val params = Params(5, 10) val newParams = modifyParams(params) // newParams = Params(6, 11) 6. 使用变长参数（Varargs）
如果你需要修改和返回变长参数，可以将它们转换为集合，然后返回修改后的集合。
def modifyParams(params: Int*): Seq[Int] = { params.map(_ + 1) } val newParams = modifyParams(1, 2, 3) // newParams = Seq(2, 3, 4) 总结
Scala 提供了多种方式来实现修改参数并返回的功能。最常见的方法是通过返回新的值或对象，这符合函数式编程的理念，并且可以避免副作用。根据具体需求，你可以选择最合适的方法来实现你的目标。
3.2）spark中的 DataFrame的操作有哪些优化措施
在 Apache Spark 中，优化 DataFrame 操作可以显著提高数据处理的效率和性能。以下是一些常见的优化措施：
1. 使用 Spark SQL Catalyst Optimizer
Catalyst 是 Spark SQL 的查询优化器，它可以自动进行多种优化，例如谓词下推、列裁剪等。尽可能使用 SQL 风格的查询或 DataFrame API，而不是 RDD 操作，因为 Catalyst 只能优化前者。
2. 缓存和持久化
对频繁使用的中间结果进行缓存或持久化，以避免重复计算。
val df = spark.read.parquet("hdfs://path/to/data") df.cache() // 或者 df.persist(StorageLevel.MEMORY_AND_DISK) 3. 使用列式存储格式
使用列式存储格式（如 Parquet 或 ORC）来存储数据，这样可以提高磁盘 I/O 性能和数据压缩率。
val df = spark.read.parquet("hdfs://path/to/parquet") 4. 谓词下推（Predicate Pushdown）
在读取数据时，尽量利用数据源支持的谓词下推功能，以减少读取的数据量。
val df = spark.read.parquet("hdfs://path/to/data").filter("age > 30") 5. 列裁剪（Column Pruning）
只选择需要的列，避免读取和处理不必要的数据。
val df = spark.read.parquet("hdfs://path/to/data").select("name", "age") 6. 使用广播变量（Broadcast Variables）
对于较小的 DataFrame，可以使用广播变量，将其复制到每个节点以减少数据传输开销。
val smallDf = spark.read.parquet("hdfs://path/to/small_data") val broadcastedDf = broadcast(smallDf) val largeDf = spark.read.parquet("hdfs://path/to/large_data") val joinedDf = largeDf.join(broadcastedDf, "key") 7. 使用适当的分区（Partitioning）
通过合理的分区策略，可以平衡任务的负载，减少数据倾斜。
val df = spark.read.parquet("hdfs://path/to/data") df.repartition(100, $"keyColumn") // 按照 "keyColumn" 列重新分区 8. 避免过度分区和少量分区
- 过度分区会导致过多的小任务，增加调度开销。
- 少量分区会导致任务负载不均，某些任务可能会变得非常重，从而拖慢整体进度。
9. 合理使用 coalesce 和 repartition
repartition用于增加或减少分区，通常用于增加分区。coalesce用于减少分区，通常用于减少分区，并且比repartition更高效。
val df = spark.read.parquet("hdfs://path/to/data") val repartitionedDf = df.repartition(100) // 增加分区 val coalescedDf = df.coalesce(50) // 减少分区 10. 启用动态分区裁剪（Dynamic Partition Pruning）
在 Spark SQL 中启用动态分区裁剪，以在执行时减少不必要的分区扫描。
spark.conf.set("spark.sql.optimizer.dynamicPartitionPruning.enabled", "true") 11. 使用高效的 UDF（User-Defined Functions）
尽量避免使用 UDF，因为它们可能会破坏 Catalyst 的优化。使用内置函数或 SQL 表达式来实现相同的功能。
12. 调整并行度配置参数
调整以下 Spark 配置参数以优化并行度：
spark.sql.shuffle.partitions：默认值为 200，可以根据数据量调整。spark.default.parallelism：调整为集群核心数的 2-3 倍。
spark.conf.set("spark.sql.shuffle.partitions", "300") 13. 合理使用 window 函数
对于需要进行分组排序的操作，合理使用 window 函数可以提高性能。
import org.apache.spark.sql.expressions.Window val windowSpec = Window.partitionBy("partitionColumn").orderBy("orderColumn") val df = df.withColumn("rank", rank().over(windowSpec)) 14. 避免重复计算
将中间结果缓存或持久化，避免重复计算。例如，多个步骤使用同一个 DataFrame 的结果。
## 3.3）spark中是两个表各自生成DataFrame后再join的效率高，还是两个表先join生成一个整体的sql,整体生成一个DateFrame的效率高？ 在 Spark 中，通常情况下，将两个表各自生成 DataFrame 后再进行 join 操作的效率会更高。这是因为： 1. **分布式计算优化**：Spark 的 Catalyst 优化器可以对 DataFrame 操作进行优化，包括 join 操作。将两个表各自生成 DataFrame 后再 join，可以利用 Catalyst 优化器的各种优化策略，例如广播 join、排序 merge join 等。 2. **延迟计算（Lazy Evaluation）**：Spark 的 DataFrame API 是延迟计算的，这意味着只有在触发行动操作（如 `count`、`collect` 等）时，Spark 才会实际执行计算。在此之前，Spark 会尽可能优化整个计算计划。如果先生成 DataFrame，再进行 join 操作，Spark 有更多机会优化执行计划。 3. **分区和分布控制**：在生成 DataFrame 之后，可以对其进行分区和重新分区，以优化 join 操作的性能。例如，可以使用 `repartition` 或 `coalesce` 来调整分区数，从而减少数据倾斜和网络传输。 4. **利用缓存**：将中间结果缓存起来，可以避免重复计算，提高性能。如果先生成 DataFrame，可以在 join 之前缓存数据。 ```scala val df1 = spark.read.json("table1.json").cache() val df2 = spark.read.json("table2.json").cache() val joinedDF = df1.join(df2, "key") 不过，具体的性能还取决于很多因素，比如数据规模、表的结构、集群配置等。建议在实际应用中进行性能测试和调优，以选择最优的方案。
以下是两个方法的示例：
各自生成 DataFrame 后再 join：
val df1 = spark.read.json("table1.json") val df2 = spark.read.json("table2.json") val joinedDF = df1.join(df2, "key")整体生成一个 SQL，再生成 DataFrame：
val sqlQuery = "SELECT * FROM table1 t1 JOIN table2 t2 ON t1.key = t2.key" val joinedDF = spark.sql(sqlQuery)
一般情况下，第一个方法更容易被 Spark 的优化器优化，但具体选择哪种方法，还是建议进行实际的性能测试。
3.3）sparkUI怎么看
Spark UI 是一个非常有用的工具，用于监视和调试 Spark 应用程序的执行。以下是如何访问和使用 Spark UI 的步骤：
1. 启动 Spark 应用程序
当你启动一个 Spark 应用程序时，无论是通过 Spark Shell、Spark Submit 还是其他方式，Spark UI 都会自动启动并在一个特定的端口上提供服务。默认情况下，Spark UI 在 4040 端口上运行。
例如，通过 Spark Shell 启动一个应用程序：
spark-shell 2. 访问 Spark UI
在浏览器中打开以下 URL：
http://localhost:4040 如果 4040 端口已经被占用，Spark 会使用下一个可用的端口（例如 4041、4042 等）。你可以在启动日志中找到实际使用的端口。
3. Spark UI 的主要组件
一旦你打开 Spark UI，你会看到几个标签页，每个标签页提供了不同的信息：
- Jobs：显示所有的 Spark 任务（Job），包括每个任务的状态、开始时间、完成时间、执行时间等。
- Stages：显示所有的阶段（Stage），包括每个阶段的详细信息和执行情况。
- Storage：显示缓存和持久化的 RDD 和 DataFrame 的信息。
- Environment：显示 Spark 应用程序的环境信息，包括 Spark 配置、系统属性、类路径等。
- Executors：显示所有的执行器（Executor）的信息，包括每个执行器的内存使用情况、磁盘使用情况、任务执行情况等。
- SQL：显示所有执行的 SQL 查询的详细信息。
4. 查看详细信息
你可以点击每个任务（Job）或阶段（Stage）来查看更详细的信息。例如，在 “Stages” 标签页中，点击某个阶段的 ID，可以查看该阶段的详细执行计划、任务（Task）列表、每个任务的执行时间、输入输出数据量等。
5. 监控运行中的应用
如果你的应用程序正在运行，你可以实时监控其执行情况。Spark UI 会动态更新任务和阶段的状态，帮助你了解应用程序的进展和性能。
6. 查看历史应用
如果你的应用程序已经完成，你可以通过 Spark 的历史服务器查看过去的应用程序执行情况。启动 Spark 历史服务器的方法如下：
./sbin/start-history-server.sh 然后在浏览器中访问：
http://localhost:18080 在历史服务器中，你可以查看所有已经完成的应用程序的详细执行情况。
通过 Spark UI，你可以深入了解 Spark 应用程序的执行情况，发现性能瓶颈，优化代码，提高应用程序的效率。
参考链接：
https://www.cnblogs.com/xing901022/p/6445254.html
SparkUI怎么看
3.4）SparkSession.sql()会实际触发查询操作
val sql = """ CREATE TEMPORARY VIEW spark_doris USING doris OPTIONS( "table.identifier"="$YOUR_DORIS_DATABASE_NAME.$YOUR_DORIS_TABLE_NAME", "fenodes"="$YOUR_DORIS_FE_HOSTNAME:$YOUR_DORIS_FE_RESFUL_PORT", "user"="$YOUR_DORIS_USERNAME", "password"="$YOUR_DORIS_PASSWORD" ); """ context.sparkSession.sql(sql) 这段代码使用Doris插件在Spark中创建一个临时视图.
这个地方sql查询的数据量的大小会影响 DataFrame创建的速度
在这段代码中，实际的数据查询操作是在 context.sparkSession.sql(sql) 这一行中发生的，而不是在创建临时视图时。因此，SQL查询的数据量大小会影响DataFrame创建的速度。
四、07.04 周四
4.1) 问题01：怎么设置log4j日志的格式中包含输出的代码所在的行号
要在日志格式中包含输出的代码所在的行号，可以使用%L占位符。修改log4j.appender.stdout.layout.ConversionPattern和log4j.appender.logfile.layout.ConversionPattern的配置如下所示：
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m (%L)%n log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m (%L)%n 这样设置后，日志输出的格式中会包含代码所在的行号信息。
五、07.06 周六
5.1） 问题01: 嵌入式处理器 PowerPC750 ，Cortex-M3，MIPS32 24K，帮忙介绍下吧
好的,我来简单介绍一下这几种常见的嵌入式处理器:
PowerPC750:
- 属于 PowerPC 架构,由 IBM、Motorola 和 Apple 共同开发。
- 32位处理器,主频范围从233MHz到750MHz不等。
- 采用超标量流水线架构,具有较强的计算性能。
- 广泛应用于工业控制、航天航空、游戏机等领域。
Cortex-M3:
- 属于 ARM Cortex-M 系列处理器,专为嵌入式应用设计。
- 32位 RISC 结构,主频可达120MHz。
- 低功耗、低成本,适用于需要高性能和实时性的嵌入式系统。
- 广泛应用于工业控制、医疗设备、家用电器等领域。
MIPS32 24K:
- 属于 MIPS 架构,由 MIPS Technologies 公司开发。
- 32位处理器,主频范围从200MHz到800MHz不等。
- 采用5级流水线,具有较高的处理性能。
- 低功耗、低成本,适用于嵌入式系统和消费电子产品。
- 广泛应用于路由器、机顶盒、游戏机等领域。
总的来说,这三种处理器都是主流的嵌入式处理器,拥有各自的特点和应用领域。PowerPC750 和 MIPS32 24K 主要面向高性能嵌入式应用,而 Cortex-M3 则更适合低功耗和实时性要求较高的嵌入式系统。具体选择时需要根据具体的应用场景和性能需求进行权衡。
5.2）问题02: Python列表中的两个冒号的含义是什么
在 Python 中，列表中的两个冒号 : 通常用于表示列表的切片操作。具体来说，stack[::-1] 表示从列表的末尾开始，以步长为-1（即反向）的方式获取整个列表的切片。
切片操作可以用来获取列表的子列表、修改列表的部分元素、实现序列的反转等。在这个例子中，通过 stack[::-1] 可以得到 stack 列表的逆序版本。
例如，对于一个列表 list = [1, 2, 3, 4, 5]，执行 list[::-1] 将得到 [5, 4, 3, 2, 1]。
这种切片操作的语法是 list[start🔚step]，其中：
 start 和 end 是可选的索引，表示切片的起始和结束位置（包含起始位置，不包含结束位置）。如果省略 start，则默认从开头开始；如果省略 end，则默认到结尾结束。
 step 是可选的步长，为正数时表示从左到右取值，为负数时表示从右到左取值，为 0 时表示取单个元素。
通过合理使用切片操作，可以方便地对列表进行各种操作和处理。
5.3）问题03: 那磁盘中的柱面，磁头，扇区都是什么
磁盘（硬盘）是一种数据存储设备，其工作原理和结构比较复杂，涉及多个关键组件和概念。以下是对柱面（Cylinder）、磁头（Head）、扇区（Sector）等术语的解释：
1. 柱面（Cylinder）
柱面是硬盘中的一个逻辑结构。硬盘通常由多个盘片（Platters）组成，每个盘片的两面都有磁道（Track）。所有盘片在相同位置的磁道集合被称为一个柱面。柱面是一个三维概念，可以认为它是沿着硬盘轴心垂直的一个柱形结构。
- 磁道（Track）：每个盘片被划分为若干同心圆，这些同心圆就是磁道。
- 柱面（Cylinder）：所有盘片上具有相同半径的磁道集合。
通过柱面的概念，可以减少磁头在不同盘片间的移动，因为在同一个柱面内，磁头只需上下移动，而不需要沿着盘片的表面移动。
2. 磁头（Head）
磁头是读写硬盘数据的部件。每个盘片的两面都有一个磁头，用于读取和写入数据。磁头悬浮在盘片表面上方，通过电磁感应来读取和写入数据。
- 数量：磁头的数量等于盘片数乘以2（因为每个盘片有两个面）。
- 移动：所有磁头通过一个共同的机械臂（通常称为磁头臂或滑动臂）进行移动。当机械臂移动时，所有磁头会同步移动到相应的磁道上。
3. 扇区（Sector）
扇区是硬盘上最小的物理存储单位。每个磁道被划分为若干个扇区，每个扇区通常存储512字节或4096字节的数据。
- 扇区大小：早期硬盘的扇区大小通常为512字节，但现代硬盘通常使用4096字节的扇区大小（也叫高级格式化）。
- 寻址：硬盘数据通过称为LBA（逻辑块地址，Logical Block Addressing）的方法进行寻址，每个扇区都有一个唯一的LBA编号。
磁盘的物理结构
硬盘的物理结构可以通过以下几个层次来理解：
- 盘片（Platters）：硬盘由多个盘片组成，每个盘片上有磁性材料涂层。
- 磁道（Track）：每个盘片分为多个同心圆环，称为磁道。
- 柱面（Cylinder）：相同半径的磁道在所有盘片上的集合。
- 扇区（Sector）：每个磁道被进一步划分为多个扇区，每个扇区存储一定数量的数据。
数据访问过程
当需要读取或写入数据时，磁盘控制器会执行以下步骤：
- 确定柱面：根据数据的逻辑地址，确定要访问的柱面。
- 移动磁头：将磁头臂移动到相应的柱面位置。
- 选择磁头：选择对应盘片上的读写磁头。
- 确定扇区：在选定的磁道上找到指定的扇区。
- 读取/写入数据：执行读取或写入操作。
示例
假设我们有一个硬盘，包含两个盘片（即四个盘面），每个盘片有2000个磁道，每个磁道有100个扇区，每个扇区存储512字节。
- 盘片数：2
- 磁头数：4（每个盘片2个面）
- 磁道数：2000
- 每磁道扇区数：100
- 每扇区字节数：512
如果我们要访问存储在第一个盘片、第1000个磁道、第50个扇区的数据，磁盘控制器会：
- 将磁头移动到第1000个磁道（柱面）。
- 选择第一个盘片的读写磁头。
- 找到第1000个磁道上的第50个扇区。
- 读取或写入512字节的数据。
上一篇：组装机什么配置比较好