[JAVA] Für SOURCE-Annotationen ist möglicherweise keine Aufbewahrung verfügbar, wenn die Annotationsverarbeitung in der IDE ausgeführt wird

Beim Ausführen der Anmerkungsverarbeitung in der IDE werden die durch "@Retention (RetentionPolicy.SOURCE)" definierten Anmerkungsinformationen unter bestimmten Bedingungen möglicherweise nicht abgerufen.

Umgebung

OS

Windows 10

Java

openjdk 10.0.2

Eclipse

Photon (4.8.0) ※Pleiades

IntelliJ

IntelliJ IDEA 2018.2.3 (Community Edition)

Gradle

Gradle 4.10

Symptome

Quellcode

Projektstruktur

|-foo/
| `-src/main/java/
|   `-sample/foo/
|     |-Fizz.java
|     `-Buzz.java
|
|-bar/
| |-src/main/java/
| | `-sample/bar/
| |   |-MyRuntimeRetention.java
| |   |-MyClassRetention.java
| |   |-MySourceRetention.java
| |   `-MyProcessor.java
| |
| `-src/main/resources/
|   `-META-INF/services
|     `-javax.annotation.processing.Processor
|
|-build.gradle
`-settings.gradle

--Multi-Projekt von foo, bar

• Ein Projekt, in dem bar die Annotationsverarbeitung implementiert --foo ist ein Projekt, das die Annotationsverarbeitung von bar verwendet
• "MyRuntimeRetention.java", "MyClassRetention.java", "MySourceRetention.java" sind ihre eigenen Anmerkungen, und "Retention" wird auf den Wert gesetzt, der dem Namen entspricht.

MyRuntimeRetention.java

package sample.bar;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRuntimeRetention {
}

MyClassRetention.java

package sample.bar;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface MyClassRetention {
}

MySourceRetention.java

package sample.bar;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface MySourceRetention {
}

• Eine Klasse, in der MyProcessor.java die Annotationsverarbeitung implementiert

MyProcessor.java

package sample.bar;

import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.tools.Diagnostic.Kind;

public class MyProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Elements elements = this.processingEnv.getElementUtils();
        
        if (!annotations.isEmpty()) {
            this.printAnnotations(elements.getTypeElement("sample.foo.Fizz"));
            this.printAnnotations(elements.getTypeElement("sample.foo.Buzz"));
        }
        
        return true;
    }
    
    private void printAnnotations(TypeElement element) {
        element.getAnnotationMirrors().forEach(annotation -> {
            this.processingEnv.getMessager().printMessage(Kind.NOTE, element.getSimpleName() + " : " + annotation);
        });
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.RELEASE_10;
    }
    
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Set.of(MySourceRetention.class.getCanonicalName());
    }
}

• Erhalten von "TypeElement" von "Fizz", "Buzz" -Klasse und Ausgeben einer Liste von Anmerkungen, die in der Klasse festgelegt sind

Fizz.java

package sample.foo;

import sample.bar.MyClassRetention;
import sample.bar.MyRuntimeRetention;
import sample.bar.MySourceRetention;

@MyRuntimeRetention
@MyClassRetention
@MySourceRetention
public class Fizz {
}

Buzz.java

package sample.foo;

import sample.bar.MyClassRetention;
import sample.bar.MyRuntimeRetention;
import sample.bar.MySourceRetention;

@MyRuntimeRetention
@MyClassRetention
@MySourceRetention
public class Buzz {
}

• Das "Fizz", "Buzz" des "foo" -Projekts enthält drei selbst erstellte Anmerkungen in der Klasse.

Verarbeitung durchgeführt werden

Ändern Sie in diesem Zustand nur die Klasse ** Fizz und führen Sie die ** Kompilierung aus. Das Ergebnis ist dann anders, wenn es in Gradle und in IDE (Eclipse, IntelliJ) ausgeführt wird.

Beim Laufen auf Gradle

> gradle :foo:compileJava

Hinweis:Fizz : @sample.bar.MyRuntimeRetention
Hinweis:Fizz : @sample.bar.MyClassRetention
Hinweis:Fizz : @sample.bar.MySourceRetention
Hinweis:Buzz : @sample.bar.MyRuntimeRetention
Hinweis:Buzz : @sample.bar.MyClassRetention
Hinweis:Buzz : @sample.bar.MySourceRetention

• Sie können alle Anmerkungsinformationen normal abrufen.

Beim Ausführen in Eclipse

• Alle Anmerkungen der Klasse "Fizz" wurden erfasst.
• @ MySourceRetention konnte jedoch die Annotation der Buzz-Klasse nicht erhalten.

Beim Ausführen auf IntelliJ

• Dies ist auch dasselbe wie Eclipse, und "@ MySourceRetention" kann nicht aus den Anmerkungsinformationen der "Buzz" -Klasse abgerufen werden.

Sie können es auch in der IDE erhalten, indem Sie Buzz ändern

• Ändern Sie nicht nur die "Fizz" -Klasse, sondern auch die "Buzz" -Klasse und führen Sie dann den Build aus, damit der Anmerkungsprozess funktioniert.
• Dann ist das Ergebnis wie folgt.

Eclipse

• Sie können auch das "@ MySourceRetention" -Set in "Buzz" erhalten.

IntelliJ

――Das Gleiche gilt hier, und Sie können @ MySourceRetention erhalten.

Rate, was passiert ist

--Wenn "Aufbewahrung" auf "QUELLE" gesetzt ist, verbleiben keine Anmerkungsinformationen in der Klassendatei /RetentionPolicy.html#SOURCE)

• Angesichts der Tatsache, dass nur die Informationen der angegebenen Annotation nicht abgerufen werden konnten, wenn sie nicht geändert wurden, wahrscheinlich wenn die Annotationsverarbeitung in IDE (Eclipse, IntelliJ), der Klasse ohne Modifikation, funktioniert Ich bin der Meinung, dass die Informationen auf dem vorherigen Kompilierungsergebnis (Klassendatei) basieren.
• Übrigens habe ich NetBeans nicht ausprobiert

Schlussfolgerung (Vermutung)

• Wenn die Annotationsverarbeitung in IDE (Eclipse, IntelliJ) funktioniert, können Sie anscheinend nicht die Informationen der Annotation abrufen, deren "Aufbewahrung" "SOURCE" ist, die in der Klasse ohne Änderung festgelegt ist.
• Der Grund ist wahrscheinlich, dass die IDE die Informationen der unveränderten Klasse aus dem vorherigen Kompilierungsergebnis (Klassendatei) zu erhalten scheint. --Wenn Sie Ihre eigene Annotationsverarbeitung schreiben, gehen Sie vorsichtig mit Annotationen um, deren "Aufbewahrung" "QUELLE" ist.
• Wenn Sie Ihre eigenen Anmerkungen machen, ist es eine gute Idee, "Aufbewahrung" auf "KLASSE" oder höher zu setzen.