Java Processor类代码示例

import javax.annotation.processing.Processor; //导入依赖的package包/类
public Collection<? extends Processor> resolveProcessors(boolean onScan) {
    ClassPath[] pps = validatePaths();
    ClassLoader cl;
    boolean isModule = false;
    final ClassLoaderRef cache = classLoaderCache;
    if (cache == null || (cl=cache.get(root)) == null) {
        ClassPath pp = pps[1];
        if (pps[0] != null && !pps[0].entries().isEmpty()) {
            pp = pps[0];
            isModule = true;
        }
        if (pp == null) {
            pp = ClassPath.EMPTY;
        }
        cl = CachingArchiveClassLoader.forClassPath(
                pp,
                new BypassOpenIDEUtilClassLoader(Context.class.getClassLoader()),
                usedRoots);
        classLoaderCache = !DISABLE_CLASSLOADER_CACHE ? new ClassLoaderRef(cl, root, isModule) : null;
    } else {
        isModule = cache.isModule;                    
    }
    Collection<Processor> result = lookupProcessors(cl, onScan, isModule);
    return result;
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
private Collection<Processor> lookupProcessors(ClassLoader cl, boolean onScan, boolean isModule) {
    Iterable<? extends String> processorNames = aptOptions.annotationProcessorsToRun();
    if (processorNames == null) {
        processorNames = getProcessorNames(cl, isModule);
    }
    List<Processor> result = new LinkedList<Processor>();
    for (String name : processorNames) {
        try {
            Class<?> clazz = Class.forName(name, true, cl);
            Object instance = clazz.newInstance();
            if (instance instanceof Processor) {
                result.add((Processor) instance);
            }
        } catch (ThreadDeath td) {
            throw td;
        } catch (Throwable t) {
            LOG.log(Level.FINE, null, t);
        }
    }
    if (!onScan)
        result.addAll(HARDCODED_PROCESSORS.lookupAll(Processor.class));
    return result;
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = JavacProcessingEnvironment.instance(context);
        procEnvImpl.setProcessors(processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (!taskListener.isEmpty())
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
@Override
public List<PluginInfo<Processor>> getAnnotationProcessors() {
    return Arrays.asList(new PluginInfo<Processor>() {
        @Override
        public String getName() {
            return "test";
        }
        @Override
        public Map<String, String> getOptions() {
            return Collections.singletonMap("testAPKey", "testAPValue");
        }
        @Override
        public Processor getPlugin() {
            return new ProcessorImpl();
        }
    });
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
static private boolean compile(Iterable<? extends Processor> processors)
{
    JavaCompiler compiler = new EclipseCompiler();
    DiagnosticCollector<JavaFileObject> diagnosticCollector =
            new DiagnosticCollector<JavaFileObject>();
    JavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8);
    JavaCompiler.CompilationTask task = compiler.getTask(
            null,
            fileManager,
            diagnosticCollector,
            ImmutableSet.<String>of(),
            ImmutableSet.of(TestTypesEclipse.class.getCanonicalName()),
            ImmutableSet.<JavaFileObject>of());
    task.setProcessors(processors);
    return task.call();
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/** Convenient JavaCompiler facade returning a ClassLoader with all compiled units. */
static ClassLoader compile(
    ClassLoader parent,
    List<String> options,
    List<Processor> processors,
    List<JavaFileObject> units) {
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  Objects.requireNonNull(compiler, "no system java compiler available - JDK is required!");
  DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
  StandardJavaFileManager sjfm =
      compiler.getStandardFileManager(diagnostics, Locale.getDefault(), StandardCharsets.UTF_8);
  Manager manager = new Manager(sjfm, parent);
  CompilationTask task = compiler.getTask(null, manager, diagnostics, options, null, units);
  if (!processors.isEmpty()) {
    task.setProcessors(processors);
  }
  boolean success = task.call();
  if (!success) {
    throw new RuntimeException("compilation failed! " + diagnostics.getDiagnostics());
  }
  return manager.getClassLoader(StandardLocation.CLASS_PATH);
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Assumes the element is valid. It uses the value specified in the annotation, if it has a package. Otherwise uses
 * the element's package.
 * @param element annotated interface, assumed valid
 * @param types   type utility, currently ignored
 * @return a representation of the generated class.
 */
@Override
protected GeneratedType createGeneratedClass(EnrichedTypeElement element, Class<? extends Processor> processorClass,
                                             Types types) {

    final String specifiedClass = element.getAnnotation(getSupportedAnnotation()).value();
    final Pair<String, String> packageAndClassName = extractPackageAndClassName(specifiedClass);
    String packageName = packageAndClassName.getLeft();
    if (packageName == null) {
        final PackageElement elementPackage = element.getPackage();
        packageName = elementPackage.getQualifiedName().toString();
    }
    String className = packageAndClassName.getRight();
    if (className == null) {
        className = element.calculateClassNameWithPrefix(getClassPrefix());
    }
    return new NoopClass(packageName, className, element, processorClass, types);
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Assumes the element is valid. It uses the value specified in the annotation, if it has a package. Otherwise uses
 * the element's package.
 * @param element annotated interface, assumed valid
 * @return a representation of the generated class.
 */
@Override
protected GeneratedType createGeneratedClass(EnrichedTypeElement element, Class<? extends Processor> processorClass,
                                             Types types) {

    final String specifiedClass = element.getAnnotation(getSupportedAnnotation()).value();
    final Pair<String, String> packageAndClassName = extractPackageAndClassName(specifiedClass);
    String packageName = packageAndClassName.getLeft();
    if (packageName == null) {
        final PackageElement elementPackage = element.getPackage();
        packageName = elementPackage.getQualifiedName().toString();
    }
    String className = packageAndClassName.getRight();
    if (className == null) {
        className = element.calculateClassNameWithPrefix(getClassPrefix());
    }
    return new DecorClass(packageName,
                          className,
                          element,
                          processorClass,
                          types,
                          element.getAnnotation(getSupportedAnnotation()).mutable());
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Assumes the element is valid. It uses the value specified in the annotation, if it has a package. Otherwise uses
 * the element's package.
 * @param element annotated interface, assumed valid
 * @param types   type utility, currently ignored
 * @return a representation of the generated class.
 */
@Override
protected GeneratedType createGeneratedClass(EnrichedTypeElement element, Class<? extends Processor> processorClass,
                                             Types types) {

    final String specifiedClass = element.getAnnotation(getSupportedAnnotation()).value();
    final Pair<String, String> packageAndClassName = extractPackageAndClassName(specifiedClass);
    String packageName = packageAndClassName.getLeft();
    if (packageName == null) {
        final PackageElement elementPackage = element.getPackage();
        packageName = elementPackage.getQualifiedName().toString();
    }
    String className = packageAndClassName.getRight();
    if (className == null) {
        className = element.calculateClassNameWithSuffix(getClassSuffix());
    }
    return new FactoryInterface(packageName, className, element, processorClass);
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    Options options = Options.instance(context);
    if (options.get("-proc:none") != null) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = new JavacProcessingEnvironment(context, processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            if (context.get(Scanner.Factory.scannerFactoryKey) == null)
                DocCommentScanner.Factory.preRegister(context);
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            if (taskListener != null)
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));


        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
static ClassLoader compile(JavaFile java, ClassLoader parent, List<String> options,
    List<Processor> processors) {
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  assert compiler != null : "no system java compiler available - JDK is required!";
  DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
  StandardJavaFileManager sjfm = compiler.getStandardFileManager(
      diagnostics,
      Locale.getDefault(),
      StandardCharsets.UTF_8);
  Manager manager = new Manager(sjfm, parent);
  CompilationTask task = compiler.getTask(
      null, // a writer for additional output from the compiler; use System.err if null
      manager,
      diagnostics,
      options,
      null, // names of classes to be processed by annotation processing, null means no classes
      Collections.singleton(java.toJavaFileObject()));
  if (!processors.isEmpty())
    task.setProcessors(processors);
  boolean success = task.call();
  if (!success)
    throw new RuntimeException("compilation failed" + diagnostics.getDiagnostics());
  return manager.getClassLoader(null);
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
@Override
public void setProcessors(Object[] processors) {
	if (!_isFirstRound) {
		throw new IllegalStateException("setProcessors() cannot be called after processing has begun"); //$NON-NLS-1$
	}
	// Cast all the processors here, rather than failing later.
	// But don't call init() until the processor is actually needed.
	_setProcessors = new ArrayList<Processor>(processors.length);
	for (Object o : processors) {
		Processor p = (Processor)o;
		_setProcessors.add(p);
	}
	_setProcessorIter = _setProcessors.iterator();

	// processors set this way take precedence over anything on the command line 
	_commandLineProcessors = null;
	_commandLineProcessorIter = null;
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
public Result run(
    String[] args,
    JavaFileManager fileManager,
    List<JavaFileObject> javaFileObjects,
    Iterable<? extends Processor> processors) {
  JavaCompiler compiler = new BaseErrorProneJavaCompiler(scannerSupplier);
  try {
    CompilationTask task =
        compiler.getTask(
            errOutput,
            fileManager,
            diagnosticListener,
            ImmutableList.copyOf(args),
            null /*classes*/,
            javaFileObjects);
    if (processors != null) {
      task.setProcessors(processors);
    }
    return task.call() ? Result.OK : Result.ERROR;
  } catch (InvalidCommandLineOptionException e) {
    errOutput.print(e);
    errOutput.flush();
    return Result.CMDERR;
  }
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
/**
 * Check if we should process annotations.
 * If so, and if no scanner is yet registered, then set up the DocCommentScanner
 * to catch doc comments, and set keepComments so the parser records them in
 * the compilation unit.
 *
 * @param processors user provided annotation processors to bypass
 * discovery, {@code null} means that no processors were provided
 */
public void initProcessAnnotations(Iterable<? extends Processor> processors) {
    // Process annotations if processing is not disabled and there
    // is at least one Processor available.
    if (options.isSet(PROC, "none")) {
        processAnnotations = false;
    } else if (procEnvImpl == null) {
        procEnvImpl = new JavacProcessingEnvironment(context, processors);
        processAnnotations = procEnvImpl.atLeastOneProcessor();

        if (processAnnotations) {
            options.put("save-parameter-names", "save-parameter-names");
            reader.saveParameterNames = true;
            keepComments = true;
            genEndPos = true;
            if (taskListener != null)
                taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
            log.deferDiagnostics = true;
        } else { // free resources
            procEnvImpl.close();
        }
    }
}
 

import javax.annotation.processing.Processor; //导入依赖的package包/类
public boolean compile(File... sourceFiles) throws Exception {
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  StandardJavaFileManager fm = compiler.getStandardFileManager(diagnosticListener, null, null);
  if (classOutput == null) {
    classOutput = createTempDir();
  }
  if (sourceOutput == null) {
    sourceOutput = createTempDir();
  }
  fm.setLocation(StandardLocation.CLASS_OUTPUT, Collections.singletonList(classOutput));
  fm.setLocation(StandardLocation.SOURCE_OUTPUT, Collections.singletonList(sourceOutput));
  Iterable<? extends JavaFileObject> fileObjects = fm.getJavaFileObjects(sourceFiles);
  Writer out = new NullWriter();
  JavaCompiler.CompilationTask task = compiler.getTask(out, fm, diagnosticListener, options, null, fileObjects);
  List<Processor> processors = Collections.<Processor>singletonList(processor);
  task.setProcessors(processors);
  try {
    return task.call();
  } catch (RuntimeException e) {
    if (e.getCause() != null && e.getCause() instanceof RuntimeException) {
      throw (RuntimeException)e.getCause();
    } else {
      throw e;
    }
  }
}