Creazione di un plug-in del compilatore Java

1. Panoramica

Java 8 fornisce un'API per la creazione di plug -in Javac . Sfortunatamente, è difficile trovare una buona documentazione per questo.

In questo articolo, mostreremo l'intero processo di creazione di un'estensione del compilatore che aggiunge codice personalizzato ai file * .class .

2. Configurazione

Innanzitutto, dobbiamo aggiungere tools.jar di JDK come dipendenza per il nostro progetto:

 com.sun tools 1.8.0 system ${java.home}/../lib/tools.jar 

Ogni estensione del compilatore è una classe che implementa l' interfaccia com.sun.source.util.Plugin . Creiamolo nel nostro esempio:

Creiamolo nel nostro esempio:

public class SampleJavacPlugin implements Plugin { @Override public String getName() { return "MyPlugin"; } @Override public void init(JavacTask task, String... args) { Context context = ((BasicJavacTask) task).getContext(); Log.instance(context) .printRawLines(Log.WriterKind.NOTICE, "Hello from " + getName()); } }

Per ora, stiamo solo stampando "Hello" per assicurarci che il nostro codice venga raccolto e incluso con successo nella compilazione.

Il nostro obiettivo finale sarà creare un plugin che aggiunga controlli di runtime per ogni argomento numerico contrassegnato con una data annotazione e generi un'eccezione se l'argomento non corrisponde a una condizione.

C'è un altro passaggio necessario per rendere l'estensione rilevabile da Javac: dovrebbe essere esposta tramite il framework ServiceLoader .

Per raggiungere questo obiettivo, abbiamo bisogno di creare un file denominato com.sun.source.util.Plugin con il contenuto che è il nome completo della classe del nostro plugin ( com.baeldung.javac.SampleJavacPlugin ) e posizionarlo nel META-INF / servizi di directory .

Dopodiché, possiamo chiamare Javac con l' opzione -Xplugin: MyPlugin :

baeldung/tutorials$ javac -cp ./core-java/target/classes -Xplugin:MyPlugin ./core-java/src/main/java/com/baeldung/javac/TestClass.java Hello from MyPlugin

Nota che dobbiamo sempre usare una stringa restituita dal metodo getName () del plugin come valore dell'opzione -Xplugin .

3. Ciclo di vita del plugin

Un plugin viene chiamato dal compilatore solo una volta, tramite il metodo init () .

Per essere avvisati degli eventi successivi, dobbiamo registrare una richiamata. Questi arrivano prima e dopo ogni fase di elaborazione per file sorgente:

  • PARSE - costruisce un albero sintassi astratto (AST)
  • INVIO : le importazioni del codice sorgente vengono risolte
  • ANALYZE - l'output del parser (un AST) viene analizzato per gli errori
  • GENERATE - generazione di binari per il file sorgente di destinazione

Ci sono altri due tipi di eventi: ANNOTATION_PROCESSING e ANNOTATION_PROCESSING_ROUND ma qui non ci interessano.

Ad esempio, quando vogliamo migliorare la compilazione aggiungendo alcuni controlli basati sulle informazioni sul codice sorgente, è ragionevole farlo nel gestore dell'evento finito PARSE :

