Concetti base del Java annotation processing

L'annotazione @Convert

L'annotazione @Convert serve ad individuare quali classi saranno soggette alla conversione in ContentValue. La definizione dell'annotazione è la seguente:

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

Come descritto in precedenza, la definizione di @Convert è collocata nel progetto "Annotation". Ad esempio, la classe Persona sarà decorata in questo modo:

@Convert
public class Persona {

	public String nome;
	public String cognome;
	public int eta;
	public int peso;
}

Una particolarità importante da tenere a mente è che le annotazioni non vengono ereditate Persona

Il processore di annotazioni

Un processore di annotazioni è una classe Java che consente di elaborare i file sorgenti passati al compilatore. Gli AP vengono agganciati alla fase di compilazione. Tra le loro particolarità bisogna sicuramente citare il fatto che vengono eseguiti in virtual machine separate. Normalmente un AP deriva dalla classe AbstractProcessor. Di seguito è riportata la struttura base di un AP.

package it.html.jap;

public class ConvertProcessor extends AbstractProcessor {
    @Override
    public synchronized void init(ProcessingEnvironment env){ ... }

    @Override
    public boolean process(Set<? extends TypeElement> annoations, RoundEnvironment env) { ... }
    @Override
    public Set<String> getSupportedAnnotationTypes() { ... }

    @Override
    public SourceVersion getSupportedSourceVersion() { ... }
}

Analizziamo brevemente lo scopo dei vari metodi:

Metodo init

È il metodo usato per inizializzare il processore di annotazioni. Normalmente dal parametro ProcessingEnvironment, passato al metodo init, si recuperano i riferimenti a:

• elements Element
• types TypeMirror
• filer

I processori di annotazione analizzano i sorgenti Java. Ogni componente della definizione di una classe viene identificato da un element. Esistono vari tipi di element che si differenziano in base a quello che rappresentano: il package, la classe, gli attributi o i metodi. Nel codice sottostante, per ogni parte della definizione della classe, all'interno dei commenti, viene riportato l'element associato.

package it.html.jap;  // PackageElement

public class Persona {  // TypeElement
  private int eta;      // VariableElement
  private String nome;  // VariableElement

  public Persona () {}  // ExecuteableElement
  public void setNome (  // ExecuteableElement
    String value         // TypeElement
  ) { ... }

  public void setEta (  // ExecuteableElement
    int value           // TypeElement
  ) { ... }
}

Bisogna sempre tener presente che i file Java contengono codice strutturato. La rappresentazione con la quale lavorano i processori è una struttura ad albero di elementi. Per esempio, se si ha un TypeElement public class Prova

TypeElement provaClass = ... ;
for (Element item : provaClass.getEnclosedElements()){ // itera sugli elementi figli
	...
}

TypeElement .java TypeElement TypeElement TypeMirror element element.asType()

Ti consigliamo anche

Java

Java e Deep Learning, la guida

Java

Quarkus, guida allo stack Java Kubernetes

Blockchain

Sviluppare Blockchain in Java, la guida

Java

Java per i sistemi Embedded, la guida

Metodo	Descrizione
init(ProcessingEnvironment env)	Viene invocato dall'annotation processing, prima dell'analisi delle classi da compilare, con un parametro di tipo ProcessingEnviroment
process(Set<? extends TypeElement> annotations, RoundEnvironment env)	Questo metodo contiene il codice per effettuare lo scan, elaborare le annotazioni e generare i file. Il parametro RoundEnviroment
getSupportedAnnotationTypes()	Restituisce l'insieme di annotazioni gestite dal processore.
getSupportedSourceVersion()	Specifica quale versione di Java è supportata. Per indicare che si vuole supportare fino all'ultima versione di Java disponibile deve restituire la costante SourceVersion.latestSupported()