I'm looking for a solution for generating code. I have googled, searched on SO and some blogs but I didn't find a good solution.
I'd like to put an annotation on my class and at compilation time, some methods and properties would be automatically added to the class.
Key points of the solution I'm looking for :
apt
have to be called (MANDATORY)For example :
@Aliasable public class MyClass { //Some properties // Contructor ... // Some methods }
My class would look like this after compilation :
public class MyClass { //Some properties private String alias; // Contructor ... // Some methods public String getAlias() { return alias; } public void setAlias(String alias) { this.alias=alias; } }
EDIT:
Finally, I turned my third requirement from MANDATORY to OPTIONAL and choosed project Lombok (easy integration with Maven and Eclipse, virtually no work to do for using it).
Annotations don't execute; they're notes or markers that are read by various tools. Some are read by your compiler, like @Override ; others are embedded in the class files and read by tools like Hibernate at runtime.
In Java SE 6, annotations cannot subclass one another, and an annotation is not allowed to extend/implement any interfaces.
Geek, now you must be wondering how can we create our own java annotations, for that refer to simple steps sequentially as follows: To create your own Java Annotation you must use @interface Annotation_name, this will create a new Java Annotation for you.
Compile-time instructions - Compile-time instructions provided by these annotations help the software build tools to generate code, XML files and many more. Runtime instructions - Some annotations can be defined to give instructions to the program at runtime. These annotations are accessed using Java Reflection.
Read the annotated class via reflection and transform it into a String which represents the source code of your new class. Write this string to file, compile this String using the Java compiler API and then load and instantiate the new class, all programatically; see exact steps here.
For an annotation to be repeatable it must be annotated with the @Repeatable annotation, which is defined in the java.lang.annotation package. Its value field specifies the container type for the repeatable annotation.
The annotation processing tool has been integrated in javac since version 1.6 and is part of the JDK. So there is no need for external tools when using the Pluggable Annotation API. You can generate any code by analysing custom annotations or method/parameter/field/class declarations using the Mirror API.
The annotation processor API says you shouldn't change existing classes. Instead you should generate subclasses of existing classes and create extension methods on those subclasses.
It seems to be possible to change classes anyway (e.g. by using bytecode manipulation libraries) though that would in contrast to the specification and could lead to issues with other annotation processors and may not work with all compilers in the same way.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With