構建工具gradle教程

目錄：

1、項目自動化
2、安裝Gradle
3、groovy介紹
4、新建一個gradle工程，打包成jar，運行其中的類的main()方法
5、構建腳本和自定義任務
6、gradle開發web工程
7、多項目構建

1、項目自動化    <--返回目錄

　　構建工具的作用：依賴管理，測試、打包、發布

　　主流構建工具：1）Ant 編譯、測試、打包  2）Maven 依賴管理、發布  3）Gradle

　　Gradle是什么：一個開源的項目自動化構建工具，建立在Apach Ant和Apache Maven概念的基礎上，並引入了基於Groovy的特定領域語言(DSL)，而不再使用XML形式管理構建腳本。

 

2、安裝Gradle    <--返回目錄

　　確保已經安裝JDK，java -version

　　從Gradle官網（https://gradle.org）下載壓縮包，解壓

　　配置環境變量 GRADLE_HOME，添加到path  %GRADLE_HOME%\bin

　　驗證是否安裝成功 gradle -v

 

3、groovy介紹    <--返回目錄

　　groovy是用於Java虛擬機的一種敏捷的動態語言，它是一種成熟的面向對象編程語言，既可以用於面向對象編程，又可以用作純粹的腳本語言。使用這種語言不必編寫過多的代碼，同時又具有閉包和動態語言中的其他特性。

　　與Java比較

1）groovy完全兼容java的語法
2）分號是可選的
3）類、方法默認是public
4）編譯器給屬性自動添加getter/setter方法
5）屬性可以直接用點號獲取
6）最后一個表達式的值會被作為返回值

　　使用 IDEA 的 Tools -> Groovy Console 測試 groovy的簡單用法

　　新建一個Project，選擇gradle工程

　　默認的gradle工程結構

 

　　選擇菜單 Tools -> Groovy Console作為環境進行測試

　　groovy 語法相對 java 的一些區別

public class User { // 類、方法默認是public，類的修飾 public 可以省略
    private Integer id;
    private String name // 分號是可選的
    public User(Integer id, String name) { // 類、方法默認是public，方法上 public 可以省略
        this.id = id;
        this.name = name;
    }
    String getUserInfo() {
        //return "id:" + id + ", name:" + name;
        //最后一個表達式的值會被作為返回值，return可以省略
        // gradle 中字符串可以使用單引號，雙引號，三單引號, 三雙引號
        //'d:' + id + ', name:' + name // 單引號
        //"id:" + id + ", name:" + name // 雙引號
        //"id:${this.id}, name: ${this.name}" // 雙引號，使用變量
        """// 三雙引號，使用變量
            id:${this.id}
            name: ${this.name}
        """
    }
    // 編譯器給屬性自動添加getter/setter方法
}
User u = new User(1, "xxx");
// 屬性可以直接用點號獲取
println u.id
println u.name

def info = u.getUserInfo()
println info

　　groovy 的一些特定用法

// 1 可選的類型定義
def version = 1

// 2 assert
assert version == 1

// 3 括號是可選的
println version

// 4 字符串
def s1 = 'zs'
def s2 = "${s1} good good study"
def s3 =
'''好好學習
天天向上
'''
def s4 =
"""${s1}
好好學習
天天向上
"""
println s1
println s2
println s3
println s4

// 5 集合api
// list
def list = ['a', 'b']
list << 'c' // 追加
assert list.getClass() == ArrayList // 對應的Java類型是ArrayList

// map
def map = ['key1': 10, 'key2': 'val2']
map.key3 = 30 // 添加
println map
println map.getClass() // class java.util.LinkedHashMap

　　閉包

// 定義一個閉包，包含參數
def c1 = {
    v ->
        println v
}
// // 定義一個閉包，不含參數
def c2 = {
    println 'hello'
}
// 將閉包作為方法參數
def fun1(Closure closure) {
    closure('param')
}
def fun2(Closure closure) {
    closure()
}
fun1(c1)
fun2(c2)

 

4、新建一個gradle工程，打包成jar，運行其中的類的main()方法    <--返回目錄

