1 SpringBoot 开发起步

1.1 概述

  • 如果要进行 SpringBoot 项目的开发肯定需要构建工具 Maven 或 Gradle ，本次使用 Gradle 作为构建工具。
  • 开发环境：
    • JDK 1.8 。
    • IDEA 2021+ 。
    • Gradle 6.5+ 。

1.2 构建 SpringBoot 应用

1.2.1 IDEA 工具创建 Gradle 项目

  • 基于 IDEA 创建一个 Gradle 项目，这个Gradle 项目所选择的类型是 Java 。

1.png

2.png

  • 随后要输入要创建的项目名称，本次的项目主要是进行了一个最简单的单实例应用，那么可以随意输入一个项目名称：firstboot 。

3.png

1..2.2 修改 Gradle Wrapper 的版本

  • 程序执行命令：
  1. gradle wrapper --gradle-version 6.5
  • 程序执行结果：

4.png

5.png

6.png

1.2.3 firstboot 项目

  • 本次由于只是一个基础的环境，所以只需要修改 build.gradle 配置文件即可：
  1. plugins {
  2.     id 'java' // Java 插件
  3. }
  5. group 'com.github.fairy.era' // 组织名称
  6. version '1.0' // 版本号
  8. sourceCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  9. targetCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  11. repositories { // 仓库配置
  12.     maven { // 阿里云的 Maven 仓库
  13.         url 'https://maven.aliyun.com/repository/public/'
  14.     }
  15.     mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  16. }
  18. dependencies { // 依赖配置
  19.     /* junit 5 */
  20.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.8.2'
  21.     /* spring-boot-starter-web */
  22.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.4.3'
  23. }
  25. test {
  26.     useJUnitPlatform()
  27. }

1.3 SpringBoot 应用

1.3.1 概述

  • SpringBoot（spring-boot-starter-web） 本质上就属于一个加强版的 SpringMVC，我们在 SpringMVC 中如何编写代码的，那么在 SpringBoot 中也可以直接进行代码的编写。

1.3.2 启动类

  1. package com.github.fairy.era;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. /**
  7.  * 启动类
  8.  *
  9.  * @author 许大仙
  10.  * @version 1.0
  11.  * @since 2021-12-31 09:14
  12.  */
  13. @SpringBootApplication 
  14. public class Application {
  15.     public static void main(String[] args) {
  16.         SpringApplication.run(Application.class, args);
  17.     }
  18. }

1.3.3 Handler 类

  1. package com.github.fairy.era.web;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. /**
  7.  * @author 许大仙
  8.  * @version 1.0
  9.  * @since 2021-12-31 09:22
  10.  */
  11. @RestController
  12. public class DemoHandler {
  14.     @GetMapping(value = "/demo")
  15.     public String demo() {
  16.         return "你好啊，SpringBoot";
  17.     }
  18. }

1.3.4 启动 SpringBoot 项目

  • 启动 SpringBoot 项目：

7.gif

  • 实际上这个时候在项目启动之后就会出现 一些 WEB 容器的信息（此时没有将项目 部署到 WEB 容器中，因为 SpringBoot 内置了 WEB 容器，所以也是可以直接启动的）： | 描述 | 信息 | | —- | —- | | 获取程序信息 | Starting Application using Java 1.8.0_131 on xxx with PID 21700 | | 自动加载 profile | No active profile set, falling back to default profiles: default | | Tomcat 启动 | Tomcat initialized with port(s): 8080 (http) | | 服务正常启动 | Starting service [Tomcat] | | 启动 Servlet 引擎 | Starting Servlet engine: [Apache Tomcat/9.0.43] | | 初始化 Spring 内置的 WEB 容器 | Initializing Spring embedded WebApplicationContext | | 根容器启动耗时 | Root WebApplicationContext: initialization completed in 519 ms | | 初始化线程池 | Initializing ExecutorService ‘applicationTaskExecutor’ | | ContextPath | Tomcat started on port(s): 8080 (http) with context path ‘’ | | JVM 初始化耗时 | Started Application in 0.977 seconds (JVM running for 1.417) |
  • 随着后续项目不断的引入更多的组件，那么以上的信息一定会做出变更。

