springboot+kotlin/java + gradle/maven 多模块项目搭建

最新推荐文章于 2024-04-26 20:19:53 发布
最新推荐文章于 2024-04-26 20:19:53 发布
阅读量1.8k 收藏 5
点赞数 2
分类专栏： kotlin springboot gradle 文章标签： spring maven kotlin gradle springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30192407/article/details/119825245
版权
kotlin 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
springboot
4 篇文章 0 订阅
订阅专栏
gradle
2 篇文章 0 订阅
订阅专栏

文章目录

1 使用gradle + kotlin 版

1.1 创建新项目

  1. 进入新建项目窗口，选择 Spring Initializr ，这是spring官方提供的构建springboot demo的网站 https://start.spring.io，也可直接在此网站上初始化项目后，下载后在导入idea。
    在这里插入图片描述
    依赖：
    在这里插入图片描述

  2. 删掉根项目的src目录
    在这里插入图片描述

1.2 修改build.gradle.kts

  1. 在尾部添加一个空的subprojects：
    在这里插入图片描述
  2. 把dependencies以及tasks移动进去：
subprojects {
    dependencies {
        implementation("org.springframework.boot:spring-boot-starter-web")
        implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
        implementation("org.jetbrains.kotlin:kotlin-reflect")
        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
        testImplementation("org.springframework.boot:spring-boot-starter-test")
    }

    tasks.withType<KotlinCompile> {
        kotlinOptions {
            freeCompilerArgs = listOf("-Xjsr305=strict")
            jvmTarget = "11"
        }
    }

    tasks.withType<Test> {
        useJUnitPlatform()
    }
}
  1. 最后在subprojects开始处apply插件，根据默认的插件进行apply：
    在这里插入图片描述
apply{
        plugin("io.spring.dependency-management")
        plugin("org.springframework.boot")
        plugin("org.jetbrains.kotlin.plugin.spring")
        plugin("org.jetbrains.kotlin.jvm")
    }

注意：plugins中的kotlin是org.jetbrains.kotlin的简写，在subprjects中注意加上即可。

1.3 创建模块

  1. File -> New -> Module，把一些必要选项勾选上：
    在这里插入图片描述
    在这里插入图片描述
  2. 这里创建两个模块：
  • api
  • app
    输入模块信息创建模块
  1. 把两个模块中build.gradle.kts文件里面删除其他部分留下repositories部分：
    在这里插入图片描述

1.4 编写模块。

api模块

  1. 首先根据根目录的build.gradle.kts创建包：
    在这里插入图片描述
  2. 编写TestApi：
package com.example.api

interface TestApi {
    fun test()
}
  1. 最后修改build.gradle.kts，加上tasks.bootJar与tasks.jar：
tasks.bootJar{
    enabled = false
}

tasks.jar{
    enabled = true
}

在这里插入图片描述

app 模块

  1. 先创建包
  2. 添加api依赖
    在这里插入图片描述
  3. 创建启动类和测试controller
    在这里插入图片描述
    代码如下
package com.example.app

import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication

@SpringBootApplication
class Application

fun main(args: Array<String>){
    SpringApplication.run(Application::class.java,*args)
}

package com.example.app

import com.example.api.TestApi
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class TestController: TestApi {
    @GetMapping("test")
    override fun test():String {
        return "kotlin+gradle 搭建多模块"
    }
}

1.5 运行测试

http://localhost:8080/test
在这里插入图片描述

2 使用gradle + java 版

2.1 创建新项目

  1. 进入新建项目窗口，选择 Spring Initializr，这是spring官方提供的构建springboot demo的网站 https://start.spring.io，也可直接在此网站上初始化项目后，下载后在导入idea。
    在这里插入图片描述
    依赖：
    在这里插入图片描述

  2. 删掉根项目的src目录，因为根目录属于管理模块目录不提供运行的应用
    在这里插入图片描述

2.2 修改build.gradle

  1. 在尾部添加一个空的subprojects：
    在这里插入图片描述

  2. 把dependencies以及test移动进去：

subprojects {
    dependencies {
        implementation 'org.springframework.boot:spring-boot-starter-web'
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
    }

    test {
        useJUnitPlatform()
    }
}
  1. 最后一步是，在subprojects开头，添加插件apply，根据默认初始化创建的plugins，逐一添加。比如这里默认使用了三个插件：
    在这里插入图片描述
    apply到subprojects中：
    在这里插入图片描述
	apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
    apply plugin: 'java'

