用Gradle构建Spring Boot项目

相比起Maven的XML配置方式，Gradle提供了一套简明的DSL用于构建Java项目，使我们就像编写程序一样编写项目构建脚本。本文将从无到有创建一个用Gradle构建的Spring Boot项目，并在此过程中讲到Gradle的一些典型用法。

本文Github代码：https://github.com/davenkin/gradle-spring-boot.git

---

#创建Gradle工程 Gradle采用了与Maven相同的目录组织结构，你可以通过Spring Initializr网站创建Spring Boot工程。但是在本文中，我们将全部通过命令行操作创建Spring Boot工程。首先在命令行中创建如下目录结构：

└── src
    ├── main
    │   └── java
    └── test
        └── java

然后在src同级目录中添加一个build.gradle文件，内容如下：

apply plugin: 'java'

大功告成，一个用Gradle构建的Java项目创建好了，尽情用以下命令编译并打包咱们的Java项目吧：

gradle build

只是现在咱们的Java项目还是一个空架子，不用急，在下文中我们将一步一步在这个空架子中搭建一个有血有肉的Spring Boot项目。

值得一提的是，虽然此时的build.gradle文件中只有一行配置（apply plugin: 'java'，作用是引入java插件），但是其背后已经帮我们做了很多事情，比如它使得我们能够运行gradle build命令。这里的build即为Gradle中的一个任务（Task），我们还可以运行以下命令查看到更多的Task。

gradle tasks

此时输出：

...
Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
classes - Assembles main classes.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles test classes.
...

这里的assemble、build和jar等Task都是java插件引入的。build.gradle是Gradle的配置文件，更多关于Gradle的知识请参考笔者的Gradle学习系列文章。

---

#使用Gradle Wrapper 对于所有的Gradle项目来说，笔者都推荐使用Gradle Wrapper，甚至应该将其当做创建代码库之后的第一件事来做。使用Gradle Wrapper有以下好处：

1. 不用安装gradle也能运行gradle
2. 所有人使用相同的gradle版本

在build.gradle中加入以下配置：

task wrapper(type: Wrapper) {
    gradleVersion = '3.0'
}

然后在命令行运行：

gradle wrapper

此时会生成以下三个文件（夹）：gradlew、gradlew.bat和gradle目录。

这里的gradlew和gradlew.bat其实只是脚本文件（前者用于Unix/Linux/Mac，后者用于Windows），在使用gradle命令的地方替换为gradlew或gradlew.bat，他们将自动下载指定的gradle版本，然后用该版本进行项目构建。如上文所示，本文中我们配置gradle版本为3.0。

请注意，这三个文件（夹）都需要提交到代码库中。当项目其他人拿到代码之后，由于gradlew和gradlew.bat文件均在源代码中，他们本地即便没有gradle，依然可以通过以下命令进行项目构建：

./gradlew build

如果你的项目有持续集成（CI）服务器（你也应该有），那么你的CI机器也没有必要安装Gradle了。另外，此时所有人都是使用的相同版本的gradle，进而避免了由于版本不同所带来的问题。

---

#添加Spring Boot依赖 在本文中，我们的业务非常简单———输出“Hello World！”。但是麻雀虽小，五脏俱全，首先需要在build.gradle中配置spring-boot插件，并引入Spring的Web组件，整个build.gradle如下：

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.2.RELEASE")
    }
}