1.3.5 访问

8.png

1.3.6 总结

  • 在传统的 SpringMVC 的时代里面，如果要想实现与之完全相同的输出操作效果，也是可以实现的，但是所付出的代码就是繁琐的配置以及一系列配置文件的定义。
  • 如果使用 SpringBoot 进行开发，那么这些繁琐的配置以及一系列配置文件的定义就彻底的消失了。

1.4 SpringBoot 注解分析

1.4.1 概述

  • 现在经过了自己的不断努力已经成功的实现了第一个 SpringBoot 应用程序，这样肯定是好事，如果我们连程序都没搞起来又谈何深入呢？首先对于当前的程序代码需要对其注解的作用进行说明。

1.4.2 注解说明

  • 示例：获取之前的代码
  1. package com.github.fairy.era;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. /**
  7.  * 启动类
  8.  *
  9.  * @author 许大仙
  10.  * @version 1.0
  11.  * @since 2021-12-31 09:14
  12.  */
  13. @SpringBootApplication
  14. public class Application {
  15.     public static void main(String[] args) {
  16.         SpringApplication.run(Application.class, args);
  17.     }
  18. }
  1. package com.github.fairy.era.web;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. /**
  7.  * @author 许大仙
  8.  * @version 1.0
  9.  * @since 2021-12-31 09:22
  10.  */
  11. @RestController
  12. public class DemoHandler {
  14.     @GetMapping(value = "/demo")
  15.     public String demo() {
  16.         return "你好啊，SpringBoot";
  17.     }
  18. }
  • 在以上的程序之中存在如下的注解，具体的作用进行分析：
  • 【SpringMVC 提供】：@RestController 相当于 @Controller + @ResponseBody。
    • @Controller 注解内部包含了一个 @Component 注解，是在进行包扫描处理的时候用于实现控制层处理类定义的（疑问？我们并没有配置包扫描，那么 Handler 类是怎么装配进 Spring 容器的？因为 SpringBoot 采用的设计思想是 “零配置”）
    • @ResponseBody 直接进行对象的响应（在 SpringMVC 里面默认采用的转换组件为 Jackson）。
  • 【SpringMVC 提供】：@GetMapping 可以在类上定义父路径，也可以在方法上定义子路径。
  • 【SpringBoot 提供】：@SpringBootApplication 相当于 @SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan。
    • @SpringBootConfiguration 表明这是一个配置类。
    • @EnableAutoConfiguration 开启自动配置。
    • @ComponentScan组件扫描。

2 Gradle 构建管理

2.1 Spring Boot Gradle 插件参考指南

2.2 dependency-management 插件

