gradle_gradle 6.1.1 - CSDN
gradle 订阅
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,目前也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy、Kotlin和Scala,计划未来将支持更多的语言。 展开全文
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,目前也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy、Kotlin和Scala,计划未来将支持更多的语言。
信息
外文名
gradle
整体设计
以作为一种语言为导向
音    标
[g'reɪdl]
中文名
gradle
基    础
Groovy 语言
服务对象
Java应用
gradle简介
Gradle是一个基于JVM的构建工具,是一款通用灵活的构建工具,支持maven, Ivy仓库,支持传递性依赖管理,而不需要远程仓库或者是pom.xml和ivy.xml配置文件,基于Groovy,build脚本使用Groovy编写。 [1] 
收起全文
  • Gradle5.4 + Spring Boot2.0快速开发

    千人学习 2019-11-28 10:47:26
    基于gradle5.4 构建,结合各种软件神器,带你轻松快速入门spring boot2.0开发;从单一工程到gradle多模块开发,告诉你模块怎么拆怎么重用;从功能开发到单元测试,教你编写可维护可扩展可测试的高质量代码。对linux...
  • Gradle笔记——Gradle的简介与安装

    万次阅读 多人点赞 2015-05-12 17:52:06
    这一篇博客,主要是面向对Gradle有所耳闻,但却没有一个比较清晰的概念的。在这篇博客里,将对Gradle进行一个简单的介绍,以及它的安装。 Gradle介绍 Gradle是一个基于JVM的构建工具,它提供了: 像Ant一样,...

    本博客对Gradle进行一个简单的介绍,以及它的安装。


    Gradle介绍

    Gradle是一个基于JVM的构建工具,它提供了:
    • 像Ant一样,通用灵活的构建工具
    • 可以切换的,基于约定的构建框架
    • 强大的多工程构建支持
    • 基于Apache Ivy的强大的依赖管理
    • 支持maven, Ivy仓库
    • 支持传递性依赖管理,而不需要远程仓库或者是pom.xml和ivy.xml配置文件。
    • 对Ant的任务做了很好的集成
    • 基于Groovy,build脚本使用Groovy编写
    • 有广泛的领域模型支持构建

    Gradle 概述

    1,基于声明和基于约定的构建。
    2,依赖型的编程语言。
    3,可以结构化构建,易于维护和理解。
    4,有高级的API允许你在构建执行的整个过程当中,对它的核心进行监视,或者是配置它的行为。
    5,有良好的扩展性。有增量构建功能来克服性能瓶颈问题。
    6,多项目构建的支持。
    7,多种方式的依赖管理。
    8,是第一个构建集成工具。集成了Ant, maven的功能。
    9,易于移值。
    10,脚本采用Groovy编写,易于维护。
    11,通过Gradle Wrapper允许你在没有安装Gradle的机器上进行Gradle构建。
    12,自由,开源。

    Gradle 安装

    1,安装JDK,并配置JAVA_HOME环境变量。因为Gradle是用Groovy编写的,而Groovy基于JAVA。另外,Java版本要不小于1.5.
    2,下载。地址是:http://www.gradle.org/downloads。在这里下载你要的版本。
    3,解压。如果你下载的是gradle-xx-all.zip的完整包,它会有以下内容:
    • 二进制文件
    • 用户手册(包括PDF和HTML两种版本)
    • DSL参考指南
    • API手册(包括Javadoc和Groovydoc)
    • 样例
    • 源代码,仅供参考使用。
    4,配置环境变量。配置GRADLE_HOME到你的gradle根目录当中,然后把%GRADLE_HOME%/bin(linux或mac的是$GRADLE_HOME/bin)加到PATH的环境变量。
    linux用户可以在~/.bashrc文件中配置。

    配置完成之后,运行gradle -v,检查一下是否安装无误。如果安装正确,它会打印出Gradle的版本信息,包括它的构建信息,Groovy, Ant, Ivy, 当前JVM和当前系统的版本信息。

    另外,可以通过GRADLE_OPTS或JAVA_OPTS来配置Gradle运行时的JVM参数。不过,JAVA_OPTS设置的参数也会影响到其他的JAVA应用程序。


    展开全文
  • Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,目前也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。...
  • Gradle 简易入门教程

    万次阅读 2018-08-23 10:51:23
    作者: Yann 来源:原力注入Gradle 是一种构建工具,它抛弃了基于XML的构建脚本,取而代之的是采用一种基于 Groovy(现在也支持 Kotlin)的内部领域...
        

    作者: Yann  

    来源:原力注入


    Gradle 是一种构建工具,它抛弃了基于XML的构建脚本,取而代之的是采用一种基于 Groovy(现在也支持 Kotlin)的内部领域特定语言。


    Gradle特点


    1. Gradle是很成熟的技术,可以处理大规模构建

    2. Gradle对多语言、多平台支持性更好

    3. Gradle关注在构建效率上

    4. Gradle发布很频繁,重要feature开发计划透明化

    5. Gradle社区很活跃,并且增加迅速


    安装Gradle


    • 从 官网 (https://gradle.org/install/)下载二进制文件。

    • 解压Zip文件,加入环境变量(在PATH中加入GRADLE_HOME/bin目录)


    如果在安装过程中遇到问题,可以进一步查看官方的安装指南(https://gradle.org/install/)。最后验证一下 Gradle 是否工作正常


    1. gradle -v

    2. ------------------------------------------------------------

    3. Gradle 4.2.1

    4. ------------------------------------------------------------

    5. Build time:   2017-10-02 15:36:21 UTC

    6. Revision:     a88ebd6be7840c2e59ae4782eb0f27fbe3405ddf

    7. Groovy:       2.4.12

    8. Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015

    9. JVM:          1.8.0_162-ea (Oracle Corporation 25.162-b01)

    10. OS:           Mac OS X 10.13.5 x86_64


    Gradle快速体验


    初始化一个项目


    • 创建一个 demo 目录

    1. ❯ mkdir gradle-demo


    • 初始化 Gradle 项目

    1. ❯ gradle init

    2. Starting a Gradle Daemon (subsequent builds will be faster)

    3. BUILD SUCCESSFUL in 3s

    4. 2 actionable tasks: 2 executed



    Gradle目录结构


    我们看看上一步我们生成了什么文件


    ├── build.gradle  ❶
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar    ➋
    │       └── gradle-wrapper.properties  ➌
    ├── gradlew    ➍
    ├── gradlew.bat  ➎
    └── settings.gradle  ➏


    ❶ 当前项目的配置脚本

    ➋ Gradle Wrapper 的执行jar包(后续介绍)

    ➌ Gradle Wrapper 的配置文件

    ➍ Gradle Wrapper Unix 系执行脚本

    ➎ Gradle Wrapper Windows 系执行脚本

    ➏ 项目脚本设置


    创建一个Task


    Gradle提供了用于通过基于Groovy或Kotlin的DSL创建和配置。项目包括一组Task,每个Task执行一些基本操作。


    • 创建一个目录叫 src

    • 在src目录创建一个 myfile.txt

    • 在构建文件中定义一个名为Copy的类型 Task ,该任务将src目录复制到名为dest的新目录


    groovy代码:

    1. task copy(type: Copy, group: "Custom", description: "Copies sources to the dest directory") {

    2.    from "src"

    3.    into "dest"

    4. }



    kotlin代码:

    1. tasks.create<Copy>("copy") {

    2.    description = "Copies sources to the dest directory"

    3.    group = "Custom"

    4.    from("src")

    5.    into("dest")

    6. }


    group 和 description 是自定义的任意值。现在让我们执行这个 task

    1. ❯ ./gradlew copy

    2. > Task :copy

    3. BUILD SUCCESSFUL in 0s

    4. 1 actionable task: 1 executed



    再一次 ls 我们就可以看见 gradle 为我们创建了一个新的 dest 目录并且将 文件复制进去。


    Gradle Task


    在Gradle中,有两个基本概念:项目和任务。

    • 项目是指我们的构建产物(比如Jar包)或实施产物(将应用程序部署到生产环境)一个项目包含一个或多个任务。

    • 任务是指不可分的最小工作单元,执行构建工作(比如编译项目或执行测试)。

    640?wx_fmt=png

    在项目目录中的 build.gradle 指定了一个项目和它的任务。


    Task执行顺序


    任务可能依赖于其他任务,或者可能被安排为始终在另一个任务之后运行。

    1. project('projectA') {

    2.    task taskX(dependsOn: ':projectB:taskY') {

    3.        doLast {

    4.            println 'taskX'

    5.        }

    6.    }

    7. }

    8. project('projectB') {

    9.    task taskY {

    10.        doLast {

    11.            println 'taskY'

    12.        }

    13.    }

    14. }



    1. > gradle -q taskX

    2. taskY

    3. taskX  // taskx 在 y 之后



    我们可以用 dependsOn 让我们的 Task 有顺序的运行起来。


    Gradle插件


    看到这里,如果每一件事情我们都需要写 Task 岂不是会累死,而且很多功能是可以被复用的,所以Gradle 提供一个 插件 功能,Gradle 默认就内置了大量的插件,比如在 base 中有一系列的功能。


    groovy代码

    1. plugins {

    2.    id "base"

    3. }



    kotlin代码:

    1. plugins {

    2.    id("base")

    3. }



    这个时候我们就可以利用一些额外的 Task,举个例子,我们要把一个目录中的东西都打成一个 ZIP 压缩包。


    groovy代码:

    1. task zip(type: Zip, group: "Archive", description: "Archives sources in a zip file") {

    2.    from "src"

    3.    setArchiveName "basic-demo-1.0.zip"

    4. }



    kotlin代码:

    1. tasks.create<Zip>("zip") {

    2.    description = "Archives sources in a zip file"

    3.    group = "Archive"

    4.    from("src")

    5.    setArchiveName("basic-demo-1.0.zip")

    6. }


    Gradle 的设计理念是

    • 在项目中添加新任务

    • 为新加入的任务提供默认配置,这个默认配置会在项目中注入新的约定(如源文件位置)。

    • 加入新的属性,可以覆盖插件的默认配置属性。

    • 为项目加入新的依赖。


    Gradle Java


    Gradle 内置了 Java 插件,Java插件将Java编译以及测试和捆绑功能添加到项目中。它是许多其他Gradle插件的基础。如果我们需要使用 Java 插件 修改 build.gradle


    1. plugins {

    2.    id 'java'

    3. }



    一旦导入了 Java 插件,就会有一系列的默认的配置值,并且会导入大量的 Task。

    Task含义
    compileJava(type: JavaCompile)Java 编译
    processResources(type: Copy)拷贝 Resources 资源
    classes(type: Task)组装 Java 类
    compileTestJava(type: JavaCompile)Java Test 编译
    processTestResources(type: Copy)拷贝 Test Resources 资源
    testClasses(type: Task)组装 Test 类
    jar(type: Jar)合成Jar包
    javadoc(type: Javadoc)生成 doc 文档
    test(type: Test)运行测试
    uploadArchives(type: Upload)上传 jar 到仓库
    clean(type: Delete)clean

    我们从这些 Task 名字就可以看出来他们分别作作了, 和其他的设计理念类型,在 Task 也会嵌入一些生命周期,其实原理也就是我们之前看的执行顺序。

    640?wx_fmt=png

    资源:Gradle插件仓库


    Gradle依赖管理


    先盗取一张官方的图。

    640?wx_fmt=png


    和 Maven 类似,Gradle 也会将依赖缓冲在本地中,方便在无网的环境使用,和依赖管理相关的有两个参数,举个例子。


    1. repositories {

    2.    mavenCentral() // 定义仓库

    3. }

    4. dependencies {

    5.    compile 'org.springframework:spring-web:5.0.2.RELEASE' // 定义依赖

    6. }


    Gradle支持以下仓库格式:

    • Ivy仓库

    • Maven仓库

    • Flat directory仓库


    lvy仓库


    我们可以通过URL地址或本地文件系统地址,将Ivy仓库加入到我们的构建中。

    1. repositories {

    2.    ivy {

    3.        url "http://ivy.petrikainulainen.net/repo"

    4.    }

    5. }

    6. //或者是本地

    7. repositories {

    8.    ivy {      

    9.        url "../ivy-repo"

    10.    }

    11. }



    Maven仓库


    1. repositories {

    2.    maven {

    3.        url "http://maven.petrikainulainen.net/repo"

    4.    }

    5. }



    在加入Maven仓库时,Gradle提供了三种“别名”供我们使用,它们分别是

    • mavenCentral()别名,表示依赖是从Central Maven 2 仓库中获取的。

    • jcenter()别名,表示依赖是从Bintary’s JCenter Maven 仓库中获取的。

    • mavenLocal()别名,表示依赖是从本地的Maven仓库中获取的。


    Flat Directory仓库


    1. repositories {

    2.    flatDir {

    3.        dirs 'lib'

    4.    }

    5. }

    6. //多个仓库

    7. repositories {

    8.    flatDir {

    9.        dirs 'libA', 'libB'

    10.    }

    11. }



    依赖管理



    在配置完项目仓库后,我们可以声明其中的依赖,首先 Java 插件指定了若干依赖配置项

    • compile 配置项中的依赖是依赖必须的。

    • runtime 配置项中包含的依赖在运行时是必须的。

    • testCompile 配置项中包含的依赖在编译项目的测试代码时是必须的。

    • testRuntime 配置项中包含的依赖在运行测试代码时是必须的。


    在 Gradle 最新版本中更是增加

    • implementation 配置项中的实现类

    • api 配置项中的暴露API


    1. dependencies {

    2.    api 'commons-httpclient:commons-httpclient:3.1'

    3.    implementation 'org.apache.commons:commons-lang3:3.5'

    4. }



    声明项目依赖


    最普遍的依赖称为外部依赖,这些依赖存放在外部仓库中。一个外部依赖可以由以下属性指定:

    • group属性指定依赖的分组(在Maven中,就是groupId)

    • name属性指定依赖的名称(在Maven中,就是artifactId)

    • version属性指定外部依赖的版本(在Maven中,就是version)


    1. dependencies {

    2.    compile group: 'foo', name: 'foo', version: '0.1'

    3. }

    4. // 我们也可以合并到一起去

    5. dependencies {

    6.    compile 'foo:foo:0.1'

    7. }



    声明项目文件依赖


    我们如何依赖本地的一些 jar 呢,正确的操作是如下

    1. dependencies {

    2.    compile files('libs/commons-lang.jar', 'libs/log4j.jar')

    3. }



    声明依赖排除项目


    我们都知道在 Maven中我们有

    1.    <dependency>

    2.        <groupId>sample.ProjectB</groupId>

    3.        <artifactId>Project-B</artifactId>

    4.        <version>1.0-SNAPSHOT</version>

    5.        <exclusions>

    6.            <exclusion>

    7.                <groupId>log4j</groupId>

    8.                <artifactId>log4j</artifactId>

    9.            </exclusion>

    10.        </exclusions>

    11.    </dependency>


    而在 Gradle 中,我们可以这么做。

    1. compile('com.example.m:m:1.0') {

    2.    exclude group: 'org.unwanted', module: 'x

    3. }



    Gradle与Kotlin


    我们想要在 gradle 中增加 kotlin 非常的简单,仅仅需要在 build.gradle 增加

    1. plugins {

    2.     id "org.jetbrains.kotlin.jvm" version "x.x.xx" // 增加插件

    3. }

    4. dependencies {

    5.  compile "org.jetbrains.kotlin:kotlin-stdlib:x.xx.xx" // 增加依赖

    6. }



    大功告成,对了,默认的 Kotlin 的源码路径是 src/main/kotlin, 测试源码是 src/text/kotlin 如果需要修改可以使用

    1. sourceSets {

    2.    main.kotlin.srcDirs += 'src/main/myKotlin'

    3.    main.java.srcDirs += 'src/main/myJava'

    4. }




    其他


    Gradle Wrapper



    Gradle Wrapper 做了三件事情

    • 解析参数传入 gradlew

    • 安装正确的 Gradle 版本

    • 调用 Gradle 执行命令


    Ops,Gradle Wrapper 为什么还需要安装 Gradle,我们在用 Maven 都知道,我们需要自己先安装好一个 Maven版本,因为 Maven 发展多年,现在已经稳定,已经不存在很多个版本并存的现状了,但是我们依然需要去在每个机器上去安装,那我什么我们不能在自己的 构建脚本 中就指定我们的构建工具呢?所以我们在 wrapper/gradle-wrapper.properties 中就可以发现 distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-bin.zip 这里也就是定义了我们的gradle所使用的版本。


    640?wx_fmt=png

    Gradle In Real World

    1. // 定义一堆基础插件

    2. apply plugin: 'java'

    3. apply plugin: 'maven'

    4. apply plugin: "jacoco"

    5. apply plugin: 'checkstyle'

    6. apply plugin: 'pmd'

    7. apply plugin: 'findbugs'

    8. apply plugin: 'eclipse'

    9. apply plugin: 'idea'

    10. // 定义项目属性

    11. group = 'Common'

    12. version = '1.0.0'

    13. description = """Giant common library"""

    14. // 定义依赖仓库

    15. repositories {

    16.    mavenCentral()

    17. }

    18. // 额外增加source path

    19. sourceSets {

    20.    main {

    21.        resources {

    22.            srcDir "src/main/profiles/${profile}"

    23.        }

    24.    }

    25. }

    26. // project依赖

    27. dependencies {

    28.    compile 'ch.qos.logback:logback-core:1.0.13'

    29.    compile 'ch.qos.logback:logback-classic:1.0.13'

    30.    compile 'ch.qos.logback:logback-access:1.0.13'

    31.    compile 'commons-io:commons-io:2.0.1'

    32.    compile 'commons-lang:commons-lang:2.6'

    33.    compile 'joda-time:joda-time:1.6.2'

    34.    compile 'org.testng:testng:6.8.7'

    35.    compile 'com.googlecode.jmockit:jmockit:1.5'

    36.    ...

    37. }

    38. // task配置

    39. checkstyle {

    40.    ignoreFailures = true

    41.    sourceSets = [sourceSets.main]

    42. }

    43. findbugs {

    44.    ignoreFailures = true

    45.    sourceSets = [sourceSets.main]

    46. }

    47. pmd {

    48.    ruleSets = ["basic", "braces", "design"]

    49.    ignoreFailures = true

    50.    sourceSets = [sourceSets.main]

    51. }

    52. jacocoTestReport {

    53.    reports {

    54.        xml.enabled true

    55.        html.enabled true

    56.        csv.enabled false

    57.    }

    58.    sourceSets sourceSets.main

    59. }

    60. tasks.withType(Compile) {

    61.    options.encoding = "UTF-8"

    62. }

    63. test {

    64.    useTestNG()

    65.    jacoco {

    66.        excludes = ["org.*"]

    67.    }

    68. }



    Gradle常用指令


    枚列所有可用任务


    1. ❯ gradle tasks

    2. ------------------------------------------------------------

    3. All tasks runnable from root project

    4. ------------------------------------------------------------

    5. Archive tasks

    6. -------------

    7. zip - Archives sources in a zip file

    8. Build tasks

    9. -----------

    10. assemble - Assembles the outputs of this project.

    11. build - Assembles and tests this project.

    12. clean - Deletes the build directory.



    构建配置属性

    1. ❯ gradle properties



    显示构建详情


    在 build.gradle 设置

    1. logging.level = LogLevel.DEBUG


    或者在运行的

    1. ❯ gradle build --stacktrace


    参考资料&推荐文档


    • Gradle入门教程(http://blog.jobbole.com/71999/)

    • Gradle介绍(https://www.jianshu.com/p/00d5469e25e7)

    • 官方教材(https://guides.gradle.org/creating-new-gradle-builds/)

    -END-


     近期热文:

    关注我

    640?wx_fmt=jpeg

    点击“阅读原文”,看本号其他精彩内容

    展开全文
  • Gradle的使用教程

    万次阅读 多人点赞 2019-12-03 16:09:13
    Gradle是一个好用的构建工具 ,使用它的原因是: 配置相关依赖代码量少,不会像maven一样xml过多 打包编译测试发布都有,而且使用起来方便 利用自定义的任务可以完成自己想要的功能 二、安装 下载地址...

    一、相关介绍

            Gradle是一个好用的构建工具 ,使用它的原因是:

    • 配置相关依赖代码量少,不会像maven一样xml过多 
    • 打包编译测试发布都有,而且使用起来方便 
    • 利用自定义的任务可以完成自己想要的功能

    二、安装

            下载地址http://services.gradle.org/distributions/  ,下载你所需要对应的版本,我这里下载的是gradle-4.7-bin.zip。下载后解压到你想要的目录即可,然后设置环境变量:

     

    在cmd模式下查看,出现以下信息证明安装成功:

    然后我们可以在在环境变量里配置gradle默认的仓库地址(和maven不太一样):

    三、IED中的使用

    1、IDEA

            使用idea创建一个web的Gradle项目

     

     

    然后对项目进行打包运行:

     

    双击war

     

    打包完成之后的war文件会在:

     

    然后把war放入对应的tomcat目录即可,这里就不多解释了。

    2、Eclipse

            eclipse中要自己安装插件,插件路径为:http://download.eclipse.org/buildship/updates/e46/releases/2.x/ 。

    四、问题说明

    1、解释build.gradle和settings.gradle

            首先是一个项目包含group、name、version 。settings.gradle是用来管理多项目的,里面包含了项目的name

     

    在build.gradle中,apply是应用的插件,如:

     

    这里我们用了java和war的插件 ,dependencies是用于声明这个项目依赖于哪些jar

     

    这里说明的是,测试编译阶段我们依赖junit的jar。其中包括complile(编译时)runtime(运行时)testCompile(测试编译时)testRuntime(测试运行时)。repositories是一个仓库gradle会根据从上到下的顺序依次去仓库中寻找jar 

     

    这里我们默认的是一个maven的中心仓库 ,从gradle源代码中我们看到地址是这样的

    这里可以进行配置,其中mavenLocal()表示使用本地maven仓库;mavenCentral()使用maven中心仓库 。使用固定的地址,这里可以使用阿里云(maven {url 'http://maven.aliyun.com/nexus/content/groups/public/'})的镜像下载速度会快一些,然后也可以使用公司内部的私服地址 。

    附加,这里加上一个spring boot的gradle配置文件,可以和maven的构建对比一下

    // buildscript 代码块中脚本优先执行
    buildscript {
    
    	// ext 用于定义动态属性
    	ext {
    		springBootVersion = '1.5.2.RELEASE'
    	}
    			
    	// 自定义  Thymeleaf 和 Thymeleaf Layout Dialect 的版本
    	ext['thymeleaf.version'] = '3.0.3.RELEASE'
    	ext['thymeleaf-layout-dialect.version'] = '2.2.0'
    	
    	// 自定义  Hibernate 的版本
    	ext['hibernate.version'] = '5.2.8.Final'
     
    	// 使用了 Maven 的中央仓库(你也可以指定其他仓库)
    	repositories {
    		//mavenCentral()
    		maven {
    			url 'http://maven.aliyun.com/nexus/content/groups/public/'
    		}
    	}
    	
    	// 依赖关系
    	dependencies {
    		// classpath 声明说明了在执行其余的脚本时,ClassLoader 可以使用这些依赖项
    		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    	}
    }
    
    // 使用插件
    apply plugin: 'java'
    apply plugin: 'eclipse'
    apply plugin: 'org.springframework.boot'
    
    // 打包的类型为 jar,并指定了生成的打包的文件名称和版本
    jar {
    	baseName = 'springboot-test'
    	version = '1.0.0'
    }
    
    // 指定编译 .java 文件的 JDK 版本
    sourceCompatibility = 1.8
    
    // 默认使用了 Maven 的中央仓库。这里改用自定义的镜像库
    repositories {
    	//mavenCentral()
    	maven {
    		url 'http://maven.aliyun.com/nexus/content/groups/public/'
    	}
    }
    
    // 依赖关系
    dependencies {
     
    	// 该依赖对于编译发行是必须的
    	compile('org.springframework.boot:spring-boot-starter-web')
     
    	// 添加 Thymeleaf 的依赖
    	compile('org.springframework.boot:spring-boot-starter-thymeleaf')
    
    	// 添加  Spring Security 依赖
    	compile('org.springframework.boot:spring-boot-starter-security')
    	
    	// 添加 Spring Boot 开发工具依赖
     	//compile("org.springframework.boot:spring-boot-devtools")
     
    	// 添加 Spring Data JPA 的依赖
    	compile('org.springframework.boot:spring-boot-starter-data-jpa')
    	
    	// 添加 MySQL连接驱动 的依赖
    	compile('mysql:mysql-connector-java:6.0.5')
    	
    	// 添加   Thymeleaf Spring Security 依赖,与 Thymeleaf 版本一致都是 3.x
    	compile('org.thymeleaf.extras:thymeleaf-extras-springsecurity4:3.0.2.RELEASE')
    	
    	// 添加  Apache Commons Lang 依赖
    	compile('org.apache.commons:commons-lang3:3.5')
    	
    	// 该依赖对于编译测试是必须的,默认包含编译产品依赖和编译时依
    	testCompile('org.springframework.boot:spring-boot-starter-test')
    	
    
    }

     

    展开全文
  • build.gradle详解

    万次阅读 多人点赞 2018-01-16 17:08:00
    简述: 1 > java开发中有两个大名鼎鼎的项目构建ANT、Maven。...Gradle是用了一种基于Groovy的领域特定语言(DSL,Domain Specific Language)来声明项目设置,摒弃了XML(如ANT和Maven)的各种繁

    简述:

    1 > java开发中有两个大名鼎鼎的项目构建ANT、Maven
    2 > Google推荐使用的Android Studio是采用Gradle来构建项目的。Gradle是一个非常先进的项目构建工具。

    Gradle是用了一种基于Groovy的领域特定语言(DSL,Domain Specific Language)来声明项目设置,摒弃了XML(如ANT和Maven)的各种繁琐配置。

    3 > 项目中一般会出现2个或者多个build.gradle文件,一个在根目录下,一个在app目录下。

    如果切换到Android模式下则全部在Gradle Scripts



    系统:Windows 7 64bit

    Android版本:Android Studio 3.0.0.18


    1、根目录下的build.gradle


    1 > repositories闭包,声明了jcenter()的配置

    2 > dependencies闭包,声明了一个Gradle插件

    buildscript {
        
        repositories {  //repositories闭包
            google()
            jcenter() //代码托管库:设置之后可以在项目中轻松引用jcenter上的开源项目
        }
        dependencies {  //dependencies闭包
            classpath 'com.android.tools.build:gradle:3.0.0' 声明gradle插件,插件版本号为3.0.0
            //gradle是一个强大的项目构建工具,不仅可以构建Android,还可以构建java,C++等
            //此处引用android的插件
            // NOTE: Do not place your application dependencies here; they belong
            // in the individual module build.gradle files
        }
    }
    
    allprojects {
        repositories {
            google()
            jcenter() //代码托管库:设置之后可以在项目中轻松引用jcenter上的开源项目
        }
    }
    
    task clean(type: Delete) {
        delete rootProject.buildDir
    }


    2、app 目录下的build.gradle


    1 > apply plugin,声明是Android应用程序还是库模块

    2 > android 闭包,配置项目构建的各种属性,compileSdkVersion用于指定项目的编译SDK版本,buildToolsVersion用于指定项目构建工具的版本。

    defaultConfig闭包:默认配置,应用程序包名,最小 sdk 版本,目标 sdk 版本,版本号,版本名

    buildTypes闭包:指定生成安装文件的配置,是否对代码进行混淆

    signingConfigs 闭包:签名信息配置

    sourceSets 闭包:源文件路径配置

    lintOptions 闭包:lint 配置

    3 > dependencies 闭包,指定当前项目的所有依赖关系,本地依赖,库依赖以及远程依赖

    4 > repositories闭包,仓库配置


    // 声明是Android程序,
    //com.android.application 表示这是一个应用程序模块,可直接运行
    //com.android.library 标识这是一个库模块,是依附别的应用程序运行
    apply plugin: 'com.android.application'
    
    android {
        //程序在编译的时候会检查lint,有任何错误提示会停止build,我们可以关闭这个开关
        lintOptions {
            //即使报错也不会停止打包
            abortOnError false
            //打包release版本的时候是否进行检测
            checkReleaseBuilds false
        }
    
        //编译sdk的版本,也就是API Level,例如API-19、API-20、API-21等等。
        compileSdkVersion 26
        //build tools的版本,其中包括了打包工具aapt、dx等等。
        //这个工具的目录位于你的sdk目录/build-tools/下
        buildToolsVersion '26.0.2'
    
        //关闭Android Studio的PNG合法性检查
        aaptOptions.cruncherEnabled = false
        aaptOptions.useNewCruncher = false
    
        defaultConfig {  //默认配置
            applicationId "com.hebbe.espressotest" //应用程序的包名
            minSdkVersion 22  //最小sdk版本,如果设备小于这个版本或者大于maxSdkVersion将无法安装这个应用
            targetSdkVersion 26 //目标sdk版本,充分测试过的版本(建议版本)
            versionCode 1  //版本号,第一版是1,之后每更新一次加1
            versionName "1.0" //版本名,显示给用户看到的版本号
    
            archivesBaseName = "weshare-$versionName" //指定打包成Jar文件时候的文件名称
            ndk {
                moduleName "hebbewifisafe"                   //设置库(so)文件名称
                ldLibs "log", "z", "m", "jnigraphics", "android"
                //引入库,比如要用到的__android_log_print
                abiFilters "armeabi", "x86", "armeabi-v7a"      //, "x86"  显示指定支持的ABIs
                cFlags "-std=c++11 -fexceptions"                // C++11
                stl "gnustl_static"
            }
    
            //当方法数超过65535(方法的索引使用的是一个short值,
            //而short最大值是65535)的时候允许打包成多个dex文件,动态加载dex。这里面坑很深啊
            multiDexEnabled true
    
            //Instrumentation单元测试
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
    
        //默认的一些文件路径的配置
        sourceSets {
            main {
                manifest.srcFile 'AndroidManifest.xml'//指定清单文件
                res.srcDirs = ['res']//指定res资源目录
                assets.srcDirs = ['assets']    //asset资源目录
                jni.srcDirs 'src/main/jni'     //jni代码目录
                jniLibs.srcDir 'src/main/jniLibs' //jni库目录
                java.srcDirs = ['src']//指定java源代码目录
                resources.srcDirs = ['src']//指定resource目录
                aidl.srcDirs = ['src']//指定aidl目录
                renderscript.srcDirs = ['src']//指定source目录
            }
            debug.setRoot('build-types/debug')//指定debug模式的路径
            release.setRoot('build-types/release')//指定release模式的路径
        }
    
        //multiDex的一些相关配置,这样配置可以让你的编译速度更快
        dexOptions {
            //让它不要对Lib做preDexing
            preDexLibraries = false
            //开启incremental dexing,优化编译效率,这个功能android studio默认是关闭的。
            incremental true
            javaMaxHeapSize "4g"     //增加java堆内存大小
        }
    
        signingConfigs {//签名配置
            release {//发布版签名配置
                storeFile file("fk.keystore")//密钥文件路径
                storePassword "123456"//密钥文件密码
                keyAlias "fk"//key别名
                keyPassword "123456"//key密码
            }
            debug {//debug版签名配置
                storeFile file("fk.keystore")
                storePassword "123456"
                keyAlias "fk"
                keyPassword "123456"
            }
        }
    
        //指定生成安装文件的配置,常有两个子包:release,debug,注:直接运行的都是debug安装文件
        buildTypes {
            //release版本的配置,即生成正式版安装文件的配置
            release {
                zipAlignEnabled true  //是否支持zip
                shrinkResources true  // 移除无用的resource文件
                minifyEnabled false //是否对代码进行混淆,true表示混淆
                //指定混淆时使用的规则文件;
                // proguard-android.txt指所有项目通用的混淆规则,proguard-rules.pro当前项目特有的混淆规则
                //release的Proguard默认为Module下的proguard-rules.pro文件
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
                debuggable false  //是否支持调试
                //ndk的一些配置
                ndk {
                    // cFlags "-std=c++11 -fexceptions -O3 -D__RELEASE__" // C++11
                    // platformVersion  = "19"
                    moduleName "hebbewifisafe" //设置库(so)文件名称
                    ldLibs "log", "z", "m", "jnigraphics", "android"
                    //引入库,比如要用到的__android_log_print
                    abiFilters "armeabi", "x86", "armeabi-v7a"//, "x86"
                    cFlags "-std=c++11 -fexceptions" // C++11
                    stl "gnustl_static"
                }
                //采用动态替换字符串的方式生成不同的release.apk
                applicationVariants.all { variant ->
                    variant.outputs.each { output ->
                        def outputFile = output.outputFile
                        if (outputFile != null && outputFile.name.endsWith('release.apk')) {
                            def timeStamp = new Date().format('yyyyMMddHH');
                            def fileName = "WeShare-${defaultConfig.versionName}" + "-" + timeStamp + "-lj-" + ".apk";
                            output.outputFile = file("${outputFile.parent}/${fileName}")
                        }
                    }
                }
                jniDebuggable false  //关闭jni调试
            }
            debug {//debug版本的配置
                minifyEnabled false
                zipAlignEnabled true
                shrinkResources true // 移除无用的resource文件
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
                debuggable true
    //          jniDebuggable true
                ndk {
                    cFlags "-std=c++11 -fexceptions -g -D __DEBUG__" // C++11
                }
                jniDebuggable true
            }
        }
    
        packagingOptions
            {
                exclude 'META-INF/ASL2.0'
                exclude 'META-INF/LICENSE'
                exclude 'META-INF/NOTICE'
                exclude 'META-INF/MANIFEST.MF'
            }
        
        compileOptions {
            //在这里你可以进行 Java 的版本配置,
            //以便使用对应版本的一些新特性
        }
        productFlavors {
            //在这里你可以设置你的产品发布的一些东西,
            //比如你现在一共软件需要发布到不同渠道,
            //且不同渠道中的包名不同,那么可以在此进行配置;
            //甚至可以设置不同的 AndroidManifest.xml 文件。
            hebbe {
            }
            googlePlay {
            }
            solo {
            }
        }
        productFlavors.all {
            flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
        }
        //所谓ProductFlavors其实就是可定义的产品特性,
        //配合 manifest merger 使用的时候就可以达成在一次编译
        //过程中产生多个具有自己特性配置的版本。
    
        //上面这个配置的作用就是,为每个渠道包产生不同的 UMENG_CHANNEL_VALUE 的值。
    }
    
    //指定当前项目的所有依赖关系:本地依赖、库依赖、远程依赖
    //本地依赖:可以对本地Jar包或目录添加依赖关系
    //库依赖:可以对项目中的库模块添加依赖关系
    //远程依赖:可以对jcenter库上的开源项目添加依赖
    //标准的远程依赖格式是 域名:组织名:版本号
    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar']) //本地依赖
        //远程依赖,com.android.support是域名部分,appcompat-v7是组名称,26.1.0是版本号
        implementation 'com.android.support:appcompat-v7:26.1.0'
        implementation 'com.android.support.constraint:constraint-layout:1.0.2'
        implementation project(':hello')//库依赖
        testImplementation 'junit:junit:4.12' //声明测试用列库
        androidTestImplementation 'com.android.support.test:runner:1.0.1'
        androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
    }
    
    //声明是要使用谷歌服务框架
    apply plugin: 'com.google.gms.google-services'
    
    //第三方依赖库的本地缓存路径
    task showMeCache << {
        configurations.compile.each { println it }
    }
    //使用maven仓库。android有两个标准的library文件服务器,一个jcenter一个maven。两者毫无关系。
    //jcenter有的maven可能没有,反之亦然。
    //如果要使用jcenter的话就把mavenCentral()替换成jcenter()
    repositories {
        mavenCentral()
    }


    简单的例子:

    // 声明是Android程序,
    //com.android.application 表示这是一个应用程序模块,可直接运行
    //com.android.library 标识这是一个库模块,是依附别的应用程序运行
    apply plugin: 'com.android.application'
    
    android {
        //编译sdk的版本,也就是API Level,例如API-19、API-20、API-21等等。
        compileSdkVersion 26
        //build tools的版本,其中包括了打包工具aapt、dx等等。
        //这个工具的目录位于你的sdk目录/build-tools/下
        buildToolsVersion '26.0.2'
    
        //关闭Android Studio的PNG合法性检查
        aaptOptions.cruncherEnabled = false
        aaptOptions.useNewCruncher = false
    
        defaultConfig {  //默认配置
            applicationId "com.hebbe.espressotest" //应用程序的包名
            minSdkVersion 22  //最小sdk版本,如果设备小于这个版本或者大于maxSdkVersion将无法安装这个应用
            targetSdkVersion 26 //目标sdk版本,充分测试过的版本(建议版本)
            versionCode 1  //版本号,第一版是1,之后每更新一次加1
            versionName "1.0" //版本名,显示给用户看到的版本号
    
            //Instrumentation单元测试
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
    
        buildTypes { //build配置
            release {
                minifyEnabled false //是否对代码进行混淆
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }
    
    //指定当前项目的所有依赖关系:本地依赖、库依赖、远程依赖
    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar']) //本地依赖
        //远程依赖,com.android.support是域名部分,appcompat-v7是组名称,26.1.0是版本号
        implementation 'com.android.support:appcompat-v7:26.1.0'
        implementation 'com.android.support.constraint:constraint-layout:1.0.2'
        testImplementation 'junit:junit:4.12' //声明测试用列库
        androidTestImplementation 'com.android.support.test:runner:1.0.1'
        androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
    }


    3、聊聊Groovy


    Gradle选择了Groovy。Groovy基于Java并拓展了Java。 Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就是把写Java程序变得像写脚本一样简单。写完就可以执行,Groovy内部会将其编译成Javaclass然后启动虚拟机来执行。

    Groovy是一种动态语言。Groovy对自己的定义是:Groovy是在java平台上的、 具有像Python, Ruby 和 Smalltalk 语言特性的灵活动态语言, Groovy保证了这些特性像 Java语法一样被 Java开发者使用。




    参考:

    详解build.gradle

    深入理解Groovy



    展开全文
  • Gradle Plugin和Gradle版本

    千次阅读 2017-01-18 13:09:14
    Android Studio构建系统基于Gradle,也就是Gradle Plugin
  • Gradle的作用

    千次阅读 2017-01-04 11:14:30
    Gradle 完整指南(Android) 本文转载自:http://www.jianshu.com/p/9df3c3b6067a 前言 为什么需要学Gradle? Gradle 是 Android 现在主流的编译工具,虽然在Gradle 出现之前和之后都有对应更快的编译...
  • Gradle史上最详细解析

    千次阅读 2017-03-08 15:31:37
    前言 对于Android工程师来说编译/打包等问题立即就成痛点了。一个APP有多个版本,Release版、Debug版、Test版。甚至针对不同APP Store都有不同的版本。在以前ROM的环境下,虽然可以配置Android.mk,但是需要依赖...
  • gradle下载与安装

    万次阅读 2018-07-25 23:05:02
    第一步:安装gradle首先,要确保已经安装了JDK1.5或以上版本,检查JDK版本,运行java -version命令。 在确保JDK版本合适的情况下,下载安装gradle 第二步:gradle下载 直接从gradle主页...
  • Maven与Gradle项目构建工具

    千次阅读 2020-09-03 10:43:32
    项目构建管理工具Maven和Gradle的介绍以及常见问题记录!^_^
  • Gradle 是一个开源的自动构建工具,其几乎可以构建任何类型的软件。 特点: 高效 High performance 基于JVM 其运行在JVM上 JVM foundation Conventions 遵守惯例,其在maven之后出现,所以使用了很多约定俗成的概念 ...
  • Gradle

    千次阅读 2019-03-31 15:40:19
    Gradle项目管理工具:Gradle是基于Ant和Maven产生的,弥补了Ant和Maven的不足,带来了一些更高效的特点;它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,抛弃了基于XML的各种繁琐的配置;Gradle面向Java...
  • gradle 详解——你真的了解Gradle吗?

    千次阅读 2019-12-24 11:25:35
    前段时间忽然发现自己对于Android studio的Gradle打包并不了解,这篇博客参考网上众多教程,为大家详细介绍GradleGradle简介 We would like to introduce Gradle to you, a build system that we think is a ...
  • 在IDEA里gradle配置和使用

    万次阅读 多人点赞 2018-07-23 20:11:52
    在IDEA里gradle配置和使用 在IDEA里gradle配置和使用 前言 Windows环境IDEA配置gradle 配置系统环境变量 下载 配置环境变量 测试 idea配置 gradle仓库设置 构建命令 创建缓存依赖 gradle.build构建脚本 ...
  • Gradle脚本基础全攻略

    万次阅读 多人点赞 2017-10-13 14:12:38
    点我开始Android技术交流】1 背景在开始Gradle之前请务必保证自己已经初步了解了Groovy脚本,特别是闭包规则,如果还不了解Groovy则可以先看《Groovy脚本基础全攻略》这一篇博客速成一下Groovy基础,然后再看此文...
  • gradle升级之后,有了新的依赖方式,下面我来介绍一下他们的使用 先看看之前的 再看看现在的 区别和使用 implementation和api implementation和api是取代之前的compile的,其中api和compile是一样的...
  • Android Studio导入项目的时候,一直卡在Building gradle project info这一步,主要原因还是因为被墙的结果。gradle官网虽然可以访问,但是速度连蜗牛都赶不上...解决办法主要有两种,一是直接下载gradle离线包,二...
  • 从Unity直接导出Gradle工程后,在Android Studio中使用Gradle编译打包时,有时会编译不过,总是报java out of memory异常,而最新的Android Studio界面设置中已经无法直接设置编译时使用的内存大小,所以需要通过...
  • Android Studio的(gradle sync failed 问题)

    万次阅读 多人点赞 2018-12-10 22:01:46
    本人累计安装Android Studio有5次多,其中3次安装后都会出现如 gradle sync failed 问题,之前参考一些博客成功解决了,不过那个是需要修改gradle版本的,很繁琐,而且每次新建一个Project都需要设置一次,不实用...
1 2 3 4 5 ... 20
收藏数 181,013
精华内容 72,405
关键字:

gradle