引言

使用 Kotlin 进行 Spring 开发已经有几年了，当初 SSM 的起步学习也是看 Java 教程然后用 Kotlin 对应来搭建学习，发现很融洽后，后面就一直用 Kotlin 在后端进行开发，其中也尝试过 ktor 和 WebFlux 这类新兴框架和新技术，在尝试后，kotlin 在后端的优势也是更加的显而易见，站在巨人肩膀上的语言确实能带给人更多的乐趣，为了更好推动 kotlin 的后端发展，觉得有必要写一篇这种引导文章给对 kotlin 感兴趣的后端开发者们，欢迎更多人了解和尝试 kotlin 的后端的使用。

环境说明

由于是纯 Kotlin 项目，所以不打算用 Maven 构建环境，而是基于 Gradle 构建。

• IDEA: 2025.1.1.1
• Gradle: 8.10
• JDK: 17 #技术分享 #掘金
• MySQL: 8.0.30

环境只是参考，能自己配置对应合适的即可， 不了解Gradle也无伤大雅，知道哪个部分是干嘛的就行，后续可以单独学习，不影响项目搭建。

重新SSM的从零搭建

1. 启动IDEA

作为一个 IDEA 高度依赖患者，为了起步方便我们直接在 IDEA 中创建我们的 Kotlin 项目来改造为 SSM 项目即可

1. 我们选择Kotlin项目创建即可，构建系统记得选Gradle，然后Gradle的DSL我们选择Kotlin(毕竟纯Kotlin项目)。 一定别选错了Kotlin和Groovy这两玩意语法是不同的！！！
2. JDK版本建议新一点17即可，因为们会用Spring6和较新的Kotlin版本。
3. 你可以展开下面的 advanced settings 来设置你用于构建的Gradle所在位置，避免它用默认的gradle下载连接和版本让你等很久。

1.1 自定义我们的Gradle

如果设置了 advanced settings 可以跳过，当然也可以学习下用于以后别的Gardle项目的配置

设置本地Gradle

如果没 advanced settings 设置也没关系，我们可以在项目创建后停止下载然后在 IDEA 菜单的 File->Settings 中来进行配置

这里的 Distribution 默认可能是 wapper，也就是用的 gradle-wrapper.properties 中的默认下载连接,切换为我们的 local installtion 就能选择我们本地的 gradle 了，

修改下载的镜像

如果你不想手动下载一个 Gradle 并且解压来指定 ，也能配置我们的 gradle-wrapper.properties 来切换国内的镜像地址来使用

设置我们的 distributionUrl 为国内阿里云镜像源
https://mirrors.aliyun.com/macports/distfiles/gradle/gradle-8.10-bin.zip 然后重写同步即可

你也可以选择单独使用Gradle进行Init来创建搭建，可能就没使用IDEA这么的方便，不过结果都是一样的都是基于Gradle项目来构建项目

1.2 简单认识一下我们的项目核心文件

下列文件都删减过只留了核心部分

build.gradle.kts

相当于 Maven 的 pom.xml ，我们是一个单体项目不是多模块的所以我们用全局 build.gradle.kts 就能配置我们的项目构建和依赖相关内容，如果是多模块项目每个模块那么每个模块都有自己的 build.gradle.kts ，然后可以从全局 build.gradle.kts 去集成一些公共构建配置和依赖

plugins {

    kotlin("jvm") version "2.1.20"
}

repositories { mavenCentral() }

dependencies { testImplementation(kotlin("test")) }

tasks.test { useJUnitPlatform() }

kotlin { jvmToolchain(17) }

settings.gradle.kts

用于设置我们整个项目的多模块相关的依赖关系和引入，主要用于声明子模块，我们目前单体项目所以没有别的模块引用，只有一个项目名称的设置，Gradle 会识别 src 作为项目的源文件入口不用额外配置。

rootProject.name = "SSMBuild"

gralde->gradle-wrapper.properties

也就是我们刚刚说的 Gradle 构建工具的相关配置，比如上面我们会通过这里去修改 Gradle 的下载源

