javax.annotation.processing.ProcessingEnvironment#getMessager ( )源码实例Demo

@Override
public void init(ProcessingEnvironment env) {
    this.processingEnv = env;
    this.filer = env.getFiler();
    this.discoveredExtensions = new ArrayList<>();
    this.discoveredBindings = new ArrayList<>();
    this.discoveredBeanFactories = new ArrayList<>();
    this.categoryClasses = new ArrayList<>();
    this.subsystemDeclararions = new ArrayList<>();
    this.requiredResourcesDeclarations = new ArrayList<>();
    this.searchIndexDeclarations = new ArrayList<>();
    this.bootstrapOperations = new ArrayList<>();
    this.runtimeExtensions = new ArrayList<>();
    this.nameTokens = new HashSet<>();

    moduleConfigs = new ArrayList<ModuleConfig>();
    moduleConfigs.add(new ModuleConfig(filer, "App_base.gwt.xml.tmpl", "App.gwt.xml"));
    moduleConfigs.add(new ModuleConfig(filer, "App_WF.gwt.xml.tmpl", "App_WF.gwt.xml"));
    moduleConfigs.add(new ModuleConfig(filer, "App_WF_full.gwt.xml.tmpl", "App_WF_full.gwt.xml"));
    moduleConfigs.add(new ModuleConfig(filer, "App_WF_dev.gwt.xml.tmpl", "App_WF_dev.gwt.xml"));
    moduleConfigs.add(new ModuleConfig(filer, "App_RH.gwt.xml.tmpl", "App_RH.gwt.xml"));
    moduleConfigs.add(new ModuleConfig(filer, "App_RH_dev.gwt.xml.tmpl", "App_RH_dev.gwt.xml"));

    env.getMessager();
    parseGwtProperties();
}
 

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

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

@Override
public void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    this.processingEnv = processingEnv;
    errorListener = new ErrorReceiverImpl(
            processingEnv.getMessager(),
            processingEnv.getOptions().containsKey(Const.DEBUG_OPTION.getValue())
    );
}
 

@Override
public void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    this.processingEnv = processingEnv;
    errorListener = new ErrorReceiverImpl(
            processingEnv.getMessager(),
            processingEnv.getOptions().containsKey(Const.DEBUG_OPTION.getValue())
    );
}
 

@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
  super.init(processingEnv);
  elements = processingEnv.getElementUtils();
  types = processingEnv.getTypeUtils();
  messager = processingEnv.getMessager();
  providedChecker = new ProvidedChecker(messager);
  declarationFactory = new AutoFactoryDeclaration.Factory(elements, messager);
  factoryDescriptorGenerator =
      new FactoryDescriptorGenerator(messager, types, declarationFactory);
}
 

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

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

@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
  super.init(processingEnv);
  messager = processingEnv.getMessager();
  filer = processingEnv.getFiler();
  elementUtils = processingEnv.getElementUtils();
  typeUtils = processingEnv.getTypeUtils();
  annotationDetector = new DefaultAnnotationDetector(elementUtils, typeUtils);
}
 

@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    mMessager = processingEnv.getMessager();
    mFiler = processingEnv.getFiler();
    elementUtils = processingEnv.getElementUtils();
    set = new HashSet<String>();

    Map<String, String> options = processingEnv.getOptions();
    if (MapUtils.isNotEmpty(options)) {
        moduleName = options.get(CompilerConstant.KEY_MODULE_NAME);
        set.add(moduleName);
    }
}
 

@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
    mFiler = processingEnv.getFiler();
    mElements = processingEnv.getElementUtils();
    mLog = new Logger(processingEnv.getMessager());

    mContext = TypeName.get(mElements.getTypeElement(Constants.CONTEXT_TYPE).asType());
    mOnRegisterType = TypeName.get(mElements.getTypeElement(Constants.ON_REGISTER_TYPE).asType());
    mRegisterType = TypeName.get(mElements.getTypeElement(Constants.REGISTER_TYPE).asType());

    mConverter = TypeName.get(mElements.getTypeElement(Constants.CONVERTER_TYPE).asType());

    mString = TypeName.get(String.class);
}
 

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

