【Scala 】注解

在 Scala 中，你可以使用注解来为类、方法或字段添加元数据，影响它们的行为。Scala 的注解使用与 Java 类似，但是 Scala 也支持自定义注解。

注解的常见使用方法

以下是一些 Scala 中常见的注解以及它们的使用方法：

1. 内置注解：

   • @deprecated：标记已过时的方法或类。

     @deprecated("This method is deprecated", "version")
     def deprecatedMethod(): Unit = {
       // method implementation
     }
     

   • @throws：标记方法可能抛出的异常。

     @throws(classOf[IOException])
     def methodThatThrowsIOException(): Unit = {
       // method implementation
     }
     

2. 元注解：

   • @AnnotationName：元注解用于定义自定义注解。

     import scala.annotation.meta._
     
     @getter @setter
     class MyClass {
       // class implementation
     }
     

3. 自定义注解：

   在 Scala 中，你可以使用 @annotation 标记创建自定义注解。

   import scala.annotation._
   
   @getter @setter
   class MyAnnotation extends StaticAnnotation
   
   @MyAnnotation
   class MyClass {
     // class implementation
   }
   

请注意，在 Scala 中，注解可以直接应用于类、方法、字段等，而不需要像 Java 一样显式地指定目标元素的类型。此外，Scala 的注解支持多重应用，即可以同时应用多个相同或不同的注解。

自定义注解

在 Scala 中，自定义注解的创建通常通过继承 scala.annotation.StaticAnnotation 来实现。下面是一个完整的例子，展示如何创建和使用一个简单的自定义注解，并通过它影响编译时的行为。

import scala.annotation.StaticAnnotation
import scala.reflect.macros.blackbox.Context

// 定义一个自定义注解
class MyAnnotation extends StaticAnnotation

// 定义一个类使用自定义注解
@MyAnnotation
class MyClass {
  def myMethod(): Unit = {
    println("Executing myMethod")
  }
}

// 定义一个宏，用于处理注解
object MyAnnotationMacro {
  def impl(c: Context)(annottees: c.Tree*): c.Tree = {
    import c.universe._

    // 处理每个被注解的元素
    val annotated = annottees.map {
      case q"$mods def $name[..$tparams](...$paramss): $tpt = $expr" =>
        // 在方法体前添加一段打印输出的代码
        q"""
          $mods def $name[..$tparams](...$paramss): $tpt = {
            println("Before method execution")
            $expr
          }
        """
      case other =>
        // 如果不是方法，则原样返回
        other
    }

    // 返回处理后的代码
    annotated.headOption.getOrElse {
      c.abort(c.enclosingPosition, "Invalid annotation target")
    }
  }
}

// 在注解上使用宏
object MyAnnotationApp extends App {
  import scala.language.experimental.macros

  // 编译时调用宏处理注解
  @MyAnnotation
  class AnnotatedClass {
    def annotatedMethod(): Unit = {
      println("Executing annotatedMethod")
    }
  }

  // 输出处理后的代码
  println(MyAnnotationMacro.impl(new scala.reflect.macros.blackbox.Context)(q"class X", q"def x = 42"))
}

在上述代码中：

1. MyAnnotation 类继承了 StaticAnnotation，它就是我们自定义注解的主体。

2. MyClass 类上应用了 @MyAnnotation 注解。

3. MyAnnotationMacro 定义了一个宏，该宏在注解被处理时会修改被注解的类或方法的行为。这个宏使用了 Scala 的宏系统。

4. MyAnnotationApp 中创建了一个带有注解的类 AnnotatedClass，并输出了宏处理后的代码。

注意：Scala 的宏系统是一项高级特性，理解和使用宏需要深入的知识。在实际开发中，大多数情况下并不需要使用宏。