[Java] gradle中的增量构建浅析

• 简单类型：简单类型就是所有实现了Serializable接口的类型，比如说string和数字。
  
• 文件类型：文件类型就是 File 或者 FileCollection 的衍生类型，或者其他可以作为参数传递给 Project.file(java.lang.Object) 和 Project.files(java.lang.Object…) 的类型。
  
• 嵌套类型：有些自定义类型，本身不属于前面的1，2两种类型，但是它内部含有嵌套的inputs和outputs属性，这样的类型叫做嵌套类型。
  

import java.io.File;
import java.util.HashMap;
import org.gradle.api.*;
import org.gradle.api.file.*;
import org.gradle.api.tasks.*;
 
public class ProcessTemplates extends DefaultTask {
private TemplateEngineType templateEngine;
private FileCollection sourceFiles;
private TemplateData templateData;
private File outputDir;
 
@Input
public TemplateEngineType getTemplateEngine() {
return this.templateEngine;
}
 
@InputFiles
public FileCollection getSourceFiles() {
return this.sourceFiles;
}
 
@Nested
public TemplateData getTemplateData() {
return this.templateData;
}
 
@OutputDirectory
public File getOutputDir() { return this.outputDir; }
 
// 上面四个属性的setter方法
 
@TaskAction
public void processTemplates() {
// ...
}
}

import java.util.HashMap;
import java.util.Map;
import org.gradle.api.tasks.Input;
 
public class TemplateData {
private String name;
private Map<String, String> variables;
 
public TemplateData(String name, Map<String, String> variables) {
this.name = name;
this.variables = new HashMap<>(variables);
}
 
@Input
public String getName() { return this.name; }
 
@Input
public Map<String, String> getVariables() {
return this.variables;
}
}

注意，上面的例子中我们使用了FileCollection作为输入的文件集合，考虑一种情况，假如只有文件集合中的某一个文件发送变化，那么gradle是会重新构建所有的文件，还是只重构这个被修改的文件呢？
留给大家讨论

• Task.getInputs() of type TaskInputs
  
• Task.getOutputs() of type TaskOutputs
  
• Task.getDestroyables() of type TaskDestroyables
  

task processTemplatesAdHoc {
inputs.property("engine", TemplateEngineType.FREEMARKER)
inputs.files(fileTree("src/templates"))
.withPropertyName("sourceFiles")
.withPathSensitivity(PathSensitivity.RELATIVE)
inputs.property("templateData.name", "docs")
inputs.property("templateData.variables", [year: 2013])
outputs.dir("$buildDir/genOutput2")
.withPropertyName("outputDir")
 
doLast {
// Process the templates here
}
}

task processTemplatesWithExtraInputs(type: ProcessTemplates) {
// ...
 
inputs.file("src/headers/headers.txt")
.withPropertyName("headers")
.withPathSensitivity(PathSensitivity.NONE)
}

task packageFiles(type: Zip) {
from processTemplates.outputs
}

task packageFiles2(type: Zip) {
from processTemplates
}

plugins {
id 'java'
}
 
task badInstrumentClasses(type: Instrument) {
classFiles = fileTree(compileJava.destinationDir)
destinationDir = file("$buildDir/instrumented")
}

task instrumentClasses(type: Instrument) {
classFiles = compileJava.outputs.files
destinationDir = file("$buildDir/instrumented")
}

task instrumentClasses2(type: Instrument) {
classFiles = layout.files(compileJava)
destinationDir = file("$buildDir/instrumented")
}

task instrumentClassesBuiltBy(type: Instrument) {
classFiles = fileTree(compileJava.destinationDir) {
builtBy compileJava
}
destinationDir = file("$buildDir/instrumented")
}

public class ProcessTemplates extends DefaultTask {
// ...
private FileCollection sourceFiles = getProject().getLayout().files();
 
@SkipWhenEmpty
@InputFiles
@PathSensitive(PathSensitivity.NONE)
public FileCollection getSourceFiles() {
return this.sourceFiles;
}
 
public void sources(FileCollection sourceFiles) {
this.sourceFiles = this.sourceFiles.plus(sourceFiles);
}
 
// ...
}

task processTemplates(type: ProcessTemplates) {
templateEngine = TemplateEngineType.FREEMARKER
templateData = new TemplateData("test", [year: 2012])
outputDir = file("$buildDir/genOutput")
 
sources fileTree("src/templates")
}

public void sources(Task inputTask) {
this.sourceFiles = this.sourceFiles.plus(getProject().getLayout().files(inputTask));
}

task copyTemplates(type: Copy) {
into "$buildDir/tmp"
from "src/templates"
}
 
task processTemplates2(type: ProcessTemplates) {
// ...
sources copyTemplates
}

task alwaysInstrumentClasses(type: Instrument) {
classFiles = layout.files(compileJava)
destinationDir = file("$buildDir/instrumented")
outputs.upToDateWhen { false }
}

normalization {
runtimeClasspath {
ignore 'build-info.properties'
}
}

normalization {
runtimeClasspath {
metaInf {
ignoreAttribute("Implementation-Version")
}
}
}

normalization {
runtimeClasspath {
metaInf {
ignoreManifest()
}
}
}

normalization {
runtimeClasspath {
metaInf {
ignoreCompletely()
}
}
}