repositories {
    jcenter()
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'


sourceCompatibility = 1.8
targetCompatibility = 1.8


task wrapper(type: Wrapper) {
    gradleVersion = '3.0'
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

然后创建Application类：

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

依然很简单，是吧？！这个Application类便是Spring Boot程序的入口。另外我们还需要一个Controller和一个业务类HelloWorld：

HelloWorldController:

@RestController("/helloworld")
public class HelloController {

    private HelloWorld helloWorld;

    public HelloController(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    @GetMapping
    public String hello() {
        return helloWorld.hello();
    }
}

HelloWorld:

@Component
public class HelloWorld {

    public String hello() {
        return "Hello World!";
    }
}

此时工程的目录结构为：

├── README.md
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── src
    ├── main
    │   └── java
    │       └── davenkin
    │           ├── Application.java
    │           ├── HelloController.java
    │           └── HelloWorld.java
    └── test
        └── java

然后运行：

./gradlew bootRun

在浏览器或者Postman中打开http://localhost:8080/gradle-spring-boot/helloworld，便可以看到久违的"Hello World！"了。

---

#生成IDE工程文件 我曾经看到不少人在Eclipse或者IntelliJ IDEA中导入Maven/Gradle工程，甚至在IDE中使用嵌入Tomcat容器。我并不推荐这么做，这些严重依赖于GUI操作的功能其实是很笨拙、很脆弱的。以嵌入Tomcat容器为例，它要求项目中所有人都在自己的IDE中手动地对Tomcat进行配置，而手动的过程总是容易出错的。在持续交付中有个原则是“凡是能够自动化的，都应该自动化”，这里的自动化说白了其实就是代码化。

因此，在使用Gradle时，笔者更推崇的一种方式是通过Gradle的IDE插件一键式地生成IDE工程文件，然后在IDE中直接打开这样的工程文件。这样的好处一是非常简单，二是所有人都使用了相同的IDE配置。

在Gradle中配置IntelliJ IDEA插件，只需在build.gradle中配置：

    apply plugin: 'idea'

然后运行：

./gradlew idea

此时将生成后缀为ipr的IntelliJ IDEA工程文件，在IntelliJ IDEA中直接打开(Open)该文件即可。

对于Eclipse，在build.gradle中增加以下配置：

    apply plugin: 'eclipse'

然后运行：

./gradlew eclipse

此时将生成Eclipse的.project工程文件。

请注意，所有IDE工程文件都不应该提交到代码库，对于Git来说应该将这些文件注册到.gitignore文件中。各个开发者拿到代码后需要各自运行./graldlw idea或./gradlew eclipse命令以生成本地工程文件。

---

#调试 至少有两种方式可以对Spring Boot项目进行调试。一种是直接运行命令：

./gradlew bootRun --debug-jvm

此时程序将默认监听5005端口，并暂停以等待调试客户端的连接，然后启动Spring Boot。

另一种方式是使用Gradle的Application插件，在build.gradle中添加：

apply plugin: 'application'
applicationDefaultJvmArgs = [ "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005" ]

此时运行：

./gradlew bootRun

程序将启动并监听5005调试端口，但是与第一种方法不同的是，程序不会暂停，而是将直接启动整个Spring Boot程序。如果你想调试Spring Boot在启动过程中的某些代码，比如Spring框架启动代码，那么请选择第一种方式；否则，第二种是更合适的选择，因为我们并不是每次启动程序都一定会调试的，对吧？！

---

#自动化测试 软件项目可以包含多种自动化测试，比如单元测试、集成测试、功能测试等。对于Spring Boot项目来说，笔者推荐将自动化测试划分为单元测试和API测试，其中单元测试即是传统的单元测试，而API测试包含了集成测试、功能测试和端到端测试的功能，它的测试对象是程序向外暴露的REST API接口，在测试时我们需要启动整个Spring Boot程序，然后模拟客户端调用这些API接口来完成业务测试用例。

单元测试相对比较简单，Spring Boot也提供了一些有助于单元测试的设施，但是我并不推荐大家使用，因为单元测试应该是非常纯粹、粒度非常小的测试，不应该有框架掺和。

通常来说，单元测试和API测试应该是分离的，也即他们的代码应该是分开的，运行测试的命令也应该是不同的。但是这给Gradle带来了难题，因为默认情况下Gradle只提供一个*./gradlew test命令用于测试，并且默认要求测试代码位于src/test/java*目录下。为此，我们需要对Gradle进行改造。

我们的目的是：

• 默认的src/test/java目录用于单元测试代码，通过*./gradlew test*运行
• 新建src/apiTest/java目录用于API测试代码，通过*./gradlew apiTest*运行

可以看到，我么将Gradle默认的测试设施用于了单元测试，也即对于单元测试我们不需要做任何改变。对于API测试而言，首先我们需要添加名为apiTest的源代码集合（SrouceSet），该SourceSet即对应了src/apiTest/java目录，在build.gradle文件中增加如下配置：

sourceSets {
    apiTest {
        compileClasspath += main.output + test.output
        runtimeClasspath += main.output + test.output
    }
}

configurations {
    apiTestCompile.extendsFrom testCompile
    apiTestRuntime.extendsFrom testRuntime
}

然后，添加一个Test类型的Task用于运行src/apiTest/java目录下的API测试代码：

task apiTest(type: Test) {
    testClassesDir = sourceSets.apiTest.output.classesDir
    classpath = sourceSets.apiTest.runtimeClasspath
}

为了使Intelli IDEA能够感知到这些新添加的测试代码，我们需要对Gradle的idea插件进行额外配置：

idea {
    module {
        testSourceDirs += file('src/apiTest/java')
        testSourceDirs += file('src/apiTest/resources')
        scopes.TEST.plus += [configurations.apiTestCompile]
        scopes.TEST.plus += [configurations.apiTestRuntime]
    }
}

另外，为了使本地构建（./gradlew biuld）过程能够先运行单元测试，再运行API测试，我们还需要做以下配置：

apiTest.mustRunAfter test
build.dependsOn apiTest

第一行的意思是API测试必须运行在单元测试之后，第二行的意思是将API测试包含在build任务中。

---

#使用JaCoCo JaCoCo是一款代码测试覆盖率统计工具，我们主要将其用于统计单元测试的覆盖率。在build.gradle中增加配置：

apply plugin: "jacoco"

此时运行*./gradlew build之后，JaCoCo将在build/jacoco*目录下为单元测试和API测试分别生成原始数据文件（test.exec和apiTest.exec），但是此时并没有测试报告生成，为此，我们还需要单独运行：

./gradlew jacocoTestReport

在浏览器中打开build/report/jacoco/test/index.html，你将看到单元测试覆盖率报告：

但是，此时的覆盖率报告只是针对单元测试的，为了得到API测试的覆盖率，我们需要添加一个新的Task：

task jacocoApiTestReport(type: JacocoReport){
    sourceSets sourceSets.main
    executionData apiTest
}

然后运行：

./gradlew jacocoApiTestReport

在浏览器中打开build/report/jacoco/jacocoApiTestReport/index.html，你将看到单元测试覆盖率报告。

有时，我们希望看到单元测试和API测试的整体覆盖率，此时我们需要再添加一个Task：

//Unit Test and API Test Code coverage all together
task jacocoAllTestReport(type: JacocoReport){
    sourceSets sourceSets.main
    executionData test, apiTest
}

然后运行：

./gradlew jacocoAllTestReport

在浏览器中打开build/report/jacoco/jacocoAllTestReport/index.html，你将看到所有测试整合后的覆盖率报告。

作为演示，我们在HelloWorld中添加一个新的anotherHello()方法，此时HelloWorld为：

@Component
public class HelloWorld {

    public String hello() {
        return "Hello World!";
    }

    public String anotherHello() {
        return "Another Hello World!";
    }
}

对应的HelloWorldController也变为：

@RestController
public class HelloController {

    private HelloWorld helloWorld;

    public HelloController(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    @GetMapping("/helloworld")
    public String hello() {
        return helloWorld.hello();
    }


    @GetMapping("/anotherHelloworld")
    public String anotherHello() {
        return helloWorld.anotherHello();
    }
}

然后，我们让HelloWorld的单元测试只测试hello()方法，让API测试只测试anotherHello()方法（也即只调用“anotherHelloworld”的URL接口）。

此时单元测试覆盖率为：

可以看到，anohterHello()方法没有被单元测试覆盖到。而集成测试虽然覆盖到了anotherHello()方法，却没有覆盖到hello()方法：

总体测试覆盖率为：

此时，总体测试覆盖率同时统计了单元测试和集成测试的覆盖率。

---

#使用Checkstyle CheckStyle是一种静态代码检查工具，主要用于检查代码风格或格式是否满足要求。首先，我们需要一份配置文件来配置这样的要求，这里我们采用Google的Checkstyle配置文件。

在biuld.gradle中增加checkstyle插件：

apply plugin: 'checkstyle'

下载Google的checkstyle文件并将其拷贝为config/checkstyle/checkstyle.xml，Gradle的checkstyle插件默认将读取该配置文件。CheckStyle检查将包含在*./gradlew build*中。注：在笔者电脑上，使用Google原始Checkstyle配置文件总是报错，对Checkstyle进行了一些精简之后运行成功。

---

#总结 在本文中，我们从无到有创建了一个使用Gradle构建的Spring Boot项目，包括了对项目的编译打包、运行单元测试和API测试，并且获得测试覆盖率报告。另外，我们提倡使用Gradle的idea/eclipse插件生成IDE工程文件，最后我们使用Checkstyle插件对代码风格/格式做了静态检查。