Scala进阶之App特质

本文探讨了Scala中的App特质,揭示了如何通过delayedInit方法处理初始化代码块,并通过反编译示例解释了初始化顺序。文章介绍了在AppInternals、C、Helper等类中的apply方法,展示了初始化代码的执行流程。

App特质的作用

App特质的作用那就是延迟初始化,从代码上看它继承自DelayedInit,里面有个delayedInit方法
trait App extends DelayedInit   
DelayedInit特质里定义了延迟初始化方法:
def delayedInit(x: => Unit): Unit
开发者可以直接在初始化块里写逻辑,(这里指的是 extends App{//todo}里的//todo代码)
然后编译器会把这段初始化代码块里的逻辑封装成一个函数对象(是(() => Unit)类型)
override def delayedInit(body: => Unit) {
initCode += (() => body)
}
缓存起来(并没有运行),然后放到一个集合(ListBuffer)中,之后在main方法里一行一行调用并执行,  
所以只有在执行到main方法的时候才会触发,从而达到延迟初始化的效果。
def main(args: Array[String]) = {
...
for (proc <- initCode) proc()
...
}

不过在实际开发中,经常需要一开始就初始化,不然会报错,如空指针异常,真正使用App的机会个人感觉都不多。

蘑菇云代码

package com.dt.scala.oop

/**
  * Created by Administrator on 2016/8/19.
  */
object AppInternals extends App{
   
   
  val c = new C
  println("Hello Spark")
}

trait Helper extends DelayedInit {
   
   
  def delayedInit(body: => Unit) = {
    println("dummy text, printed before initialization of C")
    body // evaluates the initialization code of C
  }
}

class C extends Helper {
   
   
  println("this is the initialization code of C")
}


----------


结果
dummy text, printed before initialization of C
this is the initialization code of C
Hello Spark

补充

其实上面讲的并没有说清楚,是怎么把封装的初始化代码块传给delayedInit(body: => Unit)的。
用反编译工具jd-gui.exe把上面生成的.class反编译出来,可以看到多出了好多个类,
其中主要的有
class AppInternals, delayedInitbody,App

### 学习 Scala 高级用法和技巧 Scala 是一种功能强大且灵活的语言,支持函数式编程和面向对象编程范式。以下是关于如何掌握 Scala 的高级用法和技术的一些关键点: #### 函数式编程特性 Scala 提供了许多强大的函数式编程工具,例如高阶函数、模式匹配以及不可变数据结构。这些特性能帮助开发者编写更简洁、可维护的代码。 - **高阶函数**:可以接受其他函数作为参数或者返回另一个函数。这种能力使得像 `map` 和 `filter` 这样的方法变得非常有用[^1]。 ```scala val numbers = List(1, 2, 3, 4) val doubledNumbers = numbers.map(x => x * 2) // 使用 map 方法来处理列表中的每一个元素 println(doubledNumbers) // 输出: List(2, 4, 6, 8) ``` - **模式匹配**:允许通过不同的条件分支执行特定逻辑,类似于增强版的 switch-case 结构。 ```scala def matchTest(x: Int): String = x match { case 1 => "One" case 2 => "Two" case _ => "Other number" } println(matchTest(2)) // 输出: Two ``` #### 并发与异步编程 Scala 中的并发可以通过 Akka 或者 Future 来实现。Akka 是一个用于构建高度并行、分布式系统的框架;而 Futures 则提供了一种简单的方式来管理异步操作的结果[^3]。 - **Future**: 表示可能还没有完成计算的一个值。 ```scala import scala.concurrent.Future import scala.util.{Success, Failure} implicit val ec = scala.concurrent.ExecutionContext.Implicits.global val futureValue = Future { Thread.sleep(1000); 42 } futureValue.onComplete { case Success(value) => println(s"Got the value $value") case Failure(e) => e.printStackTrace() } Thread.sleep(2000) // 让主线程等待足够长时间以便观察结果 ``` #### 类型系统与泛型 Scala 拥有极其丰富的类型系统,它不仅包含了基本的数据类型还支持复杂的复合类型定义。利用好它的泛型机制可以帮助创建更加通用和安全的库或组件。 - **自定义泛型类** ```scala class Stack[A](var elements: List[A]) { def push(element: A) = this.copy(elements = element :: elements) def pop(): (A, Stack[A]) = { require(!elements.isEmpty, "Empty stack.") (elements.head, new Stack(elements.tail)) } } ``` #### 实际应用案例分析 对于实际项目开发而言,了解某些具体技术栈的应用场景非常重要。比如,在大数据领域中经常使用的 Apache Kafka 就是一个很好的例子。下面展示了一个简单的 Kafka Consumer 示例: ```scala import org.apache.kafka.clients.consumer.KafkaConsumer import java.util.Properties object SimpleKafkaConsumer extends App { val props = new Properties() props.put("bootstrap.servers", "localhost:9092") props.put("group.id", "test-group") props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer") props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer") val consumer = new KafkaConsumer[String, String](props) try { consumer.subscribe(java.util.Collections.singletonList("my-topic")) while(true){ val records = consumer.poll(Duration.ofMillis(100)) for(record <- records.iterator().asScala){ println(s"${record.key()} : ${record.value()}") } } } finally{ consumer.close() } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值