Kotlin Spring Boot

A guide to building production Spring Boot applications with idiomatic Kotlin, covering coroutines, data classes, extension functions, REST APIs, and testing patterns for Spring Boot 3.x.

What Is This?

Overview

This skill provides Spring Boot best practices specifically for Kotlin, including project configuration, REST API design with coroutines, data access with Spring Data, security setup, and testing strategies optimized for Kotlin's language capabilities.

Who Should Use This

Perfect for Kotlin developers adopting Spring Boot, Java teams migrating to Kotlin, and backend engineers building microservices. Useful for teams wanting Kotlin's conciseness while maintaining Spring's ecosystem.

Why Use It?

Problems It Solves

Kotlin developers often write Java-style Spring code, missing data classes, null safety, coroutines, and extension functions. Without Kotlin-specific guidance, applications contain verbose boilerplate that idiomatic Kotlin eliminates naturally.

Core Highlights

• Idiomatic Kotlin - Data classes for DTOs, sealed classes for error handling
• Coroutine Integration - Spring WebFlux with Kotlin suspend functions
• Extension Functions - Enhance Spring APIs without inheritance
• Null Safety - Leverage Kotlin's type system with Spring's nullable annotations
• Concise Configuration - Kotlin DSL for beans and security setup

How to Use It?

Basic Usage

Ask Claude about Spring Boot with Kotlin, and this skill provides idiomatic patterns.

Scenario 1: REST API Controller

Ask Claude: "Create a Kotlin REST API with Spring Boot"

Claude will generate:

@RestController
@RequestMapping("/api/users")
class UserController(private val userService: UserService) {

    @GetMapping("/{id}")
    suspend fun getUser(@PathVariable id: Long): ResponseEntity<UserDto> {
        val user = userService.findById(id)
            ?: return ResponseEntity.notFound().build()
        return ResponseEntity.ok(user.toDto())
    }

    @PostMapping
    suspend fun createUser(@Valid @RequestBody request: CreateUserRequest): ResponseEntity<UserDto> {
        val user = userService.create(request)
        return ResponseEntity.status(HttpStatus.CREATED).body(user.toDto())
    }
}

data class UserDto(val id: Long, val name: String, val email: String)
data class CreateUserRequest(
    @field:NotBlank val name: String,
    @field:Email val email: String
)

fun User.toDto() = UserDto(id = id, name = name, email = email)

Scenario 2: Configuration with Kotlin DSL

Tell Claude: "Configure Spring Security with Kotlin DSL"

Claude will use Spring's Kotlin DSL:

@Configuration
@EnableWebSecurity
class SecurityConfig {
    @Bean
    fun securityFilterChain(http: HttpSecurity) = http {
        authorizeHttpRequests {
            authorize("/api/public/**", permitAll)
            authorize("/api/admin/**", hasRole("ADMIN"))
            authorize(anyRequest, authenticated)
        }
        oauth2ResourceServer { jwt { } }
        csrf { disable() }
    }
}

Real-World Examples

Microservices Migration

A logistics company migrated 12 Java Spring Boot services to Kotlin. Data classes reduced DTO boilerplate by 60%, and coroutines simplified async service communication, cutting response times by 35%.

Startup Backend

A SaaS startup built their entire backend in Kotlin Spring Boot. Extension functions created a clean domain API layer, and sealed classes provided exhaustive error handling across all endpoints.

Advanced Tips

Coroutine Error Handling

Use CoroutineExceptionHandler with Spring's @ControllerAdvice for centralized async error handling across all suspend function endpoints.

Testing with MockK

Prefer MockK over Mockito for Kotlin testing. MockK supports coroutines natively and provides idiomatic Kotlin syntax for mocks and verifications.

When to Use It?

Use Cases

• New Kotlin Services - Start Spring Boot projects with idiomatic patterns
• Java Migration - Convert existing Java Spring services to Kotlin
• Reactive APIs - Build WebFlux APIs with Kotlin coroutines
• Microservices - Create lightweight Kotlin-based microservices
• API Design - Build clean REST APIs with data classes and extensions

Related Topics

When you ask Claude these questions, this skill will activate:

• "How to use Kotlin with Spring Boot?"
• "Spring Boot coroutines best practices"
• "Kotlin data classes for Spring DTOs"
• "Configure Spring Security in Kotlin"

Important Notes

Requirements

• Kotlin 1.9+ for latest language features
• Spring Boot 3.1+ for optimal Kotlin support
• JVM 17+ required for Spring Boot 3.x
• kotlinx.coroutines 1.7+ for coroutine support
• Jackson Kotlin module for JSON serialization

Usage Recommendations

Do:

• Use data classes for DTOs - Leverage immutability and generated methods
• Prefer constructor injection - Use val properties in primary constructors
• Apply kotlin-spring plugin - Automatically opens Spring-annotated classes
• Use extension functions - Enhance Spring classes idiomatically

Don't:

• Don't mix Java patterns - Write idiomatic Kotlin, not translated Java
• Don't use field injection - Constructor injection is cleaner and testable
• Don't ignore null safety - Use Kotlin's type system to prevent NPEs

Limitations

• Some Spring annotations require open classes (use kotlin-spring plugin)
• Coroutine debugging is more complex than traditional threading
• Not all Spring libraries have first-class Kotlin support
• Reflection features may conflict with sealed or data classes