• 用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 {

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> main(String[] args) {
    SpringApplication.run(Application.<span class="hljs-keyword">class</span>, args);
}

    

    }

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

    HelloWorldController:

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

    <span class="hljs-keyword">private</span> HelloWorld helloWorld;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">HelloController</span><span class="hljs-params">(HelloWorld helloWorld)</span> </span>{
    <span class="hljs-keyword">this</span>.helloWorld = helloWorld;
}

<span class="hljs-meta">@GetMapping</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">hello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> helloWorld.hello();
}

    

    }

    HelloWorld:

    @Component
public class HelloWorld {

    <span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">hello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"Hello World!"</span>;
}

    

    }

    此时工程的目录结构为：

    ├── 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 {

    <span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">hello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"Hello World!"</span>;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">anotherHello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">"Another Hello World!"</span>;
}

    

    }

    对应的HelloWorldController也变为：

    @RestController
public class HelloController {

    <span class="hljs-keyword">private</span> HelloWorld helloWorld;

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">HelloController</span><span class="hljs-params">(HelloWorld helloWorld)</span> </span>{
    <span class="hljs-keyword">this</span>.helloWorld = helloWorld;
}

<span class="hljs-meta">@GetMapping</span>(<span class="hljs-string">"/helloworld"</span>)
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">hello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> helloWorld.hello();
}


<span class="hljs-meta">@GetMapping</span>(<span class="hljs-string">"/anotherHelloworld"</span>)
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">anotherHello</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> helloWorld.anotherHello();
}

    

    }

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

    此时单元测试覆盖率为：

    单元测试覆盖率

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

    API测试覆盖率

    总体测试覆盖率为：

    总体测试覆盖率

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

    使用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插件对代码风格/格式做了静态检查。
  • 相关阅读:
    用C#实现DES加密解密解决URL参数明文的问题
    C#数据集合分页处理
    图像处理中的hard negative mining（难例挖掘）
    目标检测最近
    Object Detection(目标检测神文)
    ssm框架整合基本步骤练习总结
    Android 数据存储之 SQLite数据库存储
    android内部存储与外部存储理解
    Android数据存储之SharePreference和内部存储
    AlertDialog和自定义对话框
  • 原文地址：https://www.cnblogs.com/edda/p/12766331.html
Copyright © 2020-2023  润新知