Gradle篇（入门到精通）

一、前言

1. 项目构建历史

1.1. 传统方式

1.2. 构建工具

1.3. Gradle

2. 初始 groovy

2.1. 什么是 Groovy

2.2. Groovy 安装环境

2.3. groovy 与 Java 对比

3. groovy 特性

3.1. 基础语法

3.2. 闭包

二、gradle 实战

1. Gradle 环境搭建

1.1. 安装 gradle

1.2. Gradle 搭建Java工程

1.3. Gradle 搭建 web 工程

2. Gradle流程

2.1. build.gradle 详解

Project对象介绍

Task任务介绍

知识结论

2.2. 自定义任务

2.3. Gradle 生命周期

三、Gradle高级

1. Gradle依赖管理

1.1. 仓库配置

1.2. 依赖管理

1.3. 解决依赖冲突

2. Gradle 多项目构建

2.1. 项目拆分

2.2. 项目发布

3. 嵌入式 tomcat 配置

配置tomcat

四、Gradle与Maven有什么区别？

一、前言

1. 项目构建历史

1.1. 传统方式

依赖管理 : 最开始的时候如果需要依赖第三方的 jar 包,需要把 jar 放到 lib 目录中,

如果 jar 包多了不好管理,很容易出现版本冲突问题.

每个项目需要使用到同一个jar包都得拷贝一份到项目中,很占用存储空间。非常麻烦！！！

测试 : 每个功能都需要书写测试类,在main中写测试非常麻烦,能不写一般都是不会写.就算写了也是很简单的测试下

而已。

打包 : 通过 eclipse或者idea 打包然后传递到服务器或者放入依赖的项目中.麻烦,繁琐。

上传 : 通过一些文件上传工具(FTP) 上传jar包到项目下。

1.2. 构建工具

依赖管理 : 可以做依赖管理,将 jar 包统一管理起来,更加的清晰和方便,而且仅仅是依赖管理,没有拷贝jar包到项目

中.

自动化: 可以自动测试\打包\发布

原则: 机器能做的事情,绝不自己动手去做.大大提高开发效率.

主流的构建工具：

Ant （Apache Ant）

软件编译、测试、部署等步骤联系在一起加以自动化的一个工具，大多用于Java 环境中的软件开发。

Maven

从 Ant 中借用了绝大多数构建任务,其突出的是依赖管理和项目发布

Gradle

使用 Groovy 语言构建脚本,不再像 Maven 一样使用 XML

1.3. Gradle

一个开源的项目自动化构建工具,建立在 Apache Ant 和 Apache Maven 概念的基础上,

并引入了基于 Groovy 的特定领域语言(DSL),而不再使用 XML 形式管理构建脚本.

DSL（Domain Specific Language）定义：针对某一领域，具有受限表达性的一种计算机程序设计语言。

只针对一个领域做出来的简洁语言,而非为了通用而设计

2. 初始 groovy

2.1. 什么是 Groovy

Groovy 是基于Java虚拟机的一种敏捷的动态语言，它是一种成熟的OOP (面向对象)编程语言，

既可以用于面向对象编程，又可以用作纯粹的脚本语言。

使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Java 与 Groovy 的不同点或优势

Groovy 完全兼容 Java 语法,可做脚本也可做类
分号是可选的,一般不加分号,以换行作为结束
类,方法,字段都是公共的,没有访问权限限制
默认生成具名(名值对)参数构造器 key:value
字段不定义访问权限时,编译器自动给字段添加 getter/setter 方法
字段可使用点来获取,无访问权限的也可使用 getter/setter 来操作
方法可省略 return 关键字,自动检索最后一行的结果作为返回值

Groovy 的高级特性

assert 断言: 可以用 assert 代替之前 Java 的断言语句
可选类型: 可使用类 JavaScript 的弱类型,可使用 def 来表示任意类型
方法调用: 调用带参方法时可省略括号.
字符串定义: 字符串定义有三种方式,单引号,双引号,三个单引号
集合 API: 集合的定义和使用更加简单,API 和 Java 有所不同,但兼容 Java API
闭包: Groovy 的一大特性,跟方法类似的代码块,可赋给一个变量也可以做为参数传递给一个方法, 像普通方法一样调用.

2.2. Groovy 安装环境

下载groovy的环境

