선물하기 시스템의 상품 재고는 어떻게 관리되어질까?

class SalesProductPrice(
    type: DiscountType,
    salesProduct: SalesProduct,
    priceCommonId: Long,
    price: Long,
    defaultFlag: Boolean,
    /** 할인 정보 **/
    amount: Long?,
    rate: Int?,
    charge: Long?,
    sellerCharge: Long?,
    franchiseCharge: Long?,
    discountStatus: DiscountStatus?,
    /** 재고 정보**/
    totalQuantity: Long?, // 총 재고수량
    perLimitTotalQuantity: Long?, // 인당 구매제한수량
    stockStatus: StockStatus?,
    status: SalesProductPriceStatus
) : BaseUuidEntity() {
 ...
}

enum class SalesProductPriceStatus(
    description: String
) {
    ON("활성"),
    OFF("비활성"),
    SOLD_OUT("품절");
}

@Entity
@Table(
    name = "stock_history",
    indexes = [
        Index(name = "idx_stock_history_sales_product_number", columnList = "salesProductNumber"),
        Index(name = "idx_stock_history_purchase_number", columnList = "purchaseNumber"),
        Index(name = "idx_stock_history_member_number", columnList = "memberNumber")
    ]
)
class StockHistory(
    salesProductNumber: String,
    purchaseNumber: String,
    memberNumber: String,
    price: Long,
    type: StockHistoryType
) : BaseUuidEntity() {

    @Column(nullable = false, length = 10)
    var salesProductNumber: String = salesProductNumber

    @Column(nullable = false, length = 10)
    var purchaseNumber: String = purchaseNumber

    @Column(nullable = false, length = 20)
    var memberNumber: String = memberNumber

    @Column(nullable = false)
    var price: Long = price

    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 20)
    var type: StockHistoryType = type
}

enum class StockHistoryType(
    val description: String
) {
    PLUS("재고사용량 증가"),
    MINUS("재고사용량 감소");
}

/**
* 재고관리 데이터 클래스
**/
data class Stock(
    val salesProductNumber: String,
    val price: Long,
    val purchaseNumber: String? = null,
    val memberNumber: String? = null
)

/**
 * 전체 재고 사용량 체크 레디스 오퍼레이션
 * 자료구조 : Set
 */
class TotalStockOperation {
    companion object {
        val log = logger()
        private var key = "stock:total"

        /**
         * SADD Operation
         */
        fun add(redisOperations: RedisOperations<String, String>, stock: Stock) {
            val key = getKey("${stock.salesProductNumber}:${stock.price}")
            redisOperations.opsForSet().add(key, stock.purchaseNumber)
            log.info { "[TotalStockOperation][add] 전체 재고 사용량 증가 key $key | 재고정보 $stock" }
        }

        /**
         * SREM Operation
         */
        fun remove(redisOperations: RedisOperations<String, String>, stock: Stock): Long? {
            val key = getKey("${stock.salesProductNumber}:${stock.price}")
            val popCnt = redisOperations.opsForSet().remove(key, stock.purchaseNumber)
            log.info { "[TotalStockOperation][remove] 전체 재고 remove key $key | 재고정보 $stock | remove원소수: $popCnt" }
            return popCnt
        }

        /**
         * SCARD Operation
         */
        fun totalUsedCount(redisOperations: RedisOperations<String, String>, stock: Stock): Long {
            val key = getKey("${stock.salesProductNumber}:${stock.price}")
            val size = redisOperations.opsForSet().size(key) ?: 0
            log.info { "[TotalStockOperation][totalUsedCount] 전체 재고량 TOTAL key $key | 재고정보 $stock | 총수량: $size" }
            return size
        }

        fun getKey(keyPrefix: String) = "$keyPrefix:$key"
    }
}

...

/**
 * 회원당 재고 사용량 체크 레디스 오퍼레이션
 * 자료구조 : Set
 */