2. Hello World

在 src->main->kotlin 下创建我们的包和 Main.kt 文件 写一个简单的 hello world

fun main() {
    println("Hello World!")
}

在我们的 main 左边会有一个绿色的运行按钮，直接点击就可以直接运行。

也可以通过application插件去指定我们的main入口所在位置去手动运行，这里我们就不用过多篇幅去说application插件的使用

3. 引入SSM相关依赖

在项目的 build.gradle.kts 中的 dependencies{......} 写入相关的依赖

plugins {

    kotlin("jvm") version "2.1.20"
}

repositories { mavenCentral() }

dependencies { implementation("org.springframework", "spring-webmvc", "6.1.7") implementation("org.springframework:spring-jdbc:6.1.7") implementation("org.mybatis:mybatis-spring:3.0.3") implementation("org.mybatis:mybatis:3.5.13") implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.16.0") runtimeOnly("com.mysql:mysql-connector-j:8.4.0") implementation("org.eclipse.jetty:jetty-server:11.0.15") implementation("org.eclipse.jetty:jetty-servlet:11.0.15") implementation("ch.qos.logback:logback-classic:1.4.14") testImplementation("junit:junit:4.13.2") testImplementation("org.springframework:spring-test:6.1.7") }

tasks.test { useJUnitPlatform() }

kotlin { jvmToolchain(17) }

4. 创建一个简单的数据库

创建一个库叫 ssm 创建一张 user 表

create table if not exists ssm.user
(
    user_id  int auto_increment comment '自增的用户ID'
        primary key,
    name     varchar(10) not null comment '用户名字',
    account  varchar(20) not null comment '账号20位长度',
    password char(32)    not null comment '密码MD5加密过，32位固定'
);

5. 创建项目文件

做一个简单的注册登录

项目的基础包已修改了为 com.ssm 请注意。实际也就构建工具不同，项目文件创建和 Java 的方式基本没区别，所以才说兼容性好，基本没太高的语言迁移成本。(项目分包纯为了快速，不具备参考性)

我们都用 Spring6x 了，所以不打算用XML进行开发，使用注解也方便配置，不折腾人.

5.1 一个model包

在 com.ssm 中创建 model 包，存放一些实体类

1. 创建了一个统一的响应对象，虽然没多少内容但是规范点还是好看的

typealias HttpRes<T> = ResponseEntity<BaseRes<T>>

data class BaseRes<T>( val message: String = "", val data: T? = null, )

1. 创建一个data class的User映射类，简单直观

data class UserEntity(
    var userId: Int? = null,
    var name: String,
    var account: String,
    var password: String
)

1. 写两个DTO用来接收注册和登录

data class UserLoginDTO(
    var account: String,
    var password: String
)
data class UserRegisterDTO(
    var name: String,
    var account: String,
    var password: String
)

1. 再来个查询的VO

data class UserSummaryVO(
    var userId: Int,
    var name: String,
    var account: String,
)

5.2 写个mapper操作表

在 com.ssm 中创建 mapper 包，进行 eneity 的映射操作

@Mapper
interface UserMapper {

@Insert("INSERT INTO user(name,account,password) VALUES(#{name}, #{account}, #{password})") fun insertUser(user: UserEntity): Int

@Select("SELECT * FROM user WHERE account = #{account}") fun getUserByAccount(account: String): UserEntity?

@Select("SELECT * FROM user WHERE name = #{name}") fun getUserByName(name: String): UserEntity?

@Select("SELECT * FROM user WHERE user_id = #{userId}") fun getUserById(userId: Int): UserEntity? }

5.3 必不可少的service

创建个 user 的 Service，不写啥 impl 了，多余的公式化操作了

@Service
class UserService(private val userMapper: UserMapper) {

fun register(userRegister: UserRegisterDTO): HttpRes<Boolean> { userMapper.getUserByAccount(userRegister.account)?.also { return ResponseEntity.status(HttpStatus.CONFLICT).body(BaseRes("账号已存在", false)) } userMapper.getUserByName(userRegister.name)?.also { return ResponseEntity.status(HttpStatus.CONFLICT).body(BaseRes("用户名称已存在", false)) } val encryptedPassword = md5(userRegister.password)

return UserEntity( name = userRegister.name, account = userRegister.account, password = encryptedPassword ).let { newUser ->

userMapper.insertUser(newUser) ResponseEntity.ok(BaseRes("注册成功", true)) } }

fun login(userLogin: UserLoginDTO): HttpRes<Int> { return userMapper.getUserByAccount(userLogin.account)?.let { user ->

val encryptedPassword = md5(userLogin.password) if (user.password == encryptedPassword) { ResponseEntity.ok(BaseRes("登录成功", user.userId)) } else { ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(BaseRes("密码错误", null)) } } ?: ResponseEntity.status(HttpStatus.NOT_FOUND).body(BaseRes("用户不存在", null)) }

fun getUserById(userId: Int): HttpRes<UserSummaryVO> { return userMapper.getUserById(userId)?.let { user ->

val userSummaryVO = UserSummaryVO(userId = user.userId!!, name = user.name, account = user.account) ResponseEntity.ok(BaseRes("查询成功", userSummaryVO)) } ?: ResponseEntity.status(HttpStatus.NOT_FOUND).body(BaseRes("用户不存在")) }

private fun md5(input: String): String { val md = MessageDigest.getInstance("MD5") val digest = md.digest(input.toByteArray()) return digest.joinToString(separator = "") { "%02x".format(it) } } }

5.4 别忘记写controller

创建一个简单的 controller，就直接用函数响应的语法糖了

@RestController
@RequestMapping("/user")
class UserController(
    private val userService: UserService,
) {

@PostMapping("/register") fun register( @RequestBody userRegisterDTO: UserRegisterDTO ): HttpRes<Boolean> = userService.register(userRegisterDTO)

@PostMapping("/login") fun login( @RequestBody userLoginDTO: UserLoginDTO ): HttpRes<Int> = userService.login(userLoginDTO)

@GetMapping("/{userId}") fun getUserById( @PathVariable userId: Int ): HttpRes<UserSummaryVO> = userService.getUserById(userId) }

5.5 再来个AppConfig

写一个 AppConfig 来扫描我们上面的相关 Bean 和配置数据库连接

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = ["com.ssm.controller", "com.ssm.service"])
@MapperScan("com.ssm.mapper")
open class AppConfig {

@Bean open fun dataSource(): DataSource { val dataSource = DriverManagerDataSource() dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver") dataSource.url = "jdbc:mysql://localhost:3306/ssm?useSSL=false&serverTimezone=UTC" dataSource.username = "root" dataSource.password = "你自己的数据库密码" return dataSource }

@Bean open fun sqlSessionFactory(): SqlSessionFactoryBean { val sqlSessionFactoryBean = SqlSessionFactoryBean() sqlSessionFactoryBean.setDataSource(dataSource()) sqlSessionFactoryBean.setTypeAliasesPackage("com.ssm.model") return sqlSessionFactoryBean } }

5.6 设置下日志库

在 src->main->resources 下建一个 logback.xml 用来配置 logback 库，我们只需要一些核心的级别日志

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">

<encoder>

<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) %cyan([%thread]) %green(%logger{36}) - %msg%n</pattern>

