스프링배치 tasklet기반 step 시작하기

환경

IDE: intellij
SpringBootVersion: 3.0.11
Gradle: 8.8
Java: 17

build.gradle.kts

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    id("org.springframework.boot") version "3.0.11"
    id("io.spring.dependency-management") version "1.1.0"
    kotlin("jvm") version "1.7.22"
    kotlin("plugin.spring") version "1.7.22"
    kotlin("plugin.jpa") version "1.7.22"
}

group = "com.example"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_17

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-batch")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.springframework.kafka:spring-kafka:3.2.0")
    implementation("mysql:mysql-connector-java:8.0.33")
    implementation("com.querydsl:querydsl-jpa:5.0.0:jakarta")
    implementation("com.querydsl:querydsl-kotlin:5.0.0")

    annotationProcessor("com.querydsl:querydsl-apt:5.0.0:jakarta")

    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.springframework.batch:spring-batch-test")
    testImplementation("org.junit.jupiter:junit-jupiter-api")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
}

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

tasks.withType<Test> {
    useJUnitPlatform()
}

Entity

import jakarta.persistence.*
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.annotation.LastModifiedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.time.LocalDateTime


enum class HouseType(val value: Int) {
    Villa(1), Apartment(0);

    companion object {
        fun fromValue(value: Int): HouseType = values().first { it.value == value }
    }
}

@Converter
class HouseTypeConverter : AttributeConverter<HouseType, Int> {
    override fun convertToDatabaseColumn(attribute: HouseType?): Int? {
        return attribute?.value
    }

    override fun convertToEntityAttribute(dbData: Int?): HouseType? {
        return dbData?.let { HouseType.fromValue(it) }
    }
}


@Entity
@EntityListeners(AuditingEntityListener::class)
data class House(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,
    val address: String,
    val price: Double,

    @Convert(converter = HouseTypeConverter::class)
    val status: HouseType,

    @CreatedDate
    @Column(nullable = false, updatable = false)
    var createdAt: LocalDateTime? = null,

    @LastModifiedDate
    @Column(nullable = false)
    var updatedAt: LocalDateTime? = null,

    @Column(nullable = true)
    var deletedAt: LocalDateTime? = null
)

Repositroy

import com.example.kotlinsimplespringbatch.domain.House
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository
import java.time.LocalDateTime

@Repository
interface HouseRepository : JpaRepository<House, Long> {

    fun findByCreatedAtBetween(
        startDateTime: LocalDateTime,
        endDateTime: LocalDateTime,
        pageable: Pageable
    ): Page<House>
}

Job

import com.example.kotlinsimplespringbatch.adapter.repository.HouseRepository
import com.example.kotlinsimplespringbatch.domain.House
import com.example.kotlinsimplespringbatch.domain.HouseType
import org.springframework.batch.core.Job
import org.springframework.batch.core.Step
import org.springframework.batch.core.job.builder.JobBuilder
import org.springframework.batch.core.launch.support.RunIdIncrementer
import org.springframework.batch.core.repository.JobRepository
import org.springframework.batch.core.step.builder.StepBuilder
import org.springframework.batch.repeat.RepeatStatus
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.transaction.PlatformTransactionManager

@Configuration
class HouseCreationJobConfig(
    val jobRepository: JobRepository,
    val transactionManager: PlatformTransactionManager,
    val houseRepository: HouseRepository
) {

    @Bean
    fun houseCreationJob(houseCreationStep: Step): Job {
        return JobBuilder("houseCreationJob", jobRepository)
            .start(houseCreationStep)
            .incrementer(RunIdIncrementer())  // 재실행
            .build()
    }

    @Bean
    fun houseCreationStep(): Step {
        return StepBuilder("houseCreationStep", jobRepository)
            .tasklet({ contribution, chunkContext ->
                val houses = (1..1000).map { index ->
                    House(
                        address = "Address $index",
                        price = (Math.random() * 1000000 + 100000),
                        status = HouseType.values().random()
                    )
                }
                houseRepository.saveAll(houses)
                RepeatStatus.FINISHED
            }, transactionManager)
            .allowStartIfComplete(true)  // 재실행
            .build()
    }
}