2.2.1 概述

  • 对于当前的项目来说，是基于 Gradle 实现的程序开发，那么既然要基于 Gradle 实现程序开发，就必须去熟悉 Gradle 对 SpringBoot 项目的支持，打开 build.gradle 配置文件，此时的配置文件的内容如下：
  1. plugins {
  2.     id 'java' // Java 插件
  3. }
  5. group 'com.github.fairy.era' // 组织名称
  6. version '1.0' // 版本号
  8. sourceCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  9. targetCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  11. repositories { // 仓库配置
  12.     maven { // 阿里云的 Maven 仓库
  13.         url 'https://maven.aliyun.com/repository/public/'
  14.     }
  15.     mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  16. }
  18. dependencies { // 依赖配置
  19.     /* junit 5 */
  20.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.8.2'
  21.     /* spring-boot-starter-web */
  22.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.4.3'
  23. }
  25. test {
  26.     useJUnitPlatform()
  27. }
  • 如果按照构建工具的标准配置来讲，此时的配置是不合理的，原因就在于应该将版本号编写在依赖库的引入之外，这样如果有需要就可以直接修改版本号而实现版本的更新。
  • 可以考虑基于 Groovy 实现一个版本的变量定义，修改 build.gradle 配置文件：
  1. // 修改内容如下所示
  3. def springBootStarterWebVersion = '2.4.3' // 版本变量的定义
  4. def junitJupiterVersion = '5.8.2' // 版本变量的定义
  6. dependencies { // 依赖配置
  7.     /* junit 5 */
  8.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: "$junitJupiterVersion" // 版本变量的引用
  9.     /* spring-boot-starter-web */
  10.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "$springBootStarterWebVersion" // 版本变量的引用
  11. }
  13. test {
  14.     useJUnitPlatform()
  15. }
  • 但是如果采用的是此类的配置方式就会存在有一个比较麻烦的问题，因为在 SpringBoot 里面要引入的相关的 starters 依赖库是非常多的（SpringBoot 官方文档告诉我们的），就可能导致该变量被引用无数次，这样的项目结构管理就有些重复了。

9.png

  • 如果要想解决这个重复的 spring-boot-starter-xxx 依赖库的版本配置问题，那么最佳的做法就考虑引入 dependency-management 插件。

2.2.2 Maven 仓库

  • 通过 Maven 的中央仓库查询插件的当前版本号：
  1. implementation group: 'io.spring.dependency-management', name: 'io.spring.dependency-management.gradle.plugin', version: '1.0.11.RELEASE', ext: 'pom'

2.2.3 项目配置插件

  • 修改 build.gradle 配置文件，设置插件的引用：
  1. plugins {
  2.     id 'java' // Java 插件
  3.     id 'org.springframework.boot' version '2.4.3' // 将版本编号配置在插件内部
  4.     id 'io.spring.dependency-management' version '1.0.11.RELEASE' // 由此插件负责版本号的维护
  5. }
  • 修改 build.gradle 配置文件，将 SpringBoot 的 starter 的 version 删除：
  1. dependencies { // 依赖配置
  2.     /* junit 5 */
  3.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.8.2'
  4.     /* spring-boot-starter-web */
  5.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'
  6. }
  • 完整的 build.gradle 配置文件内容如下：
  1. plugins {
  2.     id 'java' // Java 插件
  3.     id 'org.springframework.boot' version '2.4.3' // 将版本编号配置在插件内部
  4.     id 'io.spring.dependency-management' version '1.0.11.RELEASE' // 由此插件负责版本号的维护
  5. }
  7. group 'com.github.fairy.era' // 组织名称
  8. version '1.0' // 版本号
  10. sourceCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  11. targetCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  13. repositories { // 仓库配置
  14.     maven { // 阿里云的 Maven 仓库
  15.         url 'https://maven.aliyun.com/repository/public/'
  16.     }
  17.     mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  18. }
  20. dependencies { // 依赖配置
  21.     /* junit 5 */
  22.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.8.2'
  23.     /* spring-boot-starter-web */
  24.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'
  25. }
  27. test {
  28.     useJUnitPlatform()
  29. }
  • 此时没有在项目之中引入依赖库的位置上继续进行版本号的定义，而是在顶部将所有的版本号都固定好了。

2.3 spring-boot-gradle-plugin（旧式写法）

  • 对于当前的项目来说，即使不使用 spring-boot-gradle-plugin 也是可以实现 SpringBoot 项目的开发，当 Gradle 项目中引入了如下的插件之后：
  1. plugins {
  2.     ...
  3.     id 'io.spring.dependency-management' version '1.0.11.RELEASE' // 由此插件负责版本号的维护
  4. }
  • 实际上 Gradle 里面就会增加一些任务了：

10.png

  • 此时存在有了一个 bootRun 任务，这个任务就是让当前的项目以 SpringBoot 的方式运行。
  • 程序执行命令：
  1. gradle bootRun
  • 程序运行结果：