下载地址：The Apache Groovy programming language - Download

下载后解压，进入到bin目录下，输入命令查看对应的版本

可以使用控制台测试groovy环境

在窗口中输入 groovyConsole 命令，会弹出groovy的控制台，然后可以在控制台输入groovy的代码，

使用Ctrl + R 运行groovy的代码。

2.3. groovy 与 Java 对比

打开idea，创建groovy的工程

选择本地的groovy的开发环境。

下面演示groovy和Java的一些区别

groovy 与 Java 比较

JavaBean 的定义

可省略分号
可省略 getter/setter
可省略 return
无权限修饰符自动生成 getter/setter
默认带有具名构造器 key:value

创建对象和操作字段

getter/setter 方式操作字段
点方式调用字段
调用自动生成的getter/setter方法

定义学生的类，代码如下：

package com.zhengge.demo1

/**
 * groovy 与 Java 比较
 1 JavaBean 的定义
 1) 可省略分号
 2) 可省略 getter/setter
 3) 可省略 return
 4) 无权限修饰符自动生成 getter/setter
 5) 默认带有具名构造器  key:value

 2 创建对象和操作字段
 1) getter/setter 方式操作字段
 2) 点方式调用字段
 3) 调用自动生成的getter/setter方法
 */
class Stu {
    
    // 可以使用分号
    private String username;
    // 分号可以省略不写
    private String email
    // 无权限修饰符，自动生成get和set方法
    int age;
    
    // 提供get方法，return 可以不写
    String getUsername() {
        username
    }
    void setUsername(String username) {
        this.username = username
    }
    
}

package com.zhengge.demo1

// 按脚本的方式去执行
Stu stu = new Stu();

// 给username属性赋值
stu.setUsername("老王");
// 打印username
println(stu.getUsername());

// 给私有属性赋值
stu.email = "laowang@163.com";
// 打印私有属性   println stu.email
println(stu.email);

// 测试age，默认提供get和set方法
stu.setAge(20)
// 打印age属性
println(stu.getAge())
println(stu.age)

// 构造方法
Stu stu1 = new Stu(username: "老四",email: "laosi@163.com",age: 30);
println(stu1.username +" -- "+stu1.email +" -- "+stu1.age)

用groovy的语法定义类

package com.zhengge.demo1

class Teacher {

    def username;
    def email;
    def age;

}

编程测试类

package com.zhengge.demo1

Teacher teacher = new Teacher(username: "樱木",email: "ym@126.com",age:18);
println(teacher.username + " : " + teacher.email + " ： "+teacher.age)

3. groovy 特性

3.1. 基础语法

定义变量、字符串等

package com.zhengge.demo2

// 定义变量
def name = "yjxz";

// 定义方法
void add(){
    println("hello");
}

// 调用方法
add();

// ==========定义字符串============

// 定义字符串
def str1 = 'string';
// 引用字符串
def str2 = "hello ${str1}";
// 按格式去输出字符串
def str3 = '''
    username:yingmu 
age:18'''

println str1
println str2
println str3

定义List集合

def list = ["老王","老四","樱木"];

// 添加元素
list.add("hello");
// groovy特有的语法
list << "world";

// 打印集合
println(list)
println(list.getClass())

// 遍历集合
list.each {
    it ->
        println it
}

定义map集合

def map = ["username":"老王","age":30]

// 向map添加元素
map.put("email","laowang@163.com");
// 可以直接点属性的方式添加元素
map.gender = "男";

// 打印map
println map
println map.getClass()

// 遍历map集合
for(String key:map.keySet()){
    println map.get(key);
}

map.each {
    it ->
        println it.key +" -- " + it.value
}

3.2. 闭包

定义闭包

闭包是Groovy中非常重要的一个数据类型或者说一种概念。

闭包是一种数据类型，它代表了一段可执行的代码

闭包的语法定义： { [closureParameters -> ] statements }

其中[closureParameters->]部分是一个可选的以逗号分隔的参数列表

statements可以为空，一行或者多行代码。

当参数列表确定时，->是必须的，他负责把参数和闭包的代码块分开，代码块可以由一行或者多行语句组成

一些闭包常用的定义形式：

{ name -> println name }

如果闭包没有定义参数的话，则隐含有一个参数，这个参数的名字交it,和this作用类似，it代表闭包的参数。

