public abstract class BaseProcessor extends AbstractProcessor {
    protected Messager messager;
    protected Elements elements;
    protected Filer filer;

	 @Override
    public boolean process(Set<? extends TypeElement> annotations, 			RoundEnvironment roundEnv) {
    }
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> supports = new LinkedHashSet<>();
        supports.add(BindString.class.getCanonicalName());
        supports.add(BindInt.class.getCanonicalName());

        return supports;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        messager = processingEnv.getMessager();
        elements = processingEnv.getElementUtils();
        filer = processingEnv.getFiler();
    }

    protected void printLog(Diagnostic.Kind kind, String message) {
        messager.printMessage(kind, message);
    }

    protected void printLog(Element element, Diagnostic.Kind kind, String message) 	 {
        messager.printMessage(kind, message, element);
    }

    protected void printLog(Element element, String message, Object... args) {
        if (args.length > 0) {
            message = String.format(message, args);
        }
        messager.printMessage(ERROR, message, element);
    }
}

AutoService(Processor.class)
public class BindingProcessor extends BaseProcessor {
    private static final String BIND_CLASS_SUFFIX = "$$AnnotationBinder";

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        printLog(Diagnostic.Kind.OTHER, "BindingProcessor process.... ");

			// 处理注解类
        Map<TypeElement, BindingClass> bindingClassMap = findAndParseTargets(roundEnv);
        
        for (Map.Entry<TypeElement, BindingClass> entry : bindingClassMap.entrySet()) {
            TypeElement typeElement = entry.getKey();
            BindingClass bindingClass = entry.getValue();

            try {
                printLog(Diagnostic.Kind.OTHER, "BindingProcessor code:" + bindingClass.brewJava().toString());
                //处理结果注入代码
                bindingClass.brewJava().writeTo(filer);
            } catch (IOException e) {
                printLog(typeElement, "Unable to write view binder for type %s: %s", typeElement,
                        e.getMessage());
            }
        }
        return true;
    }

    ```

1.核心的扫描处理方法，使用roundEnv查询，然后逐个处理：
```Java
private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment roundEnv) {
        ...
        //其中:根据注解类获得使用了这个注解的类列表。
        Set<? extends Element> bindStringSet = roundEnv.getElementsAnnotatedWith(BindString.class);
        ...
    }

private void parseResourceString(Element element, Map<TypeElement, BindingClass> targetClassMap,Set<String> erasedTargetNames) {
			...
        // 使用了这个注解的类的信息
        TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
        ...
        // 获得注解里边的值或者说配置
        String value = element.getAnnotation(BindString.class).value();
        String name = element.getSimpleName().toString();
        ...
    }

//生成完整类
JavaFile brewJava() {
        TypeSpec.Builder result = TypeSpec.classBuilder(className)
                .addModifiers(PUBLIC)
                .addTypeVariable(TypeVariableName.get("T", ClassName.bestGuess(targetClass)));

        if (parentViewBinder != null) {
            result.superclass(ParameterizedTypeName.get(ClassName.bestGuess(parentViewBinder),
                    TypeVariableName.get("T")));
        } else {
            result.addSuperinterface(ParameterizedTypeName.get(BINDER, TypeVariableName.get("T")));
        }

        result.addMethod(createBindMethod());

        return JavaFile.builder(classPackage, result.build())
                .addFileComment("This is a class, create by annotation processor!")
                .build();
    }

	//生成方法
    private MethodSpec createBindMethod() {
        MethodSpec.Builder result = MethodSpec.methodBuilder("bind")
                .addAnnotation(Override.class)
                .addModifiers(PUBLIC)
                .addParameter(TypeVariableName.get("T"), "target", FINAL)
                .addParameter(Object.class, "source");

        // Emit a call to the superclass binder, if any.
        if (parentViewBinder != null) {
            result.addStatement("super.bind(target, source)");
        }

        for (StringBinding binding : stringBindings) {
            result.addStatement("target.$L = \"$L\"", binding.getName(), binding.getValue());
        }

        for (IntBinding binding : intBindings) {
            result.addStatement("target.$L = $L", binding.getName(), binding.getValue());
        }

        return result.build();
    }

  messager.printMessage(ERROR, message, element);

enum Kind {
        /**
         * Problem which prevents the tool's normal completion.
         */
        ERROR,
        /**
         * Problem which does not usually prevent the tool from
         * completing normally.
         */
        WARNING,
        /**
         * Problem similar to a warning, but is mandated by the tool's
         * specification.  For example, the Java™ Language
         * Specification mandates warnings on certain
         * unchecked operations and the use of deprecated methods.
         */
        MANDATORY_WARNING,
        /**
         * Informative message from the tool.
         */
        NOTE,
        /**
         * Diagnostic which does not fit within the other kinds.
         */
        OTHER,
    }