AGP源码浅析二

上篇文章简析了AGP插件的初始化过程，本篇将会讲解一下AGP的代码编译过程。

任务创建

上篇文章中我们曾经介绍过构建的核心任务都是在TaskManager中创建的，代码如下：

public void createTasksForVariantScope(@NonNull final VariantScope variantScope) {
        //省略部分代码...
        // Add a compile task
        createCompileTask(variantScope);
}

在项目里面Java代码的编译由compile${variantName}JavaWithJavac任务来完成，而这个任务就是在createCompileTask方法里面被创建出来，代码如下：

protected void createCompileTask(@NonNull VariantScope variantScope) {
        JavaCompile javacTask = createJavacTask(variantScope);
        //省略部分代码...
 }
public JavaCompile createJavacTask(@NonNull final VariantScope scope) {
        JavaPreCompileTask preCompileTask =
                taskFactory.create(new JavaPreCompileTask.ConfigAction(scope));
        preCompileTask.dependsOn(scope.getTaskContainer().getPreBuildTask());

        //创建JavaCompile Task
        final JavaCompile javacTask = taskFactory.create(new JavaCompileConfigAction(scope));
        scope.getTaskContainer().setJavacTask(javacTask);

        setupCompileTaskDependencies(scope, javacTask);

        postJavacCreation(scope);

        return javacTask;
    }

代码也是比较简单，大概是创建一个JavaCompile Task，然后设置它的依赖关系，通过查看JavaCompileConfigAction的源码，我们可以得到这个JavaCompile Task本质是个AndroidJavaCompile类型对象，代码如下

public class JavaCompileConfigAction implements TaskConfigAction<AndroidJavaCompile> {
     //省略部分代码...
    @NonNull
    @Override
    public String getName() {
        return scope.getTaskName("compile", "JavaWithJavac");
    }

    @NonNull
    @Override
    public Class<AndroidJavaCompile> getType() {
        return AndroidJavaCompile.class;
    }

    @Override
    public void execute(@NonNull final AndroidJavaCompile javacTask) {
        //省略部分代码...
    }
}

通过getName方法我们可以知道，JavaCompile Task的名称格式是compile${variantName}JavaWithJavac,类型是AndroidJavaCompile，AndroidJavaCompile继承于JavaCompile，其中核心的Java编译工作都是由后者完成的。

Java编译过程

JavaCompile的compile方法是Java代码编译的入口，当我们在AS里面点击Run又或者双击compile${variantName}JavaWithJavac Task会跑到compile方法里，代码如下：

protected void compile(IncrementalTaskInputs inputs) {
        if (!compileOptions.isIncremental()) {
            compile();
            return;
        }

        DefaultJavaCompileSpec spec = createSpec();
        Compiler<JavaCompileSpec> incrementalCompiler = getIncrementalCompilerFactory().makeIncremental(
            createCompiler(spec),
            getPath(),
            (IncrementalTaskInputsInternal) inputs,
            source,
            getEffectiveAnnotationProcessorPath()
        );
        performCompilation(spec, incrementalCompiler);
}

首先会先判断是否为增量编译，如果不是直接走全量编译，因为全量编译过程比较简单，这里我们只分析它的增量编译，IncrementalTaskInputs是Gradle提供的API，用来检测文件的修改，这里不多做介绍，我们重点关注makeIncremental跟createCompiler，前者返回一个Compiler对象，并且最终是调用这个对象的execute来编译代码的，但事实上真正的代码编译是由createCompiler创建出来的对象来执行的，前者通过代理模式，创建了一些列的代理Compiler来处理一些编译前工作。

