Gradle8.4构建SpringBoot多模块项目

合集 - SpringBoot的Demo(11)

1.SpringBoot自定义cron表达式注册定时任务2023-04-212.MongoDB + SpringBoot 的基础CRUD、聚合查询2023-05-183.SpringBoot实现WebSocket发送接收消息 + Vue实现SocketJs接收发送消息2023-05-194.SpringBoot获取Bean的工具类2023-10-12

5.Gradle8.4构建SpringBoot多模块项目2023-10-31

6.Gradle构建SpringBoot单模块项目2023-10-247.Java根据URL截图的4种方式2023-11-068.SpringBoot序列化、反序列化空字符串为null的三种方式2024-04-199.SpringBoot使用模版导出Word文件：poi-tl2024-12-2510.EasyExcel-读取多个sheet的方法2024-12-2511.SpringBoot将数据库中的数据导入到xml文件中2024-12-25

收起

目录

• 一、基本
  • 1、版本
  • 2、Gradle基本介绍
• 二、实现
  • 1、项目结构
  • 2、新建模块
  • 3、各个模块的配置及类
• 三、测试
  • 1、传递依赖测试，在二实现中，已经验证了，能引入依赖
  • 2、启动测试，测试业务模块的接口调用
• 四、总结

 

---

Gradle8.4构建SpringBoot多模块项目

回到顶部

一、基本

1、版本

• 这个版本是Jdk8最后一个SpringBoot版本

软件	版本
Gradle	8.4
SpringBoot	2.7.15
JDK	8

2、Gradle基本介绍

2.1、使用Wrapper方式构建

• 好处：统一gradle的版本
• 好处：不用安装gradle就可以使用
• Maven也是一样的可以用Wrapper的方式

2.2、导包方式

• 列举常用的四种

implementation
api
compileOnly
compileOnlyApi

①、implementation

• 导入依赖，不传递给子模块，依赖项将被编译和打包到项目中

②、api

• 导入依赖，传递给子模块，依赖项将被编译和打包到项目中

③、implementation和api的区别

• 关于implementation、api的传递依赖具体问题可以见我的博问（感谢大佬：@basic60）
  https://q.cnblogs.com/q/143866/

• 关于所有的导包方式的区别也可以见管网：
  https://docs.gradle.org/current/userguide/java_library_plugin.html

• 截图
  

④、compileOnly

• 导入依赖，不传递给子模块，依赖项将被编译到项目中，不打包到项目

⑤、compileOnlyApi

• 导入依赖，传递给子模块，依赖项将被编译到项目中，不打包到项目

2.3、build.gradle配置文件

• 相当于Maven的pom文件，主要是配置模块，导入依赖的作用

①、allprojects

• 里面的配置，所有模块生效
• 一般配置包的信息、编码、仓库地址

allprojects {
 
}

②、subprojects

• 里面的配置，只有自己和子模块生效
• 一般配置插件、统一包的版本管理、打包方式等等

subprojects {
 
}

③、dependencies

• 导入依赖，相当于Maven的<dependency></dependency> 导包
• 引入依赖演示

dependencies {
    // api可以传递依赖、implementation不能传递依赖
    // hutool工具类
    api 'cn.hutool:hutool-all'
}

• 引入模块演示

dependencies {
    //依赖公共模块
    api project(":模块地址")
    implementation project(":GradleParent:GradleUtil")
}

2.4、settings.gradle配置文件

• 配置模块间的信息，见后面具体实现

回到顶部

二、实现

1、项目结构

-GradleMultiModule
 -GradleParent          包装common、util的父模块（实际中可以不要，这里演示导包、传递依赖等）
  -GradleCommon         公共模块，用于装entity或者mapper等
  -GradleUtil           工具类模块
 -GradleServer          业务模块的父模块，用于给子模块统一导入springboot的包
  -GradleOne            业务模块1 - 依赖GradleCommon、GradleUtil
  -GradleTwo            业务模块2 - 依赖
  -GradleStart          启动模块 - 导入GradleOne、GradleTwo依赖，启动项目

• 结构
  

2、新建模块

• 只演示一遍
• 就是用idea创建springboot的gradle项目

3、各个模块的配置及类

3.1、GradleMultiModule模块

• 顶级父模块