</encoder>

</appender>

<root level="INFO">

<appender-ref ref="CONSOLE"/>

</root>

<logger name="org.eclipse.jetty" level="WARN" additivity="false">

<appender-ref ref="CONSOLE"/>

</logger>

<logger name="ch.qos.logback" level="WARN" additivity="false">

<appender-ref ref="CONSOLE"/>

</logger>

</configuration>

6. 启动启动！

创建程序入口，因为我们引入了 Jetty 依赖，所以就直接声明服务启动就行，用 IDEA 去配置外置的启动容器麻烦了(当然不是懒，是因为截图太占位置了)，也为了后面的打包

fun main(): Unit = with(Server(1028)) {

    val springContext = AnnotationConfigWebApplicationContext().apply {
        register(AppConfig::class.java)
    }

    handler = ServletContextHandler().apply {
        contextPath = "/"

        addEventListener(ContextLoaderListener(springContext))

        addServlet(ServletHolder(DispatcherServlet(springContext)), "/*")
    }

    start()
    join()
}

点击 main 左边的绿色按钮后查看下控制台输出

如果左边没启动识别可以右键文件去run，或去IDEA的Configuration手动配置启动

看看你的启动后的控制台是不是下图这样的( 左边文件结构可以自己对照下 )

看到我们的 Completed initialization 就证明我们启动成功了，接下来就是测下 API 了

