Gradle入门

2024-01-09 15:08:16

前言

观看笔记：https://www.bilibili.com/video/BV1iW411C7CV?from=search&seid=6869625427262249863。
相关笔记截图放在qq:198866436的空间相册当中了；
这真是我听过的课程当中费时最少的一门课程；

gradle介绍01

课程引导语

java作为一门世界级主流编程语言，有一款高效易用的项目管理工具是java开发者共同追求的心愿和目标。
是2000年Ant（项目管理工具，很好的解决在项目开发当中一系列繁琐问题，但是好景不长，Ant又暴露出了其自身的一些问题），后有2004年Maven（项目管理工具，使用率非常高，但是仍然存在有不足之处）两个工具的诞生，都在Java市场上取得了巨大的成功，但是二者都有一定的不足和局限性。

Maven具有两大特性：

  1. 管理jar包（最主要的功能）
    • 如何管理jar包
      • maven将真正的jar包存放在仓库中，项目中存放着所依赖的jar包的坐标；这个坐标的配置使用的是XML文件来进行配置的；随着项目所依赖的jar包越来越多，XML文件当中的坐标也就越来越多从而导致XML文件越来越大，XML里面的内容也就会变得越来越繁琐，这个就是很多的java开发者所不想看到的一个现象，而gradle的出现就很好的弥补了这一缺陷；gradle不使用XML来进行配置，而是使用一种新的语言叫做Groovy；Groovy是一种新的编程语言，首先对java做了一个全面的兼容，也就是所有的java语言在Groovy环境下都是可以进行执行的；当然groovy也有很多其自己的特性；使得编程变得更加的简单；融合性也更加的高；也就是说如果想学习Gradle就需要对Groovy语言有一个大概的认识；Gradle工具现阶段主要应用于Java应用；
  2. 构建项目

2012年基于Ant和Maven产生的Gradle，弥补了Ant和Maven的不足，带来了一些更高效的特点。
它使用一种基于Groovy的特定领域语言（DSL）来声明项目配置，抛弃了基于XML的各种繁琐配置。
面向Java应用为主。
当前其支持的语言限于Java、Groovy和Scala，计划未来将支持更多的语言。

课程简介

本课程主要分以下几个步骤来讲解gradle工具的使用：

  1. Gradle安装配置（Windows版）
  2. Gradle和idea集成
  3. Groovy语言简单介绍
  4. Gradle仓库的配置
  5. Gradle入门案例
  6. Gradle创建Java web工程并在tomcat下运行
  7. Gradle构建多模块项目

课程介绍

gradle的安装

下载实时最新的Gradle版本：https://gradle.org/releases/。

点击Download: binary-only or complete当中的binary-only或者complete即可下载；
下载好的gradle是一个压缩包的形式；
即首先需要进行解压；

v6.5
Jun 02, 2020

Download: binary-only or complete
User Manual
API Javadoc
DSL Reference
Release Notes
v6.4.1
May 15, 2020

Download: binary-only or complete
User Manual
API Javadoc
DSL Reference
Release Notes
v6.4
May 05, 2020

Download: binary-only or complete
User Manual
API Javadoc
DSL Reference
Release Notes
........

gradle的目录结构：

  • bin
    • gradle
    • gradle.bat(构建项目非常重要的命令，所以说之后如果想要用gradle构建项目就需要用到这个文件；)
  • caches(caches即缓存，由于是崭新下载好的，所以暂时没有缓存)
    • 4.7
    • jars-3
    • modules-2
      • files-2.1
      • metadata-2.56
        • descriptors
        • module-artifact.bin
        • module-artifacts.bin
        • module-metadata.bin
        • resource-at-url.bin
      • modules-2.lock
    • transforms-1
      • transform-1.lock
  • daemon
    • 4.7
  • init.d
    • readme.txt
  • lib(自身运行所需要的一些环境如jar包/plugins插件等)
    • plugins
    • annotations-13.0.jar
    • …
  • media
  • native
  • wrapper
  • getting-started.html
  • LICENSE
  • NOTICE

为了更好的使用gradle需要对gradle进行环境变量的配置；