makeIncremental 是IncrementalCompilerFactory对象方法，它代码如下：

    public <T extends JavaCompileSpec> Compiler<T> makeIncremental(CleaningJavaCompilerSupport<T> cleaningJavaCompiler, String taskPath, FileTree sources, RecompilationSpecProvider recompilationSpecProvider) {
        TaskScopedCompileCaches compileCaches = createCompileCaches(taskPath);
        Compiler<T> rebuildAllCompiler = createRebuildAllCompiler(cleaningJavaCompiler, sources);
        ClassDependenciesAnalyzer analyzer = new CachingClassDependenciesAnalyzer(new DefaultClassDependenciesAnalyzer(interner), compileCaches.getClassAnalysisCache());
        ClasspathEntrySnapshotter classpathEntrySnapshotter = new CachingClasspathEntrySnapshotter(fileHasher, streamHasher, fileSystemSnapshotter, analyzer, compileCaches.getClasspathEntrySnapshotCache(), fileOperations);
        ClasspathSnapshotMaker classpathSnapshotMaker = new ClasspathSnapshotMaker(new ClasspathSnapshotFactory(classpathEntrySnapshotter, buildOperationExecutor));
        PreviousCompilationOutputAnalyzer previousCompilationOutputAnalyzer = new PreviousCompilationOutputAnalyzer(fileHasher, streamHasher, analyzer, fileOperations);
        IncrementalCompilerDecorator<T> incrementalSupport = new IncrementalCompilerDecorator(classpathSnapshotMaker, compileCaches, cleaningJavaCompiler, rebuildAllCompiler, previousCompilationOutputAnalyzer, interner);
        return incrementalSupport.prepareCompiler(recompilationSpecProvider);
    }

通过上面的代码我们可以看见Compiler是被IncrementalCompilerDecorator对象的prepareCompiler方法创建出来的，prepareCompiler方法源码如下：

public Compiler<T> prepareCompiler(RecompilationSpecProvider recompilationSpecProvider) {
        Compiler<T> compiler = getCompiler(recompilationSpecProvider);
        return new IncrementalResultStoringCompiler(compiler, classpathSnapshotMaker, compileCaches.getPreviousCompilationStore(), interner);
 }

可以看到最终返回给JavaCompile的其实是个IncrementalResultStoringCompiler对象，IncrementalResultStoringCompiler顾名思义它在Java代码的编译过程中只是用来存储编译结果的，当JavaCompile调用IncrementalResultStoringCompiler的execute方法来编译Java代码时，实际上会把编译任务交给了delegate来完成，代码如下

    public WorkResult execute(T spec) {
        WorkResult result = delegate.execute(spec);
        if (result instanceof RecompilationNotNecessary) {
            return result;
        } else {
            storeResult(spec, result);
            return result;
        }
    }

这个delegate对象是通过前面的getCompiler方法创建出来的，代码如下：

    //创建delegate对象.
    private Compiler<T> getCompiler(RecompilationSpecProvider recompilationSpecProvider) {
        if (!recompilationSpecProvider.isIncremental()) {
            LOG.info("Full recompilation is required because no incremental change information is available. This is usually caused by clean builds or changing compiler arguments.");
            return rebuildAllCompiler;
        } else {
            PreviousCompilationData data = compileCaches.getPreviousCompilationStore().get();
            if (data == null) {
                LOG.info("Full recompilation is required because no previous compilation result is available.");
                return rebuildAllCompiler;
            } else {
                PreviousCompilation previousCompilation = new PreviousCompilation(data, compileCaches.getClasspathEntrySnapshotCache(), previousCompilationOutputAnalyzer);
                return new SelectiveCompiler(previousCompilation, cleaningCompiler, rebuildAllCompiler, recompilationSpecProvider, classpathSnapshotMaker);
            }
        }
    }

这个delegate其实就是个SelectiveCompiler对象，编译java代码时会调用它的execute方法，代码如下：

 public WorkResult execute(T spec) {
        // 省略全量编译判断代码...
        RecompilationSpec recompilationSpec = recompilationSpecProvider.provideRecompilationSpec(currentCompilation, previousCompilation);

        if (recompilationSpec.isFullRebuildNeeded()) {
            LOG.info("Full recompilation is required because {}. Analysis took {}.", recompilationSpec.getFullRebuildCause(), clock.getElapsed());
            return rebuildAllCompiler.execute(spec);
        }

        recompilationSpecProvider.initializeCompilation(spec, recompilationSpec);

        if (Iterables.isEmpty(spec.getSourceFiles()) && spec.getClasses().isEmpty()) {
            LOG.info("None of the classes needs to be compiled! Analysis took {}. ", clock.getElapsed());
            return new RecompilationNotNecessary();
        }

        try {
            return recompilationSpecProvider.decorateResult(recompilationSpec, cleaningCompiler.getCompiler().execute(spec));
        } finally {
            Collection<String> classesToCompile = recompilationSpec.getClassesToCompile();
            LOG.info("Incremental compilation of {} classes completed in {}.", classesToCompile.size(), clock.getElapsed());
            LOG.debug("Recompiled classes {}", classesToCompile);
        }
    }

