Sundrio :: Annotations :: Builder framework technical principle analysis (A Brief Analysis of the Technical Principles of Sundrio :: Annotations :: Builder Framework)
Sundrio :: Annotations :: Builder framework technical principles shallow analysis
Sundrio :: Annotations :: Builder is a lightweight framework for creating Java annotations. It provides a simple and powerful way to generate and operate annotations.
1. Technical overview:
Sundrio :: Annotations :: Builder framework uses a code -based method to create and configure annotations.It uses Java's reflection mechanism and dynamic agent to generate code during the compilation phase to achieve the creation and operation of the annotation.The framework uses the annotation processor to analyze the definition of the annotation and generates the corresponding construct code according to the definition.
2. Main principle:
The main principles of the mainrio :: Annotations :: Builder framework can be summarized as the following steps:
a. Definition Note: First of all, you need to define an annotation and add some parameters to configure the attributes of the configuration annotation.
b. Annotation processor: Next, write an annotation processor to analyze the definition of the annotation and generate the corresponding builder code.The annotation processor uses the Java's reflection mechanism to obtain the parameter information of the annotation and generates the corresponding constructor fields and methods.
c. Generator code: The annotation processor generates the builder code through the dynamic proxy technology during the compilation phase.This code generates a set of methods according to the definition of the annotation to set the attributes of the annotation.The generator generates an interface, which contains the setter method of all commentary parameters.
d. Construction and use of annotations: We can easily create and configure annotations in the code.By calling the setter method of the construct, you can set the various attribute values of the annotation.Once all the attribute settings are completed, the final annotation instance can be obtained by calling the `Build ()` method of the construct.
3. Code example:
The following is an example code that uses Sundrio :: Annotations :: Builder framework:
First of all, we define an annotation called `myannotation`, and add two attributes` name` and `value`:
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String name();
int value();
}
Next, we write an annotation processor `myannotationBuilderProcessor` to generate the constructor code:
@AutoService(Processor.class)
public class MyAnnotationBuilderProcessor extends AbstractProcessor {
@Override
public Set<String> getSupportedAnnotationTypes() {
return Collections.singleton(MyAnnotation.class.getName());
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
for (TypeElement annotation : annotations) {
generateBuilderClass(annotation);
}
return true;
}
private void generateBuilderClass(TypeElement annotation) {
// Analyze the parameter information of the annotation
List<VariableElement> properties = new ArrayList<>();
for (Element element : annotation.getEnclosedElements()) {
if (element.getKind() == ElementKind.METHOD) {
ExecutableElement method = (ExecutableElement) element;
properties.add(method);
}
}
// Generate a constructifier code
String builderClassName = annotation.getSimpleName() + "Builder";
TypeSpec.Builder classBuilder = TypeSpec.classBuilder(builderClassName)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(MethodSpec.methodBuilder("build")
.returns(ClassName.get(annotation))
.addStatement("return new $T($L)", ClassName.get(annotation), getArguments(properties))
.build());
for (VariableElement property : properties) {
classBuilder.addField(FieldSpec.builder(TypeName.get(property.getReturnType()), property.getSimpleName().toString())
.addModifiers(Modifier.PRIVATE)
.build())
.addMethod(MethodSpec.methodBuilder(property.getSimpleName().toString())
.returns(ClassName.get(builderClassName))
.addParameter(TypeName.get(property.getReturnType()), property.getSimpleName().toString())
.addStatement("this.$L = $L", property.getSimpleName(), property.getSimpleName().toString())
.addStatement("return this")
.build());
}
// Generate java file
JavaFile javaFile = JavaFile.builder(getPackageName(annotation), classBuilder.build())
.build();
try {
javaFile.writeTo(processingEnv.getFiler());
} catch (IOException e) {
e.printStackTrace();
}
}
private String getPackageName(TypeElement element) {
return processingEnv.getElementUtils().getPackageOf(element).getQualifiedName().toString();
}
private String getArguments(List<VariableElement> properties) {
StringBuilder arguments = new StringBuilder();
for (VariableElement property : properties) {
if (arguments.length() > 0) {
arguments.append(", ");
}
arguments.append(property.getSimpleName());
}
return arguments.toString();
}
}
Finally, we can use the generator to create and configure annotations in the code:
@MyAnnotationBuilder
.name("John")
.value(42)
.build();
Through the above code, we can generate an annotation example with the `Myannotation` with specified attribute values during runtime.
Summarize:
Sundrio :: Annotations :: Builder is a simple and powerful Java annotation creation and configuration framework.It provides us with an elegant annotation operation by generating code generation and dynamic agency.By defining the annotations, writing annotations, and the generated code generated, we can easily create and configure annotations, and obtain the corresponding annotation instance at runtime.
