当前位置： 首页>移动开发>正文

gradle--build.gradle

移动开发2024-12-25 07:59:20

​

简介

本文介绍gradle的build.gradle的用法。

gradle简介

        一个项目中只放置一个build.gradle，一个项目代表一个组件（jar/war包），构建启动后Gradle会根据build.gradle实例化一个org.gradle.api.Project类，提供了对一个项目的基本配置。

​示例（一个完整的构建脚本）​

apply plugin: 'java'
apply plugin: 'eclipse'
sourceCompatibility = 1.5
version = '1.0'

jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

test {
    systemProperties 'property': 'value'
}

uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

​属性​

属性名称

所属

说明

group

project

version

project

项目版本（全局的）

name(artifact)

project

一般写在settings.gradle

sourceCompatibility = 1.8

java插件

targetCompatibility = 1.8

java插件

compileJava.options.encoding = 'UTF-8' 

compileTestJava.options.encoding = 'UTF-8' 

​方法​

方法

说明

apply

应用

repositories

添加仓库

dependencies

添加依赖

buildscript

allprojects

subprojects

configurations

repositories{}

​简介​

repositories是project一个方法，闭包作为参数。若前边的仓库中找不到，再依次在下边的仓库中查找。

repositories {
    // 本地仓库，地址是maven本地仓库路径。不用写，默认先找本地仓库的。
    // mavenLocal()
    //maven私服，此处设置为ali的，地址是url
    maven{ url "https://maven.aliyun.com/repository/public/" }
    //远程仓库,地址是https://repo1.maven.org/maven2
    mavenCentral()
}

        上边的mavenLocal对应maven的本地仓库，maven私服对应internal repository，mavenCentral()对应中央仓库，与maven一模一样，直接看这篇即可：

​gradle的版本与http​

gradle7.0及之后，url最好是安全协议，比如https，上边的http会报警告，解决方法

maven{ url "http://maven.aliyun.com/nexus/content/groups/public" allowInsecureProtocol = true}

​修改仓库地址​

        Gradle、maven默认从中央仓库mavenCentral() 也就是 ​​http://repo1.maven.org/maven2/​​下载依赖包，但是在国内下载速度巨慢，我们只能使用国内的镜像。

​法1：全局配置​

        配置一个全局配置文件可以只配置一次。如果个别项目需要另外添加仓库地址，只需要在影响的项目下单独配置build.gradle文件增加repositories{}即可。

        下边将利用 阿里云开源镜像站 替换掉网络访问困难的 maven、jcenter。

.grable/init.grable

allprojects {
    repositories {
        def ALIYUN_REPO_NEW = 'https://maven.aliyun.com/repository/public'
        def ALIYUN_REPO_OLD = 'http://maven.aliyun.com/nexus/content/groups/public/'

        all { ArtifactRepository repo ->
            if (repo instanceof MavenArtifactRepository) {
                def url = repo.url.toString()
 
                if (url.startsWith('https://repo.maven.apache.org/maven2/') 
                        || url.startsWith('https://repo.maven.org/maven2') 
                        || url.startsWith('https://repo1.maven.org/maven2') 
                        || url.startsWith('https://jcenter.bintray.com/')){
                    //必须用双引号，不能用单引号
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPO_NEW."
                    remove repo
                }
            }
        }
        
        maven {
            url ALIYUN_REPO_NEW
            url ALIYUN_REPO_OLD
        }
    }
 
    buildscript {
 
        repositories {
            def ALIYUN_REPO_NEW = 'https://maven.aliyun.com/repository/public'
            def ALIYUN_REPO_OLD = 'http://maven.aliyun.com/nexus/content/groups/public/'
            
            all { ArtifactRepository repo ->
                if (repo instanceof MavenArtifactRepository) {
                    def url = repo.url.toString()
     
                    if (url.startsWith('https://repo.maven.apache.org/maven2/') 
                            || url.startsWith('https://repo.maven.org/maven2') 
                            || url.startsWith('https://repo1.maven.org/maven2') 
                            || url.startsWith('https://jcenter.bintray.com/')) {
                        //必须用双引号，不能用单引号
                        project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPO_NEW."
                        remove repo
                    }
                }
            }
            
            maven {
                url ALIYUN_REPO_NEW
                url ALIYUN_REPO_OLD
            }
        }
    }
}

​法2：每个项目单独配置​

每个Gradle构建的项目中，在build.gradle做如下配置

