• [개발생각] Kotlin JDSL사용을 해야 했어….

    이번 프로젝트에서

    jpa를 적극적으로 사용하되,

    배치등에서는 mybatis를 사용하고,

    어드민에서는 querydsl을 사용하는것으로 결정을 했었다.

    api프로젝트에서는 jpa를 적극적으로 사용하여, 쿼리의 중복이나 엔티티의 관리를 철저히하는 방향으로 갔고,

    배치등에서는 배치잡의 특성상 조인과 조건등이 복잡한 쿼리가 다수존재하고,

    해당 조건들을 jpa로 풀어낼수가 없는 경우도 많아서, mybatis를 사용하기로 했다.

    하지만, 지금 생각하면, 아쉬운 결정을 한것같다.

    api쪽은 jpa를 통해서 엔티티를 관리하는 방법을 사용했기에, 몇몇 통계데이터를 jpql쿼리로 사용하는것 말고는 거의 대부분을 Repository인터페이스를 통해 구현을 했기에, 일관성을 유지하고 중복을 제거하는 효과를 보았다. 

    하지만 배치쪽 프로젝트는 mybatis를 사용함에 따라..

    결국 또 중복 쿼리나 mapper가 관리가 되지않는 케이스가 발견이 되었다.

    결과가 안좋을수도있다고는 생각했지만, 개발자들이 잘 정리를 하면서 하면 되겠지 라는 안일한 생각을 했는데..

    역시, 다수의 개발자들이 개발을 진행할때, 다른개발자의 코드를 보고 중복/개선을 해나가면서 하기란 어려운듯하다..

    (뭐, 어렵지만 이걸 해내는 집단도 사실은 있다.. 하기나름이긴하지만;;;.. 어려운 일이긴하지..)

    그래도, 배치쪽의 잡들이 많이 정리가 되고, 카테고리화되고, 정제된 상태로 개발이 진행되긴해서, 

    엄청나게 관리가 안된것은 아니지만, 그래도 좀 아쉽긴 하다.

    가능하다면, kotlin jdsl로 바꾸고싶은 생각이 있다.

    역시 조금의 예외를 둬버리면, 그 틈을 파고드는게 개발인듯하다.

    mybatis의 그 무질서함의 단점이 결국은 나타나게 됬으니 말이다..

    아래 jpql

    @Query("""
        select u
        from User u
        where u.name = :name
          and u.age >= :age
    """)
    fun findUsers(
        name: String,
        age: Int
    ): List<User>

    아래 jdsl

    fun findUsers(
        name: String,
        age: Int
    ): List<User> {
        return queryFactory.listQuery<User> {
            select(
                entity(User::class)
            ).from(
                entity(User::class)
            ).whereAnd(
                path(User::name).equal(name),
                path(User::age).greaterThanOrEqualTo(age)
            )
        }
    }

    jdsl을 사용하면, 기존 jpa entity를 그대로 사용할수있고, 빌더패턴으로 쿼리를 만들어 사용할수있다.

    물론 queryDsl도 위와 비슷하게 사용이 가능하지만, QueryDsl의 단점중에 단점…

    QClass 컴파일이 jdsl은 없다는게 가장큰 장점이다.

    JpaRepository와 Jdsl을 같이 혼합하여 잘사용하면,

    jpa entity를 유지하면서, 복잡한 쿼리등을 관리하는데 더욱 유용할것같다.

    우선은 오픈하기전에 시간이 주어진다면,

    api프로젝트쪽의 jqpl쿼리로 구성된 부분은 jdsl로 수정을 하는 방향을 좀 생각해봐야겠다.

    배치, 어드민등의 프로젝트보다, 도메인의 관리가 더 철저해야하는 api프로젝트는 jdsl로 변경을해서,

    일관성을 가져가는것이 더 좋다고 생각이 되기 때문이다.

    예전에는 완성이 거의된 기능들을 유지/관리/개선의 명목으로 수정을 하는것이 너무 무서워했었다.

    당연한것이, 잘못하면 버그가 양산되는것이고, 잘하면 현재처럼 동작하는것이니, 사실 열심히해야 본전인 작업이기 때문이다.

    하지만, 요즘은 그냥 여러생각하지않고, 그냥 바로 개선/수정해버린다.

    (지금 안하면, 또 언제할까?라고 생각을 한다랄까?ㅋ)

    그 개선작업을 했냐, 안했냐에 따라, 향후 유지보수,기능추가에 막대한 영향을 끼치기 때문이다.

    개선에 대한 두려움은 이겨내야한다.

    개선하지 않은 코드들이 향후 발생시킬 버그들을 생각하면, 이겨내야한다는 말이 어떤의미인지 알수있는 날이 온다.

    요즘은 intellij가 있어서, 대량의 개선, 코드수정등도 쉽지않아? ㅋㅋㅋ

    My God is intelliJ

  • [개발생각] 미션 보상 기능을 코틀린 DSL 사용하면..

    미션이 여러개 있고, 그 미션의 조건들에 따라 보상을 다양하게 주어야하는 보상시스템을 만들어야 한다고 했을때, 

    가장 먼저 떠오르는방법은 전략패턴을 이용하여 각각의 미션 전략을 만들고, 그것들을 관리하고 동작하도록 하는 방법일것이다.

    여기서 중요한 부분은 그 전략들을 선언할때, 인터페이스를 이용하여 구현을 하게 되는데,

    이 인터페이스가 때로는, 코드를 읽거나 흐름을 파악하기가 어렵게 숨어서 동작하게 되는 케이스가 있다. 

    로직이 복잡하여,

    공통 로직을 수행하고, 여러 다양한 추가 로직을 수행하는것들이 더덕더덕 붙을때가 이런 경우중에 하나이다.

    이렇게 좀더 흐름을 쉽게 이해하고 한눈에 보이게 하려면,

    DSL을 구현하여 사용하면 좀더 깔끔하게 코드를 구성할수있다.

    DSL의미가 도메인 특화 언어(문법)이기때문에,

    도메인에 대한 흐름을 훨씬 잘 표현할수있게 구성할수있다.

    rewardPolicy {
        whenEvent<UserRegistered> {
            ifCondition {
                isFirstRegistration()
                friendCount >= 3
            }
    
            giveReward {
                point(1000)
            }
        }
    }

    위와같이 코드를 표현할수있다.

    이렇게 할수있는 이유가 lamda와 receiver등이 코틀린에서는 잘되어있기 때문이 아닐까 한다.

    아래와 같이 DSL코드를 작성하면, 위와같이 DSL로 사용할수있다.

    class RewardRuleBuilder<E : RewardEvent>(
        private val eventType: Class<E>
    ) {
    
        private val conditions =
            mutableListOf<(RewardConditionContext) -> Boolean>()
    
        private var reward: Reward? = null
    
        fun ifCondition(
            block: RewardConditionContext.() -> Unit
        ) {
            //조건 추가
        }
    
        fun giveReward(
            block: RewardBuilder.() -> Unit
        ) {
            reward = RewardBuilder()
                .apply(block)
                .build()
        }
    
        fun build(): RewardRule {
            return RewardRule(
                eventType = eventType,
                conditions = conditions,
                reward = reward
            )
        }
    }

    예전에 시나리오 베이스 챗봇 프로젝트를 코틀린으로 진행한적이 있었는데,

    그때 시나리오의 작성을 DSL로 구현을 했던적이 있다.

    뭐 대충 아래와 같이 동작하는 챗봇 DSL을 만들었었다.

    scenario {
    
        Entry("A") {
    
             condition() {
    
             }
    
        } to Entry("B") {
    
            condition() {
    
             }
    
       }
    
    }

    DSL로 구현을 하면, 해당 흐름에 대해서, 동작의 흐름이 명확하게 표현이 된다.

    그리고 여러 공통 로직이나, 여러 기능을 쉽게 녹일수가 있어서 유용하다.

    그리고 DSL만 잘 관리하면, 유지보수 측면에서도 장점이 많다.

    불행히, 이번 프로젝트에서는 적용을 하지 못했다… 

    DSL을 만들기 위해서는 정책, 흐름이 명확히 끝난 상태여야 DSL제작이 가능하고, 효과가 있다.

    흐름이 명확하지 않은 상태에서,

    이후에 DSL의 흐름을 매번 변경하는 부분은 상당히 많은 코드를 건드리고 수정해야하는 부담이 되는 작업이기 때문이다.

    interface 클래스의 default 함수를 통해, 해결을 하긴했는데,

    DSL로 구성을 했으면,

    좀더 확장성있고, 흐름을 쉽게 파악할수있는 코드로 구성할수가 있었는데… 좀 아쉽네 (그래도 나름 만족)

    향후, 좀더 흐름과 정책이 명확해진 상태에서 한번 DSL을 도입해서, 수정을 해봐야겠다.

  • [개발생각] FSM을 사용하자.

    미션 보상 서비스를 급하게 하나 만들어야 하는데… 하.. 만들지말까..정말..

    (오픈준비를 하는 시점에, 기획 해달라고 예전부터 요청한걸 묵혔다가,

    기획 정리도 안된 예전 기획서 대로 그냥 만들어달라고하여, 꼭지가 돈다)

    하지만, 아무리 그래도, 개발은 해야할듯하여, (개발자 직업을 택한 내가 죄인이다…ㅠ)

    주말에 어떻게 구현을 할것인가를 생각을 해봤는데..

    미션 보상 조건이 상당히 복잡하다.. 

    하지만 좀더 정리를 해보니, 여러조건이 순서대로 일어나고,

    해당 순서대로 조건이 부합될때 보상을 해주는 흐름인것으로 파악을 했고,

    순서가 있는 여러조건의 흐름에 맞는 설계는 FSM을 이용한 설계가 적합하지 않을까 생각이 들어서,

    시스템 설계를 좀 해봤다.

    우선, 기본적인 유저의 행동에 대한 이벤트는 이미 구현이 되어,

    실제 행동에 대한 이벤트는 이벤트큐로 받을수 있는 상태라 그나마 다행이였다.

    여기서 중요한건, 미션 보상을 위한 이벤트를 더 추가할 생각은 없다는것이다.

    이벤트가 많아지고, 그 이벤트로 동작하는 구현들이 많아지면, 나중에는 흐름이 복잡해고 파악이 상당히 어렵기 때문이다.

    그래서, 실제 해당 유저이벤트를 사용하는 리스너도 상당히 제한해서 사용하고 있다.

    따라서, 미션 보상 서비스를 쉽게 만들기 위해서 이벤트를 더 늘리지는 않으려고 한다.

    우선 코틀린에서 사용할수있는 FSM중에 KStateMachine을 사용하기로 했다.

    spring fsm도 있지만, 경험상 상대적으로 너무 무겁고, 오버스펙으로 보여서,

    우선 가볍고 사용하기 쉬운 KStateMachine으로 선택을 하였다.

    그리고 FSM을 사용할때,

    고민인 부분인 FSM을 유저기준으로 여러개를 만들것인지,

    그때그때 만들고 버리는 방법을 사용할것인지를 선택을 잘해야한다.

    물론 이 선택의 기본조건은 persistence하게 state를 유지해야한다는 것이다.

    (나는 persistence 레이어를 레디스를 사용하기로 했다)

    우선 좀더 자세한것은, 출근하면…더 보기로 하고…ㅎㅎ

    아래와 같이 간단하게 뼈대를 구성했다. 

    @Configuration
    class ComplexRewardEventConsumeJob(
        private val kafkaTopicProperties: KafkaTopicProperties,
        private val redisTemplate: RedisTemplate<String, String>,
        private val friendRewardFsm: FriendRewardFsm
    ) {
        private val log = logger()
    
        @Bean
        fun complexRewardEventConsumeRouteBuilder() = hawaiiBatch {
            fromKafka(
                topic = kafkaTopicProperties.userEvent.name,
                groupId = "complex-reward-batch-consumer",
                consumersCount = kafkaTopicProperties.userEvent.consumersCount,
                maxPollRecords = kafkaTopicProperties.userEvent.maxPollRecords,
                batching = false
            ).prepared { exchange, _, body ->
                val event = try {
                    hawaiiObjectMapper.readValue(body as String, RawUserEvent::class.java)
                } catch (ex: Exception) {
                    log.error("*complexRewardEventConsumeRouteBuilder Error : ${ex.message} , rawEvent: ${body as String}")
                    return@prepared
                }
    
                val userId = event.event["userId"] as Long
                val currentState = redisTemplate.opsForValue().get("fsm_state:${userId}") ?: UserRewardState.Pending.name!!
                val fsm = friendRewardFsm.createFriendRewardFsm(currentState,ComplexRewardContext(userId = userId))
    
                //fsm작동 (제휴사별 fsm을 만들어야함...)
                when(event.eventType) {
                    UserEventTypeEnum.REGISTER -> {
                        fsm.processEventBlocking(RewardEvent.UserRegistered)
                    }
    
                    UserEventTypeEnum.RECOMMENDER_USER -> {
                        fsm.processEventBlocking(RewardEvent.RecommenderUserCompleted)
                    }
    
                    UserEventTypeEnum.DR_SUCCESS -> {
                        fsm.processEventBlocking(RewardEvent.RewardIssued)
                    }
                    else -> {}
                }
    
            }
        }
    }

    코드의 설명은,

    camel로 user event를 컨슘하고, 해당 이벤트의 타입별로 state전이 이벤트를 발생시킨다.

    여기서 fsm을 생성할때는 redis에서 userId별로 저장된 최근 state를 가져와서 초기 상태를 설정하여, fsm을 생성한다.

    이렇게 하여 지속적인 상태를 유지하며, 전이를 발생시킨다.

    우선은 이런 흐름으로 가고, 해당 이벤트에 따른 전이시,

    각 이벤트에서 체크를 해야하는 부분은 guard에 구현을 하여 조건을 판별하도록 구현을 하면 될듯하다.

    이런 미션 이벤트의 조건이 여러셋이 있기에, 이런 fsm의 흐름을 조건별로 세트로 만들어두고 해당 fsm들에 이벤트를 던져 fsm내에서 조건을 판별하여, 전이가 일어나도록 하면, 복잡하고 조건이 많은 보상조건도 잘 정리를 하여 개발이 가능할듯하다..

    나중에는 FriendRewardFsm같이 여러 Fsm을 만들고, 체이닝하여 순회하게만 만들면, 여러 조건셋에 대한 보상기능으로도 확장이 된다.

    예전에 처음 FSM을 사용했을때가 생각이난다.

    너무 많은 유저대상으로 개별로 FSM을 풀로 생성하는 방법을 사용했다가, GC가 발생했던 문제나,

    멀티 인스턴스에서 FSM풀을 사용하고, FSM을 삭제할때, 해당 인스턴스에서만 삭제를 하여, 다른 인스턴스에 FSM이 남아있게되어, GC가 발생했던 문제…

    (라운드로빈으로 멀티 인스턴스로 요청이 들어가기에, 여러 인스턴스에 같은 유저기준으로 fsm이 만들어지게 되기에, fsm을 삭제시는 여러 인스턴스 모두에서 해당 유저기준 fsm이 있는지 확인하여 모두 삭제를 해야한다. 물론 이게 풀로 해당 fsm을 유지했기에 더문제가 컸다)

    이런 이유때문에,

    풀기능은 사용하지않고, 가벼운 fsm을 선택했고, 필요할때마다 사용하고 버리는 방식으로 구현을 하려고 한다.

    spring-fsm이 상당히 무거웠다.

    다행히 KStateMachine은 상당히 가벼운 객체이기에, 풀을 사용하지 않아도, 그때그때 사용하고 버려도 되겠다는 판단을 하였다.

    시간이 좀만더 주어졌더라면, FSM + RULE(DSL) 구조로 더 잘 만들수있었겠지.. 

    참 아쉽다..(나는 이런 상황이 참 아쉽고, 화가난다.. 더 잘할수있었는데, 못하게 되는 상황…)

    기획/요건을 제때만 주었어도, 좀더 멋들어지고, 쿨하고, 유지보수/확장성도 좋게 개발에서 알아서 만들어 줄텐데…

    왜 이런 복을 자꾸 차버리는 것일까??

    참으로 안타깝다.. 모두를 점점 더 힘들게 만드는 이런식의 일처리..

  • [개발생각] 다양한 객체를 하나의 컨슈머로 발행하여 사용하고 싶을때

    다른 형태의 객체를 같은 토픽으로 발행하고, 해당 타입에 따라, 별도로 기능을 동작시키고 싶을때,

    objectMapper를 잘사용하면, 간단하게 구현을 할수가 있다.

    아래와 같이 UserEvent객체는 각각,
    UserEventTypeEnum.AttendanceDayOnce 일때는

       – UserEvent의 event필드는 AttendanceDayOnceEvent객체가 들어가고,

    UserEventTypeEnum.UserRecommend 일때는

      – UserEvent의 event필드는 UserRecommendEvent객체가 들어간다.

    그리고 UserEvent는 같은 토픽으로 이벤트 발행이 됬을때,

    UserEvent를 RawUserEvent형태로 deserialize를 한다.

    eventType를 판단하여,

    각 이벤트에 맞게 event필드를 AttendanceDayOnceEvent, UserRecommendEvent등으로 변환한다.

    이 변환할때는 objectMapper의 convertValue함수를 이용하면 편하게 변환을 할수있다.

    예전에 convertValue를 사용하지않을때는,

    objectMapper를 이용해서, serialize를 한번하고, 다시 deserialize를 하는 방법을 사용했다..

    (물론, convertValue도 serialize와 deserialize를 내부적으로 수행하지만, 중간 단계없이 parser에서 바로 객체를 맵핑해주기에, 좀더 효율적으로 구동이 되고, 더 빠르다. 그리고 serialize, deserialize가 코드에 노출되는게 너무 꼴보기 싫어…ㅠ)

    그래서 이런 패턴일때는 convertValue함수를 적극 활용하면, 좋다.

    아래는 코드 샘플!!!

    data class RawUserEvent(
        val eventType: UserEventTypeEnum,
        val event:Map<String, Any>,
    )
    data class UserEvent(
        val eventType: UserEventTypeEnum,
        val event: UserEventSpec
    )
    
    interface UserEventSpec {
        val userId:Long
    }
    
    data class AttendanceDayOnceEvent(
        override val userId: Long,
        val loginDtm: LocalDateTime,
    ) : UserEventSpec
    
    
    data class UserRecommendEvent(
        override val userId: Long,
        val recommenderUserId: Long,
    ) : UserEventSpec

    UserEvent객체를 objectMapper.writeValueAsString(userEvent) 해서,

    kafka topic에 publish를 했다고 해보자. (AttendanceDayOnceEvent, UserRecommendEvent)

    kafka consumer에서는 아래와 같이 구현을 했을때,

    @KafkaListener(topics = ["test"])
    fun consumeEvent(rawEvent: String) {
            with(objectMapper) {
                val rawUserEvent = readValue(rawEvent, RawUserEvent::class.java)
                when (rawUserEvent.eventType) {
                    UserEventTypeEnum.AttendanceDayOnce -> {
                        val event  = convertValue<AttendanceDayOnceEvent>(rawUserEvent.event)
                        usernManageUseCase.attendanceDayOnce(event)
                    }
                    UserEventTypeEnum.UserRecommend -> {
                        val event  = convertValue<UserRecommendEvent>(rawUserEvent.event)
                        usernManageUseCase.userRecommend(event)
                    }
                    else -> {}
                }
            }
        }

    이렇게 구현하면, 하나의 토픽에서 각각의 서로다른 메세지 객체를 유연하게 사용할수있어서, 기능별로 한곳으로 모아서 처리를 할수있어서, 코드를 간결하게 관리할수있다.

    위 코드 샘플은, 프로젝트에서 유저가 어떤 행위를 했을때 , 해당 행위에 대한 이벤트를 비동기로 발생시키고,

    그 이벤트에 따른 처리를 리스너에서, 종류별로 수행을 하도록 하는 부분이 있는데,

    위와 같은 형태로 구현을 한것을 좀바꿔서 샘플을 넣은것이다.

    이벤트 버스형태로 동작하도록 만든 비즈니스 로직들은 조금만 관리가 허술해져도, 상당히 복잡하고, 스파게티처럼 꼬이게 된다.

    이 꼬이게 되는 문제중에 가장 크리티컬한게, 재귀호출이다.

    리스너에서 수행한 service안에서 다시 해당 이벤트를 발생하고, 해당 이벤트로 다시 리스너가 동작하고, 다시 이벤트가 발생하는 무한 재귀 이벤트 발생 문제를 찾아내기가 힘들다.

    따라서 미리미리 잘 관리를 해야하는데, 그런 측면에서 위와같이 동작하도록 코드를 유지하는게 우선은 선제적으로 중요하다.

    그리고 이벤트 발생은 서비스에 넣어두는것보다는, 아래와 같이..

    usernManageUseCase.attendanceDayOnce(event) {
    
           publisher(UserEventTypeEnum.AttendanceDayOnce)
    
    }

    이런식으로 람다블럭을 받아서 실행하도록 변경하고, 해당 람다블록안에서 이벤트를 발행하도록 변경을 하면,

    Listener등에서는 그냥 usernManageUseCase.attendanceDayOnce(event) 이렇게만 사용하면,

    이벤트 발행코드없이 사용할수있기에, 재귀발행을 막을수있다.

    아니면, 좀더 방어적으로 한다면,

    Aspect를 만들어서, 호출된 부모 메소드에 @KafkaListener 어노테이션이 있는경우, publisher발행함수가 무력화되게도 만들수도 있을것 같다. (근데..만들기 귀찮어..)

    이게 더 안전하긴하지만, 오버엔지니어링이라고 볼수도 있긴하다…

    이런 케이스가 많지는 않아서..

    그냥 람다방식으로 잘 정리해서 사용하면, 큰문제는 없을듯하다.

    이벤트방식을 사용할때는 재귀적으로 이벤트가 발생하는 문제는 꼭 고려를 해야한다… 무한 셀프 공격을 하는 코드를 만들수있다…ㅠ

    (내일 한번더 점검해봐야지…)

  • [개발생각] 프로와 아마추어의 차이

    초등학교 2학년 겨울방학, 옆짝꿍이 얇은 문제집을 쉬는시간에 풀고있는데, 영어가 쏼라쏼라 있어서 호기심에 들여다 봤다.

    뭔지 도통 몰라서 짝꿍한테 물어보니,

    컴퓨터 프로그래밍 gw-basic이라는거란다.

    코드를 작성하면, 별표(*)가 사각형으로 출력하고, 삼각형으로 출력되고, 별모양도 출력된단다. 

    그 모양을 출력하려면 코드를 작성해야하는데 그게 프로그래밍이라는거란다..

    충격이였다…..

    이상한 알수없는 문자를 입력하면, 저렇게 출력이 가능하다니, 멋있어보였다.

    (초등학교때 A,B,C,D 알파벳 처음봄…ㅋㅋㅋ)

    뭔가 존재하지 않는 존재를 창조하는 신이 된것같은, 창조자처럼 그당시에는 느껴졌다.

    “엄청 멋있다..”

    그날 바로 엄마에게, 컴퓨터학원에 보내달라고, 내 생애 처음이자 마지막으로 이야기를 했다.

    (컴퓨터학원빼고는 학원이라고는 한군데도 가본적이 없는 1인이다 ㅋ)

    다행히 허락을 해줬고, (그 당시 허락해준게 정말 다행이다 ㅋㅋ)

    그날부터 컴퓨터학원을 다녔고, 

    그렇게 내 꿈은 ‘컴퓨터 프로그래머’로.. 지금으로 보면 다소 이른시기인 초등학교 2학년때, 정해지게 되었다.

    ‘컴퓨터 프로그래머’로 꿈이 정해진이후, 한번도 꿈이 바뀐적이 없다.

    그래서인가?

    내 직업 ‘프로그래머’에 대해서는 자부심이 좀 강하다. (솔직히 타인이 보면, 소름끼치는 말이겠지..ㅋㅋ 자부심이니 뭐니 말하는게…)

    개발에 있어서는, 타협을 하지 않으려하고, 협의된 일정은 꼭 지키도록 노력한다.

    이것이 개발자로써 자부심으로 생각한다.

    그리고 내가 개발한 부분은 지속적으로 확인하고 개선하여 죽은 코드가 되지않게 한다.

    (수정/리팩토링을 무서워하지않는다. 고칠부분/개선할 부분이 있다면, 그 양이 많던 적던, 지금이 가장 늦지않았다고 생각하고 바꾼다)

    이런 타협하지 않는 생각이나 행동들이 때로는 동료들에게 불편함을 주는것도 알고있다.

    (왜 그렇게 까지 해야해?, 너무 어려운길로 가는거 아니야?등)

    (하지만, 이런 기준이 많는 동료와는 정말 폭발적인 시너지를 발휘한다.)

    정석으로 맞서지않고, 차선택으로 대응하면,

    결국은 문제가 발생하고, 그 문제를 해결하는게 더 어려웠던것 경험이 있어서,

    되도록이면 정석으로 진행하려고 노력한다.

    (물론 최선책이 어려운 환경에서는 최선책을 고집하지않고, 그다음의 차선책을 찾아본다.)

    이런 내 기준에 있어서, 나를 가장 힘들게 하는 부분/동료는,

    바로 일정을 지키지않는 동료/집단/사람들등등이다.

    정책/기획을 토대로 일정을 협의하는 순간, 그 책임은 온전히 그 개발을 담당하는 개발자에게 있다.

    (반대로 이야기하면, 정책/기획을 정해진 일정에 맞추어 개발자에게 건네야하는건 기획자의 책임이다.)

    그렇기에 일정 협의 회의를 엄청나게 민감하고, 세밀하게 해나가야하는게 선제적이다.

    이렇게 디테일하고, 민감하게 조율되어진 일정을 지키는 책임은 담당하는 개발자에게 있다는 말이다.

    정책/기획이 일정을 산출하기에 역부족이라면, 회의때 이슈를 이야기하는것 또한 개발자의 책임이다.

    의견을 내지않고, 후에 불만을 쏟아내는 태도는 없어야하며, 그것이 일정 지연의 변명이 되어서는 안된다.

    물론 위에는 개발자의 입장에서 이야기한것이지만,

    프로젝트에서는 개발자만이 아닌 각각의 파트의 멤버들 (기획/디자인/앱개발/서버개발/사업/QA/마케팅등등)이

    프로젝트내에서 위와 같이 행동해야하는것은 동일하고 당연한 것이다.

    그 일정을 지킴에 있어서, 어떠한 변명이 있어서도 안되고, 해서도 안된다.

    그래서, 일정을 산출하는게 치열하고, 민감하고, 세밀해야한다는것이기도 하다.

    각자의 일정을 지키지 않게되면, 도미노 현상이 발생한다.

    프로젝트는 각파트들이 유기적으로 엮여있기에, 한파트에서 일정이 지켜지지않으면, 연쇄적으로 일정이 지연되기 때문이다.

    이렇게 되면, 

    개인적인 이유/사적인 이유로 일정이 지연된 멤버들/ 실력이 부족하여, 개발일정을 맞추지 못한 멤버들등에게는

    좋은 변명감을 마련하는 경우가 될수있다.

    나의 문제를 다른이의 일정지연을 원인으로 둔갑시켜 커뮤니케이션을 할수있기 때문이다.

    안타깝다.

    일정을 지키지 않는것도 안타깝고,

    타인의 일정 지연을 방패삼아 나의 실력을 감추는것도 안타깝고,

    관리/리더로써, 이 상황에서, 일정산출이 정확해지지않는것을 알지만, 일정을 매번 산출해야하는 상황이 더 안타깝다.

    회사는 동아리가 아니고, 학교가 아니다.

    친분을 중시하고, 동료간의 인기투표에 목메어도 결국은, 실력으로 증명해야하는 곳이다.

    아무리 친해도, 매번 일정을 못맞추고, 실력도 낮은 동료와 프로젝트를 할 사람이 있을까?

    아마 앞에서는 웃으며, 뒤로는 NO 라고 거절하겠지…

    일정을 지키지않는 집단이나 멤버는 가혹하리만큼 페널티를 주어야한다.

    페널티를 주기위해, 일정이 늦어진 원인을 집요하리만큼, 파악해야한다.

    누군가의 말에 의해서나 주장에 의해서, 페널티를 주면 오히려 역효과가 나타나기에,

    합리적이고, 합당한 일정지연 원인을 레포팅하여,  그것으로 판단하고, 그것으로 페널티의 기준을 삼아야한다.

    (합당한 이유가 있다면, 페널티를 당연히주면 안되지!!)

    학교와 직장을 꼭 구분하자..

    요즘은 특히 구분을 못하는 사람들이 많은것 같다.

    직장은 경험하고 배우는곳이 아닌, 내 실력을 증명하는 자리가 되어야한다.

    실력이 부족하다면, 자기개발을 통해, 실력을 빠르게 높이도록 내가 온전히 노력해야하고, 고민해야한다.

    그 고민을 도와줄 선배/동료를 찾는것은 또 다른 이야기다.

    증명을 위해 치열해야하고, 자기개발에 철저해야한다.

    (물론, 비열하고, 야비한 경쟁을 해서는 안되고, 정당한 경쟁을 해야겠지)

    정리하면,

    프로와 아마추어의 차이를 한마디로 이야기하면,

    ‘협의된 일정을 지키는것’이지 않을까?

    어떠한 이유에서든, 내 일정을 지키지 못했으면 나는 ‘아마추어’라는것을 인정해야한다.

    그리고 당연히, 아마추어 대접에 불만을 가지면 안되겠지..

  • [개발생각] 도메인에서 코틀린으로 컴포지션 표현

    도메인에서, 비즈니스 로직을 구현하는경우, 도메인서비스를 나누고, 해당 서비스를 조합하여, 비즈니스 로직을 구현하는 케이스가 많다.

    여기서 코드가 깔끔하지 않게 되는 부분이 존재한다.

    아래 예제로 코드를 보면,

    class UserRegisterService (
       val canUserJoinValidator:CanJoinTestUserValidator,
       val validUserChecker:ValidTestUserChecker,
       val rewardUserChecker:RewardTestUserChecker
    ) {
       
        fun register(user:User) {
          with(user) {
                canUserJoinValidator.canJoinCheck(this); //canUserJoinValidator.xxxx 매번 써줘야함 ㅠ
                validUserChecker.canValidUserCheck(this); //validUserChecker.xxxx 매번 써줘야함 ㅠ
                rewardUserChecker.doReward(this); //rewardUserChecker.xxxx 매번 써줘야함 ㅠ
           }
           //실제 유저 등록 로직.
        }
    }

    위 코드를 코틀린의 delegate로 구현하면 아래와 같이 표현할수있다.

    동작은 동일하다.

    class UserRegisterService (
       canUserJoinValidator:CanJoinTestUserValidator,
       validUserChecker:ValidTestUserChecker,
       rewardUserChecker:RewardTestUserChecker
    
    ) : CanJoinValidator by canUserJoinValidator, 
        ValidUserChecker by validUserChecker,
        RewardUserChecker by rewardUserChecker
    {
    
        fun register(user:User) {
          with(user) {
                canJoinCheck(this); //canUserJoinValidator.xxxxx 기술없이, 메소드만 기술, 깔끔하다.
                canValidUserCheck(this); //canValidUserCheck.xxxxx 기술없이, 메소드만 기술, 깔끔하다.
                doReward(this);//doReward.xxxxx 기술없이, 메소드만 기술, 깔끔하다.
           }
    
           //실제 유저 등록 로직.
        }
    }

    컴포지션(구성)으로 비즈니스 로직을 조합할때 코드가 깔끔하게 된다.

    delegate를 원활하게 사용하려면,

    interface클래스가 필요한데, 도메인 레이어에서는 인프라스트럭처의 구현체를 모르게 하기위해,

    인터페이스를 정의하기 때문에, delegate와도 궁합이 잘 맞기때문이다.

    위와 같이 코딩을 하면,

    구현 클래스를 중복으로 기술하는 번거로움이 없어지고,

    해당 인터페이스의 구현체를 변경하려면, 클래스의 구현체만 교체하면 되니, 코드 수정도 깔끔해진다.

    팩토리메소드 패턴을 해당 클래스안에 함수로도 녹일수있어서,

    팩토리메소드 패턴을 같이 사용하면 훨씬 유연하게 코드를 구성할수있다.

    좀더 나아가 잘사용하기 위해서는 아래와 같은 사항은 지켜주면 더 좋을것같다.

    1. 델리게이터의 함수명을 명시적으로 잘지어야함 (함수만으로 그 행위를 알수있도록 함수명에 더 신경을 쓴다)

       -> 나는 이부분이 강제되는것 같아서, 오히려 너무나 좋은것같다. 함수명을 지을때, 좀더 고민을 하도록 만들게 되는 방법이라, 참 좋다!

    2. 델리케이터를 사용하여, 구성을 하면, 멀티 구현체에 대한 고민을 미리하게 된다.

    3. 되도록이면 도메인 레이어에서 사용하면 좋을듯하다, 

        -> 도메인 레이어에서는 행위를 하는 역할이 명확하기에, 델리게이션을 통해, 함수를 불러도 그 흐름을 명확히 알수있게 할수있는 반면,

             어플리케이션 레이어에서는 해당 도메인 서비스와 어플리케이션 서비스가 공존할수있기에,

            어느 서비스에서 온것인지 다소 애매모호하여, 출처를 알수없을수있기 때문이다. 도메인 레이어에서만 사용하도록 하면,

            좀더 깔끔하고 혼란없이 사용가능하지 않을까 한다.

            ( 이건, 개인적인 생각,의견이다… 정답은 없지..)

    더불어 하나더, 위임, 인터페이스로 구현할때, 공통적으로 수행을 해야하는 함수,로직은,

    인터페이스에 구현을 하면 더 깔끔해지는 경우가 있다.

    예를 들면)

    @Service
    class UserRegisterService(
        canAJoinValidator:ACanJoinValidator,
        validTestUserChecker:AValidTestUserChecker
    ) : CanJoinValidator by canAJoinValidator,
        ValidTestUserChecker by validTestUserChecker,
        CanJoinTestUserValidators {
    
        fun register(doRegisterFunc:() -> Unit) {
            doRegister(0) {
                //등록 로직 처리
            }
        }
    }
    
    interface CanJoinTestUserValidators : CanJoinValidator, ValidTestUserChecker {
        fun doRegister(type:Int, doRegisterFunc:() -> Unit) {
            when(type) {
                0 -> {
                    canJoinCheck()
                    canValidCheck()
                }
                1 -> canJoinCheck()
                else -> {}
            }
    
            doRegisterFunc()
        }
    }

    공통된 비즈니스 로직의 흐름은 인터페이스를 만들고 해당 인터페이스에 정의를 하면, 공통되게 구현 클래스에서 사용할수있다.

    인터페이스의 사용이 단순히 규약,스펙의 영역으로 생각을 하고 사용하면,

    그 사용의 범위가 작아지고, 생각의 스펙트럼도 좁아지게 된다.

    여러 패턴이나 기능에서의 인터페이스 클래스의 사용을 잘 알고 숙지를 하면, 

    다양한 케이스에서 활용일 가능해지고, 그에 따라 코드도 깔끔하게 구현할수있다.

    (결국, 개인 개발 스터디를 꾸준히 해야한다는 이야기..ㅠ)

    최근 인터페이스 클래스의 기능이 하나하나 늘어나는것도 이런 활용을 극대화 하기 위한, 의도가 아닐까 생각된다.

    (물론 자바에서 인터페이스에 default함수 기능이 들어간 가장큰 이유는… 레거시 호환때문인건 함정 ㅋㅋ

    자바는 과거에도 레거시 코드와의 호환때문에 어쩔수없이 기능이 추가되거나, 하는 케이스가 많이 있었어서…)

    결론은!!! 코틀린으로 빨리 갈아타라!!

  • [개발생각] DDD에서 ApplicationListener를 어떻게 설계해야 좋은가?

    DDD에서는 크게 APPLICATION, DOMAIN, INFRA영역이 존재한다.

    결국 모든 레이어는 DOMAIN을 바라보는 관계로 구현을 하게된다.

    여기서 해당 영역은 사실 명확히 경계가 존재하기에 초기 배움에서는 크게 문제가 없다.

    하지만, 조금만 더 프로젝트나, 개발을 진행하다보면,

    찝찝한 부분이 생기는데,

    이게 바로, APPLICATION_LISTERNER, KAFKA_LISTENER등의 비동기 이벤트에 따른 컨슘하는 리스너를 DDD에서 어떻게 깔끔하게 구현을 하는가 이다.

    APPLICATION_LISTERNER, KAFKA_LISTENER는 인프라스트럭처 계층이기에 인프라스트럭처에 그 구현체가 존재하게 된다.

    그런데 여기서, 결국은 해당 리스너에서는 Domain의 Service, Provider등을 실행하게 되는 방향으로 구현이 된다.

    인프라스트럭처에서 도메인 레이어의 서비스를 사용하게 되는데,

    이것은 엄밀히 보면, 크게 문제가 되지는 않는다.

    위에서 이야기했듯, 인프라, 어플리케이션 레이어는 결국 도메인에 의존적인 동작을 하도록 하는게 DDD이기 때문이다.

    하지만, 뭔가가 거슬리는 느낌이지 든다. ㅋㅋ

    이런 구성은 상당히 거슬리는게 있는데, 바로 코드의 흐름, 비즈니스의 흐름이 끊긴다는 것이다.

    어플리케이션 계층에서 시작한 구현 기능은 도메인 서비스의 구성으로 기능이 만들어지게 되는게,

    인프라계층의 리스너에서 동작하는 도메인 서비스가 어떤방식으로 동작되는지가 어플리케이션, 도메인 레이어에서 바로 파악이 어렵고,

    인프라계층까지 확인을 해야 파악이 되는 다소 모호한 상황이 발생할수있다. 

    예를 들면)

    1) 로그인 서비스 -> 2) 출석체크 서비스 (이벤트 발행) ,      3) 출석보상지급 서비스 (이벤트 컨슘)

    이렇게 로그인이 되고, 출석체크를 했다는 흐름은 선형으로 이어지는 흐름이지만, 출석보상지급 서비스는 동떨어져있다. 

    코드를 읽어서는 존재하지않는 동작이다. 리스너에서 불려지니,

    도메인 서비스에는 해당 서비스가 리스너로 동작한다는 힌트를 알수가 없지..

    이렇게 되면, 이벤트 드리븐, AOP(관점지향?)의 가장 단점인 흐름 파악이 어렵다는 문제가 나타나게된다.

    따라서, 이런경우는, 도메인 서비스에 인터페이스를 DoneAttendence등으로 도메인의 행위를 인지할수있는 네이밍으로 정하는것이 먼저 중요하다. (공학보다 인문학이다!! ㅋ 우선 잘 네이밍을 짓는게 무엇보다 중요하다. 변수짓는거 아직도 어려워…)

    그리고 해당 인터페이스는 도메인 클래스로 구현을 하고, 인프라스트럭처의 APPLICATION_LISTERNER, KAFKA_LISTENER에서는 해당 인터페이스의 구현체를 실행만 해주는 방법으로 구현을 하면, 좀더 비즈니스의 흐름을 파악하는데 도움이 되는 구조로 만들수있다.

    예를 들면)

    // 도메인
    
    interface DoneAttendence {
        fun onAttendence(userId: UserId)
    }
    
    @Service
    class UserDoneAttendenceService(
        private val userRepository: UserRepository
    ) : DoneAttendence {
    
        override fun onAttendence(userId: UserId) {
            // 출석 체크 비즈니스
        }
    }
    
    
    
    // 인프라
    
    @Component
    class AttendenceEventListener(
        private val doneAttendence: DoneAttendence
    ) {
    
        @EventListener
        fun handle(event: AttendenceEvent) {
            doneAttendence.onAttendence(event.userId)
        }
    }

    팀원끼리는 onXXXXX로 된 함수는 리스너를 통한 호출함수임을 미리 개발룰로써, 합의를 해두면 더욱더 코드읽기가 깔끔해진다.

    코드를 통해 이해할수있게 만드는것 만큼,

    미리 구성원간의 합의룰을 정하는 ‘최첨단 수동’ 방식 또한 코드구현만큼이나 소중한 방식임을 알아야한다.

    암튼, 이런식으로 도메인에 해당 리스너의 의도를 표현할수있는 방식으로 구현을 해준다면,

    좀더 도메인 로직을 잘 확인할수있게 만들수있지 않을까 한다.

    오늘 면접관으로 면접을 진행했는데… 내가 질문을 내용이다..

    그런데 질문을 내가 면접자가 이해하지 못하게 모호하게 이야기를 한것같네…ㅋ 

  • [개발생각] 면접관

    회사에서 면접을 본다.. 예전에도 면접관은 수도없이 들어갔지만.. 어느곳이든 두 부류로 나뉘는건 어쩔수없나보다.

    거의 질문 1-2개정도 하면, ‘이 사람이다’는 아니더라도, 이 사람은 ‘나가리..’라는것은 바로 알수있는것 같다.

    그 기준은 아래 두부류와 같다.

    본인이 개발한 것을 정말 눈에 보일듯이 자세히 설명을 하는 면접자,

    본인이 개발한 것을 정말 내가 개발을 안한 티가 나게 설명하는 면접자.

    사실 면접 합격여부는 이 기준으로 해도 큰 무리가 없다고 생각한다.

    내가 정말 고민하고, 공부하고, 생각하고 개발을 했다면,

    절대 그 과정을 잊어버리지 않고, 상세히 말을 할수있고,

    장황하게 말하지 않아도 듣는사람이 바로 이해할수있는 깔끔한 설명을 할수있다.

    참고로,

    나는 원래 기억력이 크게 좋지는 않다.

    그래서 다른 과목보다는 수학을 좋아했다. (자랑아님…기억력 바보라는 이야기..)

    수학은 공식을 이해하면, 유도해서 구할수 있기에,

    외우는게 다른 과목에 비해 현저히 낮아서가 그 가장 큰 이유이다.

    실제로 시험중에 ‘공식’이 생각나지않으면, 유도를 해서 하기도 했다..

    고민을 많이 해봤고, 개발한 과정에 대해서 이해도가 높다면, 그 기억은 오래 남는것을 직접 경험했다.

    무슨 능력이 있어서가 아니라…

    개고생을 하고, 해결을 하기위해 고민에 연속을 했기에… 잊을려고 해도 기억에 남아있는것이랄까..ㅠ

    따라서,

    내가 개발한 이력서에 기술되이있는 개발 경험에 대해서,

    정말 디테일하게 설명을 할수있는 사람은,

    업무를 꼼꼼하게 하고, 어떤 문제에 대해서도, 주도적으로 심도있게 스터디하고, 고민하는 사람이라고 볼수있다.

    (나는..그렇게 생각을..)

    반면에… 내가 개발했던 개발 경험에 대해서, 두르뭉실하게 이야기하거나,

    자신이 무슨말을 하고있는지도 모르게 장황하게 설명을 하는 사람은,

    위와 같은 사람이 아닐 확률이 크다.

    아니 자신있게, 위와같은 발전할수있는 개발자가 아니다.

    과감히…불합격을…선사..

    개발자중에 가장 필요한 사람은,

    어려운걸 심플하게 이야기할수있고, 어려운 흐름을 간단한 흐름으로 정리할수있는 사람이다.

    요즘에는 구현이야, AI도움을 많이 받기에 중요도가 적어졌다고 해도,

    위와같은 이해도가 높은 개발자가 정말 필요한 사람인것 같다.

    면접을 보면, 

    정말 나의 경험을 다른 면접관에게 디테일하게 잘 설명하는 면접자는.. 많이 없는것 같다.

    떨리는것과 모르는것은 티가 난다구요!!

  • [개발생각] Transactional(readOnly=true)

    마스터-레플리카 구성의 디비에서 마스터는 Read-Write로 사용하고,

    레플리카는 Read-Only로 사용하고 싶었다.

    (데이터베이스의 부하 분산 측면으로 레플리카를 조회성으로 적극활용하고 싶었기 때문이다.)

    RoutingDataSource을 확장하여, Transactional의 readOnly를 이용해서,

    마스터 <-> 레플리카로 DataSource를 스위칭하도록 설정을 하였다.

    당연히 기대한 결과는,

    1) Hibernate에서 ReadOnly=true의 기본동작인 DirtyCheck를 하지않는것 (조회 성능 최적화)

    2) 해당 트랙잭션안에서는 레플리카 디비를 사용함에 따른 save, delete, update등의 쿼리를 사용하면, 예외를 발생하는것

    위 2가지를 기대했다.

    1번은 기대했던대로 동작을 하는것으로 확인됬고,

    2번이 생각한것과는 다르게 동작했다.

    Transactional(readOnly=true) 블록안에서 save를 해도, 예외가 발생하지 않고, 해당 쿼리는 skip되었다.

    의아하게 생각되어 찾아보니,

    readOnly에서는 flush를 하지않기에, 쿼리자체가 DB쪽으로 날아가지를 않기에 쿼리 예외또한 발생하지 않는다는것이였다.

    (당연히, 쿼리가 DB에 호출이 안됬으니, 에러날 기회조차 못얻은거지..단 @Update쿼리는 자체 Flush를 설정하면, 에러가 발생함.)

    readOnly속성말고 커스텀 속성으로 동작하게 해볼까도 생각했지만,

    사실 조회성에서 중요한것중에 하나가 DirtyChecking을 하지않는것또한 성능측면에서는 중요한 요인이기에,

    readOnly속성을 사용하는건 우선 맞는 선택으로 생각이 되었다.

    RoutingDataSource의 Datasource 스위칭시, flushMode를 AUTO로 강제로 바꾸어주는 방법도 있긴하지만,

    그다지 끌리지는 않는 방법이긴했다.(뭔가 찝찝해..)

    하지만, 해당 기능을 Production에 적용하지않고, Local, Test, Stage쪽에서만 동작하게 만들어두면,

    좀더 깔끔하게 잘사용할수있겠다는 생각을 했다.

    가장 큰 문제가 개발단계에서 Save를 ReadOnly블록안에서 잘못 넣어 코딩한경우를 개발자가 알아챌수없는 것이기에,

    해당 문제를 Production이외의 환경에서는 예외를 발생하게 하여, 인지할수있도록 하고 수정할수있게 환경을 만들어주고,

    Production환경에서는 기본 취지에 맞게, ReadOnly를 사용하는게 자연스러운 사용법이라고 결론을 냈다.

    내일가면…그렇게 설정하자고 해야지 ㅋ

    당연하다고 생각한게 당연하게 동작하지 않는것에서 당황스러웠고, 다르게 동작하는 기능이 ‘잘못됬구나’ 라고 섣부르게 판단했지만,

    깊게 고민해보고, 판단해보니,

    해당 기능이 틀리지않은 동작이였다는걸 확인하고 나서는..

    음…역시 코드마다 작성한 사연과 이유가 있는것 아닐까?

    하나 배운것 같다. 

  • [개발아이디어] 대기열을 구현해보자.

    순간적으로 트래픽이 몰리는 케이스를 방어하기위해, 대기열 기능을 만들었다. (대용량 트래픽 노이로제…직업병같다..)

    우선 대기열이란, 미리 정한 특정 TPS 즉 초당 사용자의 접근을 제어하여 정해진 TPS이상으로는 시스템에서는 사용자의 활동을 제한하여, 서비스의 폭주를 막는 좋은(?) 기능이다.

    대용량 트래픽이 예상되는 서비스에서는 필수적인 기능이라고 해도 과언이 아니다

    (이렇게 해도 죽기는 하는건.. 함정 ㅋ.. 하지만 더 안정적으로 버틴다의 관점으로 봐야한다.)

    대기열을 만들기 위해서는 크게 3가지 개념을 알고있어야한다.

    1) 대기열큐

    2) 대기표

    3) 락

    이 개념만 확실히 알고있으면, 크게 어려울것은 없지만, 동시성과 락을 사용하는것이기에, 개인에 따라서, 어려운 개념일수도있다.

    우선 내가 만든 대기열은 어댑티브 적응형(?) 버전이라고 해야할듯한데..

    1) 1분마다 시스템의 로드(부하)를 프로메테스에서 수집하여 평균 로드를 구한다.

    2) 해당 평균로드가 특정 로드이상일때, 대기열이 자동으로 활성화된다. (예: 70%이상)

    3) 대기열이 활성화될때, 클라이언트에게 HttpStatus code를 429 Too Many Requests로 내려주게하고, 해당 code를 받으면, 클라이언트는 대기열 페이지를 즉시 띄우게 한다.

    4) 해당 대기열 페이지에서 tryEnter api를 통해 대기열에 들어가고, 실제 입장이 가능한지 여부를 서버에게 주기적으로 폴링을 통해 응답을 받는다. (서버가 입장이 가능하다는 응답을 주면, 클라이언트는 실제 앱기능으로 진입하도록 한다)

    전체 코드가 아니지만, 흐름을 알수있는 도메인서비스 코드로 설정한다.

    아직 완벽한 코드는 아니고, 1차적인 코드임을 감안하자..

    (실제로 테스트 돌리기가 힘들어서..쩝 – 좀더 다듬긴 해야할듯)

        //대기열 등록 및 입장 처리
        fun tryEnter(waitingTicketId: String, openWaitingQueueCondition:() -> Boolean) : AppWaitingQueueInfo {
            //1.대기열 닫힘이면 (부하떨어지면) 바로 모두 Accept
            if (!openWaitingQueueCondition()) {
                return alwaysAcceptInfo
            }
    
            //2.대기표가 있지 않으면 표발급.
            if (!appWaitingQueueRepository.contains(waitingTicketId)) {
                appWaitingQueueRepository.enter(waitingTicketId)
                return alwaysNoAcceptInfo
            }
    
            //3.만료된 대기티켓을 만료처리하고, 대기열에서 제외시킴.
            var nextTicketId: String
            for (i in 0..MAX_CHECK_EXPIRE_TICKETS) {
                val head = appWaitingQueueRepository.next() ?: return alwaysAcceptInfo
    
                if (appWaitingQueueRepository.isExpireTickets(head) == YesOrNoEnum.Y) {
                    appWaitingQueueRepository.leave(head)
                    continue
                } else {
                    nextTicketId = head
                    break
                }
            }
    
    
            //4.접근권한획득 (접근가능대기자인지 확인해서 맞으면, 권한획득을 시도해야함)
            val accept:YesOrNoEnum = if (nextTicketId == waitingTicketId) {
                if (appWaitingQueueRepository.tryLockAcquire() == YesOrNoEnum.Y) {
                    if (appWaitingQueueRepository.leave(waitingTicketId)) {
                        YesOrNoEnum.Y
                    } else {
                        appWaitingQueueRepository.releaseLockAcquire()
                        YesOrNoEnum.N
                    }
                } else  YesOrNoEnum.N
            } else YesOrNoEnum.N
    
            return AppWaitingQueueInfo(
                accept = accept,
                rank = if (accept == YesOrNoEnum.Y) 0 else appWaitingQueueRepository.getRank(waitingTicketId) ?: 1,
                waitingQueueSize = appWaitingQueueRepository.size() + 1
            )
        }

    코드 설명을 해보면,

    1번 코드 블럭 설명

      – 대기열 닫힘이면 (부하떨어지면) 대기열을 통해 입장을 할 필요가 없기에 바로 모두 사용자를 입장을 시켜준다.

    2번 코드 블럭 설명

      – 대기표를 발급받지 않은 상태(최초 호출)에는 대기표를 발급해준다.

         (대기표는 사용자 이탈을 처리하기 위해, 만료시간이 존재한다 예: 10초)

      – 대기표를 발급받은 사용자는 바로 입장여부(아래 코드블록)을 확인하지 않고 응답을 주고 빠져나가게 한다.

         이렇게 함으로써, 폴링 주기안에 다른 사용자가 들어올수있도록하여, 대기표를 받고 바로 입장해버리는 경우를 막도록 한다.

         (공정성, 락획득 분산의 이유 – 장단점이 있지만…)

    3번 코드 블럭 설명

     – 대기표를 받고 입장을 하지않는 경우(대기표화면에서 사용자 이탈, 앱종료등등)는 해당 코드블럭을 통해, 대기열에서 제거를 해준다.

    – 사용자의 이탈을 서버는 ACTIVE하게 알수가 없다. 브라우저 이탈, 앱 종료등을 완벽히 서버에게 앱이 전달해 줄수는 없기 때문이다.

        따라서 폴링 API에서 해당 만료 티켓을 종료해주는 로직을 넣어서, 처리하게 해준다.  

      – MAX_CHECK_EXPIRE_TICKETS 만큼만 동작하게하여, 무한루프에 빠지는 부분을 방어해준다.(while(true)보다는 안정적이다)

    4번 코드 블럭 설명

      – 실제 대기열에 먼저들어온순으로 대기열에 티켓정보를 내 티켓정보와 확인한다. 

      – 내 티켓과 대기열의 입장 가능 티켓이 동일하다면, 세마포어 입장 락을 획득하고, 해당 락을 획득하면,  이제 입장이 가능하기에, 대기열과 티켓정보를 제거하고 입장여부는 Y로 설정하여 클라이언트에게 응답을 내려준다.

    내가 만든 일반적인 대기열과 조금 다른 부분이 있다.

    1) ticketId를 랜덤생성하지 않고, 그앱의 유니크한 ID를 클라이언트에게 전달받는 방식을 사용하고, 티겟발급과 만료티켓처리 그리고 입장가능여부를 하나의 API로 통합하였다.

    이유는 API를 분리하고, 별도로 클라이언트가 호출을 하는 복잡도를 줄이기 위해서이다.

    (분리의 근거는 비즈니스 로직의 흐름이 상당히 연관성이 있기에, 하나의 API로 묶는게 이상하지 않다고 판단한것도 있다)

    2) 대기열의 큐에서 입장 우선순위 티켓을 꺼낼때, pop을 사용하지 않고 peak를 사용하였다.

    pop으로 큐에서 아예 꺼내버리면, 입장가능 티켓이 아닌경우, 다시 큐에 넣어야하는 불필요한 행위를 반복하게 되기때문이다.

    따라서, peak를 통해 큐에서 꺼내지않고, 조회만 하여, 입장가능 티켓인 경우에만 pop을 통해, 제거를 하도록 하여, 불필요한 반복을 줄였다.

    3) 코드전박적으로 입장권한 획득을 위한 세마포어를 제외하고, 동시성에 따른 락을 사용하지 않는 구조로 만들었다.

    분산락,락을 사용하면 성능이 떨어지기에 최대한 락을 사용하지 않는 구조로 만들었다. 다행히 브라우저의 대기열이 아니였기에, 요청하는 사용자를 특정지을수있는 유니크한 ID를 쉽게 휙득할수있기에 해당 ID를 티켓ID로 전달받아 로직을 구현하도록 만들었다.

    (웹서비스였으면, 힘들었지..ㅠ)

    테스트 코드를 작성해서 실제 잘동작하는지를 확인할예정이다.

    그리고 현재는 대기열 활성 기준을 cpu로드만 기준으로 하고있는데, network, memory등 전반적인 지표를 포함하여 기준을 잡도록 하면,

    더 멋있는 대기열 기능이 되지않을까?…생각만…ㅋ