很显然的SelectiveCompiler本身也只是个代理对象，最终它会调用cleaningCompiler的execute去编译代码，这个地方我们一会再分析，这个地方我们重点关心两个方法，一个是provideRecompilationSpec，另外一个是initializeCompilation，他们都是由RecompilationSpecProvider接口提供的，而JavaRecompilationSpecProvider类实现了这个接口，先看看provideRecompilationSpec，代码如下：

//org.gradle.api.internal.tasks.compile.incremental.recomp.JavaRecompilationSpecProvider
/**
* processClasspathChanges是用来检测classpath是否有被修改的
* 而processOtherChanges就是用来检测Java源码的修改的
*/
public RecompilationSpec provideRecompilationSpec(CurrentCompilation current, PreviousCompilation previous) {
        RecompilationSpec spec = new RecompilationSpec();
        processClasspathChanges(current, previous, spec);
        processOtherChanges(current, previous, spec);
        spec.getClassesToProcess().addAll(previous.getTypesToReprocess());
        return spec;
 }

processClasspathChanges用来负责检查classpath的改动，这里我们只分析processOtherChanges，它负责了代码修改的检测以及类依赖关系检索等等工作，源码如下：

    private void processOtherChanges(CurrentCompilation current, PreviousCompilation previous, RecompilationSpec spec) {
        SourceFileChangeProcessor javaChangeProcessor = new SourceFileChangeProcessor(previous);
        AnnotationProcessorChangeProcessor annotationProcessorChangeProcessor = new AnnotationProcessorChangeProcessor(current, previous);
        ResourceChangeProcessor resourceChangeProcessor = new ResourceChangeProcessor(current.getAnnotationProcessorPath());
        InputChangeAction action = new InputChangeAction(spec, javaChangeProcessor, annotationProcessorChangeProcessor, resourceChangeProcessor, sourceFileClassNameConverter);
        inputs.outOfDate(action);
        inputs.removed(action);
    }

processOtherChanges里面首先创建了三个Processor用来处理发生了变化的源文件，InputChangeAction实现了Gradle的Action接口，outOfDate removed都是Gradle提供的API，用来回调被增删修改文件的，InputChangeAction的代码大概如下：

class InputChangeAction implements Action<InputFileDetails> {
    
    // 省略部分代码...
    public void execute(InputFileDetails input) {
        if (spec.getFullRebuildCause() == null) {
            File file = input.getFile();
            if (FileUtils.hasExtension(file, ".java")) {
                Collection<String> classNames = sourceFileClassNameConverter.getClassNames(file);
                if (classNames.isEmpty()) {
                    spec.setFullRebuildCause("source dirs are changed", file);
                } else {
                    javaChangeProcessor.processChange(file, classNames, spec);
                }
            } else if (!FileUtils.hasExtension(file, ".jar") && !FileUtils.hasExtension(file, ".class")) {
                resourceChangeProcessor.processChange(input, spec);
            } else {
                annotationProcessorChangeProcessor.processChange(input, spec);
            }

        }
    }
}

当有源文件被修改了编译时会回调execute方法，input.getFile()会返回被修改了的文件的绝对路径，sourceFileClassNameConverter负责把/分隔的文件路径转换为.分隔的类的绝对路径，这里我们重点关心javaChangeProcessor，它是SourceFileChangeProcessor类型对象，主要负责检索代码的依赖关系的，processChange方法源码如下：

public void processChange(File inputFile, Collection<String> classNames, RecompilationSpec spec) {
    //把当前被修改文件添加到待编译文件list里面
    spec.getClassesToCompile().addAll(classNames);

    for (String className : classNames) {
       //获取类的依赖关系.
        DependentsSet actualDependents = previousCompilation.getDependents(className, IntSets.EMPTY_SET);
        if (actualDependents.isDependencyToAll()) {
            spec.setFullRebuildCause(actualDependents.getDescription(), inputFile);
            return;
        }
        spec.getClassesToCompile().addAll(actualDependents.getDependentClasses());
        spec.getResourcesToGenerate().addAll(actualDependents.getDependentResources());
    }
}