闭包实质上是一个groovy.lang.Closure类的实例，虽然他是一个代码块，但是他可以为任何一个变量或者字段赋

值，闭包中可以包含代码的逻辑，闭包中的最后一行语句，表示该闭包的返回值，不论该语句是否有return关键

字。

package com.zhengge.demo2

// 定义闭包
def c1 = {
    println "hello"
}

// 调用闭包方法
c1()
// 显示的调用
c1.call()

// ============带参数==============

def c2 = {
    str ->
        println str
        "hello"
}

def result = c2("abc");
println result

// ===============================

// 可以把闭包做为参数传入到方法中
def method1(Closure closure){
    // 调用闭包方法
    closure.call();
}
// 调用method1方法
method1(c1);

// 定义方法
def method2(Closure closure){
    closure.call("老王");
}
// 调用method2方法
method2(c2);

二、gradle 实战

1. Gradle 环境搭建

1.1. 安装 gradle

从官网上下载gradle安装文件，配置环境变量即可。

下载地址：Gradle | Releases

我下载的版本是4.6的版本，不推荐使用较高的版本。

配置环境变量

在窗口中执行gradle -v 的命令，查看执行的结果。

1.2. Gradle 搭建Java工程

创建java的工程。

输入组织名，项目或者模块名称和版本号

选择gradle对应的版本

创建后的工程

生成的项目中 build.gradle是非常重要的文件，类似于maven工程中的pom.xml配置文件。

编写Java代码，进行测试

package com.zhengge.demo1;

public class GradleDemo1 {

    public static void main(String[] args) {
        System.out.println("hello gradle");
    }

}

把编写好的工程打成jar包

生成了对应的 jar 包

1.3. Gradle 搭建 web 工程

创建web工程。

2. Gradle流程

2.1. build.gradle 详解

Gradle 构建脚本中最重要的两个概念是 project 和 Task,任何一个 Gradle 构建都由一个或者多个project 组成,

每个 project 包括许多的构建部分,可以是一个 jar 包,也可以是一个 web 应用,也可以是多个 jar 的整合,可以部署

应用和搭建环境.

每个 project 由一个或多个 Task 组成,每个 Task 表示在构建执行过程中的一个原子操作。

如编译，打包，生成 javadoc，发布到仓库等操作。

Project对象介绍

一个 project 代表一个正在构建的组件(jar/war文件),当构建开始时,Gradle 会基于 build.gradle 实例化一个

org.gradle.api.Project 对象.

并通过 project 变量来隐式调用其成员.

那 Project 的成员有哪些呢?

Project 中常用的属性有project (隐式使用),group,name,version

Project 其他常用配置

plugins , apply plugin 用来引入插
dependencies 依赖配置
repositories 仓库配置
task 任务书写
ext,gradle.properties Project 中属性的其他配置方式

结论：所有的配置都会被封装到 Project 对象中。

Task任务介绍

每个任务在构建执行过程中会被封装成 org.gradle.api.Task 对象.

主要包括任务的动作和任务依赖.

任务动作定义了一个原子操作.可以定义依赖其他任务、动作顺序和执行条件.

那任务有哪些相关操作呢?

任务主要操作动作

dependsOn : 依赖相关操作

doFirst ：任务执行之前执行的方法

doLast：任务执行之后执行的方法

定义任务代码

task t1{
    println "hello t1"
}

task t2(dependsOn:"t1"){
    doFirst {
        println("doFirst t2")
    }

    println("hello t2")

    doLast {
        println("doLast t2")
    }
}

Project 和 Project 以及 Project 和 Task 以及 Task 和 Task 之间的关系如下图：

Project1 依赖 Project2,所以需先构建 Project2 ,Project2 中有三个任务 Task FGH,

由于依赖关系,先执行 Task G 再执行Task F 再执行 Task H.

Project1 中的 Task 也是先执行被依赖的任务。

知识结论

直接定义在任务下的代码会在配置 project 时执行,其他时候不执行,就算依赖也不执行.
只有在doFirst 或 doLast 中配置的操作才会在调用任务或者依赖执行时调用。
所以以后自定义任务执行代码需要写在doFirst或doLast 中，除非先在构建Project 时就执行。

2.2. 自定义任务

自定义任务的方式

task t1{
    println "hello t1"
}

