Java JavaFileObject类代码示例

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Test public void failsIfHasReturnType() {
  JavaFileObject source = JavaFileObjects.forSourceString("test.Test", ""
      + "package test;\n"
      + "import butterknife.OnClick;\n"
      + "public class Test {\n"
      + "  @OnClick(1)\n"
      + "  public String doStuff() {\n"
      + "  }\n"
      + "}"
  );

  assertAbout(javaSource()).that(source)
      .processedWith(new ButterKnifeProcessor())
      .failsToCompile()
      .withErrorContaining("@OnClick methods must have a 'void' return type. (test.Test.doStuff)")
      .in(source).onLine(5);
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
/**
 * Verify that an alternate file manager can be specified:
 * in this case, a TestFileManager.
 */
@Test
public void testFileManager() throws Exception {
    JavaFileObject srcFile = createSimpleJavaFileObject();
    DocumentationTool tool = ToolProvider.getSystemDocumentationTool();
    StandardJavaFileManager fm = new TestFileManager();
    File outDir = getOutDir();
    fm.setLocation(DocumentationTool.Location.DOCUMENTATION_OUTPUT, Arrays.asList(outDir));
    Iterable<? extends JavaFileObject> files = Arrays.asList(srcFile);
    DocumentationTask t = tool.getTask(null, fm, null, null, Arrays.asList("-verbose"), files);
    if (t.call()) {
        System.err.println("task succeeded");
        checkFiles(outDir, standardExpectFiles);
    } else {
        throw new Exception("task failed");
    }
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Test
public void testNUnrelatedORToOneAP_creates_GeneratedFiles_WhenTwoFileToProcess() {
  //GIVEN
  JavaFileObject source0 = forSourceString("test.Test0", "" //
      + "package test;\n" //
      + "import org.gradle.incap.Annotation1;\n" //
      + "@Annotation1\n" //
      + "public class Test0 {\n" //
      + "}\n" //
      + "@Annotation1\n" //
      + "class Test1 {\n" //
      + "}");
  JavaFileObject expected = forSourceString("NUnrelatedORToOneAP_OR_Gen0", "" //
      + "\n" //
      + "public class NUnrelatedORToOneAP_OR_Gen0 {\n" //
      + "}");

  //WHEN
  //THEN
  Truth.assertAbout(JavaSourceSubjectFactory.javaSource()).that(source0) //
      .withCompilerOptions("-Xlint:-processing","-Aincap.mapping.folder=.", "-Aincap.incremental=true") //
      .processedWith(new NUnrelatedORToOneAP()) //
      .compilesWithoutError().and().generatesSources(expected);
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
/**
 * Emit a class file for a given class.
 *
 * @param c The class from which a class file is generated.
 */
public JavaFileObject writeClass(ClassSymbol c)
        throws IOException, PoolOverflow, StringOverflow {
    JavaFileObject outFile
            = fileManager.getJavaFileForOutput(CLASS_OUTPUT,
            c.flatname.toString(),
            JavaFileObject.Kind.CLASS,
            c.sourcefile);
    OutputStream out = outFile.openOutputStream();
    try {
        writeClassFile(out, c);
        if (verbose)
            log.printVerbose("wrote.file", outFile);
        out.close();
        out = null;
    } finally {
        if (out != null) {
            // if we are propogating an exception, delete the file
            out.close();
            outFile.delete();
            outFile = null;
        }
    }
    return outFile; // may be null if write failed
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Override
public JavaFileObject getJavaFileForOutput(
		final Location location,
		final String className,
		final Kind kind,
		final FileObject sibling)
		throws IOException {
	
	final URI uri = createUri(location, className, kind);
	
	if (!files.containsKey(uri)) {
		files.put(uri, new InMemoryJavaFileObject(uri));
	}
	
	return files.get(uri);
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Override
public void test(TestCase testCase, Map<String, ? extends JavaFileObject> classes)
        throws IOException, ConstantPoolException, Descriptor.InvalidDescriptor {
    for (Map.Entry<String, ? extends JavaFileObject> entry : classes.entrySet()) {
        ClassFile classFile = readClassFile(classes.get(entry.getKey()));
        Set<String> foundMethods = new HashSet<>();
        String className = classFile.getName();
        TestCase.TestClassInfo testClassInfo = testCase.classes.get(className);
        for (Method method : classFile.methods) {
            String methodName = method.getName(classFile.constant_pool) +
                    method.descriptor.getParameterTypes(classFile.constant_pool);
            if (methodName.startsWith("<init>")) {
                methodName = methodName.replace("<init>", className);
            }
            foundMethods.add(methodName);
            echo("Testing method : " + methodName);

            TestCase.TestMethodInfo testMethod = testClassInfo.getTestMethodInfo(methodName);
            if (testMethod == null) {
                continue;
            }
            testAttributes(testMethod, classFile, method);
        }
        checkContains(foundMethods, testClassInfo.methods.keySet(), "Methods in " + className);
    }
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    Map<String, Integer> map = new HashMap<>();
    Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(ContentView.class);
    for (Element element : elements) {
        TypeElement type = (TypeElement) element;
        ContentView annotation = type.getAnnotation(ContentView.class);
        String name = type.getQualifiedName().toString();
        map.put(name, annotation.value());
    }

    try {
        JavaFileObject sourceFile = filer.createSourceFile(API_PATH);
        Writer writer = sourceFile.openWriter();
        writer.write(generateCode(map));
        writer.flush();
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return true;
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Test
public void testConfigurationMayNotHaveNonPublicConstructors() throws IOException {
  JavaFileObject definitionClass = JavaFileObjects.forSourceLines(
      "test.TestClass",
      "package test;",
      "",
      "import org.springframework.context.annotation.Bean;",
      "import org.springframework.context.annotation.Configuration;",
      "",
      "@com.salesforce.aptspring.Verified",
      "@Configuration",
      "public class TestClass {",
      "",
      " private TestClass() {",
      " }",
      "",
      "}");

  assertAbout(javaSources())
          .that(Arrays.asList(definitionClass))
          .processedWith(new VerifiedSpringConfiguration())
          .failsToCompile()
          .withErrorContaining("@Configuration should not have any non-public constructors.")
          .in(definitionClass)
          .onLine(10);
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
public ModuleSymbol findSingleModule() {
    try {
        JavaFileObject src_fo = getModuleInfoFromLocation(StandardLocation.SOURCE_PATH, Kind.SOURCE);
        JavaFileObject class_fo = getModuleInfoFromLocation(StandardLocation.CLASS_OUTPUT, Kind.CLASS);
        JavaFileObject fo = (src_fo == null) ? class_fo
                : (class_fo == null) ? src_fo
                        : classFinder.preferredFileObject(src_fo, class_fo);

        ModuleSymbol msym;
        if (fo == null) {
            msym = syms.unnamedModule;
        } else {
            msym = readModule(fo);
        }

        if (msym.patchLocation == null) {
            msym.classLocation = StandardLocation.CLASS_OUTPUT;
        } else {
            msym.patchOutputLocation = StandardLocation.CLASS_OUTPUT;
        }
        return msym;

    } catch (IOException e) {
        throw new Error(e); // FIXME
    }
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Test
public void testNRelatedToOneAP_creates_GeneratedFiles_WhenSingleFileToProcess() {
  //GIVEN
  JavaFileObject source = forSourceString("test.Test", "" //
      + "package test;\n" //
      + "import org.gradle.incap.Annotation1;\n" //
      + "@Annotation1\n" //
      + "public class Test {\n" //
      + "}");

  //WHEN
  //THEN
  //we can't test that no files were generated, but we would need it.
  Truth.assertAbout(JavaSourceSubjectFactory.javaSource()).that(source) //
      .withCompilerOptions("-Xlint:-processing","-Aincap.mapping.folder=.") //
      .processedWith(new NRelatedToOneAP()) //
      .compilesWithoutError();
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@Test
public void testAnnotatedClass_asBoundInGenericParameter() {
  List<Diagnostic<? extends JavaFileObject>> diagnostics = compiler.compile(
      BETA, ANNOTATED_CLASS,
      JavaFileObjects.forSourceLines("example.Test",
          "package example;",
          "",
          "import com.google.common.foo.AnnotatedClass;",
          "",
          "import java.util.List;",
          "",
          "public class Test {",
          "  public static void foo(List<? super AnnotatedClass> list) {", // error
          "  }",
          "}")
  );

  compiler.assertErrorsOnLines("example/Test.java", diagnostics, 8);
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
/**
 * Emit plain Java source for a class.
 *
 * @param env  The attribution environment of the outermost class
 *             containing this class.
 * @param cdef The class definition to be printed.
 */
JavaFileObject printSource(Env<AttrContext> env, JCClassDecl cdef) throws IOException {
    JavaFileObject outFile
            = fileManager.getJavaFileForOutput(CLASS_OUTPUT,
            cdef.sym.flatname.toString(),
            JavaFileObject.Kind.SOURCE,
            null);
    if (inputFiles.contains(outFile)) {
        log.error(cdef.pos(), "source.cant.overwrite.input.file", outFile);
        return null;
    } else {
        BufferedWriter out = new BufferedWriter(outFile.openWriter());
        try {
            new Pretty(out, true).printUnit(env.toplevel, cdef);
            if (verbose)
                log.printVerbose("wrote.file", outFile);
        } finally {
            out.close();
        }
        return outFile;
    }
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
public void run() throws IOException {
    File srcDir = new File(System.getProperty("test.src"));
    File thisFile = new File(srcDir, getClass().getName() + ".java");

    JavaCompiler c = ToolProvider.getSystemJavaCompiler();
    try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {

        List<String> opts = Arrays.asList("-proc:only", "-doe");
        Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(thisFile);
        JavacTask t = (JavacTask) c.getTask(null, fm, null, opts, null, files);
        t.setProcessors(Collections.singleton(this));
        boolean ok = t.call();
        if (!ok)
            throw new Error("compilation failed");
    }
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@CheckForNull
private static String getResourceName (@NullAllowed final CompilationUnitTree cu) {
    if (cu instanceof JCTree.JCCompilationUnit) {
        JavaFileObject jfo = ((JCTree.JCCompilationUnit)cu).sourcefile;
        if (jfo != null) {
            URI uri = jfo.toUri();
            if (uri != null && uri.isAbsolute()) {
                try {
                    FileObject fo = URLMapper.findFileObject(uri.toURL());
                    if (fo != null) {
                        ClassPath cp = ClassPath.getClassPath(fo,ClassPath.SOURCE);
                        if (cp != null) {
                            return cp.getResourceName(fo,'.',false);
                        }
                    }
                } catch (MalformedURLException e) {
                    Exceptions.printStackTrace(e);
                }
            }
        }
    }
    return null;
}
 

import javax.tools.JavaFileObject; //导入依赖的package包/类
@NonNull
@Override
public Iterable<JavaFileObject> getFiles(
        @NonNull final String folderName,
        @NullAllowed final ClassPath.Entry entry,
        @NullAllowed final Set<JavaFileObject.Kind> kinds,
        @NullAllowed final JavaFileFilterImplementation filter,
        final boolean recursive) throws IOException {
    final Collection<Iterable<JavaFileObject>> collector = new ArrayList<>();
    for (Archive delegate : getDelegates(this)) {
        final Iterable<JavaFileObject> it = delegate.getFiles(folderName, entry, kinds, filter, recursive);
        if (!isEmpty(it)) {
            collector.add(it);
        }
    }
    return Iterators.chained(collector);
}