通过调用PreviousCompilation的getDependents方法获取被修改类的所有依赖，后者其实又调用了ClassSetAnalysis的getRelevantDependents方法来获取类依赖，其内部又会调用recurseDependents方法来深度递归 获取依赖的依赖 把所有依赖都获取出来，代码如下：

public DependentsSet getRelevantDependents(String className, IntSet constants) {
    String fullRebuildCause = annotationProcessingData.getFullRebuildCause();
    if (fullRebuildCause != null) {
        return DependentsSet.dependencyToAll(fullRebuildCause);
    }
    DependentsSet deps = getDependents(className);
    if (deps.isDependencyToAll()) {
        return deps;
    }
    if (!constants.isEmpty()) {
        return DependentsSet.dependencyToAll();
    }
    Set<String> classesDependingOnAllOthers = annotationProcessingData.getGeneratedTypesDependingOnAllOthers();
    Set<GeneratedResource> resourcesDependingOnAllOthers = annotationProcessingData.getGeneratedResourcesDependingOnAllOthers();
    if (deps.getDependentClasses().isEmpty() && classesDependingOnAllOthers.isEmpty() && resourcesDependingOnAllOthers.isEmpty()) {
        return deps;
    }

    Set<String> resultClasses = new HashSet<String>();
    Set<GeneratedResource> resultResources = new HashSet<GeneratedResource>(resourcesDependingOnAllOthers);
    //recurseDependentClasses内部会递归的调用, 直到把整个依赖链给检索出来
    recurseDependentClasses(new HashSet<String>(), resultClasses, resultResources, deps.getDependentClasses());
    recurseDependentClasses(new HashSet<String>(), resultClasses, resultResources, classesDependingOnAllOthers);
    resultClasses.remove(className);

    return DependentsSet.dependents(resultClasses, resultResources);
}

关于类的依赖的获取ClassSetAnalysis本质也是调用了ClassSetAnalysisData对象的getDependents方法去获取的，ClassSetAnalysisData会解析.class结构，从常量池里检索出依赖的类对象来，常量池里面类型为7的就是class类型，代码并不多，如果比较熟悉.class文件结构的话很容易就读懂，这里就不再分析了。

回到SelectiveCompiler的execute方法里，第一步通过调用JavaRecompilationSpecProvider对象的provideRecompilationSpec方法，把被修改的java文件，以及它的依赖文件全部都被检索出来了，接着会继续调用它的initializeCompilation方法来初始化一些编译前工作，包括设置classpath、清理被删除文件、把以.分隔的类路径转换为以/分隔的文件绝对路径等等，代码如下：

public void initializeCompilation(JavaCompileSpec spec, RecompilationSpec recompilationSpec) {
    
    //省略部分代码...
    Factory<PatternSet> patternSetFactory = fileOperations.getFileResolver().getPatternSetFactory();
    PatternSet classesToDelete = patternSetFactory.create();
    PatternSet sourceToCompile = patternSetFactory.create();

    prepareJavaPatterns(recompilationSpec.getClassesToCompile(), classesToDelete, sourceToCompile);
    //把com.nls.exapmle.Test.java格式的类路径转换为com/nls/exapmle/Test.java文件路径.
    spec.setSourceFiles(narrowDownSourcesToCompile(sourceTree, sourceToCompile));
    //设置classpath，主要是把build/intermediates/javac/debug/compileDebugJavaWithJavac路径添加进来.
    includePreviousCompilationOutputOnClasspath(spec);
    addClassesToProcess(spec, recompilationSpec);
    //处理被删文件
    deleteStaleFilesIn(classesToDelete, spec.getDestinationDir());
    deleteStaleFilesIn(classesToDelete, spec.getCompileOptions().getAnnotationProcessorGeneratedSourcesDirectory());
    deleteStaleFilesIn(classesToDelete, spec.getCompileOptions().getHeaderOutputDirectory());
    //省略部分代码...
}

SelectiveCompiler最后通过调用cleaningCompiler.getCompiler()的execute方法来编译代码，这个cleaningCompiler对象是在JavaCompile的compile里面被创建出来的，代码是在JavaCompile.createCompiler()里，源码如下：

 private CleaningJavaCompiler createCompiler(JavaCompileSpec spec) {
    Compiler<JavaCompileSpec> javaCompiler = CompilerUtil.castCompiler(((JavaToolChainInternal)getToolChain()).select(this.getPlatform()).newCompiler(spec.getClass()));
    return new CleaningJavaCompiler(javaCompiler, getOutputs());
}

