gunnarmorling / awesome-annotation-processing

A curated list of resources related to the Java annotation processing API (JSR 269)

Awesome Java Annotation Processing

Java Annotation Processing (defined by JSR 269) is a standardized API for hooking into the Java compiler, allowing you to validate the code under compilation and generate additional (source or byte) code. This Awesome List aims at providing an overview of helpful resources around that API, including existing useful annotation processors, related presentations and blog posts, implementation best practices etc.

Table of Contents

• Existing Annotation Processors
  • Android
• Useful Tools
• Slide Decks and Recordings
• Blog Posts and Articles
• Related Concepts

Existing Annotation Processors

Existing annotation processors for different purposes

• avaje-inject - Compile-time dependency injection library.

• avaje-jsonb - JSON mapping using generated source code

• chimera - Compile-time static analysis and generation of commands for Spigot plugins.

• dekorate - Generates manifests for Kubernetes/OpenShift.

• Dagger - Compile-time dependency injection framework for both Java and Android.

• derive4j - Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching, folds, optics and typeclasses.

• domino-jackson - Generates Jackson based JSON mappers where the same mapper can be used on the JVM/android or GWT client Javascript code.

• domino-rest - Generates rest clients from JaxRs compatible interfaces.

• Duzzt - Duzzt - Annotation-based Embedded DSL Generator for Java.

• Google Auto - A collection of source code generators for Java.

• Google Error Prone - A static analysis tool for Java that catches common programming mistakes at compile-time.

• Gson Path - A Java annotation processor library which generates gson type adapters using basic JsonPath style annotations.

• Hibernate Validator annotation processor - Compile-time checking of Bean Validation constraints.

• JPA Static Metamodel Generator - Creates JPA 2 static metamodel classes.

• Immutables - Java annotation processors to generate simple, safe and consistent value objects.

• JMH Generator - Generates Java Microbenchmark Harness (JMH) benchmarks.

• jbock - Generates command line parsers.

• jstachio - A typesafe Java Mustache templating engine that compiles templates into readable Java code.

• Magic Bean - A very basic library which will generate POJOs.

• MapStruct - Compile-time generator for type-safe bean-to-bean mapping code.

• Micronaut - A modern full-stack framework for building modular, easily testable microservice and serverless applications.

• Pojo Analyzer - A library enables looping over POJOs' fields or access them by their names, and retreive their getters & setters.

• Record Builder - Adds Builders and Withers for Java Records (added in Java 16).

• Sundrio - A collection of apt-based code generating tools, including advanced builder generator, dsl generator, velocity transformer and etc.

• Viper - A generator and a framework for injecting configurations via the java EE’s CDI. Put all your configuration keys in an enum, and make viper inject the configurations in your beans.

• chocotea - Generates postman collection, environment and integration tests from Java code.

Android

Annotation processors specific to Android development

• Butter Knife - Bind Android views and callbacks to fields and methods.

• Parceler - Android Parcelables made easy through code generation.

Useful Tools

Useful tools and libraries for implementing annotation processors

• Apache Velocity - A Java-based template engine

• APTK - A toolbox that helps you to build annotation processors in a more efficient way.

• Avaje Prisms - A JDK 11 fork of Hickory with some minor enhancements.

• Compile Testing - Testing tools for javac and annotation processors.

• CUTE - Testing tools for javac and annotation processors. Allows unit and black box testing.

• Elementary - A suite of JUnit 5 extensions that provides a real annotation processing environment during testing

• JavaPoet - A Java API for generating .java source files.

• Hickory - An annotation processor for generating "prisms", allowing to access known annotation types without class references; Maven coordinates, fork repo (There is no official source repo existing)

Slide Decks and Recordings

• @Eliminate("Boilerplate")

• Annotation Processing Boilerplate Destruction

• Annotation Processor, trésor caché de la JVM (French)

• Annotation Processing Hands-on Labs, Devoxx France 2015 (French)

• Code Generation with Annotation Processors: State of the Art in Java 9

• Das Annotation Processing API - Use Cases und Best Practices (German)

Blog Posts and Articles

• Annotation Processing 101

• Annotation Processing : Don’t Repeat Yourself, Generate Your Code.

• How to Unit Test Your Annotation Processor using jOOR

• Java Annotation Processing: Das könnte auch ein Computer erledigen (German)

• Java Annotation Processing and Creating a Builder

• The Problem with Annotation Processors

• Writing your own Annotation Processors in Android

• Code Generation using Annotation Processors in the Java language

Related Concepts

APIs and tools going beyond what’s doable with JSR 269

• Spoon - Source Code Analysis and Transformation for Java (allows for AST modifications, too)

• javac Plug-in API (allows for full AST inspection)

• Project Lombok - Generates boilerplate Java code like getters/setters and equals/hashCode methods.

awesome-annotation-processing's Issues

Maybe add JStachio?

Hi folks. I have new annotation processing project. https://github.com/jstachio/jstachio

I posted it on reddit (I know gunnar and @rbygrave are sometimes on reddit so maybe you guys saw it). I plan on early releasing today or Monday to Maven Central. Feel free to wait till then and I will add a comment once that happens.

I wanted to post early to see if there were any other requirements. EDIT the other reason is I am not sure if I should also add this the tools section.

JStachio is kind of a double APT project in that it uses the annotation processing framework to generate typesafe Mustache templates for web development BUT it can also be used for code generation which is usually useful for other APT projects. (perhaps MapStruct will use it instead of freemarker someday... I'm kidding freemarker is pretty awesome :) ).

I plan on some point making a JStachio option that will require zero runtime and thus no need to maven shade for annotation processors.

Potential new compiler testing tool for Java 11+

Hello!

I am currently working on a project that aims to implement compiler testing facilities for Java 11 and newer. Was wondering if this would be useful to add to the list eventually if you are interested.

Don't want to come across as making unwanted advertising, as that is definitely not my aim, but feedback from anyone who is interested in the mean time would always be welcome and useful to me, which is why I decided to ask.

The primary aim is to provide an interface that is compatible with the most bleeding edge of JDK releases to enable writing forwards-compatible and future proof annotation processors and plugins. It can also be used to integration test generated source code from codegen libraries. Additionally, you can make use of classloaders directly for generated code -- allowing you to immediately load classes generated from code under test into memory and use them with the reflection API or via dynamic typing in languages like Apache Groovy.

The project itself is still under development, but it has a few additional aims that I found the Google compiler testing module I used to work with didn't seem to support. Specifically this includes providing full JPMS support, allowing support for alternative compiler implementations other than javac, JUnit5 integration, etc. It also makes use of actual file systems that can be accessed from outside the filer API since many annotation processor libraries tend to do this. This is implemented using JIMFS by default which is effectively a pure Java RAM disk. However, a java.io.File-compatible API is also supported.

I am also looking for candidates for compiler plugins and annotation processors that will make for good acceptance tests on my side. The JSR-199 compiler plugin can be a little ambiguous in places and some annotation processor libraries can use compiler internals in surprising ways, so one of my aims is to have a large number of acceptance tests for various libraries in the repo that are run on every build to ensure no surprising behaviour has been missed. At the time of writing, I am currently testing against google autofactory, google autoservice, google autovalue, checkerframework, google dagger, spring indexer, spring boot autoconfiguration processor, spring boot configuration processor, mapstruct, lombok, manifold, and immutables.

Project is over at https://github.com/ascopes/java-compiler-testing. I aim to have a stable release by March if not sooner.

If you are interested then that would be fantastic, but if you are not, then no worries at all. Thought I would ask though! Thanks in advance!