　　新建一個Project，選擇gradle工程

　　默認的gradle工程結構

　　執行gradle的jar任務

　　生成的jar的位置

　　

4.1、運行 com.oy.App#main()方式一

　　App類很簡單，不過使用了一些第三方包 commons-lang3 等來測試運行 main() 方法時如何加載第三方包

public class App {
    public static void main(String[] args) {
        String s = "hello gradle";
        System.out.println(s);
        System.out.println(StringUtils.capitalize(s));
        System.out.println(System.getProperty("java.ext.dirs"));
    }
}

 

　　打開cmd（powshell不行？），執行 java -Djava.ext.dirs=.;./lib com.oy.App   ，其中-D用來添加系統變量，java.ext.dir 指定外部掛載的jar，com.oy.App時包含main()方法的類名

 

4.2、運行 com.oy.App#main()方式二：gradle構建可執行jar

　　在build.gradle中添加

jar {
    manifest {
        attributes 'Main-Class': 'com.oy.App'
        // 添加所有依賴，用空格隔開
        attributes 'Class-Path': 'lib/commons-lang3-3.12.0.jar lib/commons-collections4-4.1.jar'
    }
}

　　生成的 gradle-demo01-1.0-SNAPSHOT.jar 的 META-INF/MANIFEST.MF 文件的內容

Manifest-Version: 1.0
Class-Path: lib/commons-lang3-3.12.0.jar
Main-Clas: com.oy.App

　　執行 java -jar gradle-demo01-1.0-SNAPSHOT.jar

 

5、構建腳本和自定義任務    <--返回目錄

5.1、構建腳本介紹

　　構建塊：gradle構建中的兩個基本概念是項目（project）和任務（task），每個構建至少包含一個項目，項目中包含一個或多個任務。在多項目構建中，一個項目可以依賴於其他項目，類似的，任務可以形成一個依賴關系圖來確保他們的執行順序。

 

　　項目project：一個項目代表一個正在構建的組件（比如一個jar文件），當構建啟動后，gradle會基於build.gradle實例化一個org.gradle.api.Project類，並且能夠通過project變量使其隱式可用。

　　項目project的屬性：group、name、version，

　　項目project的方法：apply、dependencies、repositories、task

　　屬性的其他配置方式：ext、gradle.properties

 

　　任務task: 任務對應org.gradle.api.Task。主要包括任務動作和任務依賴。任務動作定義了一個最小的工作單元。可以定義依賴於其他任務、動作序列和執行條件。

 　　任務task：dependsOn 依賴的任務

　　　　　　　doFirst 在動作列表的最前添加動作、doLast（<<）在動作列表最后添加動作

5.2、自定義任務

def createDir = {
    path ->
        File dir = new File(path)
        if (!dir.exists()) {
            dir.mkdirs()
        }
}
task makeJavaDir() {
    def paths = ['src/main/java', 'src/main/resources', 'src/test/java', 'src/test/resources']
    doFirst {
        paths.forEach(createDir)
    }
}

task makeWebDir() {
    // 依賴 makeJavaDir 這個任務
    dependsOn 'makeJavaDir'
    def paths = ['src/main/webapp']
    doLast {
        paths.forEach(createDir)
    }
}

5.3、構建生命周期

　　初始化 -> 配置 -> 執行

// 配置
task loadVersion {
    // 修改project的version
    project.version = '1.0'
}
// 執行
task loadVersion << {
    print 'success'
}

5.4、依賴管理

// 當有依賴沖突是，gradle默認會幫我們解決，使用沖突的jar的最高版本
// 修改為：依賴沖突時，直接構建失敗
configuration.all {
    resolutionStrategy {
        failOnVersionConflict()
    }
}

// 解決依賴沖突辦法一：排除依賴
compile('org.hibernate:hibernate-core:3.6.3.Final') {
    exclude group: "org.slf4j", module: "slf4j-api"
}

// 解決依賴沖突辦法二：強制指定一個版本
configuration.all {
    resolutionStrategy {
        force 'org.slf4j:slf4j-api:1.7.24'
    }
}