class MemberStockOperation {
    companion object {
        val log = logger()
        private var key = "stock"

        /**
         * SADD Operation
         */
        fun add(redisOperations: RedisOperations<String, String>, stock: Stock) {
            val key = createKey("${stock.salesProductNumber}:${stock.price}", stock.memberNumber!!)
            redisOperations.opsForSet().add(key, stock.purchaseNumber)
            log.info { "[MemberStockOperation][add] 회원인당 재고 사용량 증가 key $key | 재고정보 $stock" }
        }

        /**
         * SREM Operation
         */
        fun remove(redisOperations: RedisOperations<String, String>, stock: Stock): Long? {
            val key = createKey("${stock.salesProductNumber}:${stock.price}", stock.memberNumber!!)
            val popCnt = redisOperations.opsForSet().remove(key, stock.purchaseNumber)
            log.info { "[MemberStockOperation][remove] 회원인당 재고 remove key $key | 재고정보 $stock | remove원소수: $popCnt" }
            return popCnt
        }

        /**
         * SCARD Operation
         */
        fun totalUsedCount(redisOperations: RedisOperations<String, String>, stock: Stock): Long {
            val key = createKey("${stock.salesProductNumber}:${stock.price}", stock.memberNumber!!)
            val size = redisOperations.opsForSet().size(key) ?: 0
            log.info { "[MemberStockOperation][totalUsedCount] 회원인당 재고량 TOTAL key $key | 재고정보 $stock | 총수량: $size" }
            return size
        }

        private fun createKey(keyPrefix: String, keyPostFix: String) = "$keyPrefix:$key:$keyPostFix"
    }
}

/**
* 레디스의 여러 오퍼레이션을 하나의 트랜잭션에서 처리하기 위해 multi() / exec() 연산으로 묶어준다.
**/
object RedisTransaction {
    fun transaction(operations: RedisOperations<String, String>, command: (operation: RedisOperations<String, String>) -> Unit) {
        operations.execute(object : SessionCallback<Void?> {
            @Throws(DataAccessException::class)
            override fun <K, V> execute(callbackOperations: RedisOperations<K, V>): Void? {
                callbackOperations.multi()
                command.invoke(operations)
                callbackOperations.exec()
                return null
            }
        })
    }
}

@Service
@Transactional // 1) 트랜잭션 Begin 5) 트랜잭션 Commit
class StockHistoryDomainService(
    private val redisTemplate: RedisTemplate<String, String>,
    private val stockHistoryRepository: StockHistoryRepository,
    private val saleProductDomainService: SalesProductDomainService
) {
    ...
    @Synchronized
    fun increaseStock(data: StockHistoryData, totalQuantity: Long, perLimitTotalQuantity: Long): StockResult {
        val stock = Stock(
            salesProductNumber = data.salesProductNumber,
            purchaseNumber = data.purchaseNumber,
            memberNumber = data.memberNumber,
            price = data.price
        )

        // 2) 유효성 검증 (인당 제한 수량 체크)
        if (!validationMemberQuantity(perLimitTotalQuantity, stock)) {
            return StockResult.MEMBER_LIMIT
        }

        // 2) 유효성 검증 (전체 재고 수량 체크)
        return if (validationTotalQuantity(totalQuantity, stock)) {
            RedisTransaction.transaction(
                redisTemplate
            ) { operations ->
                log.info { "[StockHistoryDomainService][increaseStock] 상품 구매완료 재고정보 : $stock" }
                // 3) 재고 사용량 증가
                TotalStockOperation.add(operations, stock)
                MemberStockOperation.add(operations, stock)
                // 4) 히스토리 정보 추가
                stockHistoryRepository.save(StockHistoryConverter.toEntity(data))
            }

            // 재고 품절처리
            this.checkSoldOut(totalQuantity, stock)
            StockResult.SUCCESS
        } else {
            StockResult.TOTAL_LIMIT
        }
    }

    fun validationMemberQuantity(
        perLimitTotalQuantity: Long,
        stock: Stock
    ): Boolean {
        return validateQuantity(total = perLimitTotalQuantity, quantity = MemberStockOperation.totalUsedCount(redisTemplate, stock))
    }

    fun validationTotalQuantity(
        totalQuantity: Long,
        stock: Stock
    ): Boolean {
        return validateQuantity(total = totalQuantity, quantity = TotalStockOperation.totalUsedCount(redisTemplate, stock))
    }

    private fun validateQuantity(total: Long, quantity: Long): Boolean {
        log.info { "[StockHistoryDomainService][validateQuantity] $total > $quantity (${total > quantity})" }
        return total > quantity
    }

    private fun checkSoldOut(totalQuantity: Long, stock: Stock) {
        val totalUsedCount = TotalStockOperation.totalUsedCount(redisTemplate, stock)
        log.info { "재고 품절 상태 체크 (전체수량:$totalQuantity | 전체 사용량:$totalUsedCount)" }
        if (totalQuantity <= totalUsedCount) {
            saleProductDomainService.updateSoldOut(
                salesProductNumber = stock.salesProductNumber,
                price = stock.price
            )
        }
    }

}