可以看到这个cleaningCompiler就是CleaningJavaCompiler类对象，但是CleaningJavaCompiler也仅仅是个代理对象，它并不参与代码的真正编译工作，java代码的编译工作是由newCompiler方法创建出来的对象来完成的，newCompiler是ToolProvider的一个接口，JavaToolProvider实现了这个接口，负责提供java编译所需要的compiler，代码是在org.gradle.api.internal.tasks.AbstractJavaToolChain类里，代码如下：

private class JavaToolProvider implements ToolProvider {
    //省略部分代码...
    public <T extends CompileSpec> Compiler<T> newCompiler(Class<T> spec) {
        if (JavaCompileSpec.class.isAssignableFrom(spec)) {
            Compiler<T> compiler = AbstractJavaToolChain.this.compilerFactory.create(spec);
            return compiler;
        } else if (JavadocSpec.class.isAssignableFrom(spec)) {
            Compiler<T> compilerx = new JavadocGenerator(AbstractJavaToolChain.this.execActionFactory);
            return compilerx;
        } else {
            throw new IllegalArgumentException(String.format("Don't know how to compile using spec of type %s.", spec.getClass().getSimpleName()));
        }
    }
    //省略部分代码...
}

JavaToolProvider里面会根据不同的类型创建对应的compiler，这里我们的spec是JavaCompileSpec类型，所以最终会通过JavaCompilerFactory接口的create方法来创建出compiler，DefaultJavaCompilerFactory类实现了这个接口，代码如下：

public Compiler<JavaCompileSpec> create(Class<? extends CompileSpec> type) {
    Compiler<JavaCompileSpec> result = createTargetCompiler(type, false);
    return new AnnotationProcessorDiscoveringCompiler(new NormalizingJavaCompiler(result), processorDetector);
}

private Compiler<JavaCompileSpec> createTargetCompiler(Class<? extends CompileSpec> type, boolean jointCompilation) {
    if (!JavaCompileSpec.class.isAssignableFrom(type)) {
        throw new IllegalArgumentException(String.format("Cannot create a compiler for a spec with type %s", type.getSimpleName()));
    } else if (CommandLineJavaCompileSpec.class.isAssignableFrom(type)) {
        return new CommandLineJavaCompiler(execHandleFactory);
    } else {
        return (Compiler)(ForkingJavaCompileSpec.class.isAssignableFrom(type) && !jointCompilation ? new DaemonJavaCompiler(workingDirProvider.getWorkingDirectory(), JdkJavaCompiler.class, new Object[]{javaHomeBasedJavaCompilerFactory}, workerDaemonFactory, forkOptionsFactory, classPathRegistry, actionExecutionSpecFactory) : new JdkJavaCompiler(javaHomeBasedJavaCompilerFactory));
    }
}

最终返回的compiler是AnnotationProcessorDiscoveringCompiler类型对象，但AnnotationProcessorDiscoveringCompiler也仅仅是个代理对象，真正的java编译compiler对象是下面的createTargetCompiler方法创建出来的，最终被创建出来的compiler是JdkJavaCompiler类型的对象，这个对象是真正用来编译java代码的compiler，它的execute方法代码如下：

public WorkResult execute(JavaCompileSpec spec) {
    LOGGER.info("Compiling with JDK Java compiler API.");

    JdkJavaCompilerResult result = new JdkJavaCompilerResult();
    JavaCompiler.CompilationTask task = createCompileTask(spec, result);
    boolean success = task.call();
    if (!success) {
        throw new CompilationFailedException();
    }
    return result;
}