task t1(){
    println "hello t1"
}

任务的依赖配置

定义任务时参数依赖 (dependsOn:'
任务内部依赖 dependsOn 'taskName'
外部添加依赖 taskName1.dependsOn taskName2

task t1{
    doFirst {
        println "t1"
    }
}

task t2(dependsOn:"t1"){
    doFirst {
        println("t2")
    }
}

task t3{
    dependsOn "t1"
    doFirst {
        println "t3"
    }
}

task t4{
    doFirst {
        println "t4"
    }
}
t4.dependsOn t1

2.3. Gradle 生命周期

Gradle构建过程有三个阶段。

初始化

Gradle可以构建一个和多个项目。在初始化阶段，Gradle会确定哪些项目参与构建，并且为这些项目创建一

个Project实例。

通过 settings.gradle 判断有哪些项目需要初始化,加载所有需要初始化的项目的 build.gradle 文件并为每个

项目创建 project 对象

配置（Configuration）

在这个阶段，会配置project对象。将执行构建的所有项目的构建脚本。也就是说，会执行每个项目的

build.gradle文件。

执行各项目下的 build.gradle 脚本，完成 project 的配置，并且构造 Task 任务依赖关系图以便在执行阶段按

照依赖关系执行Task中的配置代码

执行（Execution）

Gradle确定要在执行期间创建和配置的任务子集。子集由传递给gradle命令和当前目录的任务名称参数确

定。

Gradle然后执行每个选定的任务。

通过配置阶段的 Task 图,按顺序执行需要执行的任务中的动作代码,就是执行任务中写在 doFirst 或 doLast

中的代码。

可以通过回调（钩子）方法，执行自己想要执行的代码。

在settings.gradle配置类中添加如下代码

rootProject.name = 'tx_gradle_demo1'

gradle.settingsEvaluated {
    println "初始化阶段 settingsEvaluated..."
}

gradle.projectsLoaded {
    println "初始化阶段 projectsLoaded..."
}

gradle.beforeProject {
    println "初始化阶段 beforeProject..."
}

在build.gradle配置类中添加回调方法

task t1{
    doFirst {
        println "t1"
    }
}

// 钩子方法
gradle.afterProject {
    println '配置阶段 afterProject'
}
project.beforeEvaluate {
    println '配置阶段 beforeEvaluate'
}
gradle.projectsEvaluated {
    println '配置阶段 projectsEvaluated'
}
project.afterEvaluate {
    println '配置阶段 afterEvaluate'
}
gradle.taskGraph.whenReady {
    println '配置任务 whenReady'
}


// 执行阶段
gradle.taskGraph.beforeTask {
    println "执行阶段 before task"
}
gradle.taskGraph.afterTask {
    println "执行阶段 afterTask "
}
gradle.buildFinished {
    println '构建结束 buildFinished'
}

运行t1任务，执行后的结果如下

三、Gradle高级

1. Gradle依赖管理

1.1. 仓库配置

Gradle默认的本地仓库如下图

在idea中配置本地仓库的位置

在build.gradle中配置仓库

repositories {
    
    // 也可以公司内部的私服
    maven {
       url " http://localhost:8079/nexus/content/groups/public/"
    }

    // 配置阿里云私服
    maven {
        url "http://maven.aliyun.com/nexus/content/groups/public/"
    }

    // 从中央仓库下载依赖
    mavenCentral()
}

1.2. 依赖管理

Gradle依赖管理，在dependencies 中引入具体的坐标依赖。

group : 指明 jar 的组织名称
name : 指明 jar 包的项目或者模块名称
version: 指明 jar 包的版本

依赖阶段配置

在 build.gradle 中的 dependencies 中配置依赖,依赖分以下四种依赖.
源码依赖: compile , runtime
测试依赖: testCompile, runtime

依赖配置

compile 配置依赖的 jar ,源码、测试代码编译和运行期间都存在.
runtime 配置依赖的 jar,只有源码和测试代码在运行期间存在.
testCompile 配置依赖的 jar,测试代码的编译和运行期间都存在.
testRuntime 配置依赖的 jar,测试代码在运行期间存在.

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile group: 'org.mybatis', name: 'mybatis', version: '3.4.5'
    compile group: 'com.alibaba', name: 'fastjson', version: '1.2.62'
    compile group: 'dom4j', name: 'dom4j', version: '1.6.1'
}

