How to get the annotations of a method - scala

Question

Let's assume we have a scala class like this:
class MyClass {
#MyAnnotationWithParams(message = "Hello", lang = "en-US")
def myMethod1 = println("Hello everybody")
#MyAnnotationWithParams(message = "Hallo", lang = "de-DE")
def myMethod2 = println("Hallo zama")
}
How do I get the annotation values of each method at runtime?

Answer 1

The following function will return a map from method names to a map from annotation names to annotation data. Each annotation datum is a map from annotation argument name and argument value.
import scala.reflect.runtime.universe._
def methodAnnotations[T: TypeTag]: Map[String, Map[String, Map[String, JavaArgument]]] = {
val tpe = typeTag[T].tpe
val methods = tpe.declarations.collect { case m: MethodSymbol => m }
methods.map { m =>
val methodName = m.name.toString
val annotations = m.annotations.map { a =>
val annotationName = a.tpe.typeSymbol.name.toString
val annotationArgs = a.javaArgs.map { case (name, value) =>
name.toString -> value
}
annotationName -> annotationArgs
}.toMap
methodName -> annotations
}.toMap
}
Let's check how it works:
scala> import javax.xml.bind.annotation.XmlNs
import javax.xml.bind.annotation.XmlNs
scala> :paste
// Entering paste mode (ctrl-D to finish)
class Example {
#SuppressWarnings(Array("unchecked"))
def test1() {}
#XmlNs(prefix="c", namespaceURI="urn:abcd")
def test2() {}
}
// Exiting paste mode, now interpreting.
defined class Example
scala> methodAnnotations[Example]
res50: Map[String,Map[String,Map[String,reflect.runtime.universe.JavaArgument]]] = Map(<init> -> Map(), test1 -> Map(SuppressWarnings -> Map(value -> ["unchecked"])), test2 -> Map(XmlNs -> Map(prefix -> "c", namespaceURI -> "urn:abcd")))
You can see that the map was built correctly. Extracting actual values from JavaArgument class requires more actions. JavaArgument is an abstract class which has several subclasses, for example, LiteralArgument or ArrayArgument. You'll have to convert obtained values manually, depending on the actual annotation you're working with:
scala> res50("test1")("SuppressWarnings")("value").asInstanceOf[ArrayArgument]
res51: reflect.runtime.universe.ArrayArgument = ["unchecked"]
scala> res51.args.collect { case a: LiteralArgument => a.value.value }.collect { case a: String => a }
res58: Array[String] = Array(unchecked)
scala> res50("test2")("XmlNs")("prefix").asInstanceOf[LiteralArgument].value.value.asInstanceOf[String]
res59: String = c
This is the proper way of dealing with annotations via Scala reflection (probably you even should use scalaArgs instead of javaArgs; that will give different structure than the one I've used here).
There is an easier, but not that correct way. You can use Java reflection:
import scala.reflect.{ClassTag, classTag}
import java.lang.annotation.{Annotation => JAnnotation}
def javaMethodAnnotations[T: ClassTag]: Map[String, List[JAnnotation]] = {
classTag[T].runtimeClass.getDeclaredMethods.map { m =>
m.getName -> m.getAnnotations.toList
}.toMap
}
Example use:
scala> javaMethodAnnotations[Example]
res71: Map[String,List[java.lang.annotation.Annotation]] = Map(test1 -> List(), test2 -> List(#javax.xml.bind.annotation.XmlNs(prefix=c, namespaceURI=urn:abcd)))
Note that #SuppressWarnings annotation is missing. That's because its retention is not runtime. But this is usually not a problem.
This way you'll have to convert annotation objects to your annotation types:
scala> res71("test2")(0).asInstanceOf[XmlNs].prefix()
res72: String = c
Interesting links:
http://docs.scala-lang.org/overviews/reflection/overview.html