• 统一配置 build.gradle (还可以配置gradle的版本)

• 配置所有模块的关系 settings.gradle

• ①、build.gradle

• wrapper：配置gradle的版本，需要单独点击执行，执行后查看gradle版本是否生效

• 具体配置

//插件
plugins {
    id 'java'
    id 'idea'
    id 'java-library'
    id 'org.springframework.boot' version '2.7.15'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
}
 
//allprojects：所有模块生效
allprojects {
    // 配置项目信息
    group = 'com.cc'
    version = '0.0.1-SNAPSHOT'
    // 配置字符编码
    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8'
    }
 
    java {
        sourceCompatibility = '8'
        targetCompatibility = '8'
    }
 
    //仓库配置
    repositories {
        //本地
        mavenLocal()
        //阿里仓库
        maven { url 'https://maven.aliyun.com/repository/public/' }
        //公司仓库。必须用：https。Gradle默认情况下不允许使用不安全的协议，以提高安全性。
        maven { url 'https://******:****/repository/maven-public/' }
        //中央仓库
        mavenCentral()
    }
 
}
 
//subprojects：所有子模块生效——springboot配置、导包版本管理、打包管理
subprojects {
    apply plugin: 'java'
    apply plugin: 'java-library'
    apply plugin: 'idea'
    //所有子模块都是springboot项目，如不是，不能打包。
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
 
    //所有子模块的-依赖版本管理
    dependencyManagement {
        dependencies {
            dependency 'cn.hutool:hutool-all:5.0.7'
            dependency "org.apache.commons:commons-lang3:3.5"
        }
    }
 
    //使用 gradle打包工具
    jar {
        manifest.attributes provider: 'gradle'
    }
 
    tasks.named('test') {
        useJUnitPlatform()
    }
 
}
 
// 配置gradle的版本
wrapper {
    //gradle的版本
    gradleVersion = '8.4'
    //版本类型：BIN、ALL（完全版，可以看gradle的代码）
    distributionType = 'ALL'
}

• ①、settings.gradle

• 配置模块间的关系

• 可以新增一个模块配置一个模块，不用一次性配置完成

• 具体配置

rootProject.name = 'GradleMultiModule'
 
//公共模块总模块
include 'GradleParent'
include ':GradleParent:GradleCommon'
include ':GradleParent:GradleUtil'
project(':GradleParent:GradleCommon')?.name = 'GradleCommon'
project(':GradleParent:GradleUtil')?.name = 'GradleUtil'
 
//业务模块总模块
include 'GradleServer'
include ':GradleServer:GradleStart'
include ':GradleServer:GradleOne'
include ':GradleServer:GradleTwo'
project(':GradleServer:GradleStart')?.name = 'GradleStart'
project(':GradleServer:GradleOne')?.name = 'GradleOne'
project(':GradleServer:GradleTwo')?.name = 'GradleTwo'

3.2、GradleParent模块（公共）

• 统一公共模块依赖

• build.gradle

//配置所有子模块
subprojects {
    //这里可以导入公共的依赖
    dependencies {
        // compileOnly：这样做可以确保Lombok在编译时可用，但不会包含在最终的构建产物中，从而减小构建产物的大小。
        // api：依赖可以传递给子模块
        // compileOnlyApi：仅编译时可用，不包含在构建产物中，并且可以传递给子模块
        compileOnlyApi 'org.projectlombok:lombok'
        // 表示将Lombok库作为注解处理器导入。
        annotationProcessor 'org.projectlombok:lombok'
    }
}

3.3、GradleCommon模块（公共）

• 公共模块，存放Entity

• build.gradle

dependencies {
    // api可以传递依赖、implementation不能传递依赖
    // hutool工具类
    api 'cn.hutool:hutool-all'
}

新建的类

3.4、GradleUtil模块（公共）

• 存放所有工具类

• build.gradle

dependencies {
    // api可以传递依赖、implementation不能传递依赖
    api 'org.apache.commons:commons-lang3'
}

新建类

3.5、GradleServer模块（业务）

• 业务模块的父模块，用于统一导入springboot的包

• build.gradle