7. 测下API

我们用 ApiFox 测试下这三个 API，这里我就写了一个结果，其余的没问题，大家可以自行测试

避免冗余篇幅，单测可以自行编写试试，和Java的使用方式没任何区别

8. 来打一个Jar包

8.1 配置构建任务

我们现在成功运行后只是利用 IDEA 来构建运行，那么我们最终要独立出来运行肯定还是要打个包的，细心的小伙伴肯定注意到 IDEA 右边 Gradle 部分的任务里面有一个 Jar 任务，当然那个任务我们需要自己再加以改造，这也是 Gradle 强大的地方,提供了很多预制的构建任务并且我们可以自定义内容。

在 build.gradle.kts 文件中自定义 jar 包打包任务的运行规则，然后同步 Gradle。

plugins{.......}
repositories{.......}
dependencies{.......}
tasks.jar {
    manifest {

        attributes(mapOf("Main-Class" to "com.ssm.MainKt"))
    }

from(configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) })

duplicatesStrategy = DuplicatesStrategy.EXCLUDE

from(sourceSets.main.get().output) }

8.2 运行构建任务

运行任务的几种方式

• 点击右边的jar任务运行
• 使用项目的gradlew脚本运行jar任务

会使用 gradle-wrapper.properties 中的配置的 Gradle 地址下来来构建

./gradlew jar

• 使用全局的gradle运行脚本

这样做你得本机有 Gradle，并且配置环境变量中来使用，并且打包用的也是你本机的这个版本

gradle jar

8.3 运行jar包

打包后在我们的 build->libs 文件夹中就能找到咯，直接 java -jar 即可运行

9. 开源地址

Github: setruth/ssm-kotlin: ssm-kotlin

开箱即用的SpringBoot

Springboot 的构建就很方便了，IDEA 专业版直接提供了 SpringBoot 的 Kotlin 工程快速创建，其创建和开发流程和 Java 无区别就不展开说明了，如果没有使用 IDEA 专业版也可以自行去 官网构建网站 去创建，也提供了 Kotlin 的选择。当然也可以自行挑战下从 SSM 转型为 SpringBoot 工程，换依赖和文件配置都和 Java 相同。

Kotlin 的 SpringBoot 开发和 Java 无任何区别，目前也没遇到比较困难的兼容性问题，基本都是一些序列化和 Open 问题，当然都有对应的解决方案，Kotlin 在 SpringBoot 中已经很成熟了，也欢迎大家尝试。

后记

从 Spring6开始 Spring 就开始对 Kotlin 进行了相关的适配，最近 KotlinConf 也提到了 Kotlin 将和 Spring 进行合作共创 Spring 生态，这些也证明 Kotlin 的优势和好处，近几年国外和国内的 Kotlin 后端应用也说明了 Kotlin 后端确实能有一席之地，Kotlin 也不单单局限于 SSM，Kotlin 自己的后端生态框架比如 Ktorm，Ktor，Exposed 这些都是不错的选择。还有 WebFlux 这种和 Kotlin 设计天然契合的新兴技术，这些对 Kotlin 在后端领域的未来是充满潜力的。它不仅是一个站在巨人肩膀上的语言，更是一个拥有独特生态和理念的平台，有望为开发者带来更高的效率和更好的体验。欢迎大家来共创 Kotlin 后端发展。