Gradle 环境变量配置

================================================
Gradle目录：F:\Gradle\gradle-4.4-all\gradle-4.4

点击-我的电脑
↓↓↓↓↓↓
右击
↓↓↓↓↓↓
点击-属性
↓↓↓↓↓↓
点击-高级系统设置
↓↓↓↓↓↓
点击-环境变量
↓↓↓↓↓↓
点击-系统变量
↓↓↓↓↓↓
点击-新建（W）...
↓↓↓↓↓↓
变量名（N）：GRADLE_HOME
变量值（V）：F:\Gradle\gradle-4.4-all\gradle-4.4
↓↓↓↓↓↓
找到Path
↓↓↓↓↓↓
点击-编辑
↓↓↓↓↓↓
新建（N）
%GRADLE_HOME%\bin
↓↓↓↓↓↓
点击-确定
↓↓↓↓↓↓
点击-确定
================================================

如何验证Gradle配置成功

======================================
windows+r键：键入cmd；打开命令提示符；
命令行键入：gradle -v #回车

Microsoft Windows [Version 10.0.17763.1282]
(c) 2018 Microsoft Corporation。保留所有权利。

C:\Users\ASUS>gradle -v
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8

------------------------------------------------------------
Gradle 4.4
------------------------------------------------------------

Build time:   2017-12-06 09:05:06 UTC
Revision:     cf7821a6f79f8e2a598df21780e3ff7ce8db2b82

Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.9 compiled on February 2 2017
JVM:          1.8.0_202 (Oracle Corporation 25.202-b08)
OS:           Windows 10 10.0 amd64

C:\Users\ASUS> exit # 退出
=====================================
如果出现以上信息及Gradle安装成功；

gradle介绍02

在idea当中创建gradle项目；
首先打开idea；

GroupId: 公司/组织名称
ArtifactId: 项目名称
Version: 版本号
gradle的运行需要用到jdk的环境；

  1. 首先指定刚刚安装的gradle在什么地方，即选择Use local gradle wrapper(recommended)（即本地安装的gradle，选择了之后会发现它会去自动找本地所安装的gradle）

  2. gradle的运行需要用到jdk的环境；那么就需要在Gradle JVM当中选择好自己本地的jdk环境；确认一下Gradle JVM当中所录入的是否为本地jdk的位置；

  3. Use auto-import选项进行勾选上；Use auto-import的含义为：在项目开发时突然导入了一个c的jar包；那么这个时候就需要gradle来自动将这个jar包的坐标位置给找到；并且导入进来即可；

  4. 其余的不需要做改变使用默认即可；

Use auto-import 自动导入

Project name: 项目名称
Project location: 项目放置的目录

点击Finish即可；
当前创建的该项目就可以使用gradle做开发了；
当gradle在创建的时候尽量让jdk为1.8或者是电脑是一个联网的状态；
因为要去网上下载一些相应的插件；

gradle项目目录结构介绍

在开发的时候，都讲究配置文件与代码分离原则，讲究该原则的原因在于因为最终项目开发完成之后是需要发布到线上的，那么发布到线上的时候只需要发布正式的源码即可；在正式源码开发过程中将产生大量的测试文件即单元测试；
src/main/java 放置正式代码目录
src/main/resources 放置正式配置文件目录
src/test/java 放置单元测试代码目录
src/test/resources 放置测试配置文件目录
src/main/webapp 放置页面元素，比如：js，css，img，jsp，html等等

groovy简单语法

不进行创建gradle工程一样可以来进行使用该编辑器；
groovy更加的随意；

代码

//介绍groovy编程语言
// java: System.out.println("");
println("hello, good morning, fsn");
// groovy可以省略语句最末尾的分号
println("hello world")
//groovy中可以省略小括号
println"hello world, hello, world"
//groovy中如何定义变量，最后的分号加不加都行
//def 弱类型；有点类似于在JavaScript当中的var;
//groovy会自动根据情况来给变量赋予对应的类型；
//根据变量名后面的取值来进行判断是什么样的类型；
//int 类型
def abc = 21;
def defg = 22
println abc
println abc+defg
//string 类型
def s = "laowang"
println s
//定义一个集合类型
def list = ['a','b','c','d','e','f','g']
//往list中添加元素
list << 'h'
//取出list中第三个元素
println list.get(2)
println list.size()
for (int i = 0; i < list.size(); i++) {
    println list.get(i)
}
//定义一个map
def map = ['key1':'value1','key2':'value2']
//向map当中添加键值对
map.key3 = 'value3'
//打印出key3的取值
println map.get('key3')

