国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

springboot gradle kotlin 多模塊（或微服務）統(tǒng)一依賴及版本管理和構建不同環(huán)境打包task,docker鏡像構建task

2年前作者：兩顆木木三分類：Toy博客閱讀(64)違法舉報

這篇具有很好參考價值的文章主要介紹了springboot gradle kotlin 多模塊（或微服務）統(tǒng)一依賴及版本管理和構建不同環(huán)境打包task,docker鏡像構建task。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

場景描述

在maven里可以在pom.xml中統(tǒng)一定義項目依賴，依賴版本，插件，多環(huán)境構建，子模塊；定義packaging 為pom類型，各子模塊按需引入，并且指定環(huán)境profiles構建。
在gradle中也可以實現依賴統(tǒng)一管理，各模塊按需引入，區(qū)分環(huán)境的構建任務。

先上效果圖
統(tǒng)一定義依賴，依賴版本，插件
gradle 構建spring cloud 微服務工程,spring boot,kotlin,微服務,gradle,java

子模塊按需引入

分環(huán)境打包task及docker鏡像打包任務

環(huán)境

gradle8.1.1, springboot3.1.0, jdk17

步驟

創(chuàng)建項目
通過IDEA或Spring Initializer 創(chuàng)建springboot+kotlin+gradle的基礎項目；
修改gradle/wrapper/gradle-wrapper.properties 中gradle版本 https://services.gradle.org/distributions/gradle-8.1.1-bin.zip
統(tǒng)一定義依賴，版本，插件；由gradle catalogs實現，catalogs官方文檔介紹
在根目錄創(chuàng)建libs.versions.toml 文件，自己當前項目文件內容如下