注意：plugins中的kotlin是org.jetbrains.kotlin的简写，在subprjects中注意加上即可。

2.3 创建模块

  1. File -> New -> Module，把一些必要选项勾选上：
    在这里插入图片描述
    在这里插入图片描述

  2. 这里创建三个模块：

  • api
  • service
  • app
    输入模块信息创建模块
    创建好的项目结构
    在这里插入图片描述
  1. 完成创建之后，把三个模块中的build.gradle除了repositories之外的全部删去，仅保留repositories：
    在这里插入图片描述
    在这里插入图片描述

2.4 编写模块。

api模块

  1. 首先根据根目录的build.gradle创建包：com.example.api
    在这里插入图片描述
  2. 编写TestApi：
package com.example.api;

public interface TestApi {
    public String test();
}
  1. 最后修改build.gradle，加上bootJar与jar：
bootJar{
    enabled = false
}

jar{
    enabled = true
}

在这里插入图片描述

service 编写方式同上
Java代码

package com.example.service;

import org.springframework.stereotype.Service;

/**
 * @ClassName TestService
 * @Description
 * @Author qzl
 * @Date 2021/8/21 11:49 上午
 **/
@Service
public class TestService {
    public String test(){
        return "java + gradle + springboot 构建多模块开发";
    }
}

在这里插入图片描述

app 模块

  1. 先创建包

  2. 添加api依赖 和 service依赖
    在这里插入图片描述

  3. 创建启动类和测试controller
    在这里插入图片描述

代码如下

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootJavaGradleApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootJavaGradleApplication.class, args);
    }

}


package com.example;

import com.example.api.TestApi;
import com.example.service.TestService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @ClassName TestController
 * @Description
 * @Author qzl
 * @Date 2021/8/21 11:52 上午
 **/
@RestController
public class TestController implements TestApi {
    @Resource
    private TestService testService;
    @GetMapping("test")
    public String test(){
        return testService.test();
    }
}

2.5 运行测试

http://localhost:8080/test
在这里插入图片描述

3 使用maven+Java版

3.1 创建父工程

  1. 首先，先创建一个 Spring Initializr 工程 maven-java 作为 父工程（不添加任何依赖）：
    在这里插入图片描述
  2. 删除刚创建工程里不需要的文件， 只保留：.idea 文件夹 、项目 pom 文件、以及一个 *.iml 文件。
    注意： 因为父模块只做依赖管理，不需要编写代码，所以 src 文件夹可以直接删除。
    在这里插入图片描述
  3. 删除后结果如下：
    在这里插入图片描述

3.2 创建子模块

  1. 右键点击父工程，选择 New -> Module... 创建子模块。这里依次创建 api、app 共 2 个模块。
    **注意：**除了 app 子模块创建时选择添加 Spring Web 依赖（当然也可以创建时不添加，等后面再手动编辑 pom.xml 文件添加），其他模块暂时不添加依赖。
    在这里插入图片描述

3.3 编辑父工程 pom.xml 文件

将父工程 pom.xml 文件修改成如下内容，里面声明该父工程包含的子模块，同时抽取统一的配置信息和依赖版本控制，这样可以方便子 pom 直接引用，简化子 pom 的配置。

  • 多模块项目中，父模块打包类型必须是 pom。
  • 因为开发框架是 spring boot，父模块默认继承 spring-boot-starter-parent，因此可以删除 spring-boot-starter 和 spring-boot-starter-test 依赖（祖先已经包含了）
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 父模块打包类型必须为pom -->
    <packaging>pom</packaging>
    <!-- 模块说明：这里声明多个子模块 -->
    <modules>
        <module>api</module>
        <module>app</module>
    </modules>
    <!-- parent指明继承关系，给出被继承的父项目的具体信息-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.example</groupId>
    <artifactId>maven_java</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>maven_java</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <!-- 版本说明：这里统一管理依赖的版本号 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>app</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


<!--    <build>-->
<!--        <plugins>-->
<!--            <plugin>-->
<!--                <groupId>org.springframework.boot</groupId>-->
<!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
<!--            </plugin>-->
<!--        </plugins>-->
<!--    </build>-->

</project>

3.4 编辑子模块 pom.xml 文件

  1. 子模块 api 的 pom.xml 文件内容如下，其中 parent 要使用顶层的父模块，同时由于我们项目用到了 Lombok ，所以还添加了 lombok 依赖：
    **注意：**由于子模块的配置信息会继承父模块的，所以子模块原来的 properties 可删掉。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 继承本项目的父工程 -->
    <parent>
        <artifactId>maven_java</artifactId>
        <groupId>com.example</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>api</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
    </dependencies>