public void init(JavacTask task, String... args) { task.addTaskListener(new TaskListener() { public void started(TaskEvent e) { } public void finished(TaskEvent e) { if (e.getKind() != TaskEvent.Kind.PARSE) { return; } // Perform instrumentation } }); }

4. Estrai dati AST

Possiamo ottenere un AST generato dal compilatore Java tramite TaskEvent.getCompilationUnit () . I suoi dettagli possono essere esaminati tramite l' interfaccia TreeVisitor .

Notare che solo un elemento Tree , per il quale viene chiamato il metodo accept () , invia eventi a un dato visitatore.

Ad esempio, quando eseguiamo ClassTree.accept (visitor) , viene attivato solo visitClass () ; non possiamo aspettarci che, diciamo, visitMethod () sia attivato anche per ogni metodo nella classe data.

Possiamo usare TreeScanner per superare il problema:

public void finished(TaskEvent e) { if (e.getKind() != TaskEvent.Kind.PARSE) { return; } e.getCompilationUnit().accept(new TreeScanner() { @Override public Void visitClass(ClassTree node, Void aVoid) { return super.visitClass(node, aVoid); @Override public Void visitMethod(MethodTree node, Void aVoid) { return super.visitMethod(node, aVoid); } }, null); }

In questo esempio, è necessario chiamare super.visitXxx (nodo, valore) per elaborare in modo ricorsivo i figli del nodo corrente.

5. Modifica AST

Per mostrare come possiamo modificare l'AST, inseriremo controlli di runtime per tutti gli argomenti numerici contrassegnati con un'annotazione @Positive .

Questa è una semplice annotazione che può essere applicata ai parametri del metodo:

@Documented @Retention(RetentionPolicy.CLASS) @Target({ElementType.PARAMETER}) public @interface Positive { }

Ecco un esempio di utilizzo dell'annotazione:

public void service(@Positive int i) { }

Alla fine, vogliamo che il bytecode appaia come se fosse compilato da una sorgente come questa:

public void service(@Positive int i) { if (i <= 0) { throw new IllegalArgumentException("A non-positive argument (" + i + ") is given as a @Positive parameter 'i'"); } }

Ciò significa che vogliamo che venga generata un'eccezione IllegalArgumentException per ogni argomento contrassegnato con @Positive che è uguale o minore di 0.

5.1. Dove strumentare

Scopriamo come individuare i punti target in cui applicare la strumentazione:

private static Set TARGET_TYPES = Stream.of( byte.class, short.class, char.class, int.class, long.class, float.class, double.class) .map(Class::getName) .collect(Collectors.toSet()); 

Per semplicità, qui abbiamo aggiunto solo tipi numerici primitivi.

Quindi, definiamo un metodo shouldInstrument () che controlla se il parametro ha un tipo nel set TARGET_TYPES così come l' annotazione @Positive :

private boolean shouldInstrument(VariableTree parameter) { return TARGET_TYPES.contains(parameter.getType().toString()) && parameter.getModifiers().getAnnotations().stream() .anyMatch(a -> Positive.class.getSimpleName() .equals(a.getAnnotationType().toString())); }

Then we'll continue the finished() method in our SampleJavacPlugin class with applying a check to all parameters that fulfill our conditions:

public void finished(TaskEvent e) { if (e.getKind() != TaskEvent.Kind.PARSE) { return; } e.getCompilationUnit().accept(new TreeScanner() { @Override public Void visitMethod(MethodTree method, Void v) { List parametersToInstrument = method.getParameters().stream() .filter(SampleJavacPlugin.this::shouldInstrument) .collect(Collectors.toList()); if (!parametersToInstrument.isEmpty()) { Collections.reverse(parametersToInstrument); parametersToInstrument.forEach(p -> addCheck(method, p, context)); } return super.visitMethod(method, v); } }, null); 

In this example, we've reversed the parameters list because there's a possible case that more than one argument is marked by @Positive. As every check is added as the very first method instruction, we process them RTL to ensure the correct order.

5.2. How to Instrument

The problem is that “read AST” lays in the public API area, while “modify AST” operations like “add null-checks” are a private API.

To address this, we'll create new AST elements through a TreeMaker instance.

First, we need to obtain a Context instance:

@Override public void init(JavacTask task, String... args) { Context context = ((BasicJavacTask) task).getContext(); // ... }

Then, we can obtain the TreeMarker object through the TreeMarker.instance(Context) method.

Now we can build new AST elements, e.g., an if expression can be constructed by a call to TreeMaker.If():

private static JCTree.JCIf createCheck(VariableTree parameter, Context context) { TreeMaker factory = TreeMaker.instance(context); Names symbolsTable = Names.instance(context); return factory.at(((JCTree) parameter).pos) .If(factory.Parens(createIfCondition(factory, symbolsTable, parameter)), createIfBlock(factory, symbolsTable, parameter), null); }

Please note that we want to show the correct stack trace line when an exception is thrown from our check. That's why we adjust the AST factory position before creating new elements through it with factory.at(((JCTree) parameter).pos).

The createIfCondition() method builds the “parameterId< 0″ if condition:

private static JCTree.JCBinary createIfCondition(TreeMaker factory, Names symbolsTable, VariableTree parameter) { Name parameterId = symbolsTable.fromString(parameter.getName().toString()); return factory.Binary(JCTree.Tag.LE, factory.Ident(parameterId), factory.Literal(TypeTag.INT, 0)); }

Next, the createIfBlock() method builds a block that returns an IllegalArgumentException:

private static JCTree.JCBlock createIfBlock(TreeMaker factory, Names symbolsTable, VariableTree parameter) { String parameterName = parameter.getName().toString(); Name parameterId = symbolsTable.fromString(parameterName); String errorMessagePrefix = String.format( "Argument '%s' of type %s is marked by @%s but got '", parameterName, parameter.getType(), Positive.class.getSimpleName()); String errorMessageSuffix = "' for it"; return factory.Block(0, com.sun.tools.javac.util.List.of( factory.Throw( factory.NewClass(null, nil(), factory.Ident(symbolsTable.fromString( IllegalArgumentException.class.getSimpleName())), com.sun.tools.javac.util.List.of(factory.Binary(JCTree.Tag.PLUS, factory.Binary(JCTree.Tag.PLUS, factory.Literal(TypeTag.CLASS, errorMessagePrefix), factory.Ident(parameterId)), factory.Literal(TypeTag.CLASS, errorMessageSuffix))), null)))); }

Now that we're able to build new AST elements, we need to insert them into the AST prepared by the parser. We can achieve this by casting public API elements to private API types:

private void addCheck(MethodTree method, VariableTree parameter, Context context) { JCTree.JCIf check = createCheck(parameter, context); JCTree.JCBlock body = (JCTree.JCBlock) method.getBody(); body.stats = body.stats.prepend(check); }

6. Testing the Plugin

We need to be able to test our plugin. It involves the following:

  • compile the test source
  • run the compiled binaries and ensure that they behave as expected

For this, we need to introduce a few auxiliary classes.

SimpleSourceFile exposes the given source file's text to the Javac:

public class SimpleSourceFile extends SimpleJavaFileObject { private String content; public SimpleSourceFile(String qualifiedClassName, String testSource) { super(URI.create(String.format( "file://%s%s", qualifiedClassName.replaceAll("\\.", "/"), Kind.SOURCE.extension)), Kind.SOURCE); content = testSource; } @Override public CharSequence getCharContent(boolean ignoreEncodingErrors) { return content; } }

SimpleClassFile holds the compilation result as a byte array:

public class SimpleClassFile extends SimpleJavaFileObject { private ByteArrayOutputStream out; public SimpleClassFile(URI uri) { super(uri, Kind.CLASS); } @Override public OutputStream openOutputStream() throws IOException { return out = new ByteArrayOutputStream(); } public byte[] getCompiledBinaries() { return out.toByteArray(); } // getters }

SimpleFileManager ensures the compiler uses our bytecode holder:

public class SimpleFileManager extends ForwardingJavaFileManager { private List compiled = new ArrayList(); // standard constructors/getters @Override public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) { SimpleClassFile result = new SimpleClassFile( URI.create("string://" + className)); compiled.add(result); return result; } public List getCompiled() { return compiled; } }

Finally, all of that is bound to the in-memory compilation:

public class TestCompiler { public byte[] compile(String qualifiedClassName, String testSource) { StringWriter output = new StringWriter(); JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); SimpleFileManager fileManager = new SimpleFileManager( compiler.getStandardFileManager(null, null, null)); List compilationUnits = singletonList(new SimpleSourceFile(qualifiedClassName, testSource)); List arguments = new ArrayList(); arguments.addAll(asList("-classpath", System.getProperty("java.class.path"), "-Xplugin:" + SampleJavacPlugin.NAME)); JavaCompiler.CompilationTask task = compiler.getTask(output, fileManager, null, arguments, null, compilationUnits); task.call(); return fileManager.getCompiled().iterator().next().getCompiledBinaries(); } }

After that, we need only to run the binaries:

public class TestRunner { public Object run(byte[] byteCode, String qualifiedClassName, String methodName, Class[] argumentTypes, Object... args) throws Throwable { ClassLoader classLoader = new ClassLoader() { @Override protected Class findClass(String name) throws ClassNotFoundException { return defineClass(name, byteCode, 0, byteCode.length); } }; Class clazz; try { clazz = classLoader.loadClass(qualifiedClassName); } catch (ClassNotFoundException e) { throw new RuntimeException("Can't load compiled test class", e); } Method method; try { method = clazz.getMethod(methodName, argumentTypes); } catch (NoSuchMethodException e) { throw new RuntimeException( "Can't find the 'main()' method in the compiled test class", e); } try { return method.invoke(null, args); } catch (InvocationTargetException e) { throw e.getCause(); } } }

A test might look like this:

public class SampleJavacPluginTest { private static final String CLASS_TEMPLATE = "package com.baeldung.javac;\n\n" + "public class Test {\n" + " public static %1$s service(@Positive %1$s i) {\n" + " return i;\n" + " }\n" + "}\n" + ""; private TestCompiler compiler = new TestCompiler(); private TestRunner runner = new TestRunner(); @Test(expected = IllegalArgumentException.class) public void givenInt_whenNegative_thenThrowsException() throws Throwable { compileAndRun(double.class,-1); } private Object compileAndRun(Class argumentType, Object argument) throws Throwable { String qualifiedClassName = "com.baeldung.javac.Test"; byte[] byteCode = compiler.compile(qualifiedClassName, String.format(CLASS_TEMPLATE, argumentType.getName())); return runner.run(byteCode, qualifiedClassName, "service", new Class[] {argumentType}, argument); } }

Here we're compiling a Test class with a service() method that has a parameter annotated with @Positive. Then, we're running the Test class by setting a double value of -1 for the method parameter.

As a result of running the compiler with our plugin, the test will throw an IllegalArgumentException for the negative parameter.

7. Conclusion

In this article, we've shown the full process of creating, testing and running a Java Compiler plugin.

Il codice sorgente completo degli esempi può essere trovato su GitHub.