代码也比较简单，首先创建一个CompilationTask，这是JDK提供的一个接口，最后通过调用CompilationTask的call方法来编译java代码，createCompileTask方法代码如下：

  private JavaCompiler.CompilationTask createCompileTask(JavaCompileSpec spec, JdkJavaCompilerResult result) {
    //构造编译参数
    List<String> options = new JavaCompilerArgumentsBuilder(spec).build();
    //创建compiler
    JavaCompiler compiler = javaHomeBasedJavaCompilerFactory.create();
    MinimalJavaCompileOptions compileOptions = spec.getCompileOptions();
    Charset charset = compileOptions.getEncoding() != null ? Charset.forName(compileOptions.getEncoding()) : null;
    StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(null, null, charset);
    Iterable<? extends JavaFileObject> compilationUnits = standardFileManager.getJavaFileObjectsFromFiles(spec.getSourceFiles());
    boolean hasEmptySourcepaths = JavaVersion.current().isJava9Compatible() && emptySourcepathIn(options);
    JavaFileManager fileManager = GradleStandardJavaFileManager.wrap(standardFileManager, DefaultClassPath.of(spec.getAnnotationProcessorPath()), hasEmptySourcepaths);
    //创建task
    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, options, spec.getClasses(), compilationUnits);
    //省略部分代码...
    return task;
}

createCompileTask方法里调用的大多数是JDK提供的API了，这里值得关注的就是JavaCompiler，它是JDK提供的一个接口，用来负责编译java代码的，它是被JavaHomeBasedJavaCompilerFactory类的create方法创建出来，代码如下：

public JavaCompiler create() {
    JavaCompiler compiler = findCompiler();

    if (compiler == null) {
        throw new RuntimeException("Cannot find System Java Compiler. Ensure that you have installed a JDK (not just a JRE) and configured your JAVA_HOME system variable to point to the according directory.");
    }

    return compiler;
}

private JavaCompiler findCompiler() {
    File realJavaHome = currentJvmJavaHomeFactory.create();
    return SystemProperties.getInstance().withJavaHome(realJavaHome, systemJavaCompilerFactory);
}

currentJvmJavaHomeFactory对应的类型是CurrentJvmJavaHomeFactory，而systemJavaCompilerFactory对应的类型是SystemJavaCompilerFactory，定义如下：

public static class CurrentJvmJavaHomeFactory implements Factory<File>, Serializable {
    @Override
    public File create() {
        return Jvm.current().getJavaHome();
    }
}

public static class SystemJavaCompilerFactory implements Factory<JavaCompiler>, Serializable {
    @Override
    public JavaCompiler create() {
        return JdkTools.current().getSystemJavaCompiler();
    }
}

currentJvmJavaHomeFactory以及SystemProperties的withJavaHome方法会从环境变量配置里面读取JDK的配置路径，SystemJavaCompilerFactory则是负责创建JavaCompiler，JdkTools会通过反射把JavaCompiler创建出来，代码大概如下：

public JavaCompiler getSystemJavaCompiler() {
    Class<?> clazz;
    try {
        if (isJava9Compatible) {
            clazz = isolatedToolsLoader.loadClass("javax.tools.ToolProvider");
            try {
                return (JavaCompiler) clazz.getDeclaredMethod("getSystemJavaCompiler").invoke(null);
            } catch (IllegalAccessException e) {
                cannotCreateJavaCompiler(e);
            } catch (InvocationTargetException e) {
                cannotCreateJavaCompiler(e);
            } catch (NoSuchMethodException e) {
                cannotCreateJavaCompiler(e);
            }
        } else {
            clazz = isolatedToolsLoader.loadClass(DEFAULT_COMPILER_IMPL_NAME);
        }
    } catch (ClassNotFoundException e) {
        throw new IllegalStateException("Could not load class '" + DEFAULT_COMPILER_IMPL_NAME);
    }
    return DirectInstantiator.instantiate(clazz.asSubclass(JavaCompiler.class));
}

整个创建流程大致如下：

最后就是通过JDK提供的JavaCompiler接口来编译java代码。

总结

• AGP会在apply时创建出compile${variantName}JavaWithJavac任务，负责用来编译java代码，这个任务本质上是个AndroidJavaCompile类型对象，创建过程是在TaskManager里的createTasksForVariantScope方法里。

• AndroidJavaCompile被执行的时候会调用IncrementalCompilerFactory的makeIncremental方法来创建出compiler，compiler会被多重代理，最终负责编译java代码的是在JdkTools里面创建出来的JavaCompiler，它是JDK提供的接口。除了创建出compiler以外，AndroidJavaCompile还会调用JavaRecompilationSpecProvider的provideRecompilationSpec跟initializeCompilation方法，来检索出所有需要编译的java源文件。