Gradle

├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
└── gradlew.bat

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

//构建脚本（给脚本用的脚本）声明gradle脚本本身需要使用的资源
buildscript {
    //存储一个属于gradle的变量，整个工程都能用，可通过gradle.ext.springBootVersion使用
    ext {
        springBootVersion = '2.1.2.RELEASE'
    }
    /*配置仓库地址，从而找到外部依赖
    按照你在文件中(build.gradle)仓库的顺序寻找所需依赖(如jar文件)，
    如果在某个仓库中找到了，那么将不再其它仓库中寻找
    */
    repositories {
        //mavenLocal()本地库，local repository(${user.home}/.m2/repository)
        mavenCentral()//maven的中央仓库
        //阿里云Maven远程仓库
        maven { url "http://maven.aliyun.com/nexus/content/groups/public/" }
    }
    /*配置springboot插件加载
    */
    dependencies {
        // classpath 声明说明了在执行其余的脚本时，ClassLoader 可以使用这些依赖项
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
//使用以下插件
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'//jvm版本要求
// 定义仓库
repositories {
    maven{url 'http://maven.aliyun.com/nexus/content/groups/public/'}
    maven{url 'https://mvnrepository.com/'}
    mavenCentral()
}
// 定义依赖:声明项目中需要哪些依赖
dependencies {
    compile  'org.springframework.boot:spring-boot-starter'
    compile('org.springframework.boot:spring-boot-starter-web')//引入web模块，springmvc
    compile  'org.springframework.boot:spring-boot-starter-test'
}

//使用以下插件
plugins {
    id 'org.springframework.boot' version '2.3.0.RELEASE'
    id 'io.spring.dependency-management' version '1.0.9.RELEASE'
    id 'java'
}
 
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8' //jvm版本要求
 
// 定义仓库
repositories {
    maven{url 'http://maven.aliyun.com/nexus/content/groups/public/'}
    maven{url 'https://mvnrepository.com/'}
    mavenCentral()
}
//存储一个属于gradle的变量，整个工程都能用，可通过gradle.ext.springBootVersion使用
ext {
    set('springCloudVersion', "Hoxton.SR4")
}
 
// 定义依赖:声明项目中需要哪些依赖
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
}
 
dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}
 
test {
    useJUnitPlatform()
}

//settings.gradles是模块Module配置文件，大多数setting.gradle的作用是为了配置子模块，
//根目录下的setting.gradle脚本文件是针对module的全局配置
 
//settings.gradle用于创建多Project的Gradle项目。Project在IDEA里对应Module模块。
 
//例如配置module名rootProject.name = 'project-root',为指定父模块的名称，
//include 'hello' 为指定包含哪些子模块
------------------------
//平台根
rootProject.name = 'project-root'
//包含子系统以及模块
include ':project-core'
//Hello系统模块的加载
include ':project-hello'
//World系统模块的加载
include ':project-world'

buildscript {
    ext.kotlin_version = '1.3.10'
    repositories {
        mavenCentral()
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.0'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
    }
}

allprojects {
    repositories {
        google()
        jcenter()
        mavenCentral()
        maven { url 'https://jitpack.io' }
        maven { url "https://maven.google.com" }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

apply plugin: 'com.android.application' // 引入 android gradle 插件

android { // 配置 android gradle plugin 需要的内容
    compileSdkVersion 26
    defaultConfig { // 版本，applicationId 等配置
        applicationId "com.zy.easygradle"
        minSdkVersion 19
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
    }
    buildTypes { 
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions { // 指定 java 版本
        sourceCompatibility 1.8
        targetCompatibility 1.8
    }

    // flavor 相关配置
    flavorDimensions "size", "color"
    productFlavors {
        big {
            dimension "size"
        }
        small {
            dimension "size"
        }
        blue {
            dimension "color"
        }
        red {
            dimension "color"
        }
    }
}

// 项目需要的依赖
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) // jar 包依赖
    implementation 'com.android.support:appcompat-v7:26.1.0' // 远程仓库依赖
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    implementation project(':module1') // 项目依赖
}

gradle.addBuildListener(new BuildListener() {
    @Override
    void buildStarted(Gradle gradle) {
        println('构建开始')
        // 这个回调一般不会调用，因为我们注册的时机太晚，注册的时候构建已经开始了，是 gradle 内部使用的
    }

    @Override
    void settingsEvaluated(Settings settings) {
        println('settings 文件解析完成')
    }

    @Override
    void projectsLoaded(Gradle gradle) {
        println('项目加载完成')
        gradle.rootProject.subprojects.each { pro ->
            pro.beforeEvaluate {
                println("${pro.name} 项目配置之前调用")
            }
            pro.afterEvaluate{
                println("${pro.name} 项目配置之后调用")
            }
        }
    }

    @Override
    void projectsEvaluated(Gradle gradle) {
        println('项目解析完成')
    }

    @Override
    void buildFinished(BuildResult result) {
        println('构建完成')
    }
})

gradle.taskGraph.whenReady {
    println("task 图构建完成")
}
gradle.taskGraph.beforeTask {
    println("每个 task 执行前会调这个接口")
}
gradle.taskGraph.afterTask {
    println("每个 task 执行完成会调这个接口")
}

distributionUrl=https\://services.gradle.org/distributions/gradle-4.0-milestone-1-all.zip