Wie der Zugriff auf Annotation definiert auf Fall-class-Feld zur Laufzeit

Habe ich den folgenden java-Annotation definiert 

   @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.FIELD})
   @Retention(RetentionPolicy.RUNTIME)
   public @interface MyAnnotation { 
     String value() default "";
   }

Und ich habe die folgende scala Fall Klasse definiert:

@Prefer("xyz")
case class TestAnno(arg1 : String, @Prefer("abc") agr2 : String)

Ich bin in der Lage, siehe die Anmerkung definierten Fall Klasse mit der spiegelung, aber ich bin nicht in der Lage, den Zugriff auf die annotation definiert arg2 Mitglied von Fall Klasse TestAnno. De-kompilieren des Codes sehe ich, dass weder die Deklaration von Variablen oder es ist scala-accessor zu haben scheinen, die annotation. Nur der Konstruktor-definition und copy Methode scheinen behalten die Anmerkung zum Parameter definiert, wenn die Klasse Erklärung.

Gibt es eine andere Möglichkeit, um Kraft der scala-compiler zum generieren von Annotationen, die für die deklarierten Felder in Fall Klasse oder ich Lesen Sie den Konstruktor und die Benutzung einer Bibliothek wie ASM ByteCode-Bibliothek oder ParaNamer zu ermitteln, welche Parameter haben die Anmerkungen? Benötigen Sie eine Lösung, die arbeiten werden in Erster Linie für Scala case-Klassen.

InformationsquelleAutor cracked_all | 2012-07-13
  1. 15

    Brauchen Sie nur Folgendes zu tun :

    case class TestAnno(arg1 : String, @(Prefer @field)("abc") agr2 : String)

    Mehr info hier http://www.scala-lang.org/api/current/#scala.annotation.meta.package

    • Je nachdem, wie Sie den Zugriff auf diese Parameter durch die Reflexion, die Sie haben können, um @setter, @getter oder @param anstelle oder zusammen mit @field. (Sie können versuchen, mit allen von Ihnen, und entfernen Sie Sie nacheinander.)
    InformationsquelleAutor Quentin
  2. 8

    Quentin ' s Lösung funktioniert, aber IMHO ist es zu viel boilerplate für den Benutzer.

    Lesen Sie Anmerkungen auf die Argumente im Konstruktor mit dem standard-reflection-API. Ich brauchte diese für eine makro-Implementierung.

    scala> :paste
//Entering paste mode (ctrl-D to finish)

import scala.annotation.StaticAnnotation
final class min(i: Long) extends StaticAnnotation

case class Foo(@min(1) c: String)
import scala.reflect.runtime.universe._
symbolOf[Foo].asClass.primaryConstructor.typeSignature.paramLists.head.head.annotations

//Exiting paste mode, now interpreting.

import scala.annotation.StaticAnnotation
defined class min
defined class Foo
import scala.reflect.runtime.universe._
res0: List[reflect.runtime.universe.Annotation] = List(min(1L))
    • Wie kann Beschriftungs-info zugegriffen werden?
    InformationsquelleAutor Dimitri
  3. 2

    Ich habe einige suchen sich um und kam mit zwei Lösungen. Kommentare, Suggesstions, Verbesserungen sind willkommen, ich habe markiert diese Antwort als wiki. Die erste basiert auf ScalaBeans und ParaNamer.

      def valNamesWithAnnotations[T <: AnyRef](obj : T)(implicit m : Manifest[T]) : List[(String, List[java.lang.annotation.Annotation])] = {
    val descriptor = descriptorOf(obj.getClass)

    val c = descriptor.beanType.erasure

    val constructor: Option[Constructor[_]] = {
      if (c.getConstructors().isEmpty) None
      else Some(c.getConstructors()(0).asInstanceOf[Constructor[_]])
    }

    val paranamer = new BytecodeReadingParanamer
    val ctorParameterNames = constructor.map(paranamer.lookupParameterNames(_)).getOrElse(scala.Array[String]()).toList
    val ctorParamAnnos = constructor.getOrElse(sys.error("Cannot find constructor entry for class " + c.getName)).getParameterAnnotations

    val builder = List.newBuilder[(String, List[java.lang.annotation.Annotation])]
    val paramIter = ctorParameterNames.iterator
    val annoIter = ctorParamAnnos.iterator

    while(paramIter.hasNext && annoIter.hasNext ) {
      builder += ((paramIter.next, annoIter.next.toList))
    }

    builder.result
  }

    Der zweite Ansatz verwendet ScalaSignatures und ist auf dieser Basis SO beantworten:

      def valNamesWithAnnotations[C: ClassManifest] : List[(String, List[java.lang.annotation.Annotation])] = {
    val cls = classManifest[C].erasure
    val ctors = cls.getConstructors

    assert(ctors.size == 1, "Class " + cls.getName + " should have only one constructor")
    val sig = ScalaSigParser.parse(cls).getOrElse(sys.error("No ScalaSig for class " + cls.getName + ", make sure it is a top-level case class"))

    val classSymbol = sig.parseEntry(0).asInstanceOf[ClassSymbol]
    assert(classSymbol.isCase, "Class " + cls.getName + " is not a case class")

    val tableSize = sig.table.size
    val ctorIndex = (1 until tableSize).find { i =>
      sig.parseEntry(i) match {
        case m @ MethodSymbol(SymbolInfo("<init>", owner, _, _, _, _), _) => owner match {
          case sym: SymbolInfoSymbol if sym.index == 0 => true
          case _ => false
        }
        case _ => false
      }
    }.getOrElse(sys.error("Cannot find constructor entry in ScalaSig for class " + cls.getName))

    val paramsListBuilder = List.newBuilder[String]
    for (i <- (ctorIndex + 1) until tableSize) {
      sig.parseEntry(i) match {
        case MethodSymbol(SymbolInfo(name, owner, _, _, _, _), _) => owner match {
          case sym: SymbolInfoSymbol if sym.index == ctorIndex => paramsListBuilder += name
          case _ =>
        }
        case _ =>
      }
    }

    val paramAnnoArr = ctors(0).getParameterAnnotations
    val builder = List.newBuilder[(String, List[java.lang.annotation.Annotation])]

    val paramIter = paramsListBuilder.result.iterator
    val annoIter = paramAnnoArr.iterator

    while(paramIter.hasNext && annoIter.hasNext ) {
      builder += ((paramIter.next, annoIter.next.toList))
    }

    builder.result
  }
    InformationsquelleAutor
Schreibe einen Kommentar