本文主要是介绍Java和Android构建工具Gradle深入了解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
Gradle3.0编程与自动化构建
gradle是一款最新的，功能强大的构建工具，它使用程序代替传统的XML配置，构建项目更加灵活。gradle有丰富的第三方插件。
Gradle相关介绍及开发环境搭建
gradle相关概念介绍
-
领域特定语言DSL介绍
-
全称domain specific language：它分三类，包含建模语言，sql，html，groovy等
-
外部DSL
-
内部DSL
-
语言工作台
-
-
优点
1、提高开发效率，通过DSL来抽象构建模型，抽取公共的代码，减少重复的劳动；
2、和领域专家沟通，领域专家可以通过DSL来构建系统的功能；
3、执行环境的改变，可以弥补宿主语言的局限性。
-
DSL语言与系统编程语言相辅相成，核心思想是求专不求全，解决特定问题
-
-
groovy详解和初探
-
介绍
-
groovy是一种基于JVM的敏捷开发语言
-
结合了Python、Ruby和Smalltalk的许多强大特性
-
groovy可以与Java完美结合，而且可以使用java所有的库
-
-
特性
-
语法上支持动态类型，闭包等新一代语言特性
-
无缝集成所有已经存在的java类库
-
即支持面向对象编程也支持面向过程编程
-
-
-
groovy优势
-
一种更加敏捷的编程语言
-
入门非常的容易，但是功能非常的强大
-
既可以作为编程语言也可以作为脚本语言
-
有java基础很容易上手groovy
-
各系统平台下gradle开发环境搭建及工程创建
-
mac/linux环境下，groovy开发环境搭建
-
安装jdk
-
到官网下载groovy，解压到合适位置
-
配置groovy环境变量
-
输入groovy -version测试
-
-
windows环境下groovy开发环境搭建
-
安装jdk
-
到官网下载groovy，解压到合适位置
-
配置groovy环境变量
-
输入groovy -version测试
-
-
IntelliJ IDEA开发工具安装及groovy环境配置
-
下载安装idea基础版(无需破解支持groovy)
-
旧版本安装groovy插件
-
-
在idea中创建一个groovy工程
-
创建项目，选择groovy，指定groovy和jdk目录
-
新建groovy.class，groovy不仅能写java，也能写脚本语言
class HelloGroovy{static void main(args){println "hello groovy"} }
-
Gradle核心语法详解及实践
groovy基本类型会自动转为对象类型
字符串特殊用法
-
String
- 可以通过def来定义
-
GString
-
常用的三种定义方式
-
一般使用单引号：单引号是普通字符串，类似java中的双引号字符串
-
双引号：可扩展字符串，通过变量来拼接–》def sayHello=“hello: ${n}” ，这时它的类型是GStringImpl
-
三引号：预输出字符串，类似html中p标签
-
-
新增字符串操作
- 字符串扩展可以字符串和任意表达式拼接
-
新增API讲解
-
println str.center(8,‘a’’):表示用a填充字符串，原字符串在中间
-
println str.padLeft(8,‘a’)向左添加至字符串长度为8位，也有向右添加方法
-
字符串可以直接通过大于小于号进行比较，也可以通过compareTo()函数比较
-
字符串获取其中的:str[0],也可以str.getAt(0),可以获取多个-》str[0…1]
-
字符串减法：str.minus(str2)也可以直接用减号-》str-str2
-
字符串倒序操作:str.reverse()
-
str.capitalize():首字母大写
-
判断是否是int类型字符串：str.isNumber()
-
字符串直接转类型：str.toDouble()
-
-
gradle常见数据结构包含(list,map,range…)使用
-
逻辑控制
-
顺序逻辑：单步往下执行
-
条件逻辑：if/else,swtch/case
-
if/else和其它语言使用基本一样
-
switch/case
- 支持任意类型的case(list,range,string,int,double),列表中包含的时候会匹配到
-
-
循环逻辑：while,for
-
while和其它语言使用基本一样
-
for:可以使用范围0…9特有数据结构
def sum=0//范围循环for (i in 0..9){sum+=i}//循环list，list在这更像一个数组for (i in [1,2,3,4,56,78,9]){sum +=i}//map循环for (i in ['lili':1,'luck':3,'xiaoming':5]){sum+=i.value}
-
-
-
闭包
-
groovy闭包基础
-
闭包概念
-
闭包定义:闭包可以说是定义在函数中的函数，其实闭包就是一个代码块
//定义闭包 def clouser = {println 'hello groovy'} clouser.call()//简单执行 -
闭包调用:clouser.call(‘will’)/clouser()
-
-
闭包参数
//带参数闭包，这里使用双引号可以取出参数并拼接 def clouser1 = {String name ->println "hello groovy ${name}"} -
闭包返回值
def clouser = {return "hell ${it}"}//这里it表示输出默认参数,return返回值
-
-
groovy闭包使用-》常用的
-
与基本类型的结合使用
int x=fab(5) println x //结合upto函数,实现阶乘 int fab(int number){int result=11.upto(number,{num->result*=num})return result } //结合downto函数实现阶乘 int fab2(int number){int result =1number.downto(1){num->result*=num}return result } //闭包累加 int z=numAdd(6) println z int numAdd(int number){int result =0number.times {num -> result+= num}return result } -
与String结合使用
Str ing str ='the 2 and 3 is 5' //字符串遍历，方法后面加闭包 str.each {String temp -> print temp+',' } //find查找符合条件的第一个 println str.find{String s-> s.isNumber() } //闭包查找所有字符串 def list=str.findAll{String s-> s.isNumber()} println list.toListString() //any方法和闭包判断是否包含数字 def result=str.any {String s-> s.isNumber() } println result str.every//此方法是所有都符合返回ture，否则false //闭包遍历字符串转换大写 def listToUpper=str.collect {it.toUpperCase()} -
闭包进阶
-
与数据结构结合使用
-
与文件结合使用
-
-
-
闭包的关键变量
def scriptClouser={println "scriptClouser this:"+thisprintln "scriptClouser owner:"+ownerprintln "scriptClouser delegate:"+delegate}//三个变量输出结果一样scriptClouser.call()-
this:代表闭包定义处的类
-
owner:代表闭包定义处的类或者对象
-
delegate:代表任意对象，默认值与owner一致
在类中定义一个闭包，this、owner、delegate三个对象一致；在闭包中定义闭包，this和其它两个就不同；delegate对象被修改后会和owner不同
class Person{def classClouser={println "classClouser this:"+thisprintln "classClouser owner:"+ownerprintln "classClouser delegate:"+delegate} } Person p=new Person() p.classClouser.call() //闭包中定义闭包 def nestClouser={def innerClouser={println "innerClouser this:"+thisprintln "innerClouser owner:"+ownerprintln "innerClouser delegate:"+delegate}innerClouser.delegate=p//修改默认的delegateinnerClouser.call() } -
-
闭包委托策略
- 有四种委托策略(OWNER_FIRST,OWNER_ONLY,DELEGATE_FIRST,DELEGATE_ONLY),默认委托策略是OWNER_FIRST
class Person{String namedef pretty ={"My name is ${name}"}String toString() {pretty.call()}def classClouser={println "classClouser this:"+thisprintln "classClouser owner:"+ownerprintln "classClouser delegate:"+delegate} } class Teacher{String name } Person p=new Person() p.classClouser.call() def nestClouser={def innerClouser={println "innerClouser this:"+thisprintln "innerClouser owner:"+ownerprintln "innerClouser delegate:"+delegate}innerClouser.delegate=p//修改默认的delegateinnerClouser.call() } def stu=new Person(name:'xiaoming') def tea=new Teacher(name:'lili') stu.pretty.delegate=tea//修改默认delegate stu.pretty.resolveStrategy=Closure.DELEGATE_FIRST//指定闭包的委托策略 println '输出'+stu.toString()
-
闭包数据结构
-
-
列表
-
列表的定义
def list=[1,2,-3,4,5,6]//定义和初始化,默认是ArrayList def list=[1,2,3,4,5,6] as int[]//int类型数组,也可以和java一样定义 //groovy数组操作和list一样 -
列表的操作
-
增
list.addAll([10,15]) list.add(6) -
删
assert [1,'2',3,1,1,1].removeAll(['2',3]) assert list.remove(2) assert list.removeAll([4,5]) list.removeAt(1) print list -
查
//循环list，list在这更像一个数组for (i in [1,2,3,4,56,78,9]){print i}//简洁循环[1,2,3].each{it -> store += it}//find查找符合条件的第一个println str.find{String s-> s.isNumber() } //查找所有奇数 def findList=[-3,9,6,2,-7,1,5] def result=findList.findAll{return it%2!=0} print result //any和every方法 findList.any{return it%2!=0} findList.every{return it%2!=0} //查找最大和最小值;也可以闭包指定规则 findList.min() findList.max{return Math.abs(it)}//闭包绝对最大值 findList.count() -
排
def list=[1,2,-3,4,5,6] Comparator mc={a,b-> a==b? 0:Math.abs(a)return it.size()}//按照字符串长度排序
-
-
-
映射
def colors=[red:'ff0000',green:'00ff00',blue:'0000ff'] //索引方式 println colors['red'] colors.red //添加元素 colors.leftShift(white:"fffff") colors.yellow='ffff00' colors.complex=[a:1,b:2]//可以添加任意元素到map println colors.toMapString() println colors.getClass()//LinkedHashMap默认是LinkedHashMap，可以通过as关键字修改映射类型 //遍历 colors.each {def color->println "this key is ${color.key},"+"the value is ${color.value}" } colors.eachWithIndex{ def entry, int i ->println "this key is ${entry.key},"+"this index is ${i},"+"the value is ${entry.value}" } colors.each {def key,def value->println "this key is ${key},"+"the value is ${value}" } //查找 def entry=colors.find {def c->return c.value.equals('0000ff') } println entrydef students=[1:[number:'001',name:'Bob',score:55,sex:'male'],2:[number:'002',name:'Amey',score:60,sex:'male'],3:[number:'003',name:'Leo',score:77,sex:'male'],4:[number:'004',name:'Habby',score:99,sex:'male'] ] //强大的函数直接分组 def group=students.groupBy {def student->return student.value.score>=60? '及格':'不及格' } println group.toMapString() -
范围
-
范围的基本概念：范围继承list，但是比list简单点
-
范围操作：
def range=1..10 println range[0] println range.contains(10) println range.from println range.to //遍历 range.each {print it } def result=getGrade(75) println result def getGrade(Number number){def resultswitch (number){case 0..<60:result='不及格'breakcase 60..<70:result='及格'breakcase 70..<80:result='良好'breakcase 80..<100:result='优秀'break}return result }
-
gradle面向对象特性
- groovy中类，接口等的定义和使用
//class Person implements Action{//实现接口
class Person implements DefaultAction{//实现Trait类String nameInteger agedef increaseAge(Integer years){this.name+=years}@Overridevoid eat() {}@Overridevoid drink() {}@Overridevoid play() {}
}
//定义接口
interface Action {void eat()void drink()void play()}
//定义trait类型，类似接口，但是可以有实现类
trait DefaultAction {abstract void eat()void play(){println 'i can play'}
}
-
groovy中的元编程
-
groovy在执行方法的时候先判断类中是否有此方法-》有调用，没有-》判断MetaClass中是否有此方法-》判断是否重写了methodMissing()方法-》判断是否重写了InvokeMethod方法-》以上没通过抛出MissingMethodException
//class Person implements Action{ class Person {String nameInteger agedef increaseAge(Integer years){this.name+=years}//一个方法找不到时调用它来代替，否则抛出MissingMethodExceptiondef invokeMethod(String name,Object args){return "the method is ${name},the params is ${args}没有此方法"}//一个方法找不到时先调用这个方法然后调用invokeMethod方法def methodMissing(String name,Object args){return "this method ${name} is missing"} }def person=new Person(name:"will",age:25) //println person.age println person.cry()//调用一个不存在的方法 //为类动态添加一个属性 Person.metaClass.sex='male' //为类动态添加方法 Person.metaClass.sexUpperCase={-> sex.toUpperCase()} def person2=new Person(name:"will",age:25) println person2.sexUpperCase() //为类动态添加静态方法 Person.metaClass.static.createPerson={String name,int age->new Person(name:name,age:age) } def person3=Person.createPerson("Amey",30) println person3.name
-
Gradle高级用法实践
gradle中json文件处理及json，model互转，网络json处理
import groovy.json.JsonOutput
import groovy.json.JsonSlurperdef list=[new Person(name:'John',age:25),new Person(name: 'mary',age:26)]
def jsonStr= JsonOutput.toJson(list)
println jsonStr
println JsonOutput.prettyPrint(jsonStr)
def jsonSlpuer=new JsonSlurper()
//jsonSlpuer.parse()
println jsonSlpuer.parseText(jsonStr)
//从网络获取json并解析
def response=getNetWorkData('https://www.sojson.com/open/api/lunar/json.shtml')
println response.data.suit//输出网络数据
//获取数据返回对象
def getNetWorkData(String url){//发送http请求def connection=new URL(url).openConnection()connection.setRequestMethod('GET')connection.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)")connection.connect()def responese=connection.content.text//将json对象转化为实体对象def jsonSluper=new JsonSlurper()return jsonSluper.parseText(responese)
}
xml文件读取和生成
import groovy.xml.MarkupBuilderfinal String xml='''NOAA's National Weather Service
http://weather.gov/http://weather.gov/images/xml_logo.gif
NOAA's National Weather Service
http://weather.govNew York/John F. Kennedy Intl Airport, NY
KJFK
40.66
-73.78
Mon, 11 Feb 2008 06:51:00 -0500 ESTA Few Clouds
11
-12
36
West
280
18.4
29
1023.6
30.23
-11
-24
-7
-22
10.00http://weather.gov/weather/images/fcicons/
nfew.jpg
http://weather.gov/disclaimer.html
http://weather.gov/disclaimer.html'''
//开始解析xml数据
def xmlSluper=new XmlSlurper()
def response=xmlSluper.parseText(xml)
println response.current_observation.credit
//自带深度遍历
def taglist=response.depthFirst().findAll {wind_dir ->return wind_dir.text
}
println taglist
//children()方法实现广度遍历
//生成xml
def sw=new StringWriter()
def xmlBuilder=new MarkupBuilder(sw)//用来生成xml文件的核心类
//根节点langs创建
xmlBuilder.langs(type:'current',count:'3',mainstream:'true'){//第一个language节点language(flavor:'static',version:'1.5',value:'java'){age('24')}language(flavor:'dynamic',version:'1.5',value:'groovy'){age('16')}language(flavor:'dynamic',version:'1.5',value:'javaScript')
}
println sw
//对象生成xml
def langs=new Langs()
xmlBuilder.langs(type:langs.type,count:langs.count,mainstream:langs.mainstream){langs.languages.each {lang->languge(flavor:lang.flavor,version:lang.version,lang.value)}
}
println sw
class Langs{String type='current'int count =3boolean mainstream=truedef languages=[new Language(flavor: 'static',version: '1.5',value: 'java'),new Language(flavor: 'static',version: '17',value: '.c++'),new Language(flavor: 'dynamic',version: '8.0',value: 'javaScript'),new Language(flavor: 'dynamic',version: '3.5',value: 'python'),new Language(flavor: 'dynamic',version: '2.4',value: 'groovy'),]
}
class Language{String flavorString versionString value
}
普通文件的读写，文件下载功能实现
def file=new File('../HelloGroovy.iml')
def text=file.getText()//获取文件内容
//def result=file.readLines()
println text
//拷贝文件实现
def result=copyFile("../HelloGroovy.iml",'../HelloGroovy2.text')
println result
def copyFile(String sourcePath,String destationPath){try{//创建目标文件def desFile=new File(destationPath)if(!desFile.exists()){desFile.createNewFile()}new File(sourcePath).withReader {reader->def lines=reader.readLines()desFile.withWriter {writer->lines.each {line->writer.append(line+'\r\n')}}}return true}catch(Exception e){e.printStackTrace()}
}
def person=new Person(name: 'Cherry',age:19)
//saveObject(person,"../person.bean")
def objResult=readObject("../person.bean")
println objResult
//存储类到文件
def saveObject(Object object,String path){try{//创建目标文件def desFile=new File(path)if(!desFile.exists()){desFile.createNewFile()}desFile.withObjectOutputStream {out->out.writeObject(object)}return true}catch(Exception e){e.printStackTrace()}return false
}
//在文件中读取类
def readObject(String path){def obj=nulltry{def file=new File(path)if(file==null||!file.exists())return null//从文件中读取对象file.withObjectInputStream{input->obj=input.readObject()}}catch(Exception e){}return obj
}
groovy与java对比
-
写法上：没有java那么多限制
-
功能上：java中的类和方法都可以直接用，对java的功能扩展后，groovy实现功能更方便简洁
-
作用上：既可以编写应用，也可以编写脚本
Gradle概述
gradle是什么，gradle能做什么
-
gradle不仅仅是构建工具，也可以看做是一种编程框架
-
gradle组成部分
-
groovy核心语法
-
build script block
-
gradle api
-
-
优势
-
更加灵活：Maven和ant不能自己修改构建过程，gradle可以写构建脚本
-
粒度上：gradle开源，构建每一步都清晰可见，可修改
-
扩展性：支持插件，可以复用插件
-
兼容性：gradle吸取了所有构建工具的长处
-
-
gradle执行分三阶段
-
initialization初始化阶段：解析整个工程中的所有project，构建所有project对应的project对象
-
Configuration配置阶段：解析所有project对象中的task，构建好所有task的拓扑图
-
Execution执行阶段：执行具体的task及其依赖task
/*Android gradle构建阶段监听*/ /*首先在环境变量配置好gradle，具体百度*/ /*在Terminal终端输入-gradlew clean测试*/ /*在project下的build.gradle中添加如下代码*/ /*配置阶段开始前的回调监听*/ this.beforeEvaluate{println '开始' } /*配置阶段完成以后的回调监听*/ this.afterEvaluate{println '完成' } /*gradle执行完毕后的回调监听*/ this.gradle.buildFinished{println '结束' } /*在setting.gradle中输出*/ println '初始化阶段开始' /*执行gradlew clean查看终端输出*/
-
-
Gradle核心类之Project详解及实践
projectAPI组成
-
gradle生命周期api
/*配置阶段开始前的回调监听*/ this.beforeEvaluate{println '开始' } /*配置阶段完成以后的回调监听*/ this.afterEvaluate{println '完成' } /*gradle执行完毕后的回调监听*/ this.gradle.buildFinished{println '结束' } /*project相关api*/ this.getProjects() def getProjects(){println '--------------------'println 'Root project'println '--------------------'this.getAllprojects().eachWithIndex{Project project,int i->if(i==0){println "Root project--- :${project.name}"}else {println "+---*** project: ${project.name}"}} } -
project相关api
/*project api讲解*/ project('app'){Project project-> // println project.nameapplay plugin:'com.android.application'dependencies {}android {} } /*配置当前工程和其所有子工程*/ allprojects{group 'com.will'version '1.0.0=release' } /*配置所有子工程*/ subprojects{ Project project->if(project.plugin.hasPlugin('com.android.library')){applay from:'../publishToMaven.gradle'//引入Maven配置文件} } -
task相关api
-
属性相关api
/*自定义属性*/ def mCompileSdkVersion =26 def mLibAndroidSupportAppcompatV7 ='com.android.support:appcompat-v7:26.+' /*通用扩展属性,在根build中定义一次，所有子moudle都可以使用*/ext {compileSdkVersion =26libAndroidSupportAppcompatV7 ='com.android.support:appcompat-v7:26.+'}/*在moudel中使用*/android {compileSdkVersion this.rootProject.compileSdkVersionbuildToolsVersion "26.0.3"... } /*因为继承关系也可以直接调用*/ dependencies { compile this.libAndroidSupportAppcompatV7 } /** 我们可以把所有属性通过扩展属性的方式定义到一个新的common.gradle中，在根gradle中通过 apply from:this.file('common.gradle')来引用 */  //moudle中使用 android{compileSdkVersion rootProject.ext.android.compileSdkVersion } //在gradle.properties中定义属性 isLoadTest=false isLoadPullRefresh=true mCompileSdkVersion=26 //使用,在setting.gradle include ':app' println '初始化阶段开始' if(hasProperty('isLoadPullRefresh')? isLoadPullRefresh.toBoolean():false){include ':pullToRefresh' } //在moudel下gradle compileSdkVersion mCompileSdkVersion.toInteger()-
common.gradle
-
-
file相关api
-
路径获取相关api
println "根目录路径"+getRootDir().absolutePath println "build下路径"+getBuildDir().absolutePath println "project的目录"+getProjectDir().absolutePath -
文件操作相关api
/*gradle拷贝文件，可以拷贝整个目录*/ copy {from file('app.iml')into getRootProject().getBuildDir()//此方法闭包过滤不想拷贝的文件exclude{} } //文件树遍历 fileTree('build/outputs/apk/'){FileTree fileTree->fileTree.visit{FileTreeElement element->println 'the file name is:'+element.file.namecopy {from element.fileinto getRootProject().getBuildDir().path+'/test/'}} }
-
-
其它api
//当有依赖包冲突时可以使用此命令去除冲突的部分 compile this.libAndroidSupportAppcompatV7{exclude module:'support-v4'//排除指定包下的所有库exclude group:'com.android.support' transitive false//禁止传递依赖，是否使用引入的库的第三方依赖 }//compile 依赖打包时会把依赖的类和资源打包到apk，provided依赖编译时使用依赖资源，打包时不会打包依赖资源,provided会避免重复引用,尽量使用provided//使用外部命令 task(name:'apkcopy'){doLast{//在gradle执行阶段去执行def sourcePath=this.buildDir.path+'outputs/apk'def desationPath='users/Andministrotor/Download/'def command="mv -f ${sourcePath} ${desationPath}"exec {try{executable 'bash'args '-c', commandprintln 'the command is execute success'}catch(Exception e){println 'the command is execute failed'}}} } //buildscript配置maven仓库 buildscript { ScriptHandler scriptHandler->//配置我们的仓库地址scriptHandler.repositories { RepositoryIdHelper repositoryIdHelper->repositoryIdHelper.jcenter()mavenCentral()mavenLocal()//私有的maven仓库配置，可以配置多个maven {name 'personal'url 'http://localhost:8081:/nexus/repositories'creadentials{username ='admin'password = 'admin123'}}}//buildscript中的此方法配置我们工程的'插件'依赖地址dependencies {//此插件指定项目为Android项目 // classpath 'com.android.tools.build:gradle.2.2.2'classpath 'com.tencent.tinker-patch-gradle-plugin:1.7.7'//引入腾讯热修复框架}}
Gradle核心之task详解及实践
task定义及使用，task执行流程
使用gradle task命令查看当前项目的task
//创建task，配置组名和描述
task helloTask(group:'will',description:'task study'){println 'i am helloTask'doFirst{//可以多次调用,在gradle的执行周期执行，原有的task之前执行println 'the task group is:'+group}doLast{}//原有的task之后执行}
helloTask.doFirst{//外部调用先执行println 'the task description is'+description
}
//通过TaskContainer创建task
this.tasks.create(name:'helloTask2'){//使用set设置组名setGroup('will')println 'i am helloTask2'
}//计算build执行时长的功能
def startBuildTime,endBuildTime
this.afterEvaluate{Project project->//保证要找的task已经执行完毕def preBuildTask=project.tasks.getByName('preBuild')preBuildTask.doFirst {//在此task之前执行startBuildTime=System.currentTimeMillis()println 'the startTime is:'+startBuildTime}def buildTask=project.tasks.getByName('build')buildTask.doLast{endBuildTime=System.currentTimeMillis()println "the build time is:${endBuildTime-startBuildTime}"}
}
task依赖关系与输入输出，task继承与实现
task taskX {doLast {println 'taskX'}
}
task taskY {doLast {println 'taskY'}
}
task taskZ(dependsOn: [taskX,taskY]) {dependsOn this .tasks.findAll{ task->return task.name.startsWith('lib')//动态指定依赖所有lib开头的}doLast {println 'taskZ'}
}
task lib1 <<{println 'lib1'}
task lib2 <<{println 'lib2'}//task生成版本说明文件
task handlerReleaseFile {def srcFile=file('releases.xml')def destDir=new File(this.buildDir,'generated/release/')doLast{println '开始解析对应的xml...'destDir.mkdir()def releases=new XmlParser().parse(srcFile)releases.release.each{ releaseNode->//解析每个release节点的内容def name=releaseNode.name.text()def versionCode=releaseNode.versionCode.text()def versionInfo=releaseNode.versionInfo.text()//创建文件并写入节点数据def destFile=new File(destDir,"release-${name}.text")destFile.withWriter{ writer->writer.write("${name} -> ${versionCode} -> ${versionInfo}")}}}
}
task handlerReleaseFileTest(dependsOn:handlerReleaseFile){def dir =fileTree(this.buildDir.path+'generated/release/')doLast {dir.each {println 'the file name is:'+it}println '输出完成...'}
}
task修改默认构建流程，task源码解读
通过脚本把构建版本信息写入xml，然后在把写入方法添加到构建过程中
//生成版本信息xml和读取，在构建流程中加入添加版本信息到xml
//实际开发中可以把一个独立的gradle功能代码写入单独的gradle文件，然后引入
ext {versionName = '1.0.0'versionCode = '100'versionInfo = 'App的第一个版本，上线了一些最基础的核心功能'destFile = file('releases.xml')if (destFile != null && !destFile.exists()) {destFile.createNewFile()}
}
task writeTask {//为task指定输入inputs.property('versionCode', this.versionCode)inputs.property('versionName', this.versionName)inputs.property('versionInfo', this.versionInfo)//为task指定输出outputs.file destFiledoLast {def data = inputs.getProperties()File file = outputs.getFiles().getSingleFile()def versionMsg = new VersionMsg(data)def sw = new StringWriter()def xmlBuilder = new MarkupBuilder(sw)if (file.text != null && file.text.size() <= 0) {xmlBuilder.release {release {versionCode(versionMsg.versionCode)versionName(versionMsg.versionName)versionInfo(versionMsg.versionInfo)}}file.withWriter {writer->writer.append(sw.toString())}}else{xmlBuilder.release {versionCode(versionMsg.versionCode)versionName(versionMsg.versionName)versionInfo(versionMsg.versionInfo)}//将生成的数据插入到根节点之前def lines=file.readLines()def lengths=lines.size()-1file.withWriter {writer->lines.eachWithIndex{ String line, int index ->if(index!=lengths){writer.append(line+'\r\n')}else if(index==lengths){writer.append('\r\r\n'+sw.toString() +'\r\n')writer.append(lines.get(lengths))}}}}}
}task readTask {inputs.file this.destFiledoLast {def file=inputs.files.singleFileprintln file.text}
}
task taskTest {dependsOn readTask ,writeTask
// shouldRunAfter
// mustRunAfterdoLast {println '输入输出任务结束'}
}
class VersionMsg {String versionCodeString versionNameString versionInfo
}
//在构建流程中加入添加版本信息到xml
this.project.afterEvaluate {project->def buildTask=project.tasks.getByName("build")if(buildTask==null){throw GradleException('the build task is not found')}buildTask.doLast {writeTask.execute()//每次构建项目时把版本信息写入xml文件}
}
通过查看腾讯tinker源码我们可以知道它把自己的方法插入到gradle构建流程中，在processReleaseManifest之后，在processReleaseResource之前
为了自定义task方便，官方文档提供了很多不同类型的task
自动化实现工程插件更新功能
Gradle核心之其它模块详解与实践
第三方库依赖管理及gradle如何处理依赖原理详解
工程初始化核心类Setting类作用及自定义
- settings类在setting.gradle中体现其作用,通过include 引入子工程，并且可以通过自定义属性判断什么条件引入某个工程
源码管理类SourceSet详解及实际工作中的妙用
-
sourceSet类按照约定来管理java中的类和资源，默认从java下获取源码，从res获取资源进行编译;其主要作用就是管理资源、源码、库；Android时通过AndroidSourceSet类管理，java通过javaSourceSet管理
-
sourceSet修改so库即jni默认目录
sourceSets {main {//修改默认so库jni目录到libs下jniLibs.srcDirs=['libs']}} -
SourceSet修改默认的资源文件路径为多路径，对资源进行分类
插件类plugin
自定义plugin需要继承plugin类
-
首先创建一个plugin工程，工程目录结构如下，代码在groovy中，引入配置路径在resources中
//plugin工程gradle文件 apply plugin: 'groovy'sourceSets {main {groovy {srcDir 'src/main/groovy'}resources {srcDir 'src/main/resources'}} } //资源文件下配置引入路径代码 implementation-class=com.will.gradle.study.GradleStudyPlugin //自定义插件groovy类，需要继承plugin类 class GradleStudyPlugin implements Plugin {/*** 唯一需要实现的就是这个方法，参数就是引入了当前插件的Project对象* @param project*/@Overridevoid apply(Project project) {println '这里导入了自定义插件'//创建扩展属性project.extensions.create('imoocReleaseInfo',ReleaseInfoExtension)//创建Taskproject.tasks.create('imoocReleaseInfoTask',ReleaseInfoTask)} } //自定义ReleaseInfoExtension类，与自定义plugin进行参数传递 class ReleaseInfoExtension {String versionCodeString versionNameString versionInfoString fileNameReleaseInfoExtension() {}@OverrideString toString() {"""| versionCode = ${versionCode}| versionName = ${versionName}| versionInfo = ${versionInfo}| fileName = ${fileName}""".stripMargin()} } //引入plugin apply plugin: 'com.will.gradle.study' //在app下gradle 中调用plugin定义的方法传递参数 imoocReleaseInfo {versionCode = rootProject.ext.android.versionCodeversionName = rootProject.ext.android.versionNameversionInfo = '第八个版本。。。'fileName = 'releases.xml' } //在plugin中自定义task，在gradle执行过程中把版本信息写入xml package com.imooc.gradle.studyimport groovy.xml.MarkupBuilder import org.gradle.api.DefaultTask import org.gradle.api.tasks.TaskAction/*** 自定义Task,实现维护版本信息功能*/ class ReleaseInfoTask extends DefaultTask {ReleaseInfoTask() {group = 'imooc'description = 'update the release info'}/*** TaskAction注解的代码执行于gradle执行阶段的代码*/@TaskActionvoid doAction() {updateInfo()}//真正的将Extension类中的信息呢，写入指定文件中private void updateInfo() {//获取将要写入的信息String versionCodeMsg = project.extensions.imoocReleaseInfo.versionCodeString versionNameMsg = project.extensions.imoocReleaseInfo.versionNameString versionInfoMsg = project.extensions.imoocReleaseInfo.versionInfoString fileName = project.extensions.imoocReleaseInfo.fileNamedef file = project.file(fileName)//将实体对象写入到xml文件中def sw = new StringWriter()def xmlBuilder = new MarkupBuilder(sw)if (file.text != null && file.text.size() <= 0) {//没有内容xmlBuilder.releases {release {versionCode(versionCodeMsg)versionName(versionNameMsg)versionInfo(versionInfoMsg)}}//直接写入file.withWriter { writer -> writer.append(sw.toString())}} else {//已有其它版本内容xmlBuilder.release {versionCode(versionCodeMsg)versionName(versionNameMsg)versionInfo(versionInfoMsg)}//插入到最后一行前面def lines = file.readLines()def lengths = lines.size() - 1file.withWriter { writer ->lines.eachWithIndex { line, index ->if (index != lengths) {writer.append(line + '\r\n')} else if (index == lengths) {writer.append('\r\r\n' + sw.toString() + '\r\n')writer.append(lines.get(lengths))}}}}} }
Jenkins持续集成
Jenkins持续集成步骤
-
创建jenkins环境变量
-
下载jenkins.war包
-
执行java -jar jenkins.war，安装jenkins到环境变量指定的位置，期间会有密码输出
-
输入localhost:8080 访问网页进入jenkins，输入密码配置jenkins
这篇关于Java和Android构建工具Gradle深入了解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