// 子模块生效
subprojects {
    //配置子模块依赖
    dependencies {
        //导入业务模块的公共包 - SpringBoot的包
        //不用api，不用传递
        implementation 'org.springframework.boot:spring-boot-starter'
        implementation 'org.springframework.boot:spring-boot-starter-web'
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
    }
}

3.6、GradleOne模块（业务）

• 引入：GradleCommon、GradleUtil模块

• 测试是否能使用引入模块的类、引入模块的依赖

• build.gradle

dependencies {
    //依赖公共模块
    //api传递给子模块
    api project(":GradleParent:GradleCommon")
    api project(":GradleParent:GradleUtil")
}

• 启动提示
  

• 测试
  

3.7、GradleTwo模块（业务）

• 引入：GradleCommon、GradleUtil模块

• 测试是否能使用引入模块的类、引入模块的依赖

• build.gradle

dependencies {
    //依赖公共模块：implementation不传递依赖；api传递依赖
    //这里不传递依赖，因为会造成GradleStart有多个重复依赖
    implementation project(":GradleParent:GradleCommon")
    implementation project(":GradleParent:GradleUtil")
}

• 启动提示
  

• 测试
  

3.8、GradleStart启动模块（业务）

• 启动springboot项目

• 引入所有业务模块

• 配置SpringMVc

• 此模块不写任何的业务

• build.gradle

dependencies {
    // 依赖GradleOne、GradleTwo，将该模块纳入启动中（加入springboot项目中）
    api project(':GradleServer:GradleOne')
    api project(':GradleServer:GradleTwo')
 
    // 其他依赖项...
}

• SpringMvc配置

package com.cc.go.config;
 
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
import javax.annotation.Resource;
import java.util.ArrayList;
 
/** <p>SpringMvc配置<p>
 * <li>自定义Spring MVC的特性和扩展Spring MVC的功能</li>
 * @since 2023/9/21
 * @author CC
 **/
@SpringBootConfiguration
public class WebGlobalConfig implements WebMvcConfigurer {
 
    @Resource
    private MyHandlerInterceptor myHandlerInterceptor;
 
    /**
     * 拦截器（Interceptors）
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        ArrayList<String> list = new ArrayList<>();
        list.add("/login");
        //自定义拦截器，或其他拦截器
        registry.addInterceptor(myHandlerInterceptor)
                //添加拦截地址为所有拦截
                .addPathPatterns("/**")
                //不拦截的地址
                .excludePathPatterns(list);
    }
 
    /**
     * 资源处理器（Resource Handlers）
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**")
                .addResourceLocations("classpath:/resources/","classpath:/static/");
    }
 
    /**
     * 跨域资源共享（CORS）
     */
    @Bean
    public CorsFilter corsFilter() {
        //创建CorsConfiguration对象后添加配置
        CorsConfiguration config = new CorsConfiguration();
        //允许所有原始域
        config.addAllowedOriginPattern("*");
        //允许所有头部信息
        config.addAllowedHeader("*");
        //允许所有头部信息
        config.addExposedHeader("*");
        //放行的请求方式
//        config.addAllowedMethod("GET");
//        config.addAllowedMethod("PUT");
//        config.addAllowedMethod("POST");
//        config.addAllowedMethod("DELETE");
        config.addAllowedMethod("*");     //放行全部请求
 
        //是否发送Cookie
        config.setAllowCredentials(true);
 
        //2. 添加映射路径
        UrlBasedCorsConfigurationSource corsConfigurationSource =
                new UrlBasedCorsConfigurationSource();
        corsConfigurationSource.registerCorsConfiguration("/**", config);
        //返回CorsFilter
        return new CorsFilter(corsConfigurationSource);
    }
}

• 启动类

package com.cc.go;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
/** <p>启动类<p>
 * @since 2023/9/20
 * @author CC
 **/
@SpringBootApplication
public class GradleStartApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(GradleStartApplication.class, args);
    }
 
}

• application.yml

server:
  port: 2222

回到顶部

三、测试

1、传递依赖测试，在二实现中，已经验证了，能引入依赖

2、启动测试，测试业务模块的接口调用

• 启动项目，模块启动
  

• 接口调用
  

• 调用后打印的
  

回到顶部

四、总结

• 项目地址（blog-code/SpringBoot/GradleMultiModule）
  https://gitee.com/KakarottoChen/blog-code.git