Gradle构建多模块SpringBoot应用

╰半橙微兮° 2022-11-11 14:59 456阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 关于本篇 ###

本文是一篇笔记，通过实战将Gradle构建多模块的步骤记录下来，为今后新建的项目准备一个脚手架，该脚手架由两个子模块组成：二方库、SpringBoot应用，本文由以下内容组成：

1.  新建项目；
2.  新建二方库模块；
3.  新建SpringBoot应用模块；
4.  验证；

### 环境信息 ###

1.  操作系统：win10
2.  JDK：1.8.0\_181
3.  Gradle：6.8.3
4.  IDEA：2020.2.2 (Ultimate Edition)
5.  Spring Boot：2.4.4

### 源码下载 ###

*  本篇实战中的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

*  这个git项目中有多个文件夹，kubebuilder相关的应用在gradlespringbootdemo文件夹下，如下图红框所示：  
    ![在这里插入图片描述][20210327114003130.jpg]

### 新建项目 ###

1.  新建项目：  
    ![在这里插入图片描述][20210321155340146.jpg]
2.  选择新建Gradle项目：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]
3.  设置项目名gradlespringbootdemo、GroupId、ArtifactId：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]
4.  完整的build.gradle内容改为如下：

import java.time.OffsetDateTime
    import java.time.format.DateTimeFormatter
    
    // gradle自身会用到的相关设置
    buildscript { 
        // 仓库
        repositories { 
            // 本地
            mavenLocal()
    
            // 阿里云
            maven { 
                url 'http://maven.aliyun.com/nexus/content/groups/public/'
            }
            // 中央仓库
            mavenCentral()
            // grandle插件
            maven { 
                url 'https://plugins.gradle.org/m2/'
            }
        }
    
        // 子模块会用到的变量
        ext { 
            springBootVersion = '2.4.4'
        }
    }
    
    // 插件
    plugins { 
        id 'java'
        id 'java-library'
        // 有这个声明，子模块可以使用org.springframework.boot插件而无需指定版本，但是apply=false表示当前模块不使用此插件
        id 'org.springframework.boot' version "${springBootVersion}" apply false
        id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    }
    
    // gradle wrapper指定版本
    wrapper { 
        gradleVersion = '6.8.3'
    }
    
    // 取当前时间
    def buildTimeAndDate = OffsetDateTime.now()
    
    // 根据时间生成字符串变量
    ext { 
        projectVersion = project.version
        buildDate = DateTimeFormatter.ISO_LOCAL_DATE.format(buildTimeAndDate)
        buildTime = DateTimeFormatter.ofPattern('HH:mm:ss.SSSZ').format(buildTimeAndDate)
    }
    
    // 针对所有project的配置，包含根项目
    allprojects { 
        group 'com.bolingcavalry'
        version '1.0-SNAPSHOT'
    
        apply plugin: 'java'
        apply plugin: 'idea'
        apply plugin: 'io.spring.dependency-management'
    
        // 编译相关参数
        compileJava { 
            sourceCompatibility = JavaVersion.VERSION_1_8
            targetCompatibility = JavaVersion.VERSION_1_8
            options.encoding = 'UTF-8'
            options.compilerArgs =  [
                    '-Xlint:all', '-Xlint:-processing'
            ]
        }
    
        // Copy LICENSE
        tasks.withType(Jar) { 
            from(project.rootDir) { 
                include 'LICENSE'
                into 'META-INF'
            }
        }
    
        // 生成jar文件时，MANIFEST.MF的内容如下
        jar { 
            manifest { 
                attributes(
                        'Created-By': "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})".toString(),
                        'Built-By': 'travis',
                        'Build-Date': buildDate,
                        'Build-Time': buildTime,
                        'Built-OS': "${System.properties['os.name']}",
                        'Specification-Title': project.name,
                        'Specification-Version': project.version,
                        'Specification-Vendor': 'Will Zhao',
                        'Implementation-Title': project.name,
                        'Implementation-Version': project.version,
                        'Implementation-Vendor': 'Will Zhao'
                )
            }
        }
    
        // 仓库
        repositories { 
            // 本地
            mavenLocal()
            // 如果有私服就在此配置，如果没有请注释掉
            maven { 
                url 'http://192.168.50.43:8081/repository/aliyun-proxy/'
            }
            // 阿里云
            maven { 
                url 'http://maven.aliyun.com/nexus/content/groups/public/'
            }
            // 中央仓库
            mavenCentral()
            // grandle插件
            maven { 
                url "https://plugins.gradle.org/m2/"
            }
        }
    }
    
    // 类似maven的dependencyManagement，这里将所有jar的版本指定好，子模块在依赖时可以不用指定版本
    allprojects {  project ->
        buildscript { 
            dependencyManagement { 
                imports { 
                    mavenBom "org.springframework.boot:spring-boot-starter-parent:${springBootVersion}"
                    mavenBom "org.junit:junit-bom:5.7.0"
                }
    
                dependencies { 
                    dependency 'org.projectlombok:lombok:1.16.16'
                    dependency 'org.apache.commons:commons-lang3:3.11'
                    dependency 'commons-collections:commons-collections:3.2.2'
                    dependency 'net.devh:grpc-server-spring-boot-starter:2.11.0.RELEASE'
                }
            }
        }
    }