#### 定義項目所有依賴庫
## 統(tǒng)一定義版本
[versions]
project-version= "0.0.1"
springboot = "3.1.0"
kotlin = "1.8.21"
docker-plugin = "9.3.0"
mybatis-plus = "3.5.3"
velocity = "2.0"
mysql = "8.0.32"
hutool = "5.8.17"
knife4j = "4.3.0"
easyexcel = "3.2.1"
dynamic-datasource = "3.6.0"
sa-token = "1.35.0.RC"
spring-cloud = "2022.0.2"
spring-cloud-alibaba = "2022.0.0.0-RC2"
spring-doc = "2.1.0"
spring-redisson = "3.21.3"
dubbo = "3.2.0"
aliyun-sms = "2.0.23"
fastjson2 = "2.0.39"
dingtalk-service-sdk = "2.0.0"
dingtalk-sdk = "2.0.29"
flowable = "7.0.0.M1"
liteflow = "2.10.5"
rocketmq = "2.2.3"
minio = "8.5.4"
## 統(tǒng)一定義依賴
[libraries]
mybatis-plus = { module = "com.baomidou:mybatis-plus-boot-starter", version.ref = "mybatis-plus" }
mybatis-generator = { module = "com.baomidou:mybatis-plus-generator", version.ref = "mybatis-plus" }
velocity = { module = "org.apache.velocity:velocity-engine-core", version.ref = "velocity" }
mysql = { module = "mysql:mysql-connector-java", version.ref = "mysql" }
# 使用的是springdoc-openapi3, https://springdoc.org/#migrating-from-springfox 不再是springfox
knife4j = { module = "com.github.xiaoymin:knife4j-openapi3-jakarta-spring-boot-starter", version.ref = "knife4j" }
knife4j-gateway = { module = "com.github.xiaoymin:knife4j-gateway-spring-boot-starter", version.ref = "knife4j" }
hutool-core = { module = "cn.hutool:hutool-core", version.ref = "hutool" }
hutool-captcha = { module = "cn.hutool:hutool-captcha", version.ref = "hutool" }
hutool-crypto = { module = "cn.hutool:hutool-crypto", version.ref = "hutool" }
hutool-http = { module = "cn.hutool:hutool-http", version.ref = "hutool" }
hutool-extra = { module = "cn.hutool:hutool-extra", version.ref = "hutool" }
hutool-json = { module = "cn.hutool:hutool-json", version.ref = "hutool" }
easyexcel = { module = "com.alibaba:easyexcel", version.ref = "easyexcel" }
satoken-core = { module = "cn.dev33:sa-token-core", version.ref = "sa-token" }
satoken-web = { module = "cn.dev33:sa-token-spring-boot3-starter", version.ref = "sa-token" }
satoken-reactor = { module = "cn.dev33:sa-token-reactor-spring-boot3-starter", version.ref = "sa-token" }
satoken-dubbo = { module = "cn.dev33:sa-token-dubbo", version.ref = "sa-token" }
dynamic-datasource = { module = "com.baomidou:dynamic-datasource-spring-boot-starter", version.ref = "dynamic-datasource" }
spring-boot = { module = "org.springframework.boot:spring-boot-dependencies", version.ref = "springboot" }
spring-cloud = { module = "org.springframework.cloud:spring-cloud-dependencies", version.ref = "spring-cloud" }
spring-cloud-alibaba = { module = "com.alibaba.cloud:spring-cloud-alibaba-dependencies", version.ref = "spring-cloud-alibaba" }
spring-doc-common = { module = "org.springdoc:springdoc-openapi-starter-common", version.ref = "spring-doc" }
spring-doc-webflux = { module = "org.springdoc:springdoc-openapi-starter-webflux-ui", version.ref = "spring-doc" }
spring-doc-webmvc = { module = "org.springdoc:springdoc-openapi-starter-webmvc-ui", version.ref = "spring-doc" }
spring-redisson = { module = "org.redisson:redisson-spring-boot-starter", version.ref = "spring-redisson" }
spring-dubbo = { module = "org.apache.dubbo:dubbo-spring-boot-starter", version.ref = "dubbo" }
dubbo = { module = "org.apache.dubbo:dubbo", version.ref = "dubbo" }
dubbo-nacos = { module = "org.apache.dubbo:dubbo-registry-nacos", version.ref = "dubbo" }
aliyun-sms = { module = "com.aliyun:dysmsapi20170525", version.ref = "aliyun-sms" }
kotlin-fastjosn2 = { module = "com.alibaba.fastjson2:fastjson2-kotlin", version.ref = "fastjson2" }
dingtalk-service = { module = "com.aliyun:alibaba-dingtalk-service-sdk", version.ref = "dingtalk-service-sdk" }
dingtalk-sdk = { module = "com.aliyun:dingtalk", version.ref = "dingtalk-sdk" }
flowable = { module = "org.flowable:flowable-spring-boot-starter", version.ref = "flowable" }
flowable-bpmn-layout = { module = "org.flowable:flowable-bpmn-layout", version.ref = "flowable" }
liteflow = { module = "com.yomahub:liteflow-spring-boot-starter", version.ref = "liteflow" }
rocketmq = { module = "org.apache.rocketmq:rocketmq-spring-boot-starter", version.ref = "rocketmq" }
minio = { module = "io.minio:minio", version.ref = "minio" }
## 將多個需要同時引入的依賴定義成一個組，使用時直接引入組
[bundles]
hutool = ["hutool-core", "hutool-captcha", "hutool-crypto", "hutool-http", "hutool-extra", "hutool-json"]
spring-doc = ["spring-doc-common", "spring-doc-webflux", "spring-doc-webmvc"]
datasource = ["mysql", "dynamic-datasource"]
dubbo = ["dubbo", "spring-dubbo", "dubbo-nacos", "kotlin-fastjosn2", "satoken-dubbo"]
mybatisplus-generator = ["mybatis-generator", "velocity"]
flowable = ["flowable", "flowable-bpmn-layout"]
## 統(tǒng)一定義插件
[plugins]
springboot = { id = "org.springframework.boot", version.ref = "springboot" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
docker = { id = "com.bmuschko.docker-spring-boot-application", version.ref = "docker-plugin" }

在根目錄settings.gradle.kts 引入依賴文件，順便定義全局鏡像倉庫

import java.net.URI

dependencyResolutionManagement {
    repositories {
        // 使用阿里云 鏡像倉庫
        maven {url = URI("https://maven.aliyun.com/nexus/content/groups/public/") }
        //私庫
        maven { url = URI("xxx") }
        mavenCentral()
    }
    // 統(tǒng)一依賴庫定義
    versionCatalogs {
        create("projectLibs"){
            from(files("./libs.versions.toml"))
        }
    }
}
rootProject.name = "project-name"

在根目錄build.gradle.kts配置項目和子模塊通用構建配置，直接貼文件內容，有注釋說明

import org.apache.tools.ant.filters.ReplaceTokens
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import java.io.FileInputStream
import java.util.*
// 引入插件
plugins {
    alias(projectLibs.plugins.springboot)
    alias(projectLibs.plugins.kotlin.jvm)
    alias(projectLibs.plugins.kotlin.spring)
    alias(projectLibs.plugins.docker)
}
// 定義庫引用
val pLibs = projectLibs
// 加載根路徑自定義配置屬性   用于替換打包時不同環(huán)境的變量值
val envProps = Properties()
envProps.load(FileInputStream("${project.projectDir.absolutePath}${File.separator}env.properties"))
subprojects {
    // 全部項目有基礎插件kotlin jvm/spring
    apply {
        plugin(pLibs.plugins.kotlin.jvm.get().pluginId)
        plugin(pLibs.plugins.kotlin.spring.get().pluginId)
    }
    // 統(tǒng)一group和version
    group = "xxx"
    version = pLibs.versions.project.version.get()
    java.sourceCompatibility = JavaVersion.VERSION_17

    dependencies {
        // bom 管理著一組依賴的版本，各模塊按需引入其中的依賴即可，由bom統(tǒng)一約束著版本，
        // spring boot bom
        implementation(platform(pLibs.spring.boot))
        // spring cloud bom
        implementation(platform(pLibs.spring.cloud))
        // spring cloud alibaba bom
        implementation(platform(pLibs.spring.cloud.alibaba))
    }
    // 排序logback, 使用log4j2
    configurations.all {
        exclude("org.springframework.boot","spring-boot-starter-logging")
        exclude("ch.qos.logback")
    }
    tasks.withType<KotlinCompile> {
        kotlinOptions {
            freeCompilerArgs = listOf("-Xjsr305=strict", "-Xjvm-default=all")
            jvmTarget = "17"
        }
    }
    tasks.withType<Test> {
        useJUnitPlatform()
    }
    tasks.jar {
        enabled = true
        archiveClassifier.set("")
    }

    // 為擁有bootJar的模塊創(chuàng)建dev,test,prod的構建任務
    if (getTasksByName("bootJar", false).isNotEmpty()) {
        println("getTask:::" + getTasksByName("bootJar", false))
        tasks.register<Jar>("bootJar-dev") { buildJarTaskConf(this, "dev") }
        tasks.register<Jar>("bootJar-test") { buildJarTaskConf(this, "test") }
        tasks.register<Jar>("bootJar-prod") { buildJarTaskConf(this, "prod") }

        // docker鏡像
        apply {
            plugin(pLibs.plugins.docker.get().pluginId)
        }
        docker {
            // docker鏡像倉庫配置
            registryCredentials {
                url.set("http://ip:port")
                username.set("username")
                password.set("password")
            }
            springBootApplication {
                baseImage.set("xxxx/java:17-latest")
                images.set(setOf("xxx/$name:$version"))
                jvmArgs.set(listOf("-Dfile.encoding=utf-8"))
            }
        }
        // docker測試環(huán)境構建并推送鏡像任務
        tasks.register<Jar>("dockerBuildAndPushImage-test") { buildDockerTaskConf(this, "test") }
    }
	
	// 包含有bootjar的模塊在processResources 任務階段替換環(huán)境變量
    if (getTasksByName("bootJar", false).isNotEmpty() || project.name == "xxx-module") {
        // 在復制文件任務processResources階段替換變量
        tasks.processResources {
            doFirst {  // 將邏輯放到執(zhí)行階段
                val env = System.getProperty("buildEnv", "dev") // 默認dev環(huán)境
                println("===============模塊 ${project.name} 替換配置文件環(huán)境變量 , 構建環(huán)境: $env ==================")
                filter(
                    ReplaceTokens::class,
                    "tokens" to
//							envPropsToMap(env)
                            // todo 寫個函數自動讀取待替換列表轉為map
                            mapOf(
                                "nacos.server" to envProps.getOrElse("env.$env.nacos.server") {
                                    throw IllegalArgumentException(
                                        "未找到環(huán)境：$env 屬性：nacos.server 的配置"
                                    )
                                },
                                "nacos.namespace" to envProps.getOrElse("env.$env.nacos.namespace") {
                                    throw IllegalArgumentException(
                                        "未找到環(huán)境：$env 屬性：nacos.namespace 的配置"
                                    )
                                },
                                "nacos.username" to envProps.getOrDefault("env.$env.nacos.username", ""),
                                "nacos.password" to envProps.getOrDefault("env.$env.nacos.password", ""),
                                "active.env" to env
                            )
                )
                filteringCharset = "UTF-8"
            }
        }
        tasks.classes {
            dependsOn("clean")
        }
    }
}
// docker服務地址
docker {
    url.set("tcp://xxx:2375")
}

/**
 * 任務執(zhí)行順序說明
 * Task#finalizedBy 函數 的作用是為 Gradle 任務 設置任務執(zhí)行完畢后執(zhí)行的任務，A.finalizedBy B 的作用是 A 任務執(zhí)行完畢后 , 執(zhí)行 B 任務
 * A.finalizedBy B
 * B.dependsOn C
 * A 執(zhí)行完畢后執(zhí)行 B , B 依賴于 C , 執(zhí)行 B 之前要先把 C 執(zhí)行了。A -> C -> B
 */
/**
 * 構建各個環(huán)境的bootJar
 */
fun buildJarTaskConf(jarTask: Jar, env: String) {
    jarTask.group = "build"
    jarTask.dependsOn("clean")
    jarTask.doFirst {
        println("=============== 構建 ${jarTask.archiveFileName.get()} 包 , 構建環(huán)境: $env ==================")
        System.setProperty("buildEnv", env)
    }
    jarTask.finalizedBy("bootJar")
}

fun buildDockerTaskConf(dockerPushImage: Jar, env: String) {
    dockerPushImage.group = "docker"
    dockerPushImage.doFirst {
        System.setProperty("buildEnv", env)
    }
    dockerPushImage.finalizedBy("dockerPushImage")
}

根目錄創(chuàng)建env.properties

## dev
env.dev.nacos.server=xxx:8848
env.dev.nacos.namespace=xxx
env.dev.nacos.username=xx
env.dev.nacos.password=xx
## test
env.test.nacos.server=xxx:8848
env.test.nacos.namespace=xxx
env.test.nacos.username=xx
env.test.nacos.password=xx
## prod
env.prod.nacos.server=xxx:8848
env.prod.nacos.namespace=xxx
env.prod.nacos.username=xxx
env.prod.nacos.password=xxx

創(chuàng)建Module, 一種是包含springboot啟動類的模塊，一種是作為公共定義的模塊

gradle 構建spring cloud 微服務工程,spring boot,kotlin,微服務,gradle,java

9. 包含springboot啟動類的模塊的build.gradle.kts文件

公共定義的模塊的build.gradle.kts文件

在公共定義模塊多了的情況，有些模塊可能會出現互相依賴，這時候需要解決，解決方式
1. 盡可能依賴最小模塊，比如只引入mybatisplus-core
2. 抽取出來作為公共模塊
3. springboot3 自動配置類，將引入模塊的配置注入spring

撒花~

補充一個demo工程，不是文中的工程，文中的為微服務，該demo為單一服務 gitee地址文章來源地址http://www.zghlxwxcb.cn/news/detail-763443.html

到了這里，關于springboot gradle kotlin 多模塊（或微服務）統(tǒng)一依賴及版本管理和構建不同環(huán)境打包task,docker鏡像構建task的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！

本文來自互聯(lián)網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。如若轉載，請注明出處：如若內容造成侵權/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經查實，立即刪除！

分享到：

領支付寶紅包贊助服務器費用

Gradle8.4構建SpringBoot多模塊項目
這個版本是Jdk8最后一個SpringBoot版本軟件版本 Gradle 8.4 SpringBoot 2.7.15 JDK 8 2.1、使用Wrapper方式構建好處：統(tǒng)一gradle的版本好處：不用安裝gradle就可以使用 Maven也是一樣的可以用Wrapper的方式 2.2、導包方式列舉常用的四種 ①、implementation 導入依賴，不傳遞給子模塊，依賴項將
2024年02月07日
瀏覽(15)
各個微服務模塊之間互相依賴調用的問題
首先是模塊之間不能夠循環(huán)引用，否則會報循環(huán)依賴引入的錯誤。沒有了模塊之間的相互依賴，在項目中這兩個模塊是相互調用的，分別各自定義相應的Feign接口，如下：最開始寫的運行報錯的代碼如下：報錯信息，如下：報錯的原因是這里定義了兩個Feign接口，都是調用
2024年02月11日
瀏覽(19)
SpringBoot + Kotlin 中使用 GRPC 進行服務通信
示例項目見：kotlin-grpc 一、導入依賴：二、設置Proto 將 proto 文件放在 src/mian/proto 目錄下執(zhí)行 ./gradlew clean build build成功則會在 build/generated/source/proto/main 下生成對應的 grpc 、 grpckt 、 java 文件在程序中可以直接導包引入三、Server端寫一個 service 在 main 入口引入啟動四、Cl
2024年02月16日
瀏覽(26)
Kotlin中的Gradle
1.創(chuàng)建左上角【File】-【New Project】-【Project】，出現以下畫面，如下勾選在配置Gradle時，需要連接網絡下載資源，不然會出現配置失敗的情況。若在構建完畢后，左側的路徑中沒有出現src包，可以在build.gradle文件中最外部添加如下內容（對應的是5.X版本的Gradle）：點擊右側
2024年02月04日
瀏覽(18)
Kotlin版本實現Gradle插件
本文鏈接：https://blog.csdn.net/feather_wch/article/details/131746478 創(chuàng)建一個Gradle項目，并選擇Kotlin/JVM作為項目SDK。假設項目的名稱為hello-plugin。在項目中創(chuàng)建一個新的源集，比如plugin，用于存放插件的源代碼和資源。在src目錄下創(chuàng)建一個plugin目錄，并在其中創(chuàng)建一個kotlin目錄和一個
2024年02月16日
瀏覽(25)
【Android Gradle 插件】Android 依賴管理 ① ( 依賴庫匹配 | 依賴庫查找順序及路徑 | Gradle 資源庫 )
依賴庫匹配 : ?依賴庫由三部分組成依賴庫分組依賴庫名稱依賴庫版本號只有三者都對上 , 依賴庫才能匹配上 , 如依賴庫分組為 androidx.appcompat ,? 依賴庫名稱為 appcompat ,? 依賴庫版本號為 1.3.1 ,? 三者由冒號隔開 ; Android 依賴庫查找路徑 : 首先 , 查找本地的 Gradle 緩存依賴
2024年01月17日
瀏覽(29)
Springboot 多模塊（A依賴B）集成mybatis , mybatis.mapper-locations 配置多個mapper路徑配置
最近在用SpringBoot 多模塊集成mybatis，模塊A 依賴于模塊B, 模塊A 和模塊B 各自有各自的業(yè)務邏輯和mapper 文件，模塊A 的mapper xml 文件存放在resource 下的 mybatisMapper 文件夾，模塊B 的mapper xm 文件存放在 B 模塊的resource 下的 mapper 文件夾，打包時以A 模塊為主，B 以jar 包方式被A 依賴
2024年02月03日
瀏覽(23)
android中gradle的kotlin編譯配置選項
1、Android中的配置使用如下方式開啟在Android中的gradle的kotlin編譯配置：該配置在其余平臺不可用以上配置會開啟Kotlin/JVM 的上下文接收者原型功能，否則該功能不可用，開啟后編碼可以使用以下代碼：傳遞參數的發(fā)過誓可以直接在里面寫 setFreeCompilerArgs([\\\"-opt-in=org.mylibrary.
2024年02月07日
瀏覽(20)
如何查看Android 包依賴關系&gradle依賴管理
關于作者：CSDN內容合伙人、技術專家，從零開始做日活千萬級APP。專注于分享各領域原創(chuàng)系列文章，擅長java后端、移動開發(fā)、商業(yè)變現、人工智能等，希望大家多多支持。我們繼續(xù)總結學習，溫故知新。本文講述如何查看 android 依賴庫關系。 Tasks-help-dependencies 可以看項
2024年01月18日
瀏覽(23)
使用Gradle7.6.1 + SpringBoot3.0.2 + java17創(chuàng)建微服務項目（學習）
這是一個大膽的決定技術版本 spring-boot 3.0.2 spring-cloud 2022.0.2 spring-cloud-alibaba 2022.0.0.0-RC2 mybatis-plus-boot-starter 3.5.3.1 mysql-connector-java 8.0.32 技術版本 java 17 gradle 7.6.1 IDEA 2022.2.4 Nvcat 15 MySQL 8.0.32 打開IDEA創(chuàng)建 SpringBoot項目刪除父項目中的src模塊新建兩個子項目（新建時會重新創(chuàng)建
2024年02月06日
瀏覽(24)