1
2
3
4
5

   task wrapper(type: Wrapper){
      gradleVersion = '4.8'
      distributionUrl = '限定访问内网的URL'
      distributionPath = '包装器被解压缩放的相对路径'
   }

 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
27
28
29
30
31
32
33

allprojects{
    repositories {
        def ALIYUN_REPOSITORY_URL = 'https://maven.aliyun.com/repository/public'
        def ALIYUN_JCENTER_URL = 'https://maven.aliyun.com/repository/public'
        def ALIYUN_GOOGLE_URL = 'https://maven.aliyun.com/repository/google'
        def ALIYUN_GRADLE_PLUGIN_URL = 'https://maven.aliyun.com/repository/gradle-plugin'
        all { ArtifactRepository repo ->
            if(repo instanceof MavenArtifactRepository){
                def url = repo.url.toString()
                if (url.startsWith('https://repo1.maven.org/maven2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPOSITORY_URL."
                    remove repo
                }
                if (url.startsWith('https://jcenter.bintray.com/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_JCENTER_URL."
                    remove repo
                }
                if (url.startsWith('https://dl.google.com/dl/android/maven2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_GOOGLE_URL."
                    remove repo
                }
                if (url.startsWith('https://plugins.gradle.org/m2/')) {
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_GRADLE_PLUGIN_URL."
                    remove repo
                }
            }
        }
        maven { url ALIYUN_REPOSITORY_URL }
        maven { url ALIYUN_JCENTER_URL }
        maven { url ALIYUN_GOOGLE_URL }
        maven { url ALIYUN_GRADLE_PLUGIN_URL }
    }
}

1
2
3
4
5
6
7
8
9

   task helloworld{
      doLast {
         printf 'Hello World!'
      }
   }
   // 或者是 使用 << 代表doLast：
   task helloworld<<{
      println 'Hello world!'
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    sourceSets{
        main{
            proto{
                srcDir 'proto/proto'
            }
            java{
                srcDir 'out/build/generated/main'
            }
        }
    }

1
2
3
4

    configurations {
        compile.exclude module: 'commons'
        all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
    }

 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
27
28
29
30
31
32

    dependencies{
        // 依赖排除
        compile(''){
            exclude group: '' // 按group排除
            exclude module: '' // 按 artifact 排除
            exclude grop: '', module: '' // 按 group artifact 排除
        }
        // 全局依赖排除
        all*.exclude group:'org.unwanted', module: 'iAmBuggy'

        // 禁用依赖传递
        compile('com.zhyea:ar4j:1.0') {
            transitive = false
        }
        
        configurations.all {
            transitive = false
        }

        // 强制使用指定版本的依赖
        compile('com.zhyea:ar4j:1.0') {
            force = true
        }
        // 始终使用最新的依赖,  若 1.+ 则是 1.xx版本的最新版
        compile 'com.zhyea:ar4j:+'
        
        configurations.all {
            resolutionStrategy {
                force 'org.hamcrest:hamcrest-core:1.3'
            }
        }
    }

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

  repositories {
    mavenLocal()
    def aliyun = "http://maven.aliyun.com/nexus/content/groups/public/"
    def abroad = "http://central.maven.org/maven2/"
    maven {
      url = aliyun
      artifactUrls abroad
    }
    // 码云上自己的仓库
    maven {
      url = "https://gitee.com/gin9/MavenRepos/raw/master"
    }
    mavenCentral()
    jcenter()
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    // 1
    apply plugin: 'java'
    // 2
    apply{
        'java'
    }
    // 3 Gradle5 推荐
    plugins{
        id 'java'
    }

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

    // 一个典型的根项目的构建文件结构
    buildscript {
        //  构建脚本段落可以配置整个项目需要的插件，构建过程中的依赖以及依赖类库的版本号等
    }
    allprojects {
        //  在这个段落中你可以声明对于所有项目（含根项目）都适用的配置，比如依赖性的仓储等
    }
    subprojects {
        //  * 在这个段落中你可以声明适用于各子项目的配置（不包括根项目哦）
        version = "0.0.1"
    }
    //  * 对于子项目的特殊配置
    project(':common') {}
    project(':api') {}
    project(':report') {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    project(':common') {
        dependencies {
            compile("org.springframework.boot:spring-boot-starter-data-rest")
            compile("org.springframework.boot:spring-boot-starter-data-mongodb")
            compile("org.projectlombok:lombok:${lombokVersion}")
        }
    }

    project(':api') {
        dependencies {
            compile project(':common')
            compile("org.springframework.boot:spring-boot-devtools")
        }
    }

    project(':report') {
        dependencies {
            compile project(':common')
            compile("org.springframework.boot:spring-boot-devtools")
            compile files(["lib/simsun.jar"])
            compile("org.springframework.boot:spring-boot-starter-web")
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

    apply plugin: "maven-publish"

    // publish with source code
    task sourceJar(type: Jar) {
        from sourceSets.main.allJava
    }
    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
                artifact sourceJar {
                    classifier "sources"
                }
            }
        }
    }

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

    task uberJar(type: Jar) {
        archiveClassifier = 'all-dependency'

        from sourceSets.main.output

        dependsOn configurations.runtimeClasspath
        from {
            configurations.runtimeClasspath.findAll { it.name.endsWith('jar') }.collect { zipTree(it) }
        }

        manifest {
            attributes 'Main-Class': 'com.xxx.Main'
        }
    }

 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

    apply plugin: 'docker'
    buildscript {
        ext {
            springBootVersion = '2.0.1.RELEASE'
        }
        repositories {
            mavenCentral()
        }
        dependencies {
            classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
            classpath('se.transmode.gradle:gradle-docker:1.2')
        }
    }
    task buildDocker(type: Docker, dependsOn: build) {
        //设置自动上传的话，命名就不能乱取了，仓库名/镜像名：tag
    //    push = true
        test.enabled=false
        applicationName = jar.baseName
        dockerfile = file('src/main/docker/Dockerfile')
        doFirst {
            copy {
                from war
                into stageDir
            }
        }
    }

1
2
3
4
5
6

    FROM frolvlad/alpine-oraclejdk8:slim
    VOLUME /tmp
    # 配置通配符是为了不受版本影响
    ADD weixin*.war app.war
    # ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.war"]
    ENTRYPOINT ["java","-jar","/app.war"]