结果

> //介绍groovy编程语言
> // java: System.out.println("");
> println("hello, good morning, fsn");
> // groovy可以省略语句最末尾的分号
> println("hello world")
> //groovy中可以省略小括号
> println"hello world, hello, world"
> //groovy中如何定义变量，最后的分号加不加都行
> //def 弱类型；有点类似于在JavaScript当中的var;
> //groovy会自动根据情况来给变量赋予对应的类型；
> //根据变量名后面的取值来进行判断是什么样的类型；
> //int 类型
> def abc = 21;
> def defg = 22
> println abc
> println abc+defg
> //string 类型
> def s = "laowang"
> println s
> //定义一个集合类型
> def list = ['a','b','c','d','e','f','g']
> //往list中添加元素
> list << 'h'
> //取出list中第三个元素
> println list.get(2)
> println list.size()
> for (int i = 0; i < list.size(); i++) {
>     println list.get(i)
> }
> //定义一个map
> def map = ['key1':'value1','key2':'value2']
> //向map当中添加键值对
> map.key3 = 'value3'
> println map.get('key3')
hello, good morning, fsn
hello world
hello world, hello, world
21
43
laowang
c
8
a
b
c
d
e
f
g
h
value3

groovy中的闭包

Closure不可导入其他包

import com.sun.corba.se.spi.orbutil.closure.Closure
//groovy中的闭包
//介绍：什么是闭包？
//闭包其实就是一段代码块，在gradle中，主要是把闭包当参数来进行使用
//首先需要进行定义一个闭包
def test = {
    println "hello, fsn !"
}
//再定义一个方法，该方法里面需要闭包类型的参数
//Closure closure不要导jar包，任何一个包都不要导入
//在groovy当中Closure该单词就表示闭包；如果导包进来就会出错；
def method1(Closure closure){
    closure()
}
//调用方法method1()
method1(test)

示例报错

F:\jdk\jdk1.8202\jdk\bin\java.exe -Dtools.jar=F:\jdk\jdk1.8202\jdk\lib\tools.jar "-Dgroovy.home=F:\ideaUI\IntelliJ IDEA 2018.3.1" "-Dgroovy.starter.conf=F:\ideaUI\IntelliJ IDEA 2018.3.1\plugins\Groovy\lib\groovy-starter.conf" -Dfile.encoding=UTF-8 -classpath "F:\ideaUI\IntelliJ IDEA 2018.3.1\lib\idea_rt.jar" com.intellij.rt.execution.CommandLineWrapper C:\Users\ASUS\AppData\Local\Temp\idea_classpath1957904038 org.codehaus.groovy.tools.GroovyStarter --conf "F:\ideaUI\IntelliJ IDEA 2018.3.1\plugins\Groovy\lib\groovy-starter.conf" --main groovy.ui.GroovyMain -p "F:\ideaUI\IntelliJ IDEA 2018.3.1\plugins\Groovy\lib\console.groovy"