1.3. 解决依赖冲突

管理依赖的最重要的环节就是传递性依赖过程中存在的版本冲突的问题处理.

在之前的手动管理依赖过程中经常遇到版本冲突问题，版本一冲突程序就无法正常运行。

而作为版本管理工具就应该拥有解决此问题的功能。

Maven自动解决版本冲突方式

第一声明优先原则，引入坐标的位置在上方，优先声明的，默认引入到工程中。
路径近者优先原则，直接依赖的坐标比传递依赖坐标路径近，最终直接依赖的坐标引入到工程中。

Gradle 的默认自动解决版本冲突的方案是选用版本最高的。

一般项目都是向下兼容，所以 Gradle 的自动解决方案也是合理的。

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    compile group: 'org.springframework', name: 'spring-expression', version: '4.2.5.RELEASE'
    compile group: 'org.springframework', name: 'spring-beans', version: '5.1.3.RELEASE'
}

可以配置不解决冲突。

configurations.all{
    resolutionStrategy{
        // 修改 gradle不自动处理版本冲突
        failOnVersionConflict()
    }
}

设置手动解决冲突，第一种方式：

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    compile group: 'org.springframework', name: 'spring-expression', version: '4.2.5.RELEASE'
    compile (group: 'org.springframework', name: 'spring-beans', version: '5.1.3.RELEASE'){
        exclude group: "org.springframework",module: "spring-core"
    }

}

第二种方式：排除所有jar包的依赖。

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'

    compile group: 'org.springframework', name: 'spring-expression', version: '4.2.5.RELEASE'

    /*
    compile (group: 'org.springframework', name: 'spring-beans', version: '5.1.3.RELEASE'){
        // 排除依赖
        exclude group: "org.springframework",module: "spring-core"
    }
    */

    compile (group: 'org.springframework', name: 'spring-beans', version: '5.1.3.RELEASE'){
        // 排除依赖
        // exclude group: "org.springframework",module: "spring-core"
        transitive = false
    }
    
}

还可以设置锁定指定的版本。

/**/
configurations.all{
    /*
    resolutionStrategy{
        // 修改 gradle不自动处理版本冲突
        failOnVersionConflict()
    }
    */

    // 指定具体的版本
    resolutionStrategy{
        force 'org.springframework:spring-core:5.2.4.RELEASE'
    }

}

2. Gradle 多项目构建

2.1. 项目拆分

按着模块进行项目拆分，首先有父工程（子模块项目管理，公共信息配置）、domain模块（存放实体类）、

core模块（存放业务类和持久层类）、admin模块（系统后台管理模块）、portal模块（门户模块）。

项目结构及其依赖关系如下：

创建父工程，父工程是用来管理子模块，不需要编写代码，可以把src的目录删除掉。

在父工程中创建子模块，有domain、core、admin（web工程）和portal（web工程）子模块。

创建后的项目结构

查看父工程的settings.gradle的配置类，里面定义了所有的子模块。

设置项目之间的依赖关系

core模块依赖 domain模块

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    // 依赖domain模块
    compile project(":tx_domain")
}

admin依赖core模块

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile project(":tx_core")
}

portal依赖 core 模块

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile project(":tx_core")
}

在父工程中管理所有的公共信息的配置，修改build.gradle的配置。

// 所有的项目统一进行属性管理，包括父工程
allprojects {
    // 组织名称
    group 'cn.tx'
    // 版本
    version '1.0-SNAPSHOT'
    // java插件
    apply plugin: 'java'
    // jdk编译版本
    sourceCompatibility = 1.8
    // 仓库
    repositories {
// 公司私服
maven {
    url " http://localhost:8079/nexus/content/groups/public/"
}
// 配置阿里云私服
maven {
    url "http://maven.aliyun.com/nexus/content/groups/public/"
}

        mavenCentral()
    }
}

// 子模块的配置，不包含父工程
subprojects {
    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
    }
}

删除掉其他子模块build.gradle重复的配置

在父工程或者子工程中引入坐标依赖

// 子模块的配置，不包含父工程
subprojects {
    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
        // 引入jar包
        compile group: 'com.alibaba', name: 'fastjson', version: '1.2.47'

    }
}

2.2. 项目发布

