Създаване на приставка за компилатор на Java

1. Общ преглед

Java 8 предоставя API за създаване на приставки на Javac . За съжаление е трудно да се намери добра документация за него.

В тази статия ще покажем целия процес на създаване на разширение на компилатора, което добавя персонализиран код към * .class файлове.

2. Настройка

Първо, трябва да добавим инструментите на JDK tools.jar като зависимост за нашия проект:

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

Всяко разширение на компилатора е клас, който реализира com.sun.source.util.Plugin интерфейс. Нека го създадем в нашия пример:

Нека го създадем в нашия пример:

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()); } }

Засега просто отпечатваме „Здравейте“, за да гарантираме, че нашият код е успешно взет и включен в компилацията.

Нашата крайна цел ще бъде да създадем плъгин, който добавя проверки по време на изпълнение за всеки числов аргумент, маркиран с дадена анотация, и да хвърли изключение, ако аргументът не отговаря на условие.

Има един по-необходима стъпка, за да Видим разширение от Javac: тя трябва да бъде изложен през ServiceLoader рамка.

За да се постигне това, трябва да създадем файл с име com.sun.source.util.Plugin със съдържание, което е напълно квалифициран името на класа на приставката ни ( com.baeldung.javac.SampleJavacPlugin ) и го поставете в META-INF / услуги директория .

След това можем да се обадим на Javac с превключвателя -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

Имайте предвид, че винаги трябва да използваме низ, върнат от метода getName () на приставката като стойност на опцията -Xplugin .

3. Жизнен цикъл на приставката

А плъгин се нарича от компилатора само веднъж, през първоначален () метод.

За да бъдем уведомени за последващи събития, трябва да регистрираме обратно обаждане. Те пристигат преди и след всеки етап на обработка за изходен файл:

  • PARSE - изгражда абстрактно синтаксисно дърво (AST)
  • ENTER - импортирането на изходен код е разрешено
  • ANALYZE - изходът на парсер (AST) се анализира за грешки
  • GENERATE - генериране на двоични файлове за целевия изходен файл

Има още два вида събития - ANNOTATION_PROCESSING и ANNOTATION_PROCESSING_ROUND, но ние не се интересуваме от тях тук.

Например, когато искаме да подобрим компилацията чрез добавяне на някои проверки въз основа на информация за изходния код, е разумно да направим това в обработващия събитие 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. Извличане на AST данни

Можем да получим AST, генериран от компилатора на Java чрез TaskEvent.getCompilationUnit () . Подробностите му могат да бъдат разгледани чрез интерфейса TreeVisitor .

Имайте предвид, че само елемент Tree , за който е извикан метод accept () , изпраща събития до дадения посетител.

Например, когато изпълняваме ClassTree.accept (посетител) , се задейства само visitClass () ; не можем да очакваме, че, да речем, visitMethod () също е активиран за всеки метод в дадения клас.

Можем да използваме TreeScanner за преодоляване на проблема:

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); }

В този пример е необходимо да извикате super.visitXxx (възел, стойност), за да обработите рекурсивно децата на текущия възел.

5. Променете AST

За да покажем как можем да модифицираме AST, ще вмъкнем проверки по време на изпълнение за всички числови аргументи, маркирани с @Positive анотация.

Това е проста анотация, която може да се приложи към параметрите на метода:

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

Ето пример за използване на анотацията:

public void service(@Positive int i) { }

В крайна сметка искаме байт кода да изглежда така, сякаш е компилиран от източник като този:

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

Това означава, че искаме IllegalArgumentException да бъде хвърлен за всеки аргумент, маркиран с @Positive, който е равен или по-малък от 0.

5.1. Къде да Инструментирам

Нека да разберем как можем да намерим целеви места, където трябва да се приложи инструментариумът:

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()); 

За простота тук сме добавили само примитивни числови типове.

След това нека дефинираме метод shouldInstrument () , който проверява дали параметърът има тип в набора TARGET_TYPES, както и анотацията @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.

Пълният изходен код на примерите може да бъде намерен в GitHub.