feat: 배치 작업 안정성 개선

src/main/kotlin/com/eodigo/batch/KamisAnnualPriceBatchConfiguration.kt

@@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Value
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.transaction.PlatformTransactionManager
+import org.springframework.web.reactive.function.client.WebClientRequestException
 
 @Configuration
 class KamisAnnualPriceBatchConfiguration(
@@ -50,6 +51,9 @@ class KamisAnnualPriceBatchConfiguration(
             .reader(kamisAnnualPriceReader())
             .processor(kamisAnnualPriceProcessor())
             .writer(kamisAnnualPriceJpaItemWriter())
+            .faultTolerant()
+            .retryLimit(3)
+            .retry(WebClientRequestException::class.java)
             .build()
     }
 
@@ -59,7 +63,7 @@ class KamisAnnualPriceBatchConfiguration(
             .name("kamisAnnualPriceReader")
             .entityManagerFactory(entityManagerFactory)
             .pageSize(CHUNK_SIZE)
-            .queryString("SELECT p FROM Product p ORDER BY p.id ASC")
+            .queryString("SELECT p FROM Product p WHERE p.categoryCode != '500' ORDER BY p.id ASC")
             .build()
     }
 

src/main/kotlin/com/eodigo/batch/KamisDailyPriceBatchConfiguration.kt

@@ -24,6 +24,7 @@ import org.springframework.beans.factory.annotation.Value
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.transaction.PlatformTransactionManager
+import org.springframework.web.reactive.function.client.WebClientRequestException
 
 @Configuration
 class KamisDailyPriceBatchConfiguration(
@@ -55,6 +56,9 @@ class KamisDailyPriceBatchConfiguration(
             .reader(kamisDailyPriceApiReader(null))
             .processor(kamisDailyPriceProcessor(null))
             .writer(kamisDailyPriceJpaWriter())
+            .faultTolerant()
+            .retryLimit(3)
+            .retry(WebClientRequestException::class.java)
             .build()
     }
 

src/main/kotlin/com/eodigo/batch/processor/KamisAnnualPriceProcessor.kt

@@ -4,6 +4,7 @@ import com.eodigo.domain.product.entity.AnnualNationalPrice
 import com.eodigo.domain.product.entity.Product
 import com.eodigo.domain.product.enums.MarketType
 import com.eodigo.external.kamis.KamisApiClient
+import com.eodigo.external.kamis.KamisYearlyPriceItemDto
 import com.eodigo.external.kamis.KamisYearlyPriceSectionDto
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
@@ -22,58 +23,98 @@ class KamisAnnualPriceProcessor(
     private val objectMapper: ObjectMapper = jacksonObjectMapper()
 
     override fun process(item: Product): List<AnnualNationalPrice>? {
-        val currentYear = LocalDate.now().year.toString()
         val kindCode = item.kindCode ?: return null
 
+        val currentYear = LocalDate.now().year.toString()
+
+        try {
+            // 1. API 호출
+            val responseString = fetchAnnualPriceData(item.itemCode, kindCode, currentYear)
+            if (responseString == null) {
+                return null
+            }
+
+            // 2. 응답 파싱 및 필터링
+            val priceItems = parseAndFilterPriceItems(responseString)
+            if (priceItems == null) {
+                return null
+            }
+
+            // 3. 엔티티로 변환
+            return convertToEntities(priceItems, item, currentYear)
+        } catch (e: InterruptedException) {
+            log.warn("Annual price processing was interrupted for product id: ${item.id}", e)
+            Thread.currentThread().interrupt()
+            return null
+        } catch (e: Exception) {
+            log.error(
+                "Failed to process annual price for product id: ${item.id}. Error: ${e.message}"
+            )
+            return null
+        }
+    }
+
+    /** API를 호출하고 응답 문자열을 반환합니다. 유효하지 않은 응답은 null을 반환합니다. */
+    private fun fetchAnnualPriceData(
+        itemCode: String,
+        kindCode: String,
+        currentYear: String,
+    ): String? {
         val responseString =
             kamisApiClient.getYearlyPrices(
                 certKey = apiKey,
                 certId = certId,
                 year = currentYear,
-                itemCode = item.itemCode,
+                itemCode = itemCode,
                 kindCode = kindCode,
             )
 
+        Thread.sleep(200)
+
         if (responseString.isNullOrBlank() || responseString.contains("결과가 존재하지 않습니다.")) {
             return null
         }
+        return responseString
+    }
 
+    /** API 응답을 파싱하여 유효한 가격 아이템 리스트를 반환합니다. 유효 데이터가 없으면 null을 반환합니다. */
+    private fun parseAndFilterPriceItems(responseString: String): List<KamisYearlyPriceItemDto>? {
         val priceSections = normalizePriceSections(responseString)
-
         if (priceSections.isNullOrEmpty()) {
             return null
         }
 
-        // 3. 소매 가격/'상품' 등급인 첫 번째 섹션을 찾음
         val retailPriceSection =
             priceSections.find { it.productClsCode == "01" && it.caption?.contains("상품") == true }
 
-        if (retailPriceSection?.items == null) {
-            return null
-        }
+        return retailPriceSection?.items
+    }
+
+    /** DTO 리스트를 엔티티 리스트로 변환합니다. 현재 연도의 데이터만 필터링합니다. */
+    private fun convertToEntities(
+        priceItems: List<KamisYearlyPriceItemDto>,
+        product: Product,
+        currentYear: String,
+    ): List<AnnualNationalPrice> {
+        return priceItems
+            .filter { it.div == currentYear }
+            .mapNotNull { priceItem ->
+                val yearStr = priceItem.div
+                val priceStr = priceItem.avgData?.replace(",", "")
 
-        // API 응답 item을 엔티티 리스트로 변환
-        return retailPriceSection.items.mapNotNull { priceItem ->
-            val yearStr = priceItem.div
-            val priceStr = priceItem.avgData?.replace(",", "")
-
-            if (
-                yearStr != null &&
-                    yearStr.all { it.isDigit() } &&
-                    !priceStr.isNullOrBlank() &&
-                    priceStr.all { it.isDigit() }
-            ) {
-
-                AnnualNationalPrice(
-                    product = item,
-                    price = priceStr.toInt(),
-                    surveyYear = yearStr.toInt(),
-                    marketType = MarketType.RETAIL,
-                )
-            } else {
-                null
+                if (
+                    yearStr != null && priceStr?.all(Char::isDigit) == true && priceStr.isNotEmpty()
+                ) {
+                    AnnualNationalPrice(
+                        product = product,
+                        price = priceStr.toInt(),
+                        surveyYear = yearStr.toInt(),
+                        marketType = MarketType.RETAIL,
+                    )
+                } else {
+                    null
+                }
             }
-        }
     }
 
     private fun normalizePriceSections(responseString: String): List<KamisYearlyPriceSectionDto>? {

src/main/kotlin/com/eodigo/batch/reader/KamisDailyPriceApiReader.kt

@@ -4,6 +4,7 @@ import com.eodigo.batch.dto.KamisDailyPriceApiData
 import com.eodigo.external.kamis.KamisApiClient
 import java.time.LocalDate
 import java.time.format.DateTimeFormatter
+import org.slf4j.LoggerFactory
 import org.springframework.batch.item.ItemReader
 
 class KamisDailyPriceApiReader(
@@ -15,6 +16,8 @@ class KamisDailyPriceApiReader(
     private val surveyDate: LocalDate,
 ) : ItemReader<KamisDailyPriceApiData> {
 
+    private val log = LoggerFactory.getLogger(javaClass)
+
     // 1. 처리할 모든 API 호출 결과(가격 아이템)를 담아둘 리스트
     private var allItems: MutableList<KamisDailyPriceApiData>? = null
     // 2. 현재 읽고 있는 아이템의 인덱스
@@ -45,26 +48,39 @@ class KamisDailyPriceApiReader(
 
         for (categoryCode in categoryCodes) {
             for (regionCode in regionCodes) {
-                val response =
-                    kamisApiClient.getDailyPrices(
-                        certKey = apiKey,
-                        certId = certId,
-                        regDay = regDay,
-                        categoryCode = categoryCode,
-                        countryCode = regionCode,
-                    )
+                try {
+                    val response =
+                        kamisApiClient.getDailyPrices(
+                            certKey = apiKey,
+                            certId = certId,
+                            regDay = regDay,
+                            categoryCode = categoryCode,
+                            countryCode = regionCode,
+                        )
 
-                if (response?.data?.errorCode == "000") {
-                    response.data.items?.let { items ->
-                        val wrappedItems =
-                            items.map { item ->
-                                KamisDailyPriceApiData(regionCode = regionCode, item = item)
-                            }
-                        allItems?.addAll(wrappedItems)
+                    if (response?.data?.errorCode == "000") {
+                        response.data.items?.let { items ->
+                            val wrappedItems =
+                                items.map { item ->
+                                    KamisDailyPriceApiData(regionCode = regionCode, item = item)
+                                }
+                            allItems?.addAll(wrappedItems)
+                        }
                     }
+                    Thread.sleep(200)
+                } catch (e: InterruptedException) {
+                    log.warn("API call delay was interrupted", e)
+                    Thread.currentThread().interrupt()
+                } catch (e: Exception) {
+                    log.error(
+                        "Failed to fetch data for category: {}, region: {}. Error: {}",
+                        categoryCode,
+                        regionCode,
+                        e.message,
+                    )
                 }
             }
         }
-        println("KamisDailyPriceApiReader: Total ${allItems?.size} items initialized.")
+        log.info("KamisDailyPriceApiReader: Total ${allItems?.size} items initialized.")
     }
 }