</project>
  1. 子模块 app 的 pom.xml 文件内容如下，同样 parent 要使用顶层的父模块，并添加 api 子模块：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 继承本项目的父工程 -->
    <parent>
        <artifactId>maven_java</artifactId>
        <groupId>com.example</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>app</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.5 编写代码

api 模块
在这里插入图片描述

package com.example.api;

public interface TestApi {
    public String test();
}

app 模块
在这里插入图片描述
启动类

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @ClassName Application
 * @Description
 * @Author qzl
 * @Date 2021/8/21 1:29 下午
 **/
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

测试类

package com.example;

import com.example.api.TestApi;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName TestController
 * @Description
 * @Author qzl
 * @Date 2021/8/21 1:32 下午
 **/
@RestController
public class TestController implements TestApi {
	@GetMapping("test")
    @Override
    public String test() {
        return "maven + java + springboot 多模块开发搭建";
    }
}

3.6 启动测试

在这里插入图片描述

3.7 打包部署

  1. 出现maven 打包Could not resolve dependencies for project
    先对父项目进行 clean install 然后子项目clean package发布 ok

4 maven + kotlin 版本

4.1 创建父工程

  1. 首先，先创建一个 Spring Initializr 工程 maven-java 作为 父工程（不添加任何依赖）：
    在这里插入图片描述

  2. 删除刚创建工程里不需要的文件， 只保留：.idea 文件夹 、项目 pom 文件、以及一个 *.iml 文件。
    注意： 因为父模块只做依赖管理，不需要编写代码，所以 src 文件夹可以直接删除。
    在这里插入图片描述

  3. 删除后结果如下：
    在这里插入图片描述

4.2 创建子模块

  1. 右键点击父工程，选择 New -> Module... 创建子模块。这里依次创建 api、app 共 2 个模块。
    **注意：**除了 app 子模块创建时选择添加 Spring Web 依赖（当然也可以创建时不添加，等后面再手动编辑 pom.xml 文件添加），其他模块暂时不添加依赖。
    在这里插入图片描述
  2. 删除不需要的文件,仅仅保留：src,.iml,pom.xml
    删除后的项目结构
    在这里插入图片描述

4.3 编辑父工程 pom.xml 文件

将父工程 pom.xml 文件修改成如下内容，里面声明该父工程包含的子模块，同时抽取统一的配置信息和依赖版本控制，这样可以方便子 pom 直接引用，简化子 pom 的配置。

  • 多模块项目中，父模块打包类型必须是 pom。
  • 因为开发框架是 spring boot，父模块默认继承 spring-boot-starter-parent，因此可以删除 spring-boot-starter 和 spring-boot-starter-test 、kotlin-reflect,kotlin-stdlib-jdk8依赖（祖先已经包含了）
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 父模块打包类型必须为pom -->
    <packaging>pom</packaging>
    <!-- 模块说明：这里声明多个子模块 -->
    <modules>
        <module>api</module>
        <module>app</module>
    </modules>
    <!-- parent指明继承关系，给出被继承的父项目的具体信息-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>maven_kotlin</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>maven_kotlin</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <kotlin.version>1.5.21</kotlin.version>
    </properties>
<!--    包统一管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>app</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

4.4 编辑子模块 pom.xml 文件

  1. 子模块 api 的 pom.xml 文件内容如下，其中 parent 要使用顶层的父模块
    **注意：**由于子模块的配置信息会继承父模块的，所以子模块原来的 properties 可删掉。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <!-- 引用父模块 -->
    <parent>
        <artifactId>maven_kotlin</artifactId>
        <groupId>com.example</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>api</name>
    <description>Demo project for Spring Boot</description>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib-jdk8</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>
  1. 子模块 app 的 pom.xml 文件内容如下，同样 parent 要使用顶层的父模块，并添加 api 子模块：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>
    <!-- 引用父模块 -->
    <parent>
        <artifactId>maven_kotlin</artifactId>
        <groupId>com.example</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>app</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>app</name>
    <description>Demo project for Spring Boot</description>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-kotlin</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib-jdk8</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>api</artifactId>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <configuration>
                    <args>
                        <arg>-Xjsr305=strict</arg>
                    </args>
                    <compilerPlugins>
                        <plugin>spring</plugin>
                    </compilerPlugins>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-allopen</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

4.5 编写代码

api 模块
在这里插入图片描述

package com.example.api