> import com.sun.corba.se.spi.orbutil.closure.Closure
> //groovy中的闭包
> //介绍：什么是闭包？
> //闭包其实就是一段代码块，在gradle中，主要是把闭包当参数来进行使用
> //首先需要进行定义一个闭包
> def test = {
>     println "hello, fsn !"
> }
> //再定义一个方法，该方法里面需要闭包类型的参数
> //Closure closure不要导jar包，任何一个包都不要导入
> //在groovy当中Closure该单词就表示闭包；如果导包进来就会出错；
> def method1(Closure closure){
>     closure()
> }
> //调用方法method1()
> method1(test)
hello, good morning, fsn
hello world
hello world, hello, world
21
43
laowang
c
8
a
b
c
d
e
f
g
h
value3
groovy.lang.MissingMethodException: No signature of method: com.sun.proxy.$Proxy5.call() is applicable for argument types: () values: []
Possible solutions: wait(), any(), wait(long), each(groovy.lang.Closure), any(groovy.lang.Closure), wait(long, int)
	at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.unwrap(ScriptBytecodeAdapter.java:71)
	at org.codehaus.groovy.runtime.callsite.PojoMetaClassSite.call(PojoMetaClassSite.java:48)
	at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:47)
	at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:116)
	at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:120)
	at ideaGroovyConsole.method1(ideaGroovyConsole.groovy:50)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.codehaus.groovy.runtime.callsite.PogoMetaMethodSite$PogoCachedMethodSiteNoUnwrap.invoke(PogoMetaMethodSite.java:190)
	at org.codehaus.groovy.runtime.callsite.PogoMetaMethodSite.callCurrent(PogoMetaMethodSite.java:59)
	at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCallCurrent(CallSiteArray.java:51)
	at org.codehaus.groovy.runtime.callsite.AbstractCallSite.callCurrent(AbstractCallSite.java:157)
	at org.codehaus.groovy.runtime.callsite.AbstractCallSite.callCurrent(AbstractCallSite.java:169)
	at ideaGroovyConsole.run(ideaGroovyConsole.groovy:53)
	at groovy.lang.GroovyShell.runScriptOrMainOrTestOrRunnable(GroovyShell.java:263)
	at groovy.lang.GroovyShell.run(GroovyShell.java:507)
	at groovy.lang.GroovyShell.run(GroovyShell.java:486)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.codehaus.groovy.runtime.callsite.PogoMetaMethodSite$PogoCachedMethodSite.invoke(PogoMetaMethodSite.java:169)
	at org.codehaus.groovy.runtime.callsite.PogoMetaMethodSite.call(PogoMetaMethodSite.java:71)
	at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:136)
	at console.run(console.groovy:11)
	at groovy.ui.GroovyMain.processReader(GroovyMain.java:576)
	at groovy.ui.GroovyMain.processFiles(GroovyMain.java:485)
	at groovy.ui.GroovyMain.run(GroovyMain.java:327)
	at groovy.ui.GroovyMain.process(GroovyMain.java:315)
	at groovy.ui.GroovyMain.processArgs(GroovyMain.java:134)
	at groovy.ui.GroovyMain.main(GroovyMain.java:114)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:116)
	at org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:138)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.intellij.rt.execution.CommandLineWrapper.main(CommandLineWrapper.java:67)

正确示意

//groovy中的闭包
//介绍：什么是闭包？
//闭包其实就是一段代码块，在gradle中，主要是把闭包当参数来进行使用
//首先需要进行定义一个闭包
def test = {
    println "hello, fsn !"
}
//再定义一个方法，该方法里面需要闭包类型的参数
//Closure closure不要导jar包，任何一个包都不要导入
//在groovy当中Closure该单词就表示闭包；如果导包进来就会出错；
def method1(Closure closure){
    closure()
}
//调用方法method1()
method1(test)

正确结果

hello, fsn !

大概的执行流程

首先method1()方法需要一个参数Closure closure，闭包类型的参数；
而上面的test变量正好是一个闭包类型；
所以可以将test变量传递下来到method1()方法当中；
在method1()拿到该闭包参数之后并没有其他的动作仅仅只是执行了闭包方法，即执行了test()方法当中的代码；而闭包方法即test()方法当中的代码即为输出打印；

带有参数的闭包代码

//定义一个带有参数的闭包方法
def test2 = {
    v ->
        println "hello ${v}"
}
//定义一个方法，方法里面需要闭包类型的参数
def method2(Closure closure){
    closure("隔壁老王")
}
method2(test2)

结果打印

hello 隔壁老王

gradle配置文件的介绍

build.gradle

====================================================================
https://mvnrepository.com/artifact/org.springframework/spring-context/5.0.2.RELEASE

如果是maven工程直接选择Maven即可；
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