11.png

  • 也可以使用 Gradle 旧式的写法来进行 SpringBoot 项目依赖的锁定，那么此时就可以考虑通过一个专属的插件 spring-boot-gradle-plugin 来完成，修改 build.gradle 配置文件：
  1. buildscript { // 定义脚本使用资源
  2.     repositories { // 脚本资源仓库
  3.         maven {
  4.             url 'https://maven.aliyun.com/repository/gradle-plugin'
  5.         }
  6.     }
  7.     dependencies { // 依赖管理
  8.         classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.4.3'
  9.     }
  10. }
  12. plugins {
  13.     id 'java' // Java 插件
  14. //    id 'org.springframework.boot' version '2.4.3' // 将版本编号配置在插件内部
  15. //    id 'io.spring.dependency-management' version '1.0.11.RELEASE' // 由此插件负责版本号的维护
  16. }
  18. apply plugin: 'org.springframework.boot' // 引用之前的两个插件
  19. apply plugin: 'io.spring.dependency-management' // 引用之前的两个插件

注意：此时你会感到疑惑 plugins 和 buildscript + apply plugin ？

  • ① plugins 是后来添加的特性，换言之，buildscript + apply plugin 是早期的语法（官网地址）。
  • ② plugins 中指定的插件必须是 https://plugins.gradle.org/ 存在的。
  • ③ apply plugin 可以用在 allprojects 和 subprojects 中。
  • 完整的 build.gradle 文件的内容如下：
  1. buildscript { // 定义脚本使用资源
  2.     repositories { // 脚本资源仓库
  3.         maven {
  4.             url 'https://maven.aliyun.com/repository/gradle-plugin'
  5.         }
  6.     }
  7.     dependencies { // 依赖管理
  8.         classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.4.3'
  9.     }
  10. }
  12. plugins {
  13.     id 'java' // Java 插件
  14. //    id 'org.springframework.boot' version '2.4.3' // 将版本编号配置在插件内部
  15. //    id 'io.spring.dependency-management' version '1.0.11.RELEASE' // 由此插件负责版本号的维护
  16. }
  18. apply plugin: 'org.springframework.boot' // 引用之前的两个插件
  19. apply plugin: 'io.spring.dependency-management' // 引用之前的两个插件
  21. group 'com.github.fairy.era' // 组织名称
  22. version '1.0' // 版本号
  24. sourceCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  25. targetCompatibility = JavaVersion.VERSION_1_8 // 本次的项目都是基于 JDK-8 的版本
  27. repositories { // 仓库配置
  28.     maven { // 阿里云的 Maven 仓库
  29.         url 'https://maven.aliyun.com/repository/public/'
  30.     }
  31.     mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  32. }
  34. dependencies { // 依赖配置
  35.     /* junit 5 */
  36.     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.8.2'
  37.     /* spring-boot-starter-web */
  38.     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-web'
  39. }
  41. test {
  42.     useJUnitPlatform()
  43. }
  • 现在所有和 SpringBoot 相关的有关版本编号都统一的交给了 spring-boot-gradle-plugin 来定义了，而后相关你的任务也会自动的进行关联。

2.4 多模块拆分

2.4.1 概述

  • 任何一个项目都会有若干个子模块组成，所以现在虽然使用了 Gradle 搭建了一个完成的 SpringBoot 项目，但是考虑到后期项目开发的可维护性，依然需要进行父子模块的构建。

2.4.2 IDEA 工具

  • 创建一个新的 Gradle 项目，名称为 microboot 。

12.png

13.png

14.png

2.4.3 microboot 项目（删除 src 目录）

  • 删除 microboot 项目中的 src 目录。

15.gif

2.4.4 修改 Gradle Wrapper 的版本

  • 程序执行命令：
  1. gradle wrapper --gradle-version 6.5
  • 程序执行结果：略。