interface TestApi {
    fun test():String
}

app 模块
在这里插入图片描述
启动类

package com.example

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class AppApplication

fun main(args: Array<String>) {
    runApplication<AppApplication>(*args)
}

测试类

package com.example.app

import com.example.api.TestApi
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class TestController: TestApi {
    @GetMapping("test")
    override fun test(): String {
        return "maven + kotlin + springboot 多模块搭建"
    }
}

4.6 启动测试

在这里插入图片描述

4.7 打包部署

  1. 出现maven 打包Could not resolve dependencies for project
    先对父项目进行 clean install 然后子项目clean package发布 ok

5 项目源码

https://gitee.com/qiangzhouliang_admin/springboot_moremodule_framework

善良的爱心话
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
build.gradle.kts添加maven仓库
海阔天空
12-24 4270
build.gradle.kts添加maven依赖
GradleKotlinSpringBootMybatisSQLiteDemo:Gradle+Kotlin结合Spring Boot+Mybatis+SQLite快速开发轻量级服务器应用
05-16
《Gradle+Kotlin结合Spring Boot+Mybatis+SQLite快速开发轻量级服务器应用》 标题想了很多，感觉很多的标题都合适，比如: 《Kotlin + Spring Boot会不会成为一种新的选择？》 《写给Android工程师的服务端开发架构》 《打造轻量级的Java服务器框架，无需部署Tomcat，也无需部署Mysql》 前言 我一直以来都是使用Maven+Java+Tomcat+Springmvc+Mybatis+Mysql来搭建小型服务器应用，这套框架很简单，也方便易用，最近我在想会不会有更好的解决方案，加上最近在学习了Kotlin语言开发Android，所以就有了这篇文章。 框架介绍 该架构使用Gradle+Kotlin+Spring Boot+Mybatis+SQLite来代替Maven+Java+Tomcat+Springmvc+Mybatis+Mys
springboot gradle kotlin 多模块（或微服务）统一依赖及版本管理和构建不同环境打包task,docker镜像构建task
qq_36279799的博客
07-28 2811
在maven里可以在pom.xml中统一定义项目依赖，依赖版本，插件，多环境构建，子模块；定义packaging 为pom类型，各子模块按需引入，并且指定环境profiles构建。在gradle中也可以实现依赖统一管理，各模块按需引入，区分环境的构建任务。先上效果图统一定义依赖，依赖版本，插件子模块按需引入分环境打包task及docker镜像打包任务。
kt-GreeterPlugin：一个快速的小型Kotlin插件，带有Gradle（+ Kotlin DSL）
02-13
迎宾插件 描述 一个用Kotlin（+ Gradle Kotlin DSL）编写的Minecraft插件的简单示例。 该插件的作用是欢迎所有带有“ {name}”的用户加入！ 每当他们加入服务器时。 您应该在游戏中和服务器日志中看到输出。 随时使用，不受惩罚。 为什么这样 使用Maven使我想把头发扯下来。 不得不读/写XML标记感觉不对且已过时，或者我只是对Maven不够熟悉，无法知道其用途。 因此，我认为我会尝试另一个流行的构建系统Gradle。 就我而言，在使用它的几天里，我能够弄清楚如何为Minecraft（Paper）插件进行适当的构建。 话虽如此，如果构建变得比实际复杂，我似乎最终将需要一些Groovy知识。
kotlin-lombok-integration：如何在混合KtJava项目中将Kotlin与Lombok一起使用
02-03
Kotlin + Java / Lombok构建演示 在使用Kotlin已经引起了很多人的问题，用在计算器上与其他地方的一些问题在现有的Java项目中使用Kotlin（见 ， ， ， ， ， ， ） 查看它，有一些建议可以使用Kapt和/或Delombok，但是没有明确的指导，直到我找到： 如果将Java和Kotlin代码放在​​不同的模块中，则应该可以使用。 原理：Kotlin将看到字节码中的所有声明，但看不到Lombok在源代码中即时生成的任何内容 该项目显示了使用Gradle多项目构建的Hello World应用程序，但如果将Java＆Kotlin拆分为，它也适用于Maven。 有关Kotlin + Lombok的更多信息，请参阅此 。 参考文献 这个hello-world应用程序是JetBrains的示例的改编版本。 有关多项目构建的更多信息，请参见（ ＆）。 运行应用 Gradle 运行Main.kt ： $ cd kotlin-lombok-integration $ ./gradlew build $ ./gradlew run > Task :ko
基于最新的Java 21和SpringBoot 3.2 根据eladmin项目进行改造+源代码+文档说明
11-28
要特性 - 使用最新技术栈，社区资源丰富，基于Java 21(Core Module Support 17-21)、Spring Boot 3.2。 (Support Virtual Threads/fibre/loom) - 基于注解的动态查询（Specification），可根据需要扩充查询注解。 - 支持接口级别的功能权限，动态权限控制 - 支持数据字典，可方便地对一些状态进行管理 - 高效率开发，代码生成器可一键生成前后端代码 - 对一些常用前端组件封装：表格数据请求、数据字典等 - 前后端统一异常拦截处理，统一输出异常，避免繁琐的判断 - 使用ShardingSphere实现多数据源和读写分离。该方式针对MySQL数据库。对系统侵入性小。（只需引入依赖，并在yaml中配置数据源信息即可） [unicorn-starter](https://github.com/lWoHvYe/unicorn-starter)。 - 整合Redisson拓展Redis的功能，读写分离 - 整合消息队列RabbitMQ，实现消息通知、延迟消息，服务解耦。 - 各模块独立，基本可插拔：若只需查询注解等基础功能，只需引入Core模块即可，Beans, Security, Logging, 3rd Tools, Code Gen 模块可插拔， 除了传统To B业务，还可用于To C业务（see [OAuth2.0 part](unicorn-oauth2) ） #### 系统功能 - 用户管理：提供用户的相关配置，新增用户后，默认密码为123456 - 角色管理：对权限与菜单进行分配，菜单权限、数据权限(Draft)、接口权限(_In Progress_) - 菜单管理：已实现菜单动态路由，后端可配置化，支持多级菜单 - 部门管理：可配置系统组织架构，树形表格展示(Draft) - 岗位管理：配置各个部门的职位(Draft) - 字典管理：可维护常用一些固定的数据，如：状态，性别等 - 系统日志：记录用户操作日志与异常日志，方便开发人员定位排错 - 定时任务：整合Quartz做定时任务，加入任务日志，任务运行情况一目了然 - 代码生成：高灵活度生成前后端代码，减少大量重复的工作任务（逆向有很多方案，这种基于template的有一定的灵活性） - 邮件工具：配合富文本，发送html格式的邮件 #### 项目结构 项目采用按功能分模块的开发方式，结构如下 - `unicorn-core` 系统的Core模块，BaseClass及各种Util，(基于Multi-Release JAR Files，Support Java 17 - 21) - `unicorn-beans` 基础Beans的Definition及Configuration，To C业务可只引入该dependency - `unicorn-sys-api` Sys Module基础实体及API，方便服务拆分 - `unicorn-security` 系统权限模块，包含权限配置管理等。 - `unicorn-logging` 系统的日志模块，其他模块如果需要记录日志需要引入该模块，亦可自行实现 - `unicorn-tp-tools-kotlin` 第三方工具模块，包含：邮件、S3，可视情况引入 - `unicorn-code-gen-kotlin` 系统的代码生成模块。这部分待优化，亦非必须模块 - `unicorn-starter` [启动类(Maven)，项目入口，包含模块及组件配置（DB读写分离 + Cache读写分离）](https://github.com/lWoHvYe/unicorn-starter) - `valentine-starter` 启动配置示例(Gradle)，尝试Kotlin/Kotlinx - `unicorn-oauth2` OAuth2 Sample，AuthorizationServer, OAuth2Client + Gateway, ResourceServer #### 详细结构 ``` - unicorn-core 公共模块 ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。
gradle-maven-publish-plugin,gradle插件，配置一个uploadarchives任务，自动将所有java、kotlin或android库上载到任何maven实例。.zip
10-11
Gradle插件，创建一个UploadArchives任务，自动将所有Java、Kotlin或Android库上载到任何Maven实例。这个插件基于chris-banes的初始实现，并且已经被增强以添加kotlin支持并跟上最新的更改。
KotlinSpringBoot:带有Spring Boot应用程序和Vanilla Kotlin库模块的多模块Gradle项目
05-19
如何运行 $ ./gradlew build && java -jar application/build/libs/gs-spring-boot-0.1.0.jar
使用Kotlin开发SpringBoot项目
qq_36699660的博客
04-08 620
Springboot的Kotlin使用
Gradle--›Spring Kotlin多模块项目搭建√
<angcyo>菜鸟视角
05-26 1776
文章目录参考文档联系作者 参考文档 Spring官方Gradle构建文档 Spring官方使用Gradle创建Java项目 Spring官方创建多模块项目 联系作者 群内有各(pian)种(ni)各(jin)样(qun)的大佬,等你来撩. 点此QQ对话 该死的空格 点此快速加群 ...
maven工程多模块、项目打包问题
qq_44795091的博客
04-23 4609
（1）找到主类，主类就是你要运行那个作为启动类就是主类，就在主类的pom里加上如下配置（2）这个主类你依赖了其它模块那么子模块的，这个medica-auth模块的pom的build啥也不加，因为spring-boot-maven-plugin的原理就是打成可运行jar包，可运行jar包就是如图这样的，带BOOT-INF。注意这种文件要是你的子模块也打成了BOOT，那么主类启动是扫描不到的，因为springboot是扫描的com.什么什么的，和你配置的包扫描是冲突的。
laboratory:多模块Kotlin Android项目的功能标志
03-18
实验室 :alembic: 多模块Kotlin Android项目的功能标志。 请访问以获取完整的文档和。 TLDR 将实验室依赖项添加到您的项目中。 repositories { mavenCentral() } dependencies { implementation " io.mehow.laboratory:laboratory:0.11.0 " } 启用Java 8支持。 android { compileOptions { sourceCompatibility JavaVersion . VERSION_1_8 targetCompatibility JavaVersion . VERSION_1_8 } kotlinOptions { jvmTarget = " 1.8 " freeCompilerArgs + = " -Xjv
maven-central-publish:只需最少的工作就可以为Gradle项目配置发布到Maven Central
04-05
Maven中央发布 只需最少的工作即可为Gradle项目配置发布到Maven Central存储库。 特征 任务checkPublicationCredentials 确保设置了发布凭据。 任务checkMavenCentralPublication 确保已准备好发布所有已配置的必需信息的项目。 出版mavenCentral 注册名为mavenCentral的出版物。 配置Pom，存储库，凭据以及Maven Central所需的所有其他信息。
gradle-maven-publish-plugin：Gradle插件，用于配置uploadArchives任务以自动将所有Java，Kotlin或Android库上传到任何Maven实例
02-04
gradle-maven-publish-plugin Gradle插件创建了uploadArchives任务，以自动将所有Java，Kotlin或Android库上传到任何Maven实例。 该插件基于并已得到增强，以添加Kotlin支持并紧跟最新变化。 建立 module/build.gradle buildscript { repositories { mavenCentral() } dependencies { classpath ' com.vanniktech:gradle-maven-publish-plugin:0.13.0 ' // F
kotlin-jlink-examples：示例如何在gradle和maven中将jlink与kotlin一起使用
02-04
kotlin-jlink-examples 示例如何在gradle和maven中将jlink与kotlin一起使用。 您可以从以下子目录打开项目： — Gradle示例 — Maven示例
jitpackdemo：具有maven Publishing和kotlin-dsl的多模块android项目的演示
02-05
jitpackdemo：具有maven Publishing和kotlin-dsl的多模块android项目的演示
SpringBoot项目打包分离高阶操作
Record Little
04-23 572
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
SpringCloudAlibaba：2.1nacos
最新发布
m0_63040701的博客
04-26 494
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
spring-security5.x+jwt
qq_67832732的博客
04-26 235
创建过滤器@Component@Autowired@Override//获取tokenif (!//放行return;//解析tokentry {throw new RuntimeException("token非法");//从redis中获取用户信息throw new RuntimeException("用户未登录");//存入SecurityContextHolder。
springboot项目kotlin文件不能打包
05-24
在使用 Spring Boot 开发 Kotlin 项目时，需要确保以下几点： 1. 确认你的项目中包含了 Spring Boot Starter Parent，它可以帮助你自动引入必要的依赖和插件。 2. 确认你的项目中包含了 Kotlin Spring 插件，它可以让 Spring Boot 应用识别 Kotlin 文件。 3. 在打包项目时，需要使用 `mvn clean package` 命令来进行打包。如果你使用的是 Gradle，则需要使用 `gradle clean build` 命令。 如果你已经按照以上步骤配置了项目，但仍然无法打包 Kotlin 文件，可能是由于以下原因： 1. 项目中存在编译错误，导致 Kotlin 文件无法正确编译。需要检查项目中的代码是否存在语法错误或逻辑错误，并进行修复。 2. 项目中缺少必要的依赖或插件。需要检查项目的依赖和插件配置是否正确，并进行修复。 如果以上方法无法解决问题，可以尝试在 Maven 或 Gradle 的配置文件中添加 debug 参数，查看具体的编译错误信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值