repositories {
    //本地仓库，地址是maven本地仓库路径
    mavenLocal()
    //maven私服。此处设置为ali的旧库，地址是url
    maven{ url "http://maven.aliyun.com/nexus/content/groups/public" }
    //阿里云新库
    maven { url "https://maven.aliyun.com/repository/central" }
    maven { url "https://maven.aliyun.com/repository/google" }
    maven { url "https://maven.aliyun.com/repository/gradle-plugin" }
    maven { url "https://maven.aliyun.com/repository/jcenter" }
    maven { url "https://maven.aliyun.com/repository/spring" }
    maven { url "https://maven.aliyun.com/repository/spring-plugin" }
    maven { url "https://maven.aliyun.com/repository/public" }
    maven { url "https://maven.aliyun.com/repository/releases" }
    maven { url "https://maven.aliyun.com/repository/snapshots" }
    maven { url "https://maven.aliyun.com/repository/grails-core" }
    maven { url "https://maven.aliyun.com/repository/mapr-public" }
    maven { url "https://maven.aliyun.com/repository/apache-snapshots" }
    //maven的里程碑版本。有些依赖只能在这里边找到
    maven { url "https://repo.spring.io/milestone" }
    maven { url 'https://repo.spring.io/libs-milestone' }
    //远程仓库,地址是https://repo1.maven.org/maven2
    mavenCentral()
}

​不同位置repositories的作用​

不同位置的代码示例

说明

build.gradle

repositories {

...

}

dependencies {

...

}

根级别的repositories主要是为了当前项目提供所需依赖包，比如log4j、spring-core等依赖包可从mavenCentral仓库获得。

build.gradle

buildscript {
    repositories {
    ...
    }

    dependencies {
    ...
    }

}

buildScript块的repositories主要是为了Gradle脚本自身的执行，可以声明的资源包括依赖项、第三方插件、maven仓库地址等。我在写的一篇博客《尝试Artifactory》中Gradle脚本需要com.jfrog.artifactory插件才能执行成功，而这个插件是从URL为https://plugins.gradle.org/m2/的Maven仓库获得。

build.gradle

allprojects {
    repositories {
    ...
    }

    dependencies {
    ...
    }

}

allprojects块的repositories用于多项目构建，为所有项目提供共同所需依赖包。而子项目可以配置自己的repositories以获取自己独需的依赖包。

dependencies{}

​简介​

dependencies是project一个方法，闭包作为参数。

​依赖范围​

其他网址：

​​gradle依赖：implementation 和compile的区别 - 简书Managing Dependencies of JVM Projects​​（官网文档）

项

说明

compile/testCompile    //deprecated

implementation/testImplementation

compile在3.x及之后依然能用。

compileOnly/testCompileOnly

只在编译时有效，不会参与打包 

compileClasspath

testCompileClasspath

继承自：compile, compileOnly, implementation

继承自：testCompile, testCompileOnly, testImplementation

annotationProcessor

使能注解处理器。比如：lombok就要到。

runtime/testRuntime   //deprecated

runtimeOnly/testRuntimeOnly

编译时不会参与，很少用

runtimeClasspath

testRuntimeClasspath

继承自：runtimeOnly, runtime, implementation

继承自：testRuntimeOnly, testRuntime, testImplementation

archives

uploadArchives任务会用到

default

继承自：runtimeClasspath

​implementation与compile区别​

compile：            普通的依赖, 第三方库在 module 中依赖后其他 module 都可以使用该库

implementation：将该依赖隐藏在内部，而不对外部公开。它仅仅对当前的m​​odule​​提供接口。

例如我们当前项目结构如下

gradle--build.gradle,gradle--build.gradle_spring,第1张

LibraryA 中引用了 LibraryC 的库，如果对 LibraryC 的依赖用的是 implementation 关键字。 如下：

dependencies {
    . . . . 
    implementation project（path：'：libraryC'）
}

        那么LibraryC 中的接口，仅仅只能给 LibraryA 使用，而我们的 App Module 是无法访问到 LibraryC 提供的接口的，也就是将该依赖隐藏在内部，而不对外部公开。这就是implementation关键字的作用。

​建议​

在Google IO 相关话题的中提到了一个建议，就是依赖首先应该设置为implementation的，如果没有错，那就用implemention，如果有错，那么使用compile指令，这样会使编译速度有所增快。

那为什么要这么做呢？

答案是： 1. 加快编译速度。2. 隐藏对外不必要的接口。

为什么能加快编译速度呢？

这对于大型项目含有多个​​Module​​​模块的， 以上图为例，比如我们改动 ​​LibraryC​​​ 接口的相关代码，这时候编译只需要单独编译​​LibraryA​​​模块就行， 如果使用的是​​api​​​或者旧时代的​​compile​​​，由于​​App Module​​​ 也可以访问到 ​​LibraryC​​​,所以 ​​App Module​​部分也需要重新编译。当然这是在全编的情况下。

​写法​

​单个依赖​

dependencies {
    //写法1
    compile group: 'ch.qos.logback', name: 'logback-classi', version: '1.2.3'
    //写法2
    compile "ch.qos.logback:logback-classic:1.2.3"
}

