Gradle8.4构建SpringBoot多模块项目

一、基本

1、版本

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

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的 导包
• 引入依赖演示

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;

/** 
SpringMvc配置

 * 
自定义Spring MVC的特性和扩展Spring MVC的功能
 * @since 2023/9/21
 * @author CC
 **/
@SpringBootConfiguration
public class WebGlobalConfig implements WebMvcConfigurer {

    @Resource
    private MyHandlerInterceptor myHandlerInterceptor;

    /**
     * 拦截器（Interceptors）
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        ArrayList 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;

/** 
启动类

 * @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