如果是Gradle工程则选择Gradle即可；
// https://mvnrepository.com/artifact/org.springframework/spring-context
compile group: 'org.springframework', name: 'spring-context', version: '5.0.2.RELEASE'
====================================================================

/**
 * 运行的环境
 */
plugins {
    id 'java'
}

/**
 * group 公司/团队名
 * version 版本
 */
group 'com.fsn'
version '1.0-SNAPSHOT'

/**
 * java jdk版本
 */
sourceCompatibility = 1.8

/**
 * 指定所使用仓库的路径
 * mavenCentral() 表示使用*仓库，此刻项目中所需要的jar包都会默认从*仓库下载到本地指定目录
 *
 */
repositories {
    mavenCentral()
}

/**
 * 1. gradle工程所有的jar包的坐标都在dependencies属性内放置
 * 2. 每一个jar包的坐标都由三个基本元素组成 group、name、version
 * 3. testCompile 表示该jar包在测试的时候起作用，该属性为jar包的作用域；
 *    在gradle里面添加坐标的时候都要带上jar包的作用域
 * compile/testCompile其实是一个方法
 */
dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile group: 'org.springframework', name: 'spring-context', version: '5.0.2.RELEASE'
}
====================================================================

让gradle使用本地maven仓库

gradle默认使用的仓库是*仓库即repositories{mavenCentral()}。

对该仓库进行重新配置；
如何使用本地的maven仓库来进行开发gradle工程；
复制得到本地maven仓库地址:F:\maven\apache-maven-3.6.1-bin\repository。
将该路径配置到环境变量当中；

================================================
Maven仓库目录：F:\maven\apache-maven-3.6.1-bin\repository

点击-我的电脑
↓↓↓↓↓↓
右击
↓↓↓↓↓↓
点击-属性
↓↓↓↓↓↓
点击-高级系统设置
↓↓↓↓↓↓
点击-环境变量
↓↓↓↓↓↓
点击-系统变量
↓↓↓↓↓↓
点击-新建（W）...
↓↓↓↓↓↓
变量名（N）：GRADLE_USER_HOME
变量值（V）：F:\maven\apache-maven-3.6.1-bin\repository
↓↓↓↓↓↓
点击-确定
↓↓↓↓↓↓
点击-确定
================================================
环境变量设置完成之后查看IDEA的Default Settings当中的Service directory path就将会变成maven仓库的目录；
也就意味着将从本地仓库当中找jar包；

由于build.gradle当中repositories{mavenCentral()}该写法仍然会从*仓库当中进行下载；此时则需要让它先从本地仓库当中进行查找即在mavenCentral()之前添加mavenLocal()；
写法为

/**
 * 指定所使用仓库的路径
 * mavenCentral() 表示使用*仓库，此刻项目中所需要的jar包都会默认从*仓库下载到本地指定目录
 * mavenLocal() 表示使用本地maven仓库；
 *
 * mavenLocal()
 * mavenCentral()
 * 以上配置表示先从本地仓库寻找依赖，如果没有再从*仓库下载。
 * mavenCentral()
 * 如果只配置*仓库，表示直接从*仓库下载jar包；
 * 但是如果指定下载的位置已经有了，就不会再次下载了；
 */
repositories {
    mavenLocal()
    mavenCentral()
}

gradle介绍03

点击查看External Libraries下载好的jar包；

Tasks

  • build
    • assemble
    • build
    • buildDependents
    • buildNeeded
    • classes
    • clean
    • jar
      • 当前工程为一个java工程，所以只能打jar包；双击该命令行即可；
      14:36:50: Executing task 'jar'...

:compileJava
:processResources
:classes
:jar

BUILD SUCCESSFUL in 3s
3 actionable tasks: 3 executed
14:36:53: Task execution finished 'jar'.
    • testClasses
  • build setup
  • documentation
  • help
  • other
  • verification

gradle开发web工程

仓库地址：https://github.com/fengshana/gradleDemo。

gradle工程拆分与聚合

仓库地址：https://github.com/fengshana/gradleDemo。

上一篇：「Groovy」- 处理路径地址 @20210210


下一篇：Jmeter中的 JSR223 使用