public TreeBackedProcessingEnvironment(
    FrontendOnlyJavacTask task, ProcessingEnvironment javacProcessingEnvironment) {
  this.task = task;
  this.javacProcessingEnvironment = javacProcessingEnvironment;
  messager = new TreeBackedMessager(task, javacProcessingEnvironment.getMessager());
  filer = new TreeBackedFiler(task, javacProcessingEnvironment.getFiler());

  options.putAll(javacProcessingEnvironment.getOptions());
  options.put("com.facebook.buck.java.generating_abi", "true");
}
 

@Provides
@Singleton
public Logger getLogger(ProcessingEnvironment processingEnvironment, @Named(DEBUG) boolean debug){
    return new MessagerLogger(getLogPreprend(), processingEnvironment.getMessager(), debug);
}
 

public ErrorReceiverImpl(ProcessingEnvironment env) {
    this(env.getMessager());
}
 

@Override
public synchronized void init(final ProcessingEnvironment processingEnv) {
	super.init(processingEnv);
	messager = processingEnv.getMessager();
	androidManifestAccess = new AndroidManifestAccess(processingEnv);
}
 

@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
    super.init(processingEnvironment);
    mMessager = processingEnvironment.getMessager();
}
 

@Override
public void init(ProcessingEnvironment pe) {
    super.init(pe);
    elements = pe.getElementUtils();
    messager = pe.getMessager();
}
 

static Value parse(Element element, ProcessingEnvironment processingEnv) {
  Messager messager = processingEnv.getMessager();

  if (element.getKind() != ElementKind.METHOD) {
    messager.printMessage(
        Diagnostic.Kind.ERROR,
        String.format(
            "Value specs must be methods, found %s: %s",
            element.getKind().toString().toLowerCase(), element),
        element);
    return null;
  }

  ExecutableElement methodElement = (ExecutableElement) element;
  if (!isValueSpecMarker(methodElement.getReturnType(), processingEnv)) {
    messager.printMessage(
        Diagnostic.Kind.ERROR,
        String.format(
            "Value specs must return dataenum_case, found %s: %s",
            methodElement.getReturnType(), element),
        element);
    return null;
  }

  if (methodElement.getTypeParameters().size() != 0) {
    messager.printMessage(
        Diagnostic.Kind.ERROR,
        String.format(
            "Type parameters must be specified on the top-level interface, found: %s", element),
        element);
    return null;
  }

  if (methodElement.isVarArgs()) {
    messager.printMessage(
        Diagnostic.Kind.ERROR,
        String.format("Vararg parameters not permitted: %s", element),
        element);
    return null;
  }

  List<Parameter> parameters = new ArrayList<>();
  for (VariableElement parameterElement : methodElement.getParameters()) {
    String parameterName = parameterElement.getSimpleName().toString();
    TypeName parameterType = TypeName.get(parameterElement.asType());

    boolean nullable = isAnnotationPresent(parameterElement, ValueParser::isNullableAnnotation);
    boolean redacted = isAnnotationPresent(parameterElement, ValueParser::isRedactedAnnotation);
    Element parameterTypeElement =
        processingEnv.getTypeUtils().asElement(parameterElement.asType());
    boolean isEnum =
        parameterTypeElement != null && parameterTypeElement.getKind() == ElementKind.ENUM;

    parameters.add(new Parameter(parameterName, parameterType, nullable, redacted, isEnum));
  }

  String javadoc = processingEnv.getElementUtils().getDocComment(element);

  if (javadoc != null) {
    javadoc = javadoc.trim();
  }

  String valueSimpleName = methodElement.getSimpleName().toString();
  return new Value(
      valueSimpleName, javadoc, parameters, parseMethodAnnotations(methodElement, messager));
}
 

public ErrorReceiverImpl(ProcessingEnvironment env) {
    this(env.getMessager());
}