/**
* 재고사용량 차감 이벤트 서브스크라이버
**/
@Component
class StockNotificationSubscriber(
    private val stockNotificationProcessor: StockNotificationProcessor
) {

    val log = logger()

    @SqsListener(
        value = ["\${messaging.subscriber.sqs-url.gift-product-purchase-stock-event}"],
        deletionPolicy = SqsMessageDeletionPolicy.NEVER
    ) // 재고사용량 차감에 대한 이벤트를 수신한다.
    fun receivePurchaseStockEvent(
        @Header("ApproximateReceiveCount") receiveCount: String,
        @Header("MessageId") messageId: String,
        @Payload payLoad: StockPurchasePayload,
        acknowledgment: Acknowledgment
    ) {
        try {
            log.info("[StockNotificationSubscriber][receivePurchaseStockEvent] messageId : $messageId | payload: $payLoad")
            stockNotificationProcessor.process(payLoad) // 이벤트 프로세서에서 차감 로직을 수행하도록 호출한다.
            acknowledgment.acknowledge()
        } catch (e: Exception) {
            log.error("[StockNotificationSubscriber][receivePurchaseStockEvent] ERROR messageId : $messageId, receiveCount : $receiveCount", e)
        }
    }
}

...

/**
* 재고사용량 차감 이벤트 프로세서
**/
@Component
class StockNotificationProcessor(
    private val stockHistoryDomainService: StockHistoryDomainService
) {

    val log = logger()

    fun process(payLoad: StockPurchasePayload) {
        log.info("[StockNotificationProcessor][process] 이벤트 프로세싱 시작: $payLoad")
        stockHistoryDomainService.decreaseStock(convertData(payLoad)) // 재고 사용량을 차감한다.
        log.info("[StockNotificationProcessor][process] 이벤트 프로세싱 끝 | payload: $payLoad")
    }

    private fun convertData(payLoad: StockPurchasePayload) = StockHistoryData(
        salesProductNumber = payLoad.salesProductNumber,
        purchaseNumber = payLoad.purchaseNumber,
        memberNumber = payLoad.memberNumber,
        price = payLoad.price,
        type = StockHistoryType.MINUS
    )
}

/**
* 재고사용량 감소 서비스레이어
**/
@Service
@Transactional
class StockHistoryDomainService(
    private val redisTemplate: RedisTemplate<String, String>,
    private val stockHistoryRepository: StockHistoryRepository,
    private val saleProductDomainService: SalesProductDomainService
) {
    ...
    fun decreaseStock(data: StockHistoryData) {
        val stock = Stock(
            salesProductNumber = data.salesProductNumber,
            purchaseNumber = data.purchaseNumber,
            memberNumber = data.memberNumber,
            price = data.price
        )

        RedisTransaction.transaction(
            redisTemplate
        ) { operations ->
            log.info { "[StockHistoryDomainService][decreaseStock] 상품 취소완료 재고정보 : $stock" }
            TotalStockOperation.remove(operations, stock) // Redis 전체 재고 사용량 차감
            MemberStockOperation.remove(operations, stock) // Redis 인당 재고 사용량 차감
            stockHistoryRepository.save(StockHistoryConverter.toEntity(data)) // 히스토리 저장
        }
    }
}