task学习

发表于 | 分类于
字数统计: 814 | 阅读时长 ≈ 4

java代码写在脚本中

gradle构建脚本本可以写java代码，groove语言支持java代码

java 类定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class VersionEntity {

	private Integer major;
	
	private Integer minor;
	
	private boolean release;

	@Override
	public String toString() {
		return "VersionEntity [major=" + major + ", minor=" + minor + ", release=" + release + "]";
	}
	public VersionEntity(Integer major, Integer minor, boolean release) {
		super();
		this.major = major;
		this.minor = minor;
		this.release = release;
	}
	public VersionEntity() {
		super();
		this.major = 2121;

	}
	
	
}

定义属性文件
ext.f = file(“version.properties”);

java 方法定义

1
2
3
4
5
6
7
8
9
VersionEntity GenerateVersion() throws FileNotFoundException, IOException{
	
	Properties properties = new Properties();
	
	properties.load(new FileInputStream(f));

	return new VersionEntity(Integer.valueOf(properties.get("major").toString()),Integer.valueOf(properties.get("minor").toString()), properties.getProperty("release").toString().equals("false"));

}

调用project的task方法创建继承于defaultTask的task

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
task ver {
     /*直接调用java方法*/
     project.version = GenerateVersion()
     version.release = true
	 /*配置代码块中定义 输入 输出，定义的task便能执行增量式构建*/
     inputs.property('release',version.release)
     outputs.file f 
     doLast {
     println  project.version
      ant.propertyfile(file: f){
	       /*修改属性文件中的值*/
	       entry(key: 'release',type: 'string',operation: '=',value: 'true')
	       println 'ver执行'
      }
      println  project.version
    }              
}

自定义task类

自定义task 类 也可以在java代码中定义，不过需要导入相应的包，此处gradle已经提供

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class myDefaultTask extends DefaultTask {

   /* 使用注解标识 输入 输出*/
   @Input String pi
   @OutputDirectory  po
   
   myDefaultTask (){
   
   group = '定义task'
   description = '定义task,封装实现，只提供输入输出'
   }
   
   /*定义动作*/
   @TaskAction 
   void start() {
   
        /*这里定义逻辑*/
        println '输入的是：'+pi
   
   }

}

测试增量式构建

1
2
3
4
5
6
7
task ceShiMyDefaultTask(type: myDefaultTask){         
        /*输入输出不变时，不在执行task*/
        pi = 'hahhh--900'
        po=  file("/lib")

       doLast {println 'ceShiMyDefaultTask'}
 }

文件复制，可以参考api中Copy类

这种文件复制 类似于 调用方法

1
2
3
4
5
6
7
8
9
 task ccc(){
   doLast{
	   copy() {
	   /* from into  都是copy对象的方法*/
	     from "lib" 
	    into "test"
	   }
   }
}

这种文件复制 类似于继承 输入输出定义在父类中 此task执行一次就不会执行了

1
2
3
4
5
6
7
8
9
10
11
12

task hhh(type: Copy){
 inputs.property('release',11)
 outputs.dir   file("111")  
  doLast {
  println '-----------------------00000'
  
  }
  from "111" 
  into "2222"
  include "111.png"
}

task规则

简单task只需project的task即可以添加，但是task规则只能通过taskContainer容器的addRule(String,Closure)方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
tasks.addRule('Pattern: Test<Classifier>My: 测试task规则.'){
    String taskName ->
 if (taskName.startsWith('Test') && taskName.endsWith('My')){
    task (taskName) {
      doLast{
	     String classifier = taskName - 'Test' - 'My'
	     switch(classifier){
	     
	       case '1' : println '任务---1'
	                  break
	       case '2' : println '任务---2'
	                  break
	       default:  println '任务000'
	     }
	   }
    }
 }

}

编写生命周期钩子，类似于监听，事件是任务蓝图创建完成后

1
2
3
4
5
6
7
8
9
10
 gradle.taskGraph.whenReady {taskGraph ->  
 
    /*包含不一定执行动作，一定执行配置，因为有可能是最新的，*/
    if(taskGraph.hasTask(':addTask')) {  
       println ' 存在的逻辑'
    } else {  
        println ' 不存在的逻辑'
    }  
   
}

不依赖依赖的task，控制执行顺序

1 finalizedBy就是在task执行完之后要执行的task。

2 mustRunAfter并不会添加依赖，它只是告诉Gradle执行的优先级如果两个task同时存在

总结

  • 重点把握对生命周期、执行顺序的认识
  • 借助gradle插件库查看源码，进行学习