2.4.5 microboot 项目（配置项目的相关属性）

  • 在 microboot 项目中新建 gradle.properties 文件，内容如下：
  1. project_group=com.github.fairy.era
  2. project_version=1.0
  3. project_jdk=1.8

16.gif

2.4.6 microboot 项目（创建 dependencies.gradle 文件）

  • 在 microboot 项目中新建 dependencies.gradle 文件，其作用是实现所有项目之中依赖库的版本管理，内容如下：
  1. ext.versions = [ // 定义所有要使用到的依赖库的版本号
  2.                  springboot: '2.4.3' // SpringBoot 的版本号
  3. ]
  5. ext.librariest = [ // 定义所有的依赖库
  6.                    'spring-boot-gradle-plugin': "org.springframework.boot:spring-boot-gradle-plugin:${versions.springboot}"
  7. ]

17.gif

2.4.7 microboot 项目（修改 build.gradle 配置文件）

  • 修改 build.gradle 配置文件，引入相关的子配置文件：
  1. buildscript { // 定义脚本使用资源
  2.     apply from: 'dependencies.gradle' // 引入所需要的依赖库文件
  3.     repositories { // 脚本资源仓库
  4.         maven {
  5.             url 'https://maven.aliyun.com/repository/gradle-plugin'
  6.         }
  7.     }
  8.     dependencies { // 依赖管理
  9.         classpath libraries.'spring-boot-gradle-plugin'
  10.     }
  11. }
  12. apply from: 'dependencies.gradle' // 引入所需要的依赖库文件
  14. allprojects { // 所有模块/项目的通用配置
  15.     apply plugin: 'idea'
  16.     apply plugin: 'java'
  17.     apply plugin: 'java-library'
  18.     group project_group // 组织名称
  19.     version project_version // 版本号
  20.     sourceCompatibility = project_jdk // 本次的项目都是基于 JDK-8 的版本
  21.     targetCompatibility = project_jdk // 本次的项目都是基于 JDK-8 的版本
  22. }
  24. subprojects { // 子模块的配置
  26.     apply plugin: 'org.springframework.boot' // 将版本编号配置在插件内部
  27.     apply plugin: 'io.spring.dependency-management' // 由此插件负责版本号的维护
  29.     repositories { // 仓库配置
  30.         maven { // 阿里云的 Maven 仓库
  31.             url 'https://maven.aliyun.com/repository/public/'
  32.         }
  33.         mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  34.     }
  36.     dependencies { // 公共依赖管理
  38.     }
  40.     test {
  41.         useJUnitPlatform()
  42.     }
  44.     sourceSets { // 建立源代码的目录集合
  45.         main {
  46.             java {
  47.                 srcDirs = ['src/main/java']
  48.             }
  49.             resources {
  50.                 srcDirs = ['src/main/resources']
  51.             }
  52.         }
  53.         test {
  54.             java {
  55.                 srcDirs = ['src/test/java']
  56.             }
  57.             resources {
  58.                 srcDirs = ['src/test/resources']
  59.             }
  60.         }
  61.     }
  63.     gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  64.         tasks.each { task ->
  65.             if (task.name.contains('test')) { // 如果发现有 test 任务，就跳过
  66.                 task.enabled = true // 当前任务不执行
  67.             }
  68.         }
  69.     }
  71.     // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  72.     task sourceJar(type: Jar, dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  73.         archiveClassifier.set 'sources' // 文件的分类
  74.         from sourceSets.main.allSource // 所有源代码的读取路径
  75.     }
  77.     task javadocTask(type: Javadoc) {
  78.         source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  79.     }
  81.     tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  82.         options.encoding = "UTF-8"
  83.     }
  85.     tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  86.         options.encoding = "UTF-8"
  87.     }
  89.     task javadocJar(type: Jar, dependsOn: javadocTask) { // 先生成 javadoc，才可以打包
  90.         archiveClassifier.set 'javadoc' // 文件的分类
  91.         from javadocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  92.     }
  94.     artifacts { // 最终的打包操作任务
  95.         archives sourceJar
  96.         archives javadocJar
  97.     }
  99.     [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
  100. }
  102. project(':microboot-common') { // 设置子项目的配置，独享配置
  103.     dependencies { // 配置子模块依赖
  105.     }
  106. }
  108. project(':microboot-web') { // 设置子项目的配置，独享配置
  109.     dependencies { // 配置子模块依赖
  110.         implementation(project(':microboot-common')) // 引入其他子模块
  111.     }
  113.     gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  114.         tasks.each { task ->
  115.             if (task.name.contains('javadoc')) { // 如果发现有 test 任务，就跳过
  116.                 task.enabled = false // 当前任务不执行
  117.             }
  118.         }
  119.     }
  121. }