​多个依赖​

dependencies {
    //写法1
    compile "javax.servlet:javax.servlet-api:3.1-b07"
    compile "org.slf4j:slf4j-log4j12:1.7.5"
    //写法2
    compile (  
        "javax.servlet:javax.servlet-api:3.1-b07",  
        "org.slf4j:slf4j-log4j12:1.7.5"
    )  
}

​工程依赖​

同一个构建中可以建立工程依赖，一个工程的 jar 包可以提供给另外一个工程使用。例如我们可以让 api 工程以依赖于 my_base 工程的 jar 包。这样 Gradle 在构建 api 之前总是会先构建 my_base工程。

api工程的build.gradle文件：

dependencies {
    compile project(':my_base')
}

​文件夹下的jar依赖​

可以依赖指定文件夹下的jar文件，如，依赖lib目录下所有的jar文件

dependencies {
    implementation fileTree(dir:'lib',includes:['*.jar'])
}

buildscript{}

​简介​

        gradle在执行脚本时，会优先执行buildscript代码块中的内容，然后才会执行剩余的build脚本。

        如果你想在脚本中使用一些第三方的插件、类库等，就需要自己手动添加对这些插件、类库的 引用。而这些插件、类库又不是直接服务于项目的，而是支持其它build脚本的运行。所以你应当将这部分的引用放置在buildscript代码块中。

​项目实例​

buildscript {
    ext {
        springBootVersion = '2.1.1.RELEASE'
        lombokVersion = '1.18.10'
    }
    repositories {
      ...
    }
    
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
 
group = 'abcd'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

ext['springCloudVersion'] = 'Greenwich.RC2'

dependencies {
  //Spring Boot
  compile('org.springframework.boot:spring-boot-starter')
  //Spring MVC
  compile('org.springframework.boot:spring-boot-starter-web')
  compile('org.springframework.boot:spring-boot-starter-aop')
  compile("org.projectlombok:lombok:${lombokVersion}")
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

ext{}

​其他网址​

​​ext官网文档​​

​简介​

        ext是Gradle领域对象的一个属性，我们可以将自定义的属性添加到ext对象上，Build.gradle中的其它代码片段可以使用。Gradle的属性可以用此命令打印出来：gradle properties。

        ext属性是​​ExtensionAware​​类型的一个特殊的属性，ExtentionAware接口的实现类为Project, Settings, Task, SourceSet等，ExtentionAware可以在运行时扩充属性，而这里的ext，就是里面的一个特殊的属性而已。

        一般单项目中，ext所在类型为project，即，通过project.${key}可以访问到；root项目中，ext所在类型为rootProject，即，通过rootProject.${key}可以访问到。

        gradle.properties跟build.gradle的ext{}有同样作用

​单项目示例​

build.gradle

buildscript {
  ext {
    springBootVersion = '2.1.1.RELEASE'
    lombokVersion = '1.18.10'
  }
  repositories {
    ...
  }

  dependencies {
    classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
  }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'abcd'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

ext['springCloudVersion'] = 'Greenwich.RC2'

dependencies {
  //Spring Boot
  compile('org.springframework.boot:spring-boot-starter')
  //Spring MVC
  compile('org.springframework.boot:spring-boot-starter-web')
  compile('org.springframework.boot:spring-boot-starter-aop')
  compile("org.projectlombok:lombok:${lombokVersion}")
}

dependencyManagement {
  imports {
    mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
  }
}

​多项目示例​

build.gradle（root项目）

buildscript {
  ...
}
allprojects {
  ...
}
...
ext {
  lombokVersion = '1.18.10'
}

build.gradle（module级项目）

dependencies {
  compile("org.projectlombok:lombok:${rootProject.lombokVersion}")
  //这样也可以
  //compile("org.projectlombok:lombok:${rootProject.ext.lombokVersion}")
}

sourceSets{}

​其他网址​

​​The Java Plugin​​

​说明​

Java插件默认的目录项目如下：

src/main/java              //Production Java source.
src/main/resources         //Production resources, such as XML and properties files.
src/test/java              //Test Java source.
src/test/resources         //Test resources.
src/sourceSet/java         //Java source for the source set named sourceSet.
src/sourceSet/resources    //Resources for the source set named sourceSet

这个目录是可以修改的，例如：

sourceSets {
    main {
        java {
            srcDirs = ['src/main/java', '../my_base/src/main/java']
        }
        /*resources {
            srcDirs = ['../my_base/main/resources']
        } */
    }
}

 这样修改之后，把base（根项目）放到子项目同级路径之下，子项目就可以包含根项目了。

其他

allprojects{}

subprojects{}

configurations{}

artifacts{}

publishing{}

​


https://www.xamrdz.com/mobile/4m62016772.html

相关文章：