1.  上述配置中，我使用了自己在局域网搭建的nexus3服务器作为私服，目的是缓存jar库，局域网内的速度还是要比阿里云快一些的，如果您没有搭建此类私服，将此配置删除即可（我这里是http://192.168.50.43:8081/repository/aliyun-proxy/）；

*  现在父工程已经设置完成，可以添加子模块了；

### 新增二方库子模块 ###

1.  二方库是常用功能，A系统调用B系统服务时，通常要求B系统提供二方库，里面包含了数据结构和接口定义，这样双方的数据结构和接口都能对齐了，因此咱们来创建一个二方库子模块，里面包含了数据结构和接口；
2.  新增Module：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 2]
3.  新增module时，依旧是选中Gradle、JDK1.8、Java：  
    ![在这里插入图片描述][20210321231858823.jpg]
4.  模块名为democlient：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 3]
5.  新增的模块内也有build.gradle文件，将里面内容清空后写为以下内容：

// 构建二方库的插件
    plugins { 
        id 'java-library'
    }
    
    // 这里可以指定构建出来的jar的文件名
    archivesBaseName = 'demo-client'
    
    // 子模块自己的依赖
    dependencies { 
        // 使用api，将依赖传递给使用democlient的模块
        api 'org.projectlombok:lombok'
        // annotationProcessor不会传递，使用了lombok生成代码的模块，需要自己声明annotationProcessor
        annotationProcessor 'org.projectlombok:lombok'
    }

1.  给democlient模块增加一个类，其他模块会用到此类：

package com.bolingcavalry.dto;
    
    import lombok.Builder;
    import lombok.Data;
    import lombok.ToString;
    
    @Data
    @ToString
    @Builder
    public class Student { 
        String name;
        int age;
    }

1.  democlient模块编码完成了，试试构建任务，操作如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 4]
2.  构建完成后生成下图红框中的jar文件：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 5]
3.  用解压工具解开上图红框中的文件，除了预料之中的class文件，再来检查META-INF/MANIFEST.MF，如下图所示，是咱们在前面的gradle脚本中定制的内容：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 6]

### 新增SpringBoot应用模块 ###

接下来要创建的是一个SpringBoot应用，并且使用了democlient模块中的Student类；

1.  新建Gradle模块：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 7]
2.  基本信息如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 8]
3.  新模块的build.gradle内容如下，有几处要注意的地方稍后会讲到：