2.4.8 microboot 项目（创建一个 microboot-common 子模块）

  • 创建 microboot-common 子模块，这个一个公共的模块，用来定义一些公共的程序类。

18.gif

  • 修改 build.gradle 文件：
  1. plugins {
  2.     id 'java'
  3.     id 'idea'
  4. }

2.4.9 microboot 项目（创建一个 microboot-web 子模块）

  • 创建一个 microboot-web 子模块，这个模块的主要作用是引用 microboot-common 子模块，并实现 WEB 程序的开发。
  • 创建过程和 创建 microboot-common 子模块 类似。
  • 修改 build.gradle 文件：
  1. plugins {
  2.     id 'java'
  3.     id 'idea'
  4. }

2.4.10 microboot 项目（进行子模块的定义）

  • 修改 build.gradle 文件，增加如下的配置：
  1. project(':microboot-common') { // 设置子项目的配置，独享配置
  2.     dependencies { // 配置子模块依赖
  4.     }
  5. }
  7. project(':microboot-web') { // 设置子项目的配置，独享配置
  8.     dependencies { // 配置子模块依赖
  9.         implementation(project(':microboot-common')) // 引入其他子模块
  10.         implementation 'org.springframework.boot:spring-boot-starter-web' // 引入 SpringBoot 的 web 的依赖
  11.     }
  13.     gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  14.         tasks.each { task ->
  15.             if (task.name.contains('javadoc')) { // 如果发现有 test 任务，就跳过
  16.                 task.enabled = false // 当前任务不执行
  17.             }
  18.         }
  19.     }
  21. }
  • 完整的 build.gradle 文件的内容如下：
  1. buildscript { // 定义脚本使用资源
  2.     apply from: 'dependencies.gradle' // 引入所需要的依赖库文件
  3.     repositories { // 脚本资源仓库
  4.         maven {
  5.             url 'https://maven.aliyun.com/repository/gradle-plugin'
  6.         }
  7.     }
  8.     dependencies { // 依赖管理
  9.         classpath libraries.'spring-boot-gradle-plugin'
  10.     }
  11. }
  12. apply from: 'dependencies.gradle' // 引入所需要的依赖库文件
  14. allprojects { // 所有模块/项目的通用配置
  15.     apply plugin: 'idea'
  16.     apply plugin: 'java'
  17.     apply plugin: 'java-library'
  18.     group project_group // 组织名称
  19.     version project_version // 版本号
  20.     sourceCompatibility = project_jdk // 本次的项目都是基于 JDK-8 的版本
  21.     targetCompatibility = project_jdk // 本次的项目都是基于 JDK-8 的版本
  22. }
  24. subprojects { // 子模块的配置
  26.     apply plugin: 'org.springframework.boot' // 将版本编号配置在插件内部
  27.     apply plugin: 'io.spring.dependency-management' // 由此插件负责版本号的维护
  29.     repositories { // 仓库配置
  30.         maven { // 阿里云的 Maven 仓库
  31.             url 'https://maven.aliyun.com/repository/public/'
  32.         }
  33.         mavenCentral() // 默认情况下所提供的是 Maven 的中央仓库
  34.     }
  36.     dependencies { // 公共依赖管理
  38.     }
  40.     test {
  41.         useJUnitPlatform()
  42.     }
  44.     sourceSets { // 建立源代码的目录集合
  45.         main {
  46.             java {
  47.                 srcDirs = ['src/main/java']
  48.             }
  49.             resources {
  50.                 srcDirs = ['src/main/resources']
  51.             }
  52.         }
  53.         test {
  54.             java {
  55.                 srcDirs = ['src/test/java']
  56.             }
  57.             resources {
  58.                 srcDirs = ['src/test/resources']
  59.             }
  60.         }
  61.     }
  63.     gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  64.         tasks.each { task ->
  65.             if (task.name.contains('test')) { // 如果发现有 test 任务，就跳过
  66.                 task.enabled = true // 当前任务不执行
  67.             }
  68.         }
  69.     }
  71.     // 最终生成的 jar 文件名称：baseName-version-classifier.extension
  72.     task sourceJar(type: Jar, dependsOn: classes) { // 定义一个源代码的打包任务，并依赖于 classes 这种 Gradle 内置的任务
  73.         archiveClassifier.set 'sources' // 文件的分类
  74.         from sourceSets.main.allSource // 所有源代码的读取路径
  75.     }
  77.     task javadocTask(type: Javadoc) {
  78.         source sourceSets.main.allJava // 定义所有的 Java 源代码的路径
  79.     }
  81.     tasks.withType(Javadoc) { // 文档生成一定要有乱码处理
  82.         options.encoding = "UTF-8"
  83.     }
  85.     tasks.withType(JavaCompile) { // 针对程序编译的任务进行配置
  86.         options.encoding = "UTF-8"
  87.     }
  89.     task javadocJar(type: Jar, dependsOn: javadocTask) { // 先生成 javadoc，才可以打包
  90.         archiveClassifier.set 'javadoc' // 文件的分类
  91.         from javadocTask.destinationDir // 通过 javaDocTask 任务中找到目标路径
  92.     }
  94.     artifacts { // 最终的打包操作任务
  95.         archives sourceJar
  96.         archives javadocJar
  97.     }
  99.     [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
  100. }
  102. project(':microboot-common') { // 设置子项目的配置，独享配置
  103.     dependencies { // 配置子模块依赖
  105.     }
  106. }
  108. project(':microboot-web') { // 设置子项目的配置，独享配置
  109.     dependencies { // 配置子模块依赖
  110.         implementation(project(':microboot-common')) // 引入其他子模块
  111.         implementation 'org.springframework.boot:spring-boot-starter-web' // 引入 SpringBoot 的 web 的依赖
  112.     }
  114.     gradle.taskGraph.whenReady { // 在所有的操作准备好之后触发
  115.         tasks.each { task ->
  116.             if (task.name.contains('javadoc')) { // 如果发现有 test 任务，就跳过
  117.                 task.enabled = false // 当前任务不执行
  118.             }
  119.         }
  120.     }
  122. }

2.4.11 microboot-web 项目

  • 将之前 firstboot 项目中的代码拷贝到当前的项目之中，进行测试。
  • 启动类：
  1. package com.github.fairy.era;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. /**
  7.  * 启动类
  8.  *
  9.  * @author 许大仙
  10.  * @version 1.0
  11.  * @since 2021-12-31 09:14
  12.  */
  13. @SpringBootApplication
  14. public class Application {
  16.     public static void main(String[] args) {
  17.         SpringApplication.run(Application.class, args);
  18.     }
  19. }
  • Handler 类：
  1. package com.github.fairy.era.web;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. /**
  7.  * @author 许大仙
  8.  * @version 1.0
  9.  * @since 2021-12-31 09:22
  10.  */
  11. @RestController
  12. public class DemoHandler {
  14.     @GetMapping(value = "/demo")
  15.     public String demo() {
  16.         return "你好啊，SpringBoot";
  17.     }
  18. }