项目发布可以将咱们写好的模块发布给别人去使用,也可以发布到公司的公共仓库以供依赖的项目使用.

这是公司中多项目协同合作的重要环节。

在父工程的build.gradle中添加发布插件。

// 所有的项目统一进行属性管理，包括父工程
allprojects {
    // 组织名称
    group 'cn.tx'
    // 版本
    version '1.0-SNAPSHOT'
    // java插件
    apply plugin: 'java'
    // 发布插件
    apply plugin :'maven-publish'
    // jdk编译版本
    sourceCompatibility = 1.8
    // 仓库
    repositories {
        // 公司私服
        maven {
            url " http://localhost:8079/nexus/content/groups/public/"
        }
        // 配置阿里云私服
        maven {
            url "http://maven.aliyun.com/nexus/content/groups/public/"
        }
        // 从中央仓库下载依赖
        mavenCentral()
    }

    // 编写配置
    publishing {
        publications {
            // publishProject 为自定义名称,可写多个发布任务
            publishProject(MavenPublication){
                from components.java  // 发布 jar 包
                // from components.war  // 发布 war 包
            }
        }

        // 配置发布到哪里
        repositories {
            maven {
                //指定要上传的 maven 私服仓库
                url = "http://localhost:8079/nexus/content/repositories/snapshots/"
                //认证用户和密码
                credentials {
                    username 'admin'
                    password 'admin123'
                }
            }
        }
    }
}

// 子模块的配置，不包含父工程
subprojects {
    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
        // 引入jar包
        compile group: 'com.alibaba', name: 'fastjson', version: '1.2.47'
    }
}

generatePomFileForPublishProjectPublication : 生成 pom 文件

publish : 发布到 repositories 中指定的仓库(一般为 Maven 私服)

publishPublishProjectPublicationToMavenLocal : 执行 publishProject 指定操作到指定仓库

publishPublishProjectPublicationToRepository : 执行 publishProject 中的操作并发布到指定仓库(私服)

publishToMavenLocal : 执行所有发布任务中的操作发布到本地 maven 仓库

一般在公司就是将项目发布到私服供其他项目使用.直接操作 publish,发布到本地使用 publishToMavenLocal 即

可.

3. 嵌入式 tomcat 配置

配置tomcat

对于 JavaWeb 项目来说，web 容器是必不可少的，毕竟 JavaWeb 项目需要运行在 web 容器中，

接下来咱们就看下使用 Gradle 如何加入 web 容器。

gradle 使用嵌入式 Tomcat 部署 web 项目。

在 gradle 中,嵌入式 Tomcat 使用 gradle-tomcat-plugin

文档 : https://github.com/bmuschko/gradle-tomcat-plugin/blob/master/README.md

在tx_admin中的工程中，build.gradle中添加如下的配置代码。

// war包插件
apply plugin: 'war'

// 引入tomcat插件
apply plugin: "com.bmuschko.tomcat"

// 将二进制插件添加到 build.gradle
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "com.bmuschko:gradle-tomcat-plugin:2.5"
    }
}

dependencies {
    compile project(":tx_core")
    // https://mvnrepository.com/artifact/com.alibaba/fastjson
    compile group: 'com.alibaba', name: 'fastjson', version: '1.2.68'

    // 配置依赖 Tomcat 版本
    def tomcatVersion = '8.0.42'
    tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}",
            "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}",
            "org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}"
}

// tomcat配置
tomcat{
    httpPort = 8080
    contextPath = "/"
}

引入tomcat插件后，右侧显示出了tomcat插件运行的命令。

启动 Tomcat,运行项目：在 IDEA右边出现 4个任务按钮,如右

tomcatJasper : 调用 jsp 转化器,将 jsp 转为类并编译为 class 文件.

tomcatRun : 启动 tomcat 服务器部署项目.

tomcatRunWar : 启动 tomcat 服务器部署 war

tomcatStop : 关闭 tomcat 服务器.

编写一个servlet进行测试

加入servlet的依赖

providedCompile group: "javax.servlet",name: "javax.servlet-api",version: "3.1.0"

编写servlet，打开浏览器访问

package cn.tx.demo1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "Demo1Servlet",value = "/demo1")
public class Demo1Servlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("hello gradle");
        response.getWriter().println("hello gradle");
    }
}