5.5、自動化測試

 　　測試發現：哪些類會被 gradle 的 "build" 發現為測試用例

1）任何繼承自 junit.framework.TestCase或groovy.util.GroovyTestCase的類
2）任何被@RunWith注解的類
3）任何至少包含一個被@Test注解的類

5.6、發布

apply plugin: 'maven-publish'
publishing {
    publications {
        myPublish(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {
            name "myRepo"
            url "maven私服地址"
        }
    }
}

 

6、gradle開發web工程    <--返回目錄

　　使用 'war'插件

  　　build.gradle

plugins {
    id 'java'
    id 'war'
}

group 'org.example'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenLocal()       // 使用本地maven倉庫
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
    mavenCentral()     // 使用maven中心倉庫
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile group: 'org.springframework', name: 'spring-context', version: '5.0.2.RELEASE'
    compile group: 'org.springframework', name: 'spring-web', version: '5.0.2.RELEASE'
    compile group: 'org.springframework', name: 'spring-webmvc', version: '5.0.2.RELEASE'
    compileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: '3.0.1'
    compileOnly group: 'javax.servlet', name: 'jsp-api', version: '2.0'
}

　　web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         id="oy" version="2.5">
    <display-name>project-manager</display-name>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>

    <!-- 初始化spring容器 -->
<!--    <context-param>-->
<!--        <param-name>contextConfigLocation</param-name>-->
<!--        <param-value>classpath:springmvc.xml</param-value>-->
<!--    </context-param>-->
<!--    <listener>-->
<!--        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>-->
<!--    </listener>-->

    <!-- 解決post亂碼 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- springmvc的前端控制器 -->
    <servlet>
        <servlet-name>project-manager</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- contextConfigLocation不是必須的， 如果不配置contextConfigLocation，
             springmvc的配置文件默認在：WEB-INF/servlet的name+"-servlet.xml" -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>project-manager</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

　　IDEA配置local server

 

　　啟動后服務：http://localhost:8001/hello/test , 因為配置的server context為"/" ，8001后面就沒有服務名稱

　　查看關聯的本地tomcat/webapps，上面服務發布路徑就為ROOT

 

 7、多項目構建    <--返回目錄

　　項目模塊化：在企業項目中，包層次和類關系比較復雜，把代碼拆分成模塊通常是最佳實踐，這需要你清晰的划分功能的邊界，比如把業務邏輯和數據持久化拆分開來。項目符合高內聚低耦合時，模塊化就變得很容易，這是一條非常好的軟件開發實踐。

　　測試項目結構

　　父工程下的build.gradle

subprojects {
    group 'org.example'
    version '1.0-SNAPSHOT'

    repositories {
        mavenLocal()       // 使用本地maven倉庫
        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
        mavenCentral()     // 使用maven中心倉庫
    }
}

　　settings.gradle

rootProject.name = 'parent'
include 'dao'
include 'service'
include 'web'

　　web模塊

 　　web模塊下的build.gradle

plugins {
    id 'java'
    id 'war'
}
sourceCompatibility = 1.8

dependencies {
    compile project(":service")
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile group: 'org.springframework', name: 'spring-context', version: '5.0.2.RELEASE'
    compile group: 'org.springframework', name: 'spring-web', version: '5.0.2.RELEASE'
    compile group: 'org.springframework', name: 'spring-webmvc', version: '5.0.2.RELEASE'
    compileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: '3.0.1'
    compileOnly group: 'javax.servlet', name: 'jsp-api', version: '2.0'
}

　　service模塊下的build.gradle

plugins {
    id 'java'
}
sourceCompatibility = 1.8

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

　　dao模塊下的build.gradle

plugins {
    id 'java'
}
sourceCompatibility = 1.8

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

　　同前面一樣配置local server

 

 　　查看關聯的本地tomcat/webapps，上面服務發布路徑就為ROOT，查看 WEB-INF/lib即為web工程所有的依賴，可以看到server模塊和dao模塊都被添加進來了

 

參考：

　　1）Gradle構建可執行Jar包