*
    默认jar保存路径:
    C:\Users\gangtaoyu\.gradle
    window->preferences->gradle

    官网
    https://docs.gradle.org/current/userguide/userguide_single.html
    下载
    http://gradle.org/gradle-download/
    http://services.gradle.org/distributions
    中文手册
    http://pkaq.org/gradledoc/docs/userguide/userguide.html
    http://pkaq.github.io/gradledoc/docs/userguide/userguide.html
    api
    http://pkaq.org/gradledoc/docs/dsl/index.html

    *
    在android Studio里的默认路径
    D:\Program Files\Android\Android Studio\gradle\gradle-2.4

    *
    常用命令
    gradle properties #列出可配置项、插件属性
    gradle tasks #查看项目的task列表
    gradle build
    gradle assembleDebug
    gradle assembleRelease
    gradle clean

    gradle :help
    gradle tasks #可执行的task
    gradle help --task $taskName #查看某个task的帮助文档
    gradle projects #项目父子关系
    gradle dependencies $projectName:dependencies #项目依赖清单
    gradle -q api:dependencies --configuration $dependencieName(testCompile) #指定某个依赖名
    gradle -q webapp:dependencyInsight --dependency $jarName --configuration compile #观察对某个jar的依赖
    gradle $projectName:properties #查看项目属性
    gradle --profile #在build/reports/profile下生成报告文件,分析build的执行时间

     

    *
    常用参数
    -q 减少显示信息
    -s 输出详细堆栈错误
    -S 输出全部堆栈信息
    -x 跳过任务
    --continue 碰到错误继续执行
    --profile 产生运行时间报告
    -b 指定构件文件build.gradle

     

     

    *
    在eclipse下制定目录路径
    android{ //模块
    sourceSets { //属性
    main{
    manifest.srcFile 'AndroidManifest.xml'
    java.srcDirs = ['src']
    sesources.srcDirs = ['src']
    aidl.srcDirs = ['src']
    renderscript.srcDirs = ['src']
    res.srcDirs = ['src']
    assets.srcDirs = ['src']
    }
    }
    }
    注意:具体目录配置说明文档见 com.android.build.gradle.api.AndroidSourceSet.html

     


    *
    配置
    本地文档路径
    file:///D:/Program%20Files/Android/Android%20Studio/gradle/gradle-2.4/docs/dsl/org.gradle.api.invocation.Gradle.html
    dependencies{
    compile 'com.android.support:support-v4:21.0.0+' //导入单个jar
    compile fileTree(include:'*.jar',dir:'libs') //批量导入,导入目录下的所有jar
    }

    productFlavors { //渠道包
    phone{
    applicationId 'com.win16.myapplication'
    signingConfig singingConfigs.releasekey
    }

    pad {
    applicationId 'com.win16.myapplication'
    signingConfig singingConfigs.debugkey
    }
    }

    sourceSets{
    phone{
    manifest.srcFile 'src/phone/AndroidManifest.xml'
    assets.srcDirs = ['src/phone/assets']
    }
    pad{
    manifest.srcFile 'src/phone/AndroidManifest.xml'
    assets.srcDirs = ['src/pad/assets']
    }
    }


    *
    DSL
    使用声明式的方式为你的领域建模
    基于Groovy实现的DSL
    有很强的表达能力(比xml强多了)
    可以使用Groovy对DSL进行扩展


    *
    Groovy与 DSL
    http://lggege.iteye.com/blog/543730
    DSL:是特定领域的语言
    Groovy:通用领域的语言(同java一样都是)
    基于Groovy实现的DSL有:GANT, GORM, XMLBuilder, HtmlBuilder,Gradle
    Groovy方便实现DSL得力于如下特性:
    Groovy脚本,不用定义 class
    Groovy的 invokeMethod方法
    方法可不书写()
    语句末尾省略;分号
    不书写 return
    注意: 基于Groovy自身的语法简洁和众多特性,实现一个专属的DSL还是蛮简单的
    Groovy的语法
    meta { } //调用 meta方法,参数为一个闭包,闭包不执行任何代码
    table (style:'margin:5px;') { } //调用 table方法,第一个参数为 Map,第二个参数为闭包
    tr ('class':'trClass', style:'padding:5px;') { //调用 tr方法,第一个参数为 Map,第二个参数为闭包
    td {'Cell1'} //参数都为一个闭包;闭包中直接返回了一个字符串
    td {'Cell2'}
    td {'Cell3'}
    }
    Groovy自动引入了io、lang、math、net、util等包
    GString 用来做字符串叠加 ${var1}
    def dx = tasks.findByName("dex${variant.name.capitalize()}")
    apply 方法
    apply plugin: 'com.android.application' //plugin是参数,后面的是值
    闭包
    {} 作为方法的参数、一个代码块、方法指针
    闭包的参数和代码通过箭头(->)进行分隔
    (1..10).each{ counter -> log+=counter}
    map.each{k,v->
    println k
    println v
    }
    map.each{//it为魔法变量,不需要声明
    println it.key
    println it.value
    }
    匿名内部类
    resourceHandler.handle(new ResourceUser(){ //java无闭包
    public void use (Resource resource) {
    resource.doSomething()
    }
    resourceHandler.handle { resource -> resource.doSomething() } //Groovy移除无用代码后

     

    *
    定义Task
    http://blog.csdn.net/bolg_hero/article/details/19718235
    task helloTask {
    doLast{
    println "Hello world $name"
    }
    doFirst{
    println "$name" //helloTask
    }
    }
    定义依赖
    task intro(dependsOn: ['helloTask','helloTask2']) << { //dependsOn是关键字,支持多依赖。使用Groovy的list语法
    println "I'm Gradle"
    }
    task loadTestData {
    dependsOn << compileTestClasses
    dependsOn << createSchema
    }
    task world { //可变长数组
    dependsOn compileTestClasses, createSchema
    }
    task world
    world.dependsOn compileTestClasses, createSchema //调用task的dependsOn方法


    *
    属性定义
    System Properties
    jvm的属性 -D
    cmd
    gradle xxx -DmySystemProp=xxxx
    build.gradle
    System.properties['system']
    Project Properties
    Project的属性 -P
    cmd
    gradle xxx -PmyProjectProp=xxxxx
    build.gradle
    project.hasProperty('commandLineProjectProp')
    Ext(ra) Properties
    动态属性
    使用关键字 ext(是ExtraPropertiesExtension的实例)定义动态属性
    build.gradle
    ext.projectProperties="ext projectProperties-value"
    ext.taskProperties="ext.task.properties-value"


    *
    增量式构件
    一个Task对输入进行操作,然后产生输出
    如果输入、输出与上次一样,则不执行task
    每个Task都有inputs和outputs属性(类型分别为TaskInputs和TaskOutputs)
    实例
    task combineFileContentIncremental {
    def sources = fileTree('sourceDir')
    def destination = file('destination.txt')
    inputs.dir sources //定义输入
    outputs.file destination //定义输出
    doLast {
    destination.withPrintWriter { writer ->
    sources.each {source ->
    writer.println source.text
    }
    }
    }
    }


    *
    Groovy语法
    http://www.cnblogs.com/CloudTeng/p/3418072.html
    Bean
    为Bean自动生成get和set (绕一圈又回到起点。。。)
    使用bean.name直接调用get方法
    delegate
    Gradle大量地使用了:Groovy闭包的delegate机制
    修改闭包内代码的作用域
    c.delegate = child //闭包对象.delegate = 闭包代码操作的对象(作用域)
    c.setResolveStrategy Closure.DELEGATE_FIRST //闭包内变量的解析方式,设置闭包会首先查找delegate
    delegate机制的一个好处是可以增加所创建DSL的可读性
    基本语法
    List stringList = ['a', 'b','']
    Map map = [a:4,b:'d']
    闭包 {}


    *
    Plugin
    Gradle的项目构建生命周期并不是Gradle的内建机制,而是由Plugin自己引入的
    base Plugin
    标准的插件文档
    http://pkaq.org/gradledoc/docs/userguide/standard_plugins.html
    base #基础插件,添加生命周期task,为其他task添加合适的标准配置
    java-base #java源码支持
    groovy-base #groovy源码支持
    scala-base #scala源码支持
    reporting-base #分享、报告支持
    java Plugin
    引入的Task(描述了java项目构建的生命周期)
    :compileJava
    :processResources
    :classes
    :jar
    :assemble
    :compileTestJava
    :processTestResources
    :testClasses
    :test
    :check
    :build
    向Project中添加的Property
    sourceCompatibility 源码的java版本
    archivesBaseName 打包生成的文件名
    目录结构
    Gradle采用了与Maven相同的Java项目目录结构
    src/main/java
    /resources
    /test/java
    /resources
    Maven标准目录结构,请参考Maven官网
    可以通过配置来修改这些目录结构
    源码目录设置
    属性java //指定源文件集合
    属性resources //指定资源文件集合
    sourceSets {
    test{
    java {srcDir 'test/java/java-sources'} //默认值
    resources {srcDir 'test/java/resources'} //默认值
    runtimeClasspath = runtimeClasspath + files(api.output.classesDir) //将api编译生成的class文件放在main的classpath下
    }
    main{
    java {srcDir 'java-sources'} //非默认值
    resources {srcDir 'resources'} //非默认值
    compileClasspath = compileClasspath + files(api.output.classesDir) //将api编译生成的class文件放在main的classpath下
    }
    api{ //新增source set
    java {${path-to-project}/src/api/java} //默认值
    resources {${path-to-project}/src/api/resources} //默认值
    }
    }
    Gradle会为新建sourceSet创建相应的Task
    compile<mySourceSetName>Java
    process<mySourceSetName>Resources
    <mySourceSetName>Classes
    执行:gradle <mySourceSetName>Classes
    对于main而言,Gradle并没有相应的compileMainJava
    因在于:由于main是Gradle默认创建的source set,compileJava作为main的编译Task
    对于test来说,Gradle依然采用了compileTestJava


    *
    依赖管理
    Gradle可以使用Maven和Ivy的Repository
    可以使用本地文件系统作为Repository
    添加依赖库
    配置Maven的Repository
    repositories {
    mavenCentral()
    }
    定义依赖
    每一组依赖(编译依赖、运行依赖)称为一个Configuration
    configurations { //定义一组依赖,名为myDependency
    myDependency
    }
    dependencies { //为myDependency添加具体依赖包
    myDependency 'org.apache.commons:commons-lang3:3.0'
    }
    java Plugin自动定义的依赖名:
    compile :用于编译Java源文件
    testCompile :用于编译Java测试源文件
    runtime:用于运行时依赖
    testRuntime:用于测试运行时依赖
    依赖冲突
    Gradle会选择最新版本
    Maven会选择离依赖树最近的版本
    通过Configuration的resolutionStrategy来修改依赖冲突的处理规则
    依赖项目
    dependencies {
    compile project(':ProjectB') //依赖项目ProjectB的文件
    }
    依赖文件系统
    dependencies {
    compile files('spring-core.jar', 'spring-aap.jar')
    compile fileTree(dir: 'deps', include: '*.jar')
    }


    *
    定义项目
    http://blog.csdn.net/meegomeego/article/details/39453469
    构建多个项目
    http://www.cnblogs.com/CloudTeng/p/3418425.html
    Gradle为每个build.gradle都会创建一个相应的Project领域对象
    编写Gradle脚本操作的是Project对象
    多项目构建,是操作多个Project对象
    settings.gradle
    必须包含各个子项目的名称
    定义一个3个子项目的项目:core、web、mobile
    方法一
    include 'core', 'web', 'mobile'
    方法二
    include(':core')
    project(':core').projectDir = new File(settingsDir, 'core-xxx')
    include(':web)
    project(':web').projectDir = new File(settingsDir, 'web-xxx')
    include(':mobile)
    project(':mobile').projectDir = new File(settingsDir, 'mobile-xxx')
    定义公共配置
    allprojects { //将配置应用于所有项目(包括root和sub项目)(包括task的定义)
    task hello << {task -> println "I'm $task.project.name" }
    }
    subprojects { //只应用于子项目
    hello << {println "- I am the sub project of A"}
    }
    project(':core').hello << {
    println "- I'm the core component and provide service for other parts."
    }
    注意:
    子项目的遍历顺序是:按子项目的首字母顺序
    在根目录下执行gradle hello,那么所有子项目的“hello” Task都会被执行
    可以将groovy的所有语言特性用在Gradle的领域对象上

    *
    自定义Task(类)
    http://www.cnblogs.com/CloudTeng/p/3421934.html
    可以在build.gradle文件中定义Task类
    实例
    class HelloWorldTask extends DefaultTask {
    @Optional
    String message = 'I am davenkin'

    @TaskAction
    def hello(){
    println "hello world $message"
    }
    }
    task hello1(type:HelloWorldTask){
    message ="I am a programmer"
    }
    注意:
    定义Task的文件是用groovy写的,需要在该项目的build.gradle文件中引入groovy Plugin
    apply plugin: 'groovy'
    apply plugin: 'maven'


    *
    自定义plugin
    http://www.cnblogs.com/CloudTeng/p/3422009.html


    *
    常用插件
    1.Gradle Templates Plugin ( 初始化项目目录插件)
    https://github.com/townsfolk/gradle-templates
    安装
    buildscript {
    repositories {
    maven {
    url 'http://dl.bintray.com/cjstehno/public'
    }
    }
    dependencies {
    classpath 'gradle-templates:gradle-templates:1.5'
    }
    }
    apply plugin:'templates'
    或者
    apply from: 'http://www.tellurianring.com/projects/gradle-plugins/gradle-templates/1.3/apply.groovy'
    运行
    gradle createJavaProject
    2.The War Plugin
    文档
    插件使用说明文档
    http://pkaq.org/gradledoc/docs/userguide/war_plugin.html
    war任务api文档
    http://pkaq.org/gradledoc/docs/dsl/org.gradle.api.tasks.bundling.War.html#org.gradle.api.tasks.bundling.War:webInf(groovy.lang.Closure)
    继承自The Java Plugin
    build.gradle
    apply plugin: 'war'
    Tasks
    war (DependsOn:compile)
    assemble (DependsOn:war)
    即: classes<-war<-assemble
    Dependency management
    providedCompile
    providedRuntime
    Convention properties
    webAppDirName src/main/webapp
    webAppDir projectDir/webAppDirName
    War
    src/main/webapp/
    webapp/WEB-INF/web.xml
    webapp/WEB-INF/classes/
    webapp/WEB-INF/lib/
    Customizing例子
    configurations {
    moreLibs
    }
    repositories {
    flatDir { dirs "lib" }
    mavenCentral()
    }
    dependencies {
    compile module(":compile:1.0") {
    dependency ":compile-transitive-1.0@jar"
    dependency ":providedCompile-transitive:1.0@jar"
    }
    providedCompile "javax.servlet:servlet-api:2.5"
    providedCompile module(":providedCompile:1.0") {
    dependency ":providedCompile-transitive:1.0@jar"
    }
    runtime ":runtime:1.0"
    providedRuntime ":providedRuntime:1.0@jar"
    testCompile "junit:junit:4.12"
    moreLibs ":otherLib:1.0"
    }
    war {
    from 'src/rootContent' // adds a file-set to the root of the archive
    webInf { from 'src/additionalWebInf' } // adds a file-set to the WEB-INF dir.
    classpath fileTree('additionalLibs') // adds a file-set to the WEB-INF/lib dir.
    classpath configurations.moreLibs // adds a configuration to the WEB-INF/lib dir.
    webXml = file('src/someWeb.xml') // copies a file to WEB-INF/web.xml
    from(sourceSets.main.java.srcDirs) { //包含指定资源文件
    include '**/*.xml' //mybatis配置文件随classes打包
    //include 'src/main/java/com/jj/app/data/UserMapper.xml'
    into("WEB-INF/classes") //必须设置into,否则xml丢失
    }
    }
    3.The Eclipse Plugins
    eclipse
    task
    cleanEclipse #清理所有eclipse的配置文件
    cleanEclipseProject #删除.project
    cleanEclipseClasspath
    cleanEclipseJdt
    cleanEclipseWtpComponent #删除.settings/
    配置说明
    http://pkaq.org/gradledoc/docs/dsl/org.gradle.plugins.ide.eclipse.model.EclipseClasspath.html
    4.The Java Plugin
    Usage 使用
    apply plugin: 'java'
    Source sets 源码目录
    Tasks 任务
    compileJava
    JavaCompile
    https://docs.gradle.org/current/dsl/org.gradle.api.tasks.compile.JavaCompile.html
    processResources
    classes
    Project layout 目录结构
    Dependency management 依赖
    Convention properties 属性
    reportsDirName
    reportsDir
    sourceSets
    manifest
    Working with source sets 源码设置
    5. jetty插件
    文档
    jetty使用文档
    http://pkaq.org/gradledoc/docs/userguide/jetty_plugin.html
    jettyRun任务api文档
    http://pkaq.org/gradledoc/docs/dsl/org.gradle.api.plugins.jetty.JettyRun.html
    常用属性文档
    http://pkaq.org/gradledoc/docs/dsl/org.gradle.api.plugins.jetty.JettyPluginConvention.html


    *
    buildscript代码块
    声明脚本自身需要使用的资源
    优先被执行
    可以声明的资源包括依赖项、第三方插件、maven仓库地址等
    例子
    buildscript {
    repositories {
    maven {
    url 'http://dl.bintray.com/cjstehno/public'
    }
    }
    dependencies {
    classpath 'gradle-templates:gradle-templates:1.5'
    classpath 'org.apache.commons:commons-csv:1.0' #使用Groovy语法在脚本中定义task时,可以被直接调用
    // compile ""
    }
    }


    *
    仓库
    maven仓库缓存在~/.gradle/caches目录下
    仓库直接在Android Studio应用内部


    *
    任务监听
    class TimingsListener implements TaskExecutionListener, BuildListener {
    void afterExecute(Task task, TaskState taskState) {} //用来计时、加入任务
    void buildFinished(BuildResult result) {} //用来计时
    void buildStarted(Gradle gradle) {}
    void projectsEvaluated(Gradle gradle) {}
    void projectsLoaded(Gradle gradle) {}
    void settingsEvaluated(Settings settings) {}
    }
    注意:
    可以用来理解任务的作用,打印出inputs和outputs
    改一行代码build的时间主要花费在了dex上,buck牛逼的地方就是对这个地方进行了优化,大大减少了增量编译运行的时间


    *
    gradle中的applicationid用来区分应用
    packageName用来指定R文件包名
    apk中的manifest文件的packageName还是会被applicationid替换掉


    *
    引入脚本
    引用另一个脚本文件
    apply from 'other.gradle'
    other.gradle需要重新配置buildscript

    *
    productFlavors渠道包
    http://tech.meituan.com/mt-apk-packaging.html
    包名、应用名
    为flavor关联对应的sourceSet
    src/$flavorName
    Gradle在构建应用时,会优先使用flavor所属dataSet中的同名资源
    个性化渠道配置
    android {
    defaultConfig {
    buildConfigField "boolean", "AUTO_UPDATES", "true"
    }
    productFlavors {
    qihu360 {
    buildConfigField "boolean", "AUTO_UPDATES", "false"
    }
    }
    }
    dependencies { //第三方SDK
    provided 'com.qihoo360.union.sdk:union:1.0'
    qihu360Compile 'com.qihoo360.union.sdk:union:1.0'
    }


    *
    上传aar到Maven仓库
    apply plugin: 'maven'
    uploadArchives {
    repositories {
    mavenDeployer {
    pom.groupId = $GROUP_ID
    pom.artifactId = $ARTIFACT_ID
    pom.version = $VERSION
    repository(url: $RELEASE_REPOSITORY_URL) {
    authentication(userName: $USERNAME, password: $PASSWORD)
    }
    }
    }
    }
    注意:其中变量添加到gradle.properties文件


    *
    属性文件Properties配置
    http://somefuture.iteye.com/blog/1990172


    *
    AndroidManifest.xml中文注释乱码问题
    解决: 修改GRADLE_HOME/bin/gradle(windows系统中是gradle.bat)中的变量DEFAULT_JVM_OPTS
    DEFAULT_JVM_OPTS="-Dfile.encoding=UTF-8"


    *
    定义task的执行顺序(依赖)
    http://blog.csdn.net/lzyzsd/article/details/46935405
    方式一:
    processResources {
    dependsOn 'replace'
    doLast {
    println 'xxxxxxxxxxxxxx'
    }
    }
    方式二:
    processResources.dependsOn('replace')


    *
    打印变量
    println "${project.webAppDir}"
    注意:需要使用双引号,单引号不转义,同shell脚本


    *
    渠道包
    gradle assembleWandoujiaDebug #混淆Debug包
    gradle assembleWandoujiaRelease #混淆Release包
    gradle assembleWandoujiaInnertest #内测包(不混淆的Release包)
    gradle assembleRelease #所有渠道包,会很慢


    *
    初始环境配置
    本地安装
    下载解压后的目录(安装目录)
    /Users/yugangtao/Applications/gradle-3.1/
    /usr/local/bin/gradle
    ln -s /Users/yugangtao/Applications/gradle-3.1/bin/gradle /usr/local/bin/gradle
    或者修改~/.zshrc
    GRADLE_HOME=/Users/yugangtao/Applications/gradle-3.1
    export GRADLE_HOME
    export PATH=$PATH:$GRADLE_HOME/bin
    eclipse插件安装
    插件Gradle STS (将被替代,可以与插件buildship互相转换)
    插件buildship
    eclipse中,配置
    preferences->Gradle->/Users/yugangtao/Applications/gradle //此目录包含各个版本的gradle,以及gradle wapper
    gradle wapper
    默认目录
    /Users/yugangtao/Applications/gradle/wrapper/dists/gradle-2.14.1-bin/2r579t5wehc7ew5kc8vfqezww/gradle-2.14.1
    配置文件
    gradle-wrapper.properties
    下载指定的gradle版本distributionUrl=https\://services.gradle.org/distributions/gradle-3.1-bin.zip
    项目中,插件配置文件
    .settings/org.eclipse.buildship.core.prefs
    默认为使用gradle wapper
    connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
    使用本地安装的gradle
    connection.gradle.distribution=GRADLE_DISTRIBUTION(LOCAL_INSTALLATION(/Users/yugangtao/Applications/gradle-3.1))
    指定jdk路径:containers=org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8/
    其他配置...
    编辑器Minimalist Gradle Editor
    安装Gradle STS自带,也可以单独安装


    *
    maven项目转Gradle项目
    gradle init --type pom


    *
    gradle语法
    变量
    定义变量
    ext{
    springframeworkVersion = '4.2.5.RELEASE'
    }
    使用变量
    compile group: 'org.springframework', name: 'spring-core', version:"${springframeworkVersion}"
    注意:需要使用双引号!!!
    打印变量
    println buildDir
    println "$buildDir"
    println "${buildDir}"
    赋值与函数
    变量赋值 webXml = file('src/someWeb.xml') // copies a file to WEB-INF/web.xml
    函数调用 webInf { from 'src/additionalWebInf' } // adds a file-set to the WEB-INF dir.
    注意:
    使用等号是变量赋值,即覆盖
    不使用等号是函数调用,即添加
    type
    定义类(类型)
    可以使用Groovy、scala、java代码来定义
    在build.gradle中定义,需要使用相应的插件来解析
    扩展(基础)一个类(类型)
    task hello1(type:HelloWorldTask){ //HelloWorldTask是类,task是关键字
    message ="I am a programmer"
    }
    依赖一个类(类型)
    task intro(dependsOn: ['helloTask','helloTask2']) << { //dependsOn是关键字,支持多依赖。使用Groovy的list语法
    println "I'm Gradle"
    }
    使用一个类(类型)
    jettyRun {
    httpPort = 8080
    }
    定义依赖
    war.dependsOn('copyProductionConfig') //copyProductionConfig任务依赖war任务
    关键字
    ext, dependsOn, task,
    数组
    ['x1','x2']
    闭包
    { var-> var.x } //var为变量,{}声明闭包对象
    源码集合
    sourceSets中默认定义了main和test两种源码,各自有各自的属性(compileClasspath、runtimeClasspath)
    可以再定义其他名字的源码
    用属性文件替换配置文件
    http://www.tuicool.com/articles/muuIfmy
    插件
    apply plugin: 'eclipse' //eclipse项目基本插件
    apply plugin: 'eclipse-wtp' //eclipse web项目插件
    注意:
    1.eclipse插件是为了让eclipse现实正常,因此,当build.gradle中有类似jar依赖变化,需要重新执行cleanEclipseClasspath和eclipseClasspath两个任务
    如果不执行eclipse相关任务,则eclipse现实编译报错,而执行build任务却不报错!!
    2.使用eclipse的tomcat运行任务,与是否在build.gradle中修改output.classesDir无关
    eclipse项目默认编译输出到framework/bin,tomcat发布时,会自动使用此目录
    初始化
    使用eclipse的gradle插件为项目添加gradle特性,即可生成build.gradle等文件 #即一般初始化,或者手动写
    gradle init --type pom #从maven项目转gradle项目
    gradle eclipse #初始化ide:eclipse
    常用官方文档
    http://pkaq.org/gradledoc/docs/userguide/userguide.html
    中文 http://wiki.jikexueyuan.com/project/gradle/war-package.html
    http://pkaq.org/gradledoc/docs/dsl/index.html
    文件
    destinationDir= file("buildWar") //赋值文件
    file('buildWar').deleteDir() //删除文件