原文网址:gradle--build.gradle_IT利刃出鞘的博客-CSDN博客
简介
本文介绍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一模一样,直接看这篇即可:maven系列--镜像/仓库_feiying0canglang的博客-CSDN博客
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 { dependencies { } | buildScript块的repositories主要是为了Gradle脚本自身的执行,可以声明的资源包括依赖项、第三方插件、maven仓库地址等。我在写的一篇博客《尝试Artifactory》中Gradle脚本需要com.jfrog.artifactory插件才能执行成功,而这个插件是从URL为https://plugins.gradle.org/m2/的Maven仓库获得。 |
build.gradle allprojects { 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:将该依赖隐藏在内部,而不对外部公开。它仅仅对当前的module
提供接口。
例如我们当前项目结构如下
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是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{}有同样作用,见:gradle系列--其他文件_feiying0canglang的博客-CSDN博客
单项目示例
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{}
其他网址
说明
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(根项目)放到子项目同级路径之下,子项目就可以包含根项目了。