plugins { 
        id 'org.springframework.boot'
    }
    
    // 用了插件org.springframework.boot之后，jar task会失效，可用bootJar取代
    bootJar { 
        archiveBaseName = project.name
        archiveVersion = project.version
    
        manifest { 
            attributes(
                    'Created-By': "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})".toString(),
                    'Built-By': 'travis',
                    'Build-Date': buildDate,
                    'Build-Time': buildTime,
                    'Built-OS': "${System.properties['os.name']}",
                    'Specification-Title': project.name,
                    'Specification-Version': projectVersion,
                    'Specification-Vendor': 'Will Zhao',
                    'Implementation-Title': project.name,
                    'Implementation-Version': projectVersion,
                    'Implementation-Vendor': 'Will Zhao'
            )
        }
    }
    
    tasks.withType(JavaCompile) { 
        options.encoding = "UTF-8"
    }
    
    // 子模块自己的依赖
    dependencies { 
        implementation 'org.springframework.boot:spring-boot-starter-web'
        // 二方库依赖
        implementation project(':democlient')
        // annotationProcessor不会传递，使用了lombok生成代码的模块，需要自己声明annotationProcessor
        annotationProcessor 'org.projectlombok:lombok'
    
    }
    
    test { 
        useJUnitPlatform()
    }

1.  上述脚本中需要有以下四点需要注意：  
    a. 要使用springboot的插件org.springframework.boot，此处无需指定版本，因为根模块中已通过mavenBom导入了版本依赖关系；  
    b. jar\{…\}的配置会失效，如果想设置jar的一些信息，如文件名、manifest等，要使用bootJar配置；  
    c. 依赖了democlient模块，这是典型的二方库开发和使用方式；  
    d. 稍后的java代码中会实例化Student对象，此时用到lombok生成的代码，因此要用annotationProcessor依赖lombok库，否则编译会出问题；
2.  最后新建一个启动类DemoApplication，用于验证springboot应用能否正常启动，代码中有使用Student类，这是为了验证使用二方库是否正常：

package com.bolingcavalry;
    
    import com.bolingcavalry.dto.Student;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Date;
    
    @SpringBootApplication
    @RestController
    public class DemoApplication { 
    
        @RequestMapping(value = "/hello", method = RequestMethod.GET)
        public String hello() { 
            return "Hello "
                    + new Date()
                    + "--"
                    + new Student("Tom", 11);
        }
    
    
        public static void main(String[] args) { 
            SpringApplication.run(DemoApplication.class, args);
        }
    }

1.  运行应用试试，操作如下图红框：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 9]
2.  符合预期：  
    ![在这里插入图片描述][2021032710385579.jpg]
3.  再验证打包成jar是否正常，先停掉前面启动的应用，然后操作如下图红框：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 10]
4.  已生成jar文件：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 11]
5.  在jar文件所在目录执行命令java -jar webapp-1.0-SNAPSHOT.jar，启动应用正常：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 12]

*  至此，多模块Gradle项目开发就完成了，如果您正在新建此类项目，希望本文能给您提供一些参考；

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 1]
6.  [DevOps系列][DevOps]

### 欢迎关注公众号：程序员欣宸 ###

> 微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[20210327114003130.jpg]: /images/20221022/caebdbcee6c14dd993ebaf88a0330528.png
[20210321155340146.jpg]: /images/20221022/caa88c711d9d4cb89c51a019d66b7b6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]: /images/20221022/3cbe5345a71440f0954ad095c73146d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]: /images/20221022/e0420fb387a1465ea5a6b1c3c1f7d3d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 2]: /images/20221022/822b1304025c419b85242a2bff0e0851.png
[20210321231858823.jpg]: /images/20221022/1469331a237b4377af52f3ea2f279d40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 3]: /images/20221022/9218d5542f7647789c4ba69750af6ee8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 4]: /images/20221022/2c8dc3591bb0416580399cd4a90e1231.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 5]: /images/20221022/6f959992c82240a08a58712288e2a345.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 6]: /images/20221022/19b830c95deb4fdd9526c7b3576869d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 7]: /images/20221022/eb687bf057e941c6ab7dea4839782e75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 8]: /images/20221022/57ecb52b615d4fd1b32a07afd7b3fe42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 9]: /images/20221022/fa24fae431354e6aab45f6c92251e687.png
[2021032710385579.jpg]: /images/20221022/a2b535d8f03e4d9f81f0689a54224cec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 10]: /images/20221022/8f79127a7ecf4d528262ace55e29ce63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 11]: /images/20221022/420b05b9c8484ea4ad50fa52317819aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 12]: /images/20221022/c27026ae0757498da76762440888d2e9.png
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 1]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920