0n1dev's LOG

취소와 타임아웃 #3

0n1dev — Fri, 15 Apr 2022 21:37:54 +0900

취소와 타임아웃 #3

Job에 대해 취소

import kotlinx.coroutines.*

suspend fun doOneTwoThree() = coroutineScope {
    val job1 = launch {
        println("launch1: ${Thread.currentThread().name}")
        delay(1000L)
        println("3!")
    }

    val job2 = launch {
        println("launch2: ${Thread.currentThread().name}")
        println("1!")
    }

    val job3 = launch {
        println("launch3: ${Thread.currentThread().name}")
        delay(500L)
        println("2!")
    }

    delay(800L)
    job1.cancel()
    job2.cancel()
    job3.cancel()
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

job1은 1000ms 동안 지연 되기 때문에 3!은 출력이 안됨.

취소 불가능한 Job

launch(Dispatchers.Default)는 다른 스레드에서 수행 됨.

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }

    delay(200L)
    job1.cancel()
    println("doCount Done!")
}

fun main() = runBlocking {
    doCount()
}

doCount Done!이 작업이 끝나기 전에 출력이 됨.

실제 job1이 취소가 되지 않음.

cancel과 join

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }
    
    delay(200L)
    job1.cancel()
    job1.join()
    println("doCount Done!")
}

fun main() = runBlocking {
    doCount()
}

cancel 이후에 join을 넣으면 doCount가 끝날 때 doCount Done!가 출력 됨.

cancelAndJoin

cancel을 하고 join을 하는 일은 자주 일어나는 일이기 때문에 한번에 하는 cancelAndJoin이 준비되어 있음.

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }
    
    delay(200L)
    job1.cancelAndJoin()
    println("doCount Done!")
}

fun main() = runBlocking {
    doCount()
}

isActive

isActive를 호출하면 해당 코루틴이 여전히 활성화된지 확인이 가능.

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10 && isActive) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }

    delay(200L)
    job1.cancelAndJoin()
    println("doCount Done!")
}

fun main() = runBlocking {
    doCount()
}

finally를 같이 사용

suspend 함수들은 JobCancellationException를 발생하기 때문에 표준 try catch finally로 대응할 수 있음.

import kotlinx.coroutines.*

suspend fun doOneTwoThree() = coroutineScope {
    val job1 = launch {
        try {
            println("launch1: ${Thread.currentThread().name}")
            delay(1000L)
            println("3!")
        } finally {
            println("job1 is finishing!")
        }
    }

    val job2 = launch {
        try {
            println("launch2: ${Thread.currentThread().name}")
            delay(1000L)
            println("1!")
        } finally {
            println("job2 is finishing!")
        }
    }

    val job3 = launch {
        try {
            println("launch3: ${Thread.currentThread().name}")
            delay(1000L)
            println("2!")
        } finally {
            println("job3 is finishing!")
        }
    }

    delay(800L)
    job1.cancel()
    job2.cancel()
    job3.cancel()
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

취소 불가능한 블록

어떤 코드는 취소가 불가능해야 함.

withContext(Noncancellable) 을 이용하면 취소 불가능한 블록을 만들 수 있음.

import kotlinx.coroutines.*

suspend fun doOneTwoThree() = coroutineScope {
    val job1 = launch {
        withContext(NonCancellable) {
            println("launch1: ${Thread.currentThread().name}")
            delay(1000L)
            println("3!")
        }
        delay(1000L)
        print("job1: end")
    }

    val job2 = launch {
        withContext(NonCancellable) {
            println("launch1: ${Thread.currentThread().name}")
            delay(1000L)
            println("1!")
        }
        delay(1000L)
        print("job2: end")
    }

    val job3 = launch {
        withContext(NonCancellable) {
            println("launch1: ${Thread.currentThread().name}")
            delay(1000L)
            println("2!")
        }
        delay(1000L)
        print("job3: end")
    }

    delay(800L)
    job1.cancel()
    job2.cancel()
    job3.cancel()
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

타임 아웃

일정 시간이 끝난 후 종료하고 싶으면 withTimeout을 사용.

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10 && isActive) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }
}

fun main() = runBlocking {
    withTimeout(500L) {
        doCount()
    }
}

취소가 되면 TimeoutCancellationException 예외가 발생

withTimeoutOrNull

import kotlinx.coroutines.*

suspend fun doCount() = coroutineScope {
    val job1 = launch(Dispatchers.Default) {
        var i = 1
        var nextTime = System.currentTimeMillis() + 100L

        while (i <= 10 && isActive) {
            val currentTime = System.currentTimeMillis()
            if (currentTime >= nextTime) {
                println(i)
                nextTime = currentTime + 100L
                i++
            }
        }
    }
}

fun main() = runBlocking {
    val result = withTimeoutOrNull(500L) {
        doCount()
        true
    } ?: false
    println(result)
}

성공할 경우 withTimeoutOrNull의 마지막에서 true를 리턴하고, 실패했을 경우 null을 반환

스코프 빌더, 잡 #2

0n1dev — Fri, 15 Apr 2022 20:37:48 +0900

스코프 빌더, 잡 #2

suspend 함수에서 코루틴 빌더 호출

import kotlinx.coroutines.*

suspend fun doOneTwoThree() {
    launch {
        println("launch1: ${Thread.currentThread().name}")
        delay(1000L)
        println("3!")
    }

    launch {
        println("launch2: ${Thread.currentThread().name}")
        println("1!")
    }

    launch {
        println("launch3: ${Thread.currentThread().name}")
        delay(500L)
        println("2!")  
    }
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

해당 코드는 오류가 발생.

runBlocking을 제외한 코루틴 빌더는 코루틴 스코프 내에서 호출 되어야 함.

코루틴 스코프

코루틴 스코프 만드는 다른 방법은 스코프 빌더(coroutineScope)를 이용하는 것.

import kotlinx.coroutines.*

suspend fun doOneTwoThree() = coroutineScope {
    launch {
        println("launch1: ${Thread.currentThread().name}")
        delay(1000L)
        println("3!")
    }

    launch {
        println("launch2: ${Thread.currentThread().name}")
        println("1!")
    }

    launch {
        println("launch3: ${Thread.currentThread().name}")
        delay(500L)
        println("2!")  
    }
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

runBlocking은 현재 스레드를 멈추게 만들고 기다리지만, coroutineScope는 현재 스레드를 멈추게 하지 않음.

호출한 쪽이 suspend 되고 시간이 되면 다시 활동하게 됨.

Job을 이용한 제어

코루틴 빌더 launch 는 Job 객체를 반환하며 이를 통해 종료될 때까지 기다릴 수 있음.

import kotlinx.coroutines.*

suspend fun doOneTwoThree() = coroutineScope {
    val job = launch {
        println("launch1: ${Thread.currentThread().name}")
        delay(1000L)
        println("3!")
    }
    job.join()

    launch {
        println("launch2: ${Thread.currentThread().name}")
        println("1!")
    }

    launch {
        println("launch3: ${Thread.currentThread().name}")
        delay(500L)
        println("2!")
    }
    println("4!")
}

fun main() = runBlocking {
    doOneTwoThree()
    println("runBlocking: ${Thread.currentThread().name}")
    println("5!")
}

스코프 빌더 #1

0n1dev — Thu, 14 Apr 2022 23:29:47 +0900

스코프 빌더 #1

runBlocking

코루틴을 만드는 가장 간단한 함수. (코루틴 빌더라고 함)

코루틴을 만들고 코드 블록의 수행이 끝날 때까지 runBlocking 다음 코드를 수행하지 못하게 막음.

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    println(Thread.currentThread().name)
    println("Hello")
}

코루틴 빌더의 수신 객체

runBlocking안에서 this를 수행하면 코루틴이 수신 객체(Receiver)인 것을 알 수 있음.

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    println(this)
    println(Thread.currentThread().name)
    println("Hello")
}

BlockingCoroutine{Active}@2ff5659e 이런 형태의 결과가 나옴.

BlockingCoroutine은 CoroutineScope의 자식이다. 코틀린 코루틴을 쓰는 모든 곳에는 코루틴 스코프가 있다고 생각하면 됨.

코루틴 컨텍스트

코루틴 스코프는 코루틴을 제대로 처리하기 위한 정보, 코루틴 컨텍스트를 가지고 있음.

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    println(coroutineContext)
    println(Thread.currentThread().name)
    println("Hello")
}

launch 코루틴 빌더

launch는 코루틴 빌더임.

launch는 "할 수 있다면 다른 코루틴 코드를 같이 수행"시키는 코루틴 빌더.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("launch: ${Thread.currentThread().name}")
        println("World!")
    }
    println("runBlocking: ${Thread.currentThread().name}")
    println("Hello")
}

launch 안에 있는 내용이 runBlocking 안에 있는 내용 보다 늦게 수행 됨.

메인 스레드를 다 사용할 때 까지 launch의 코드 블록이 기다림.

delay 함수

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("launch: ${Thread.currentThread().name}")
        println("World!")
    }
    println("runBlocking: ${Thread.currentThread().name}")
    delay(500L)
    println("Hello")
}

delay가 호출이 되면 runBlocking의 코드가 쉬어가면서 500ms 동안 launch의 코드 블록이 먼저 수행 됨.

코루틴 내에서 sleep

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("launch: ${Thread.currentThread().name}")
        println("World!")
    }
    println("runBlocking: ${Thread.currentThread().name}")
    Thread.sleep(500)
    println("Hello")
}

Thread.sleep 은 delay 스레드가 중단되기 때문에 스레드를 양보하지 않음.

한번에 여러 launch

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("launch1: ${Thread.currentThread().name}")
        delay(1000L)
        println("3!")
    }
    launch {
        println("launch2: ${Thread.currentThread().name}")
        println("1!")
    }
    println("runBlocking: ${Thread.currentThread().name}")
    delay(500L)
    println("2!")
}

중단 이후 깨어나는 순서에 따라 결과가 달라짐.

상위 코루틴은 하위 코루틴을 끝까지 책임짐

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        launch {
            println("launch1: ${Thread.currentThread().name}")
            delay(1000L)
            println("3!")
        }
        launch {
            println("launch2: ${Thread.currentThread().name}")
            println("1!")
        }
        println("runBlocking: ${Thread.currentThread().name}")
        delay(500L)
        println("2!")
    }
    print("4!")
}

runBlocking 안에 두 launch 가 속해 있는데 계층화 되어 있어 구조적.

launch가 모두 끝나기 전까지 종료되지 않음.

suspend 함수

코드의 일부를 함수로 분리할 때 suspend 키워드를 붙여서 함수를 생성하면 됨.

import kotlinx.coroutines.*

suspend fun doThree() {
    println("launch1: ${Thread.currentThread().name}")
    delay(1000L)
    println("3!")
}

suspend fun doOne() {
    println("launch1: ${Thread.currentThread().name}")
    println("1!")
}

suspend fun doTwo() {
    println("runBlocking: ${Thread.currentThread().name}")
    delay(500L)
    println("2!")
}

fun main() = runBlocking {
    launch {
        doThree()
    }
    launch {
        doOne()
    }
    doTwo()
}

doOne 함수는 delay와 같은 suspend 함수를 사용하지 않았기 때문에 suspend 생략 가능.

public suspend fun delay(timeMillis: Long) {
    if (timeMillis <= 0) return // don't delay
    return suspendCancellableCoroutine sc@ { cont: CancellableContinuation<Unit> ->
        // if timeMillis == Long.MAX_VALUE then just wait forever like awaitCancellation, don't schedule.
        if (timeMillis < Long.MAX_VALUE) {
            cont.context.delay.scheduleResumeAfterDelay(timeMillis, cont)
        }
    }
}

코루틴 등장 #0

0n1dev — Thu, 14 Apr 2022 21:30:09 +0900

코루틴 등장 #0

코루틴 등장

동시성
병렬성

동시성

동시성 없이는 사용자가 불편

다운로드 중에는 다운로드만
- 다운로드 시간이 오래걸릴수록 아무것도 할 수 없음.
프로그램을 다운받다 잘못되면 그 디스크의 처음부터 다시 다운로드

동시성 없이는, 하드웨어 리소스도 낭비

초당 수백만개 처리가능한 리소스가 있을 때, 동시성 없이는 사용중인 리소스 외 다른 리소스를 사용할 수 없음.

병렬성

여러 CPU가 개별 캐쉬를 사용하게 되면서 문제 발생

공유하고 있는 캐쉬의 데이터 불일치가 발생할 수 있음.
락이나 메모리 베리어가 필요할 수 있음.

=> 이러한 문제들을 콜백과 RxJava가 해결해 주었지만 아직도 많은 문제들이 있음.

콜백 코드 지옥

#0. 자료구조란

0n1dev — Wed, 6 Apr 2022 22:01:19 +0900

#0. 자료구조란

1. 자료구조는 데이터를 저장, 조직, 관리하는 방법

자료구조는 자료(데이터)에 효율적으로 접근하고 수정할 수 있도록 저장, 조직, 관리하는 방법에 관한 이론.

2. 자료구조는 문제 해결에 사용할 부품

문제 해결 작업을 수행하기 위해 입력을 받아 원하는 출력을 만들어내는 과정을 기술한 것을 알고리즘이라 하는데 자료구조는 이 과정에서 부품 같은 역할을 함.

자료구조를 몰라도 프로그램을 작성할 수 있지만 이는 재료의 속성이나 구조물의 구성 방법을 모르고 건축묵을 만드는 것과 같음.

3. 자료구조는 생각하는 방법을 훈련하는 도구

자료구조를 구현하는 과정, 자료구조들을 이용해서 문제를 해결하는 과정, 문제를 해결하는 과정에서 논리의 골격이 구성되는 방법 또는 스타일 등(생각하는 방법)이 중요.

4. 자료구조의 종류와 자바의 컬렉션 패키지

자료구조는 종류가 다양하지만 사향과 목적에 맞게 적절한 자료구조를 선택함으로써 효율적인 데이터 관리가 가능.

자바의 경우 자료구조 관련 클래스를 모아둔 컬렉션 패키지가 있음.

5. 이 책에서 다루는 자료구조

리스트
스택
큐
검색 트리
힙
해시 테이블
그래프

F-Lab 멘토링 회고

0n1dev — Tue, 8 Mar 2022 15:00:32 +0900

F-Lab 멘토링 회고

들어가며...

내돈 내산... 금액은 가려놓겠다. (수강료에 변동이 있는 듯)

해당 글은 광고도 아니며 내돈내산해서 F-LAB이라는 멘토링을 진행하고 남기는 후기겸 회고이다.

개발 언어에 대한 고민이 있거나 F-LAB을 수강을 할까 고민하는 취준생 혹은 이직러들의 고민의 해답을 찾을 수 있는 글이 되었으면 좋겠다.

이직에 대한 고민 그리고 언어 전환...

첫 직장에서 1년동안 PHP를 사용하였다. 단순하게 개발이 좋아서 개발자가 되었고, 그 당시에는 국내 개발 시장에서 PHP의 선호도가 그렇게 낮은 줄 몰랐다.

입사 후 첫 회식에서 사수분께서 말씀하시길 "신입일 때 PHP로 시작하는건 별로다..." 입사하자마자 개발 커리어에 대한 고민이 시작되지 않았나 싶다...

코드를 보니 스파게티가 먹고 싶다...

PHP로 개발한지 1년이 지난 시점 내가 개발한 서비스를 돌아 보니 단순한 이벤트성 페이지로 가득 채워졌다.

물론 단순 이벤트성 페이지만 개발한건 아니다. 하지만 조금 큰 서비스 프로젝트를 보면 PHP 언어 자체의 문제점은 아닐거라 생각이 들지만 정말 로직을 파악하는것 자체가 힘들정도로 코드들이 꼬여있었다.

맡은 일을 열심히 하다 보니 운이 좋게 좀 더 중요 서비스를 담당하게 되었는데 외주사에서 개발한 프로젝트를 기반으로 보다 더 고도화 시키고 신규개발을 하게 되었다.

외주사에서 진행한 프로젝트는 Java로 개발이 되어있었고 협업 툴을 활용해 보다 체계적인 개발 문화를 보여주고 있었는데 나는 정말 충격이었다. (첫 직장에서는 3개의 본부에서 한 레포에 붙어서 개발하고 있었다... 실화인가?)

같이 입사한 주변 동기들도 1년만에 더 좋은 개발 문화를 찾아서 떠났다. 나 또한 더 좋은 개발 문화를 원했고 새롭게 담당한 프로젝트 언어에 대한 공부 또한 필요했다.

어차피 공부를 해야했으니 이직을 위한 공부를 시작하기로 마음을 먹었다.

F-LAB을 선택한 이유...

인터넷을 찾아보면 정말 수많은 강의 후기를 볼 수 있다. 항상 느끼지만 인터넷에는 너무 과한 정보들이 많기 때문에 질 좋은 정보를 얻는것도 하나의 능력이라 생각이 된다.

내가 F-LAB을 선택한 이유는 아래와 같다.

공부는 어차피 스스로 해야한다. 얼마나 효율적인 방향성을 제시해 주나?
회사에는 코드 리뷰라던가 동료 개발자로 부터 피드백을 받기 어려운 개발 문화다. 내가 무심코 작성한 코드가 정말 최선일지 같이 고민을 해주나?
이직을 위해서는 회사 프로젝트 외에 추가적인 프로젝트가 필요했다. 수강 기간중 프로젝트가 진행이 되는가?

실제 멘토링 중 코드 리뷰

F-LAB에서는 직접 코드 리뷰가 어떤식으로 진행되는지 GitHub로 공개되어 있어서 레포 하나하나 확인해 보고 신중하게 결정할 수 있었고, 또 상담 신청을 하면 1:1로 많은 대화를 얻을 수 있는데 상담만 받아도 많은걸 되돌아 볼 수 있었고 더 고민하는 것 보다 빠르게 시작해서 열심히 하는게 좋을것 같다는 생각이 들어 바로 카드를 긁었다... (할부의 노예 시작...)

6개월이라는 시간동안...

멘토링은 멘토님이 정해준 책을 읽어와서 멘토링 시간동안 기술면접 보듯 질문을 주신다. 나는 그 질문에 대해 답변을 드리면 점점 꼬리 물기로 질문을 주시는 형태이다.

질문이 다 끝나면 피드백과 추가로 보면 좋을만한 부분을 알려주신다.

나는 회사와 병행하며 멘토링을 소화하려니 정말 많이 힘들고 정신이 없었다.

중간 중간 회사에서 장애도 있었고... 순수하게 멘토링에만 집중할 수 있는 상황은 아니었다. (이 부분에 대해 아직도 아쉬움이 남는다...)

이러한 고민을 멘토님께 말씀 드렸고 보다 효율적으로 시간 관리하며 공부하는 방법에 대해 제시해 주셔서 보다 준비 된 멘토링 시간을 가질수 있었다.

멘토링 기간동안 계속해서 이직과 좀 더 경력을 쌓는것에 대한 고민이 있었는데 더 큰 기업의 서비스를 개발하고 더 나은 개발 문화를 경험하고 싶다는 생각에 이직을 결심하게 되었다.

이직 성공 후 퇴사...

내가 이직을 위해 지원한 회사는 카카오, 네이버, 넥슨 3곳이다.

많은것을 경험하기 위해서는 스타트업도 좋다는 멘토님의 말씀도 있었지만 보다 안정감을 줄수있고 다양한 개발자를 만나며 큰 서비스를 경험해 보고 싶은 욕심이 있었기에 큰 서비스를 개발하는 IT회사 중 흥미가 있는 도메인을 골라 지원하게 되었다.

그 결과 ...

카카오 - 코테 탈

네이버 - 최종 탈

넥슨 - 최종 합

합격을 받은 순간까지 정말 많은 고민을 했다. 내가 과연 이직하는게 옳은 생각일까? 하지만 계속 머물러 있기 보다는 흐르는 물이 되고 싶었기 때문에 이직을 선택하게 되었다.

10월 22일 부로 퇴사를 하게 되었는데 퇴사하는 날 자리 정리 후 마지막으로 집으로 돌아가는데 정말 말 그대로 "시원 섭섭"했다.

멘토링을 끝내며...

멘토링을 하는 당시에는 정말 내가 적지 않은 돈을 쓰면서 내 인생에 긍정적인 변화가 있을까? 하는 많은 걱정이 있었지만 수료를 하면서 이직도 성공하게 되어 힘들었지만 보람찬 6개월이 되었다.

또 단순하게 지식만 얻고 끝난게 아닌 내가 앞으로 어떤식으로 나아가야 할 지 남은 개발 인생의 방향성을 어느정도 잡게 되었다. (아직 많이 부족하지만...)

개발자 커뮤니티

마지막으로 F-LAB의 장점중 하나가 수료를 하고나서 그냥 끝나는게 아닌 커뮤니티에 가입이 된다.

여러 수료생 혹은 멘토분들과 교류를하며 계속해서 긍정적인 영향을 공유하는 모임이라 볼 수 있다.

현재는 자격만 된다면 커뮤니티에 합류도 가능하니 신청해보면 좋을것 같다.

https://intro.f-lab.kr/?utm_source=graduate&utm_medium=blog&utm_campaign=event&utm_content=15

Spring Boot 기반으로 개발하는 Spring Security #1

0n1dev — Thu, 27 Jan 2022 00:34:08 +0900

Spring Boot 기반으로 개발하는 Spring Security #1

Logout 처리, LogoutFilter

        http.logout() // 로그아웃 처리
                .logoutUrl("/logout") // 로그아웃 처리 URL
                .logoutSuccessUrl("/login") // 로그아웃 성공 후 이동 페이지
                .deleteCookies("JESSIONID", "remember-me") // 로그아웃 후 쿠키 삭제
                .addLogoutHandler() // 로그아웃 핸들러
                .logoutSuccessHandler() // 로그아웃 성공 후 핸들러러

로그아웃은 기본적으로 POST 방식으로 함.

Remember Me 인증

세션이 만료되고 웹 브라우저가 종료된 후에도 애플리케이션이 사용자를 기억하는 기능.
Remember-Me 쿠키에 대한 Http 요청 을 확인한 후 토큰 기반 인증을 사용해 유효성을 검사하고 토큰이 검증되면 사용자는 로그인 됨.
사용자 라이프 사이클
- 인증 성공
- 인증 실패
- 로그아웃

        http
            .rememberMe() // rememberMe 기능이 작동
                .rememberMeParameter("remember") // 기본 파라미터명은 remember-me
                .tokenValiditySeconds(3600) // Default는 14일
//                .alwaysRemember(true) // 리멤버 미 기능이 활성화되지 않아도 항상 실행
                .userDetailsService(userDetailsService); // 리멤버 미 인증할 때 필요한 서비스스

RememberMeAuthenticationFilter

Spring Boot 기반으로 개발하는 Spring Security #0

0n1dev — Wed, 26 Jan 2022 22:40:26 +0900

Spring Boot 기반으로 개발하는 Spring Security #0

스프링 시큐리티의 의존성 추가 시 일어나는 일

서버가 기동되면 스프링 시큐리티의 초기화 작업 및 보안 설정이 이루어짐
별도의 설정이나 구현을 하지 않아도 기본적인 웹 보안 기능이 현재 시스템에 연동되어 작동
- 모든 요청은 인증이 되어야 자원에 접근 가능.
- 인증 방식은 폼 로그인 방식과 httpBasic 로그인 방식을 제공
- 기본 로그인 페이지 제공
- 기본 계정 한 개를 제공

추가 목표

계정 추가, 권한 추가, DB 연동 등.
기본적인 보안 기능 외에 시스템에서 필요로 하는 더 세부적이고 추가적인 보안기능이 필요.

사용자 정의 보안 기능 구현

WebSecurityConfigurerAdapter 클래스
- 스프링 시큐리티의 웹 보안 기능 초기화 및 설정. (가장 기본적인 초기 설정)
- HttpSecurity 생성.
HttpSecurity 클래스
- 세부적인 보안 기능을 설정할 수 있는 API 제공.
- 인증 API
  - http.formLogin()
  - http.logout()
  - http.csrf()
  - http.httpBasic()
  - http.SessionManagement()
  - http.RememberMe()
  - http.ExceptionHandling()
  - http.addFilter()
- 인가 API
  - http.authorizeRequests()
  - http.antMatchers("/admin")
  - http.hasRole(USER)
  - http.permitAll()
  - http.authenticated()
  - http.fullyAuthentication()
  - http.access(hasRole(USER))
  - http.denyAll()

스프링 시큐리티에서 제공되는 기본 설정

	private void applyDefaultConfiguration(HttpSecurity http) throws Exception {
		http.csrf();
		http.addFilter(new WebAsyncManagerIntegrationFilter());
		http.exceptionHandling();
		http.headers();
		http.sessionManagement();
		http.securityContext();
		http.requestCache();
		http.anonymous();
		http.servletApi();
		http.apply(new DefaultLoginPageConfigurer<>());
		http.logout();
	}

Form Login 인증

        http.formLogin() // Form 로그인 인증 기능 작동
                .loginPage() // 사용자 정의 로그인 페이지
                .defaultSuccessUrl() // 로그인 성공 후 이동 페이지
                .failureUrl() // 로그인 실패 후 이동 페이지
                .usernameParameter() // 아이디 파라메터명 설정
                .passwordParameter() // 패스워드 파라메터명 설정
                .loginProcessingUrl() // 로그인 Form Action Url
                .successHandler() // 로그인 성공 핸들러
                .failureHandler() // 로그인 실패 핸들러

Reactive Programming #1. Reactive Streams

0n1dev — Fri, 21 Jan 2022 23:15:14 +0900

Reactive Programming #1. Reactive Streams

Reactive Streams란?

Non-Blocking Back pressure로 비동기적 스트림 처리를 제공하는 표준.

Reactive Programming #0. 옵저버 패턴

0n1dev — Mon, 17 Jan 2022 00:49:53 +0900

Reactive Programming #0. 옵저버 패턴

옵저버 패턴이란?

어떠한것들을 감지하고, 상태의 변경을 지켜보는 디자인 패턴.
여러개의 객체가 어떠한 특정 상태의 변경을 감지하고 반응을 해야하는 경우 적용.
Pub/Sub 패턴을 쉽게 구현 가능.

채팅 서버/클라이언트 기반 예시 (옵저버 패턴 적용 전)

ChatServer 클래스

class ChatServer(
    private val messages: MutableMap<String, MutableList<String>> = mutableMapOf()
) {

    fun add(subject: String, message: String) {
        messages[subject]?.let {
            it.add(message)
        }?: kotlin.run {
            val messageList = mutableListOf<String>()
            messageList.add(message)
            messages.put(subject, messageList)
        }
    }

    fun getMessage(subject: String): MutableList<String>? {
        return messages[subject]
    }
}

User 클래스

class User(
    private val chatServer: ChatServer
) {

    fun sendMessage(subject: String, message: String) {
        chatServer.add(subject, message)
    }

    fun getMessage(subject: String): MutableList<String>? {
        return chatServer.getMessage(subject)
    }
}

Client 메인 함수

fun main() {
    val chatServer = ChatServer()

    val user1 = User(chatServer)
    user1.sendMessage("디자인패턴", "이번엔 옵저버 패턴입니다.")
    user1.sendMessage("롤드컵2021", "LCK 화이팅!")

    val user2 = User(chatServer)
    println(user2.getMessage("디자인패턴"))

    user1.sendMessage("디자인패턴", "예제 코드 보는 중..")
    println(user2.getMessage("디자인패턴"))
}

user1이 메세지를 보냈을때 user2는 계속해서 메세지를 가져와야 함.

위 경우에는 user2가 메세지를 받으려고 계속해서 요청을 보내는 형태. (Calling 매커니즘)

이러한 경우 메세지가 존재하면 좋겠지만 메세지가 존재하지 않을 경우도 있기 때문에 해당 애플리케이션에 맞지 않음.

-> 이럴때 옵저버 패턴을 사용한다.

옵저버 패턴 좀 더 자세하게!

다수의 객체가 특정 객체 상태 변화를 감지하고 알림 받는 패턴.

Subject

여러 옵저버들을 등록하거나 해지 할 수 있는 기능을 제공.

Subject의 상태가 변경되면 자신에게 등록 된 모든 옵저버를 순회하며 옵저버가 제공하는 모든 메서드를 호출.

채팅 서버/클라이언트 기반 예시 (옵저버 패턴 적용 후)

ChatServer 클래스 (Subject 역할)

class ChatServer(
    private val _subscribers: MutableMap<String, MutableList<Subscriber>> = mutableMapOf()
) {

    fun register(subject: String, subscriber: Subscriber) {
        _subscribers[subject]?.let {
            it.add(subscriber)
        }?: kotlin.run {
            val subscribers = mutableListOf<Subscriber>()

            subscribers.add(subscriber)
            _subscribers.put(subject, subscribers)
        }
    }

    fun unregister(subject: String, subscriber: Subscriber) {
        _subscribers[subject]?.let {
            it.remove(subscriber)
        }
    }

    fun sendMessage(user: User, subject: String, message: String) {
        _subscribers[subject]?.forEach {
            val receiver = it as? User

            it.handleMessage("${user.name} -> ${receiver?.name} : $message")
        }
    }
}

Subscriber 인터페이스 (Observer 인터페이스 역할)

interface Subscriber {

    fun handleMessage(message: String)
}

User 클래스 (ConcreteObserver 역할)

class User(
    val name: String
): Subscriber {

    override fun handleMessage(message: String) {
        println(message)
    }
}

Client 메인 함수

fun main() {

    val chatServer = ChatServer()

    val user1 = User("u1")
    val user2 = User("u2")

    chatServer.register("코틀린", user1)
    chatServer.register("코틀린", user2)

    chatServer.register("RX", user1)

    chatServer.sendMessage(user1, "코틀린", "코틀린 꿀잼?")
    chatServer.sendMessage(user1, "RX", "리액티브 스트림 어려워?")
}

옵저버 패턴의 장/단점

장점

상태를 변경하는 객체(publisher)와 변경을 감지하는 객체(subscriber)의 관계를 느슨하게 유지할 수 있음.
Subject의 상태 변경을 주기적으로 조회하지 않고 자동으로 감지할 수 있음.
런타임에 옵저버를 추가하거나 제거할 수 있음.

단점

복잡도가 증가.
다수의 Observer 객체를 등록 이후 해지 하지 않으면 Memory Leak이 발생.

자바에 적용된 옵저버 패턴

Java 9 이전
- Observer 인터페이스 (Java 9 부터 사용 권장하지 않음.)
- Observable 클래스 (Java 9 부터 사용 권장하지 않음.)
Java 9 이후
- java.beans
  - PropertyChangeListener
  - PropertyChangeSupport
- Flow API (Reactive Stream을 구현할 수 있도록 제공되는 인터페이스)
  - Subscription
  - Subscriber
  - Publisher
  - 해당 인터페이스 만으로는 동기적으로 작동함. 비동기적으로 사용하려면 SubmissionPublisher와 같이 사용해야 함.
  - 구독을 하는쪽에서 백프레셔를 제어 가능.

참고

https://www.inflearn.com/course/%EB%94%94%EC%9E%90%EC%9D%B8-%ED%8C%A8%ED%84%B4

Kotlin으로 개발하는 Spring Boot Web MVC #5

0n1dev — Sun, 16 Jan 2022 19:24:25 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #5

실습 환경

IntelliJ
Kotlin
Gradle
JDK 11
Spring Boot 2.6.2

실습 코드

https://github.com/0n1dev/kotlin-spring-practice

GitHub - 0n1dev/kotlin-spring-practice: 인프런 강의

인프런 강의. Contribute to 0n1dev/kotlin-spring-practice development by creating an account on GitHub.

github.com

JUnit

@WebMvcTest
@AutoConfigureMockMvc
internal class ExceptionApiControllerTest {

    @Autowired
    lateinit var mockMvc: MockMvc

    @Test
    fun indexOutOfBoundTest() {
        mockMvc.perform(
            get("/api/exception/index-out-of-bound")
        ).andExpect(
            status().isOk
        ).andDo(print())
    }

    @Test
    fun getTest() {
        val queryParams = LinkedMultiValueMap<String, String>()

        queryParams.add("name", "0n1dev")
        queryParams.add("age", "20")

        mockMvc.perform(
            get("/api/exception")
                .queryParams(queryParams)
        ).andExpect(
            status().isOk
        ).andExpect(
            content().string("0n1dev 20")
        ).andDo(print())
    }

    @Test
    fun getFailTest() {
        val queryParams = LinkedMultiValueMap<String, String>()

        queryParams.add("name", "0n1dev")
        queryParams.add("age", "1")

        mockMvc.perform(
            get("/api/exception")
                .queryParams(queryParams)
        ).andExpect(
            status().isBadRequest
        ).andExpect(
            content().contentType("application/json")
        ).andExpect(
            jsonPath("\$.result_code").value("Fail")
        ).andDo(print())
    }

    @Test
    fun postTest() {
        val userRequest = UserRequest().apply {
            this.name = "0n1dev"
            this.age = 20
            this.phoneNumber = "010-3333-3333"
            this.address = "fawefawf"
            this.email = "test@naver.com"
            this.createdAt = "2022-01-16 18:50:00"
        }

        val json = jacksonObjectMapper().writeValueAsString(userRequest)

        mockMvc.perform(
            post("/api/exception")
                .content(json)
                .contentType("application/json")
                .accept("application/json")
        ).andExpect(
            status().`is`(200)
        ).andDo(print())
    }
}

Kotlin으로 개발하는 Spring Boot Web MVC #4

0n1dev — Sun, 16 Jan 2022 17:59:03 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #4

실습 환경

IntelliJ
Kotlin
Gradle
JDK 11
Spring Boot 2.6.2

실습 코드

https://github.com/0n1dev/kotlin-spring-practice

GitHub - 0n1dev/kotlin-spring-practice: 인프런 강의

인프런 강의. Contribute to 0n1dev/kotlin-spring-practice development by creating an account on GitHub.

github.com

ControllerAdvice

Global 에외 처리 및 특정 Package / Controller 예외 처리

ExceptionHandler

특정 Controller의 예외처리

-> 실습코드는 깃허브에 있습니다.

Kotlin으로 개발하는 Spring Boot Web MVC #3

0n1dev — Sun, 16 Jan 2022 15:43:46 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #3

실습 환경

IntelliJ
Kotlin
Gradle
JDK 11
Spring Boot 2.6.2

실습 코드

https://github.com/0n1dev/kotlin-spring-practice

GitHub - 0n1dev/kotlin-spring-practice: 인프런 강의

인프런 강의. Contribute to 0n1dev/kotlin-spring-practice development by creating an account on GitHub.

github.com

Spring Boot Validation

Custom Validation Annotation 만들어서 사용하기

@Constraint(validatedBy = [StringFormatDateTimeValidator::class])
@Target(
    AnnotationTarget.FIELD,
    AnnotationTarget.PROPERTY_GETTER,
    AnnotationTarget.PROPERTY_SETTER
)
@Retention(AnnotationRetention.RUNTIME)
@MustBeDocumented
annotation class StringFormatDateTime(
    val pattern: String = "yyyy-MM-dd HH:mm:ss",
    val message: String = "시간 형식이 유효하지 않습니다.",
    val groups: Array<KClass<*>> = [],
    val payload: Array<KClass<out Payload>> = []
)

class StringFormatDateTimeValidator: ConstraintValidator<StringFormatDateTime, String> {

    private var pattern: String? = null

    override fun initialize(constraintAnnotation: StringFormatDateTime?) {
        this.pattern = constraintAnnotation?.pattern
    }

    // 정상이면 true, 비정상이면 false
    override fun isValid(value: String?, context: ConstraintValidatorContext?): Boolean {
        return try {
            LocalDateTime.parse(value, DateTimeFormatter.ofPattern(pattern))
            true
        } catch (e: Exception) {
            false
        }
    }
}

Kotlin으로 개발하는 Spring Boot Web MVC #2

0n1dev — Sun, 16 Jan 2022 00:24:40 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #2

실습 환경

IntelliJ
Kotlin
Gradle
JDK 11
Spring Boot 2.6.2

실습 코드

https://github.com/0n1dev/kotlin-spring-practice

GitHub - 0n1dev/kotlin-spring-practice: 인프런 강의

인프런 강의. Contribute to 0n1dev/kotlin-spring-practice development by creating an account on GitHub.

github.com

Spring Boot Validation

참고: https://beanvalidation.org/2.0-jsr380/spec/#builtinconstraints

Bean Validation specification

BeanNode, PropertyNode and ContainerElementNode host getContainerClass() and getTypeArgumentIndex(). If the node represents an element that is contained in a container such as Optional, List or Map, the former returns the declared type of the container and

beanvalidation.org

기존 DeleteApiController 수정

@RestController
@RequestMapping("/api")
@Validated
class DeleteApiController {

    // 1. path variable
    // 2. request param

    @DeleteMapping(path = ["/delete-mapping/name/{name}/age/{age}"])
    fun deleteMappingPath(
        @PathVariable
        @NotNull
        @Size(min = 1, max = 10)
        name: String,

        @NotNull(message = "age 값이 누락되었습니다.")
        @Min(value = 20, message = "age는 20보다 커야 합니다.")
        @PathVariable
        age: Int
    ): String {
        return "$name $age"
    }

    @DeleteMapping(path = ["/delete-mapping"])
    fun deleteMapping(
        @RequestParam name: String,
        @RequestParam age: Int
    ): String {
        return "$name $age"
    }
}

기존 Data Class 수정

@JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy::class)
// @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy::class) PropertyNamingStrategy Class Deprecated
data class UserRequest(
    // @Size(min = 2, max = 8) // 자바에서 사용하는 방식
    @field:NotEmpty
    @field:Size(min = 2, max = 8) // 코틀린에서 Data Class 필드에 어노테이션을 붙일 때
    var name: String?=null,

    @field:PositiveOrZero // 0 이상의 숫자를 검증
    var age: Int?=null,

    @field:Email // email 양식
    var email: String?=null,

    @field:NotBlank // 공백을 검증
    var address: String?=null,

    @field:Pattern(regexp = """^\d{2,3}-\d{3,4}-\d{4}$""") // 정규식 검증
    // @JsonProperty("phone_number") Json에서는 스네이크케이스를 주로 사용해서 서로 매핑되도록 지정.
    var phoneNumber: String?=null // 코틀린에서는 기본적으로 카멜케이스 사용.
)

BindingResult 활용

@RestController
@RequestMapping("/api")
class PutApiController {

    @PutMapping("/put-mapping")
    fun putMapping(): String {
        return "put-mapping"
    }

    @RequestMapping(method = [RequestMethod.PUT], path = ["/request-mapping"])
    fun requestMapping(): String {
        return "put-mapping"
    }

    @PutMapping(path = ["/put-mapping/object"])
    fun putMappingObject(@Valid @RequestBody userRequest: UserRequest,
                         bindingResult: BindingResult): ResponseEntity<String> {

        if (bindingResult.hasErrors()) {

            val msg = StringBuilder()
            bindingResult.allErrors.forEach {
                val field = it as FieldError
                val message = it.defaultMessage

                msg.append("${field.field} $message\n")
            }

            return ResponseEntity.badRequest().body(msg.toString())
        }

//        // 0. Response
//        return UserResponse().apply {
//
//            // 1. result
//            Result().apply {
//                this.resultCode = "OK"
//                this.resultMessage = "성공"
//            }
//
//
//        }.apply {
//
//            // 2. description
//            this.description = "@@@@@@"
//        }.apply {
//
//            // 3. user mutable list
//            val userList = mutableListOf<UserRequest>()
//
//            userList.add(userRequest)
//            userList.add(UserRequest().apply {
//                this.name = "a"
//                this.age = 11
//                this.email = "test@naver.com"
//                this.address = "dd"
//                this.phoneNumber = "01018838303"
//            })
//
//            this.userRequest = userList
//        }
        return ResponseEntity.ok("")
    }
}

Kotlin으로 개발하는 Spring Boot Web MVC #1

0n1dev — Sat, 15 Jan 2022 22:25:56 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #1

실습 환경

IntelliJ
Kotlin
Gradle
JDK 11
Spring Boot 2.6.2

실습 코드

https://github.com/0n1dev/kotlin-spring-practice

GitHub - 0n1dev/kotlin-spring-practice: 인프런 강의

인프런 강의. Contribute to 0n1dev/kotlin-spring-practice development by creating an account on GitHub.

github.com

GET

단순 GET Mapping
PathVariable
QueryParam
- 객체로 받는 방법

POST

단순 POST Mapping
RequestBody
JsonNaming 컨벤션

PUT

단순 PUT Mapping
RequestBody

DELETE

PathVariable
QueryParam

ResponseEntity

상황별 HttpStatus 코드 반환

-> 모든 코드는 실습 코드 깃헙에 업로드 되어있습니다.

Kotlin으로 개발하는 Spring Boot Web MVC #0

0n1dev — Sat, 15 Jan 2022 19:43:33 +0900

Kotlin으로 개발하는 Spring Boot Web MVC #0

Why Kotlin?

JVM 언어 / Java와 100% 호환.
- 코틀린 <-> 자바 서로 임포트해서 사용할 수 있음.
현대 언어 지향
코틀린의 Elvis Operation을 통해 안정적으로 NULL Point 대응 가능.
Java에 비해 간결한 코드.
코틀린만의 표준 함수.
타입추론의 편리함 (Java10에서는 지원)

Spring Boot

단순히 실행되며, 프로덕션 레벨의 애플리케이션을 쉽게 만들 수 있음.

Spring Framework의 구성 설정이 거의 필요 하지 않음.

java -jar로 실행하는 Java 애플리케이션을 만들 수 있음.

Web 개론

Web이란?

World Wide Web, WW, W3이라 불리는데 인터넷에 연결된 컴퓨터를 통해 사람들이 정보를 공유할 수 있는 전 세계적인 정보 공간을 말함.

Web의 용도를 우리가 제일 많이 접하는 부분으로 정리.

Web Site (Google, Naver, Daum ...)
User Interface (Chrome, Safari, Explorer ...)
API (Application Programming Interface)

Web의 기반

HTTP (Hypertext Transfer Protocol)
- 애플리케이션 컨트롤
- Get, Post, Put ... 등의 메서드 존재
URI (Uniform Resource Identifier)
- 리소스 식별자
- 특정 사이트, 특정 쇼핑 목록 ...
- 모든 정보에 접근 할 수 있는 정보
HTML (Hyper Text Markup Language)
- 하이퍼미디어 포맷
- XML을 바탕으로한 범용 문서 포맷
- 웹 브라우저에서 사용자가 알아보기 쉬운 형태로 표현

REST

REST (Representational State Transfer, 자원의 상태 전달)

네트워크 아키텍처 원리

Client, Server: 클라이언트와 서버가 서로 독립적으로 분리되어져 있어야 함.
Stateless: 요청에 대해서 클라이언트의 상태가 서버에 저장하지 않음.
캐시: 클라이언트는 서버의 응담을 캐시 할 수 있어야 함.
- 캐시를 통해 응답을 재사용할 수 있어야 하며, 이를 통해 서버의 부하를 낮춤.
계층화: 서버와 클라이언트 사이에, 방화벽, 게이트웨이, Proxy 등 다계층 형태를 구성할 수 있어야 하며, 확장 할 수 있어야 함.
인터페이스 일관성: 아키텍처를 단순화시키고 작은 단위로 분리하여서, 클라이언트와 서버가 독립적으로 개선될 수 있어야 함.
- 자원 식별: 웹 기반의 REST에서는 리소스 접근을 URI를 사용.
- 메시지를 통한 리소스 조작: 리소스 타입을 알려주기 위해 header 부분에 content-type을 통해서 어떠한 타입인지 명시 가능.
- 자기서술적 메시지: 요청하는 데이터가 어떻게 처리 되어야 하는지 충분한 데이터를 포함 할 수 있어야 함.
  - HTTP 기반의 REST에서는 HTTP Method와 Header의 정보로 이를 표현.
- 애플리케이션 상태에 대한 엔진으로서 하이펑미디어: HATOS
Code On Demand (Optional): 자바 애플릿, 자바스크립트, 플래시 등 특정기능을 서버가 클라이언트에 코드를 전달하여 실행 할 수 있어야 함.

URI

URI (Uniform Resource Identifier)
- 인터넷에서 특정 자원을 나타내는 주소값. 해당 값은 유일.
URL (Uniform Resource Locator)
- 인터넷 상에서의 자원, 특정 파일이 어디에 위치하는지 식별 하는 주소

-> URL은 URI의 하위 개념.

URI 설계원칙 (RFC-3986)

슬래시 구분자(/)는 계층 관계를 나타내는 데 사용.
URI 마지막 문자로(/)는 포함하지 않음.
하이픈(-)은 URI의 가독성을 높이는데 사용.
밑줄(_)은 사용하지 않음.
URI 경로에는 소문자가 적합.
파일 확장자는 URI에 포함하지 않음.
프로그래밍 언어에 의존적인 확장자를 사용하지 않음.
구현에 의존적인 경로를 사용하지 않음.
세션 ID를 포함하지 않음.
프로그래밍 언어의 메서드명을 이용하지 않음.
명사에 단수형 보다는 복수형을 사용해야 함.
- 컬렉션에 대한 표현은 복수로 사용.
컨트롤러 이름으로는 동사나 동사구를 사용.
경로 부분 중 변하는 부분은 유일한 값으로 대체.
- https://kotlin.example.co.kr/vehicles/suv/q7/{car-id}/users/{user_id}/release
- https://kotlin.example.co.kr/vehicles/suv/q7/117/users/0n1dev/release
CRUD 기능을 나타내는것은 URI에 사용하지 않음.
URI Query Parameter 디자인
- URI 쿼리 부분으로 컬렉션 결과에 대해서 필터링 할 수 있음.
  - https://kotlin.example.co.kr/vehicles/suv?model=q7
- URI 쿼리는 컬렉션의 결과를 페이지로 구분하여 나타내는데 사용.
  - https://kotlin.example.co.kr/vehicles/suv?page=0&size=10&sort=asc
API에 있어서 서브 도메인은 일관성 있게 사용해야 함.
클라이언트 개발자 포탈 서브 도메인은 일관성 있게 만듬.

HTTP (추후 깊게 다시 공부)

Hyper Text Transfer Protocol 로 RFC-2616에서 규정된 Web에서 데이터를 주고 받는 프로토콜.
이름에는 하이퍼 텍스트 전송용 프로토콜로 정의되어 있지만 실제로는 HTML, XML, JSON, Image 등 다양한 형태의 데이터를 전송 할 수 있음.
HTTP는 TCP를 기반으로한 REST의 특징을 모두 구현하고 있는 Web 기반의 프로토콜 (HTTP 3.0 부터는 UDP... 추후 공부)
HTTP는 메세지를 주고 (Request) 받는 (Response) 의 형태의 통신 방식.
HTTP Method
- GET
  - 리소스 취득
- POST
  - 리소스 생성, 추가
- PUT
  - 리소스 갱신, 생성
- PATCH
  - 리소스 갱신
- DELETE
  - 리소스 삭제
- HEAD
  - 헤더 데이터 취득
- OPTIONS
  - 지원하는 메서드 취득
- TRACE
  - 요청 메세지 반환
- CONNECT
  - 프록시 동작의 터널 접속으로 변경
HTTP Status Code
- 1XX
  - 처리중
- 2XX
  - 성공
- 3XX
  - 리다이렉트
- 4XX
  - 클라이언트 에러
- 5XX
  - 서버 에러

Kotlin In Action #5

0n1dev — Mon, 10 Jan 2022 21:10:16 +0900

Kotlin In Action #5

클래스, 객체, 인터페이스

object 키워드: 클래스 선언과 인스턴스 생성

코틀린에서 object 키워드를 다양한 상황에서 사용하지만 모든 경우 클래스를 정의하면서 동시에 인스턴스(객체)를 생성한다는 공통점이 있음.

객체 선언은 싱글턴을 정의하는 방법 중 하나.
동반 객체는 인스턴스 메서드는 아니지만 어떤 클래스와 관련 있는 메서드와 팩터리 메서드를 담을 때 사용.
- 동반 객체 메서드에 접근할 때는 동반 객체가 포함된 클래스의 이름을 사용할 수 있음.
객체 식은 자바의 무명 내부 클래스 대신 쓰임.

객체 선언: 싱글턴 쉽게 만들기

자바에서는 클래스의 생성자를 private로 제한하고, 정적 필드에 그 클래스의 유일한 객체를 저장하는 형태로 구현.

코틀린은 객체 선언 기능을 통해 싱글턴을 언어에서 기본 지원.

object Payroll {
    
    val allEmployees = arrayListOf<Person>()
    
    fun calculateSalary() {
        for (person in allEmployees) {
            ...
        }
    }
}

객체 선언은 클래스를 정의하고 그 클래스의 인스턴스를 만들어서 변수에 저장하는 모든 작업을 한 문장으로 처리.
클래스와 마찬가지로 객체 선언 안에도 프로퍼티, 메서드, 초기화 블록 등이 들어갈 수 있음.
생성자는 객체 선언에 쓸 수 없음.

import java.io.File

object CaseInsensitiveFileComparator: Comparator<File> {

    override fun compare(o1: File?, o2: File?): Int {
        return o1!!.path.compareTo(o2!!.path, ignoreCase = false)
    }
}


println(CaseInsensitiveFileComparator.compare(File("/User"), File("/user")))

동반 객체: 팩토리 메서드와 정적 멤버가 들어갈 장소

class A {
    companion object {
        fun bar() {
            println("Companion Object called")
        }
    }
}

코틀린 클래스 안에는 정적인 멤버가 없음.
대신 코틀린에서는 패키지 수준의 최상위 함수와 객체 선언을 활용.
클래스 안에 정의된 객체 중 하나에 companion 이라는 특별한 표시를 붙이면 그 클래스의 동반 객체로 만들 수 있음.

class User private constructor(val nickname: String) {
    companion object {
        fun newSubscribingUser(email: String) = User(email.substringBefore('@'))
        
        fun newFaceBookUser(accountId: Int) = User(getFacebookName(accountId))
    }
}

클래스를 확장해야 하는 경우 동반 객체 멤버를 하위 클래스에서 오버라이드할 수 없으므로 여러 생성자를 사용하는 편이 더 나은 방법.

[당근마켓 밋업 정리] - Kotlin Coroutines 톺아보기

0n1dev — Sun, 9 Jan 2022 18:46:30 +0900

[당근마켓 밋업 정리] - Kotlin Coroutines 톺아보기

해당 자료에 대한 내용은 당근마켓 유튜브를 참고하여 정리한 내용입니다.

참고 자료 : https://youtu.be/eJF60hcz3EU

기본 개념

Synchronous (동기)

요청과 결과가 동시에 일어난다는 약속.
- 요청을 하면 시간이 얼마가 걸리던지 요청한 자리에서 결과가 주어져야 함.
요청을 하면 System Call이 끝날때까지 기다렸다 결과물을 가져옴.
설계가 매우 간단하고 직관적이지만, 결과가 주어질 때까지 어무것도 못하고 대기해야 함.

Asynchronous (비동기)

요청과 결과가 동시에 일어나지 않음.
- 요청한 그 자리에서 결과가 주어지지 않음.
요청을 하면 System Call이 완료되지 않아도 나중에 완료가 되면 그때 결과물을 가져옴.
- 주로 Callback 함수를 통해 결과물을 가져옴.
동기에 비해 코드가 복잡하고 추적과 에러 핸들링이 어렵지만, 결과가 주어지는데 시간이 걸리더라도 다른 작업을 할 수 있어 자원을 효율적으로 사용할 수 있음.

비동기에 대한 고민

다양한 비동기 라이브러리

스프링에서는 Spring Reactor
일부에서는 Java8의 CompletableFuture
Hibernate Reactive의 MUTINY

어떤걸 사용해야 하고 어떻게 혼용해서 써야 할까?

Coroutine이 해결사?

우수한 가독성
에러 핸들링
동시성 처리
Flow
Channel

Coroutine 소개

주문 생성 동기 코드

fun execute(inputValues: InputValues): Order {
    val (userId, productIds) = inputValues

    // 1. 구매자 조회
    val buyer = userRepository.findUserByIdSync(userId)

    // 2. 주소 조회 및 유효성 체크
    val address = addressRepository.findAddressByUserSync(buyer).last()
    checkValidRegion(address)
    
    // 3. 상품들 조회
    val products = productRepository.findAllProductsByIdsSync(productIds)
    check(products.isNotEmpty())
    
    // 4. 스토어 조회
    val stores = storeRepository.findStoresByProductsSync(products)
    check(stores.isNotEmpty())
    
    // 5. 주문 생성
    val order = orderRepository.createOrderSync(buyer, products, stores, address)
    
    return order
}

비동기 코드로

RxJava3의 Maybe

Maybe는 Observable의 또 다른 형태.
최대 데이터 하나를 발행할 수 있으며 추가로 데이터 없이도 완료할 수도 있음.
0 .. 1, Error
총 3가지 알림을 보냄.
- onSuccess: 데이터 하나를 발행함과 동시에 종료
- onError: 에러가 발생했음을 알림
- onComplete: 데이터 발행이 완료됐음을 알림

interface UserAsyncRepository {
    fun findUserByIdMaybe(userId: String): Maybe<User>
}

class UserRxRepository: UserAsyncRepository {
    
    override fun findUserByIdMaybe(userId: String): Maybe<User> {
        val user = prepareUser(userId)
        return Maybe.just(user)
            .delay(TIME_DELAY_MS, TimeUnit.MILLISECONDS)
    }
}

JDK9 ReactiveStream (구현 생략)

Non-Blocking과 BackPressure을 이용하여 비동기 서비스를 할 때 기본이되는 스펙.
정해진 개수 만큼 Publish 하고나면 complete 이벤트로 Flow 종료.

interface AddressAsyncRepository {
    fun findAddressByUserAsPublisher(user: User): Flow.Publisher<Address>
}

Reactor의 Flux (구현 생략)

0 .. n, Error

interface ProductAsyncRepository {
    fun findAllProductsByIdsAsFlux(productIds: List<String>): Flux<Product>
}

Mutiny의 Multi (구현 생략)

0 .. n, Error

interface StoreAsyncRepository {
    fun findStoresByProductsAsMulti(products: List<Product>): Multi<Store>
}

JDK8 CompletableFuture

complete 되는 시점에 결과 반환

interface OrderAsyncRepository {
    fun createOrderAsFuture(
        buyer: User,
        products: List<Product>,
        stores: List<Store>,
        address: Address0
    ): CompletableFuture<Order>
}

위의 비동기 라이브러리를 혼합해서 사용하면 어떤일이 벌어질까?

Callback 지옥... 이런 느낌이 아닐까...?

subscribe 지옥...

subscribe는 결과를 얻은 시점에 주어진 subscriber (consumer)를 실행하는 일종의 callback.
반환값들이 아래에서 계속 필요하여 subscribe가 중첩.

Coroutine

코루틴화 시킬 수 있는 코드는 suspend라는 키워드가 붙은 함수들에 한 해서 가능.

Maybe<T>.awaitSingle
Publisher<T>.awaitLast
Flow<T>.toList
CompletableFuture<T>.await

위의 함수들은 모두 확장 함수에 포함됨.

suspend fun execute(inputValues: InputValues): Order {
    val (userId, productIds) = inputValues

    // 1. 구매자 조회
    val buyer = userRepository.findUserByIdAsMaybe(userId).awaitSingle()

    // 2. 주소 조회 및 유효성 체크
    val address = addressRepository.findAddressByUserAsPublisher(buyer).awaitLast()
    checkValidRegion(address)

    // 3. 상품들 조회
    val products = productRepository.findAllProductsByIdsAsFlux(productIds).asFlow.toList()
    check(products.isNotEmpty())

    // 4. 스토어 조회
    val stores = storeRepository.findStoresByProductsAsMulti(products).asFlow.toList()
    check(stores.isNotEmpty())

    // 5. 주문 생성
    val order = orderRepository.createOrderAsFuture(buyer, products, stores, address).await()

    return order
}

Kotlin In Action #4

0n1dev — Wed, 5 Jan 2022 00:33:55 +0900

Kotlin In Action #4

클래스, 객체, 인터페이스

뻔하지 않은 생성자와 프로퍼티를 갖는 클래스 선언

자바에서 생성자를 하나 이상 선언할 수 있고, 코틀린도 비슷하지만 주 생성자와 부 생성자를 구분함.

코틀린에서는 초기화 블록을 통해 초기화 로직을 추가할 수 있음.

클래스 초기화: 주 생성자와 초기화 블록

class User(val nickname: String)

클래스에서 중괄호가 아닌 괄호로 둘러싸인 코드를 주 생성자라 함.
주 생성자는 생성자 파라메터를 지정하고, 생성자 파라메터에 의해 초기화되는 프로퍼티를 정의하는 두 가지 목적에 사용 됨.

위 코드를 명시적인 선언으로 풀어보자.

class User constructor(_nickname: String) {

    val nickname: String
    
    init {
        nickname = _nickname
    }
}

constructor 키워드는 주 생성자나 부 생성자 정의를 시작할 때 사용.
init 키워드는 초기화 블록을 시작.
- 초기화 블록에는 클래스의 객체가 만들어질 때 실행될 초기화 코드가 들어감.
- 주로 초기화 블록은 주 생성자와 함께 사용.
생성자 파라메터 _nickname에서 밑줄(_)은 프로퍼티와 생성자 파라메터를 구분할때 사용

class User(val nickname: String, 
            val isSubscribed: Boolean = true) // 디폴트 값 제공
            
fun main() {
    val user = User("0n1dev")
    println(user.isSubscribed)
}

기반 클래스가 있다면 주 생성자에서 기반 클래스의 생성자를 호출해야 할 필요가 있음.

open class User(val nickname: String,
                   val isSubscribed: Boolean = true)

class TwitterUser(nickname: String): User(nickname) {}


fun main() {
    val user = TwitterUser("0n1dev")
    println(user.isSubscribed)
}

유일한 주 생성자의 변경자로 private를 붙이면, 외부에서 인스턴스화할 수 없음.

class Secretive private constructor()

부 생성자: 상위 클래스를 다른 방식으로 초기화

open class View {
    constructor(ctx: Context) {
        
    }
    
    constructor(ctx: Context, attr: AttributeSet) {
        
    }
}

super나 this를 사용하여 다른 생성자에게 위임 할 수 있음.

open class View {
    constructor(ctx: Context) {

    }

    constructor(ctx: Context, attr: AttributeSet) {

    }
}

class MyButton: View {
    constructor(ctx: Context): this(ctx, AttributeSet.NameAttribute as AttributeSet) {

    }

    constructor(ctx: Context, attr: AttributeSet): super(ctx, attr) {

    }
}

인터페이스에 선언된 프로퍼티 구현

인터페이스에 추상 프로퍼티 선언을 넣을 수 있음.

interface User {
    val nickname: String
}

해당 User 인터페이스를 구현하는 클래스는 nickname의 값을 얻을 수 있는 방법을 제공해야 한다는 뜻.

class PrivateUser(override val nickname: String) : User

class SubscribingUser(val email: String) : User{
    override val nickname: String
        get() = email.substringBefore('@')
}

class FacebookUser(val accountId: Int) : User{
    override val nickname: String
        get() = getFacebookName(accountId)

    private fun getFacebookName(accountId: Int): String {
        TODO("Not yet implemented")
    }
}

인터페이스에는 추상 프로퍼티뿐 아니라 게터와 세터가 있는 프로퍼티를 선언할 수 있음.

interface User {
    val email: String
    val nickname: String
        get() = email.substringBefore('@')
}

추상 프로퍼티 email은 반드시 오버라이드해야 하며, nickname은 오버라이드하지 않고 상속 가능.

게터와 세터에서 뒷받침하는 필드에 접근

세터에서 뒷받침하는 필드 접근하기

class User(val name: String) {
    var address: String = "unspecified"
        set(value: String) {
            println("""
               Address was changed for $name:
               "$field" -> "$value"
            """.trimIndent()) // 뒷받침하는 필드 값 읽기
            field = value // 뒷받침하는 필드 값 변경
        }
}

접근자의 가시성 변경

class LengthCounter {
    var counter: Int = 0
        private set
    fun addWord(word: String) {
        counter += word.length
    }
}

컴파일러가 생성한 메서드: 데이터 클래스와 클래스 위임

코틀린은 필수 메서드(equals, hashCode, toString 등)로 인한 잡음 없이 코드를 깔끔하게 유지할 수 있음.

모든 클래스가 정의해야 하는 메서드

Client 클래스의 초기 정의

class Client(val name: String, val postalCode: Int)

문자열 표현: toString()

class Client(val name: String, val postalCode: Int) {
    override fun toString(): String = "Client(name='$name', postalCode=$postalCode)"
}

객체의 동등성: equals()

내부에 동일한 데이터를 포함하는 경우 그 둘을 동등한 객체로 간주.

자바에서 ==는 원시 타입과 참조 타입을 비교할 때 사용.
원시 타입의 경우 두 피연산자의 값이 같은지 비교. (동등성)
참조 타입의 경우 두 피연산자의 주소가 같은지 비교. (동일성)
자바에서 동등성을 알려면 equals를 호출해야 함.

코틀린에서는 == 연산자가 두 객체를 비교하는 기본적인 방법.
==는 내부적으로 equals를 호출해서 객체를 비교.
참조 비교를 위해서는 === 연산자를 사용.

class Client(val name: String, val postalCode: Int) {
    override fun equals(other: Any?): Boolean {
        if (other == null || other !is Client) {
            return false
        }
        
        return name == other.name &&
                postalCode == other.postalCode
    }
}

해당 코드는 복잡한 작업을 수행해보면 제대로 작동하지 않는 경우가 있음.

hashCode 정의를 빠뜨려서 그렇다.

해시 컨테이너: hashCode()

equals를 오버라이드할 때 반드시 hashCode도 함께 오버라이드해야 함.

JVM 언어에서는 equals()가 true를 반환하는 두 객체는 반드시 같은 hashCode()를 반환해야 함.
원소를 비교할 때 비용을 줄이기 위해 먼저 객체의 해시 코드를 비교하기 때문.

class Client(val name: String, val postalCode: Int) {
    override fun equals(other: Any?): Boolean {
        if (other == null || other !is Client) {
            return false
        }

        return name == other.name &&
                postalCode == other.postalCode
    }

    override fun hashCode(): Int = name.hashCode() * 31 + postalCode
}

데이터 클래스: 모든 클래스가 정의해야 하는 메서드 자동 생성

어떤 클래스가 데이터를 저장하는 역할만을 수행한다면 toString, equals, hashCode를 반드시 오버라이드해야 함.

코틀린에서는 data라는 변경자를 클래스 앞에 붙이면 필요한 메서드를 컴파일러가 자동으로 만들어줌.

data class Client(val name: String, val postalCode: Int)

해당 클래스는 아래 요구사항의 메서드를 포함.

인스턴스 간 비교를 위한 equals
HashMap과 같은 해시 기반 컨테이너에서 키로 사용할 수 있는 hashCode
클래스의 각 필드를 선언 순서대로 표시하는 문자열 표현을 만들어주는 toString

위 세개 말고 몇 가지 유용한 메서드를 추가로 생성해줌.

데이터 클래스와 불변성: copy() 메서드

데이터 클래스의 프로퍼티가 꼭 val일 필요는 없음.

하지만 데이터 클래스의 모든 프로퍼티를 읽기 전용으로 만들어서 데이터 클래스를 불변 클래스로 만들라고 권장.

HashMap 등의 컨테이너에 데이터 클래스 객체를 담는 경우엔 불변성이 필수적.

코틀린은 copy 메서드를 제공하면서 객체를 메모리상에서 직접 바꾸는 대신 복사본을 만들며 일부 프로퍼티를 바꿀수 있게 해줌.

클래스 위임: by 키워드 사용

상속을 허용하지 않는 클래스에 새로운 동작을 추가해야 할 때가 있음.

이럴 때 사용하는 일반적인 방법이 데코레이터 패턴.

class DelegatingCollection<T>: Collection<T> {

    private val innerList = arrayListOf<T>();
    
    override val size: Int
        get() = innerList.size

    override fun contains(element: T): Boolean = innerList.contains(element)

    override fun containsAll(elements: Collection<T>): Boolean = containsAll(elements)

    override fun isEmpty(): Boolean = isEmpty()

    override fun iterator(): Iterator<T> = iterator()
}

데코레이터 패턴을 구현하는데 있어서 위와 같이 단순한 인터페이스를 구현하는것 조차 복잡한 코드를 작성해야 함.
이러한 위임을 언어가 제공하는 일급 시민 기능으로 지원하는것이 코틀린의 장점.

class DelegatingCollection<T>(
    innerList: Collection<T> = ArrayList<T>()
): Collection<T> by innerList

class CountingSet<T>(
    val innerSet: MutableCollection<T> = HashSet<T>()
): MutableCollection<T> by innerSet {
    
    var objectsAdded = 0

    override fun add(element: T): Boolean {
        objectsAdded++
        return innerSet.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        objectsAdded += elements.size
        return innerSet.addAll(elements)
    }
}

2021년 마무리 회고

0n1dev — Tue, 4 Jan 2022 10:16:11 +0900

2021년 마무리 회고

2021년에는 크게 3가지의 인생 전환점이 있었다.

공채 동기들의 이직.
F-Lab 유료 멘토링 수강.
이직 준비 ... 그리고 성공.

지금 와서 생각해보면 이러한 전환점들이 있었기 때문에 나를 발전시키고 있는 게 아닐까라는 생각이 든다.

공채 동기들의 이직

나는 2020년 첫 회사를 신입 공채로 입사하였다.

입사일에 보면 신입으로 같은 팀으로 들어간 공채 동기가 나 포함 4명이었다.

늘 항상 혼자 개발을 하다가 (심지어 개발자 친구도 없었음...) 개발에 관심이 많은 동기들과 함께 개발에 대한 얘기를 하다 보면 나는 많은 반성을 하게 된다.

공채 동기들과 대화를 하며 개발에 대한 방향성을 잡으며 1년이란 시간을 보냈더니 동기들 2명이 좋은 곳으로 이직하였다.

개발에 대한 욕심이 많은 동기들의 이직 소식은 나 또한 이직을 하고 싶다는 욕심을 만들어주었다.

F-Lab 유료 멘토링 수강

주로 사용하게 될 언어가 Java로 바뀌면서 빠르고 깊게 공부하기 위한 방법을 찾아보았다.

회사를 다니면서도 선배 개발자의 조언을 얻을만한 기회가 크게 많지가 않아 고민하던 도중 흔히 말하는 네카라쿠배에서도 큰 성과를 만들어낸 선배 개발자분들의 멘토링 F-Lab에 대해서 알게 되었다.

어차피 공부를 시작하기로 마음먹은 거 비싼 금액이지만 투자를 해보는 것도 좋을 것이라 생각되어 바로 결단을 내렸다.

F-Lab에서는 자바의 기본 내용부터 스프링까지 모든 내용을 다뤘으며, 공부의 방향성 및 방법 그리고 앞으로 나아가야 할 자세를 배울 수 있었다.

또, 공부한 내용에 대해서 멘토님께서 질문을 해주시는데 항상 질문을 받을 때마다 좀 더 깊게 공부하지 않았던 부분에 대해 반성하는 시간들이 있었다.

이직 준비.. 그리고 성공

멘토링도 들었고 공부도 했다고 생각이들어 무작정 이직하고 싶다는 마음에 세 곳에 지원을 하게 되었다.

흔히 말하는 노란색 회사, 초록색 회사 그리고 지금 회사다.

우선 내가 회사를 결정한 부분은 아래 요소와 같다.

기존 회사보다 큰 회사
- 기존 중견 규모의 회사로 서비스의 TPS만 봤을 때는 국내에서 손에 꼽히는 회사다.
나의 고민을 같이 고민해줄 선배 개발자 유무
- 기존 회사에서는 시니어 개발자는 물론 Java 개발자가 없어서 항상 고민이 생기면 조언을 구할 수가 없었다.
흥미가 생기는 도메인

노란색 회사는 코테에서 떨어졌다.

문제는 다 풀었다고 생각이 들었는데 예외 케이스를 통과를 못한 것 같다.

솔직히 코딩 테스트를 제대로 준비해본 경험이 없다. 약간 코딩 테스트라고 하면 구현을 하면 된다는 안일한 생각을 가지고 있었기 때문에 떨어졌다고 생각이 들어 이러한 부분에서 2022년의 목표는 알고리즘을 제대로 한번 공부해 보자는 반성의 시간을 가졌다.

초록색 회사는 최종 면접에서 떨어졌다.

보통 최종 면접이라고 하면 인성 면접을 생각할 텐데 심화 기술 면접이었다.

해당 면접 때 나의 부족함에 정말 많은 자괴감이 들었고... 반성하고 다음에 다시 지원하게 된다면 붙을 수 있을 것 같다는 희망도 생겼다.

지금 회사는 최종 합격이다. (그러니깐 다니고 있지)

코테에서 조금 당황했다. 평소 생각하던 코테와 다른 유형의 문제들이 출제되었기 때문이다.

그래도 풀 수는 있었다. 한 문제 정도에서 테스트 케이스를 통과 못했던 것으로 기억난다.

어찌 됐던 세 가지 회사에 지원을 하였고 한 곳에 합격하여 지금 회사를 다니고 있다.

어느 정도 만족스러운 결과를 얻었지만 이번에 이직하면서 느낀 부분은 이직 생각이 없어도 항상 준비를 해두어야 언제든지 이직을 할 수 있다고 생각이 된다.

반성

나는 늘 공부를 하고 있다고 생각을 했다. 하지만 여러 개발자의 공부하면서 남아있는 기록을 보면 정말 열심히 하는 것 같다 나는 그것에 비해 게을르고 그렇게 많이 공부를 하는것 같지가 않다.

새해에는 조금 더 부지런하게 살아야겠다.

2022년 목표

0n1dev — Tue, 4 Jan 2022 09:41:08 +0900

2022년 목표

2021년 마무리 목표는 지켜지지가 않았다.. 정신차리고 해야하는데...

2021년을 너무 정신없이 지내다보니 의욕이 살짝 떨어진것 같다.

다시 정신 차려서 진행해야겠다.

1. 코틀린 제대로 시작해보기

코틀린 공부.
코틀린 기반으로 Spring 진영의 모듈 다시 정리해보기.

2. 개발 방법론 공부하기

DDD
클린 아키텍처
...

3. 파이썬 기반 알고리즘 공부

자료구조 부터 주 3회 이상 시작하기

4. 회고 꾸준히 작성하기

Kotlin In Action #3

0n1dev — Wed, 22 Dec 2021 00:00:02 +0900

Kotlin In Action #3

클래스, 객체, 인터페이스

코틀린의 클래스와 인터페이슨느 자바의 클래스, 인터페이스와 약간 다름.

자바와 달리 코틀린 선언은 기본적으로 public, final 임.

코틀린은 중첩 클래스는 기본적으로 내부 클래스가 아님.

클래스 계층 정의

코틀린 인터페이스

코틀린은 자바 8 인터페이스와 비슷.
코틀린 인터페이스 안에는 추상 메서드뿐 아니라 구현 메서드도 정의 가능. (자바 8의 디폴트 메서드와 비슷)
인터페이스에 아무런 필드가 들어갈 수 없음.

interface Clickable {
    fun click()
}

class Button: Clickable {
    override fun click() = println("Button Click")
}

자바에서는 extends와 implements 키워드를 사용하지만, 코틀린에서는 클래스 이름 뒤에 콜론(:)을 사용해 클래스 확장과 인터페이스 구현을 모두 처리.
자바와 동일하게 인터페이스는 개수 제한 없이 구현 가능하지만, 클래스는 오직 하나만 확장 가능.
override 변경자는 자바의 @Override 어노테이션과 비슷하지만 필수적으로 사용해야 함.

interface Clickable {
    fun click()
    fun showOff() = println("Show Off")
}

자바와 다르게 메서드에 디폴트 구현을 할 때 특별한 키워드가 필요 없음.

interface Focusable {
    fun setFocus(b: Boolean) = println("I ${if (b) "got" else "lost"} focus.")
    fun showOff() = println("Focusable")
}

class Button: Clickable, Focusable {
    override fun click() = println("Button Click")
    override fun showOff() {
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

이름과 시그니처가 동일한 멤버 메서드에 대해 둘 이상의 디폴트 구현이 있는 경우 하위 클래스에서 명시적으로 새로운 구현을 제공해야 함.

open, final, abstract 변경자: 기본적으로 final

자바에서 final로 명시적으로 상속을 금지하지 않은 모든 클래스는 다른 클래스가 상속 가능.

기본적으로 상속이 가능하면 편리한 경우도 있지만 문제가 생기는 경우도 많음.

취약한 기반 클래스라는 문제는 하위 클래스가 기반 클래스에 대해 가졌던 가정이 기반 클래스를 변경함으로써 깨져버린 경우.
코틀린은 클래스와 메서드는 기본적으로 final임.

열린 메서드를 포함하는 열린 클래스 정의

open class RichButton : Clickable { // 해당 클래스는 다른 클래스가 상속 가능

    fun disable() {} // final 함수, 하위 클래스가 오버라이드할 수 없음

    open fun animate() {} // 열려있는 함수, 하위 클래스에서 오버라이드 가능

    override fun click() {} // 오버라이드한 함수는 기본적으로 열려있음
}

오버라이드한 함수는 기본적으로 열려있음. 이를 방지하려면 앞에 final을 붙여줘야 함.

추상 클래스 정의

abstract class Animated { // 추상 클래스는 인스턴스를 만들 수 없음. (구현이 없는 추상 멤버가 있기 때문)

    abstract fun animate() // 추상 함수는 기본적으로 open

    open fun stopAnimating() {} // 추상 클래스에 속했더라도 비추상 함수는 기본적으로 final

    fun animateTwice() {}
}

가시성 변경자: 기본적으로 공개

가시성 변경자는 코드 기반에 있는 선언에 대한 클래스 외부 접근을 제어함.
특정 클래스의 구현에 대한 접근을 제한함으로써 그 클래스에 의존하는 외부 코드를 깨지 않고도 클래스 내부 구현을 변경할 수 잇음.
가시성 변경자 종류
- public (default)
- protected
- private
코틀린은 패키지를 네임스페이스를 관리하기 위한 용도로만 사용하여 package-private (자바의 default)를 사용하지 않음.
- 패키지 전용 가시성에 대한 대안으로 internal이라는 새로운 가시성 변경자를 도입.
- internal은 "모듈 내부에서만 볼 수 있음"
  - 모듈은 한 번에 컴파일되는 코틀린 파일들을 의미.

변경자	클래스 멤버	최상위 선언
public (default)	모든 곳에서 볼 수 있음.	모든 곳에서 볼 수 있음.
internal	같은 모듈 안에서만 볼 수 있음.	같은 모듈 안에서만 볼 수 있음.
protected	하위 클래스 안에서만 볼 수 있음.	최상위 선언에 적용할 수 없음
private	같은 클래스 안에서만 볼 수 있음.	같은 파일 안에서만 볼 수 있음.

internal open class TalkativeButton : Focusable {

    private fun yell() = println("Hey!")
    protected fun whisper() = println("Let's talk!")
}

fun TalkativeButton.giveSpeech() { // "public" 멤버가 자신의 "internal" 수신 타입인 "TalkativeButton"을 노출함
    yell() // "yell"에 접근할 수 없음.
    whisper() // "whisper"에 접근할 수 없음.
}

public 함수 안에서 그보다 가시성이 더 낮은 타입을 참조하지 못하게 함.
- giveSpeech 함수는 public / TalkativeButton 클래스는 internal
가시성은 같거나 더 높아야 한다는 일반적인 규칙이 있음.

코틀린의 가시성 변경자와 자바
코틀린의 public, protected, private 변경자는 컴파일된 자바 바이트 코드 안에서도 그대로 유지 됨.
유일한 예외는 자바에서는 클래스를 private로 만들 수 없으므로 내부적으로 코틀린의 private 클래스를 패키지 전용 클래스로 컴파일 함.
internal 변경자는 자바에 딱 맞는 가시성이 없음. 바이트 코드상으로는 public이 됨.

코틀린과 자바 가시성 규칙의 다른 차이는 코틀린에서는 외부 클래스가 내부 클래스나 중첩 클래스의 private 멤버에 접근할 수 없음.

내부 클래스와 중첩된 클래스: 기본적으로 중첩 클래스

코틀린의 중첩 클래스는 자바와 다르게 명시적으로 요청하지 않는 한 바깥쪽 클래스 인스턴스에 대한 접근 권한이 없음.

예시1)

직렬화할 수 있는 상태가 있는 뷰 선언

import java.io.Serializable

interface State: Serializable

interface View {
    fun getCurrentState() : State
    fun restoreState(state: State) {}
}

자바에서 내부 클래스를 사용해 View 구현

import org.jetbrains.annotations.NotNull;

public class Button implements View{
    @NotNull
    @Override
    public State getCurrentState() {
        return new ButtonState();
    }

    @Override
    public void restoreState(@NotNull State state) {
        /* ... */
    }
    
    public class ButtonState implements State {
        /* ... */
    }
}

State 인터페이스를 구현한 ButtonState 클래스를 정의하여 Button에 대한 구체적인 정보를 저장.
버튼의 상태를 직렬화하면 NotSerializableException: Button 발생.
- 자바에서는 다른 클래스 안에 정의한 클래스는 자동으로 내부 클래스가 됨.
- ButtonState 클래스는 바깥쪽 Button 클래스에 대한 참조를 묵시적으로 포함.
- 해결하기 위해서는 ButtonState를 static 클래스로 선언해야 함. (묵시적인 참조가 사라짐)

중첩 클래스를 사용해 코틀린에서 View 구현하기

class Button : View {
    override fun getCurrentState(): State = ButtonState()

    override fun restoreState(state: State) {
        /* ... */
    }

    class ButtonState :State {
        /* ... */
    }
}

코틀린 중첩 클래스에는 아무런 변경자가 붙지 않으면 자바 static 중첩 클래스와 같음.
반대로 바깥족 클래스에 대한 참조를 포함하게 만들고 싶으면 inner 변경자를 붙여야 함.

Inner 클래스에서 Outer 클래스의 참조에 접근

class Outer {
    val a = 1;
    
    inner class Inner {
        fun getOuterReference()  : Outer = this@Outer
        fun getValue() : Int = a
    }
}

봉인된 클래스: 클래스 계층 정의 시 계층 확장 제한

인터페이스 구현을 통한 식 표현하기

interface Expr
class Num(val value: Int): Expr
class Sum(val left: Expr, val right: Expr): Expr

fun eval(e: Expr): Int = 
    when (e) {
        is Num -> e.value
        is Sum -> eval(e.right) + eval(e.left)
        else ->
            throw IllegalArgumentException("Unknown expression")
    }

코틀린은 when을 사용하여 Expr 타입의 값을 검사할 때 꼭 디폴트 분기인 else 분기를 덧붙이게 강제함.
새로운 하위 클래스를 추가했을때 컴파일러가 when이 모든 경우를 처리하는지 제대로 검사가 불가능.
- sealed 변경자를 붙이면 하위 클래스 정의를 제한할 수 있음.

sealed class Expr { // sealed로 봉인
    class Num(val value: Int): Expr() // 기반 클래스의 모든 하위 클래스를 중첩 클래스로 나열
    class Sum(val left: Expr, val right: Expr): Expr()
}

fun eval(e: Expr): Int =
    when (e) { // when 식이 모든 하위 클래스를 검사하므로 별도의 else 분기 필요 없음.
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
    }

sealed로 표시된 클래스는 자동으로 open 변경자.
내부적으로 Expr 클래스는 private 생성자를 가짐.

코틀린 1.0에서는 하위 클래스는 중첩 클래스여야 하고, 데이터 클래스로 sealed 클래스를 상속할 수 없음.
1.1 부터는 해당 제한이 완화 됨.

Raspberry pi4를 활용한 Kubernetes Cluster #1

0n1dev — Wed, 15 Dec 2021 23:01:36 +0900

Raspberry pi4를 활용한 Kubernetes Cluster #1

OS 환경은 Ubuntu 20.04 64bit 라즈베리용에서 진행됨.

호스트네임 수정

sudo vi /etc/cloud/cloud.cfg

preserve_hostname = true

sudo hostnamectl set-hostname 호스트이름

sudo reboot

아이피 설정

sudo vi /etc/netplan/50-cloud-init.yaml

network:
    ethernets:
        eth0:
            dhcp4: false
            # optional: true
            addresses: [172.30.1.1/24]
            gateway4: 172.30.1.254
            nameservers:
                addresses: [168.126.63.1, 168.126.63.2]
    version: 2
    
sudo netplan apply

패키지 업데이트

sudo apt update
sudo apt -y upgrade && sudo systemctl reboot

Kubelet, Kubeadm, Kubectl 설치

sudo apt update
sudo apt -y install curl apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update
sudo apt -y install vim git curl wget kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

Cgroup 메모리 구성

cgroup="$(head -n1 /boot/firmware/cmdline.txt) cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1 swapaccount=1"
echo $cgroup | sudo tee /boot/firmware/cmdline.txt

메모리 스왑 비활성화

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
sudo swapoff -a

커널 모듈 활성화

sudo modprobe overlay
sudo modprobe br_netfilter

sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sudo sysctl --system

Raspberry pi4를 활용한 Kubernetes Cluster #0

0n1dev — Tue, 14 Dec 2021 23:42:16 +0900

Raspberry pi4를 활용한 Kubernetes Cluster #0

재료
- Raspberry pi4 8GB 3개
  - 마스터 노드 1개
  - 워커 노드 2개 (추후 1개 늘려줄 예정)
- iUniker Raspberry Pi Cluster Case (아마존 직구 배송중)
- MicroSD 삼성 32GB 3개
- 액토 고속 충전기
- C타입 고속충전 케이블 0.2m
- IPTIME H6005
- 랜케이블 짧은거로 3개

Kotlin In Action #2

0n1dev — Sat, 11 Dec 2021 23:01:10 +0900

Kotlin In Action #2

함수 정의와 호출

모든 프로그램에서 핵심이라 할 수 있는 함수 정의와 호출 기능을 코틀린이 어떻게 개선했는지 살펴보자.

추가로 확장 함수와 프로퍼티를 사용해 자바 라이브러리를 코틀린 스타일로 적용하는 방법을 살펴보자.

코틀린에서 컬렉션 만들기

    val set = hashSetOf(1, 7, 53)
    val list = arrayListOf(1, 7, 53)
    val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

map에서 사용된 to는 언어가 제공하는 키워드가 아닌 일반 함수.

fun main(args: Array<String>) {
    val set = hashSetOf(1, 7, 53)
    val list = arrayListOf(1, 7, 53)
    val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

    println(set.javaClass)
    println(list.javaClass)
    println(map.javaClass)
}

해당 코드를 실행해 보면 아래와 같은 결과를 얻을수 있음.

class java.util.HashSet
class java.util.ArrayList
class java.util.HashMap

코틀린은 자신만의 컬렉션 기능을 제공하지 않음.

코틀린이 자체 컬렉션을 제공하지 않는 이유는 표준 자바 컬렉션을 활용하면 자바 코드와 상호작용하기 훨씬 쉽기 때문.

코틀린은 자바보다 더 많은 기능을 제공.

    println(set.last())
    println(list.maxOrNull())

함수 호출하기 쉽게 만들기

fun <T> joinToString(
    collection: Collection<T>,
    separator: String,
    prefix: String,
    postfix: String
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

해당 함수는 제네릭 함.

어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있음.

해당 함수를 계속해서 사용하기에는 매번 인자 4개를 모두 전달해야 해서 번잡함이 있다. 이를 해결해보자.

이름 붙인 인자

joinToString(list, separator = "; ", prefix =  "(", postfix = ")")

IDE 도움을 받아 시그니처를 표시할 수 있겠지만, 코드 자체가 모호하기 때문에 인자의 이름을 명시 할 수 있음.

이름을 명시하고 나면 혼동을 막기 위해 그 뒤에 오는 모든 인자의 이름을 꼭 명시해야 함.

디폴트 파라미터 값

자바에서는 일부 클래스에서 오버로딩한 메서드가 너무 많아진다는 문제가 있음.

코틀린에서는 함수 선언에서 파라미터의 디폴트 값을 사용해 오버로드 중 상당수를 피할 수 있음.

fun <T> joinToString(
    collection: Collection<T>,
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
): String

정적인 유틸리티 클래스 없애기: 최상위 함수와 프로퍼티

자바
- 모든 코드를 클래스의 메소드로 작성해야 함.
- 어느 한 클래스에 포함시키기 어려운 코드가 많음.
- 정적 메소드만 모아두는 역할을 담당하는 특별한 상태나 인스턴스가 없는 클래스가 생겨남.
코틀린
- 무의미한 클래스가 필요 없음.
- 함수를 직접 소스 파일의 최상위 수준, 모든 다른 클래스의 밖에 위치 시키면 됨.

최상위 프로퍼티

함수와 마찬가지로 프로퍼티도 파일의 최상위 수준에 놓을 수 있음.

var opCount: Int = 0

fun performOperation() {
    opCount++
}

fun reportOperationCount() {
    println("Operation performed $opCount times")
}

최상위 프로퍼티 값은 정적 필드에 저장됨.

최상위 프로퍼티를 활용해 상수를 추가할 수 있음.

const val UNIX_LINE_SEPARATOR = "\n"

그냥 val만 사용하면 게터가 생김.

const를 붙이면 public static final 필드로 컴파일.

메서드를 다른 클래스에 추가: 확장 함수와 확장 프로퍼티

자바 라이브러리 기반 혹은 자바 프로젝트와 통합하는 경우 코틀린으로 직접 변환할 수 없거나 미처 변환하지 않은 기존 자바 코드를 처리할 수 있어야 함.

기존 자바 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 사용할 수 있게 해주는 확장 함수.

fun String.lastChar(): Char = this.get(this.length - 1)

확장 함수를 만들려면 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 덧붙이면 됨.

여기서 String은 수신 객체 타입이고, this는 수신 객체.

수신 객체 멤버에 this없이 접근 가능.

fun String.lastChar(): Char = get(length - 1)

확장 함수가 캡슐화를 깨지 않음.

클래스 안에서 정의한 메서드와 달리 확장 함수 안에서는 클래스 내부에서만 사용 가능한 private 혹은 protected 멤버를 사용할 수 없음.

임포트와 확장 함수

확장 함수를 사용하기 위해서는 그 함수를 다른 클래스나 함수와 마찬가지로 임포트해야 사용 가능.

import strings.lastChar

fun main(args: Array<String>) {
    println("Kotlin".lastChar())
}

import strings.*

fun main(args: Array<String>) {
    println("Kotlin".lastChar())
}

as 키워드를 사용하면 임포트한 클래스나 함수를 다른 이름으로 부를 수 있음.

여러 패키지의 동일한 함수를 가져와야 하면 충돌을 막기 위해 사용.

import strings.lastChar as last

fun main(args: Array<String>) {
    println("Kotlin".last())
}

자바에서 확장 함수 호출

lastChar() 함수의 파일명을 LastKt로 했으면 아래와 같이 사용하면 됨.

char c = LastKt.lastChar("dddd");

joinToString() 함수 확장 함수로 정의

package strings

fun <T> Collection<T>.joinToString(
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

확장 함수는 오버라이드할 수 없다

open class View {
    open fun click() = println("View")
}

class Button: View() {
    override fun click() = println("Button")
}

fun main(args: Array<String>) {
    val v: View = Button()
    v.click()
}

Button이 View의 하위 타입이기 때문에 View 타입 변수를 선언해도 Button 타입 변수 대입 가능.
Button 클래스가 click 함수를 오버라이드했다면 Button이 오버라이드한 click 함수가 호출 됨.

fun View.showOff() = println("View2")
fun Button.showOff() = println("Button2")

fun main(args: Array<String>) {
    val v: View = Button()
    v.showOff()
}

확장 함수는 정적으로 결정되기 때문에 View 클래스의 showOff 함수가 호출 됨.

확장 프로퍼티

확장 프로퍼티를 사용하면 기존 클래스 객체에 대한 프로퍼티 형식의 구문으로 사용할 수 있는 API를 추가할 수 있음.

상태를 저장할 적절한 방법이 없기 때문에 확장 프로퍼티는 아무 상태도 가질 수 없음.

val String.lastChar: Char
    get() = get(length - 1)

변경 가능한 프로퍼티

var StringBuilder.lastChar: Char
    get() = get(length - 1)
    
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }

컬렉션 처리: 가변 길이 인자, 중위 함수 호출, 라이브러리 지원

vararg 키워드를 사용하면 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있음.
중위 함수 호출 구문을 사용하면 인자가 하나뿐인 메서드를 간편하게 호출할 수 있음.
구조 분해 선언을 사용하면 복합적인 값을 분해해서 여러 변수에 나눠 담을 수 있음.

자바 컬렉션 API 확장

코틀린에서의 컬렉션은 자바와 같은 클래스를 사용하지만 더 확장된 API를 제공.

대표적인 예시로 last나 maxOrNull 함수가 있음.

fun main(args: Array<String>) {
    val list = listOf<String>("test1", "test2", "test3")
    println(list.last())

    val numbers = setOf<Int>(9, 1, 10, 5, 6)
    println(numbers.maxOrNull())
}

public fun <T> List<T>.last(): T {
    if (isEmpty())
        throw NoSuchElementException("List is empty.")
    return this[lastIndex]
}

public fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var max = iterator.next()
    while (iterator.hasNext()) {
        val e = iterator.next()
        if (max < e) max = e
    }
    return max
}

last나 maxOrNull은 확장 함수라는 것.

가변 인자 함수: 인자의 개수가 달라질 수 있는 함수 정의

리스트를 생성하는 listOf 함수를 보자.

public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

가변 길이 인자는 메서드를 호출할 때 원하는 개수만큼 값을 인자로 넘기면 컴파일러가 배열에 그 값들을 넣어주는 기능.
자바의 ...과 비슷. 코틀린에서는 vararg 변경자를 쓰면 됨.

fun main(args: Array<String>) {
    val list = listOf("args : ", *args)
    println(list)
}

자바에서는 가변 길이 인자를 넘길 때 배열을 사용함.
코틀린에서는 배열을 명시적으로 풀어 배열의 각 원소가 인자로 전달되게 해야 함. (스프레드 연선자)

값의 쌍 다루기: 중위 호출과 구조 분해 선언

중위 호출 시 수신 객체와 유일한 메소드 인자 사이에 메소드 이름을 넣음.

    val map = mapOf(1 to "one", 7 to "seven", 53 to "fifty-three")
    
    1.to("one")
    1 to "one"

1.to("one") <- "to" 메서드를 일반적인 방식으로 호출
1 to "one" <- "to" 메서드를 중위 호출 방식으로 호출

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

함수를 중위 호출에 사용하게 허용하고 싶으면 infix 변경자를 함수 선언 앞에 추가.
to 함수는 Pair의 인스턴스를 반환.
- Pair는 코틀린 표준 라이브러리 클래스로, 두 원소로 이루어진 순서쌍을 표현.

    val (number, name) = 1 to "one"

Pair 클래스를 사용하여 두 변수를 즉시 초기화.
해당 기능을 구조 분해 선언이라 부름.

문자열과 정규식 다루기

코틀린 코드가 만들어낸 문자열을 아무 자바 메서드에 넘겨도 되고, 자바 코드에서 받은 문자열을 아무 코틀린 표준 라이브러리 함수에 전달해도 문제 없음.

특별한 변환과 자바 문자열을 감싸는 별도의 래퍼가 필요 없음.

문자열 나누기

println("324.23gerag23.23549.234gw-ew".split("\\.|-".toRegex())) // 정규식을 명시적으로 만듬.

println("324.23gerag23.23549.234gw-ew".split(".", "-")) // 여러 구분 문자열을 지정.

정규식과 3중 따옴표로 묶은 문자열

String 확장 함수를 사용해 경로 파싱

fun String.parsePath(): String {
    val directory = this.substringBeforeLast("/")
    val fullName = this.substringAfterLast("/")
    val fileName = fullName.substringBeforeLast(".")
    val extension = fullName.substringAfterLast(".")

    return "Dir: $directory, name: $fileName, ext: $extension"
}

정규식 사용해 경로 파싱

fun String.parsePath(): String {
    val regex = """(.+)/(.+)\.(.+)""".toRegex()
    val matchResult = regex.matchEntire(this)
    if (matchResult != null) {
        val (directory, fileName, extension) = matchResult.destructured
        return "Dir: $directory, name: $fileName, ext: $extension"
    }

    return ""
}

3중 따옴표 문자열에서는 역슬래시(\)를 포함한 어떤 문자도 이스케이프할 필요가 없음.

여러 줄 3중 따옴표 문자열

fun main(args: Array<String>) {
    val text = """|ddd
        .|ddddfeafe
        .|wefw
    """

    println(text.trimMargin("."))
}

이스케이프를 피하기 위해서만 아닌 줄 바꿈을 쉽게 표현하기 위해서도 사용.

코드 다듬기: 로컬 함수와 확장

함수에서 추출한 함수를 원 함수 내부에 중첩시킬 수 잇음.

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException(
            "Can't save user ${user.id}: empty Name"
        )
    }

    if (user.address.isEmpty()) {
        throw IllegalArgumentException(
            "Can't save user ${user.address} empty Address"
        )
    }
}

로컬 함수를 사용해 중복 코드 줄이기

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun saveUser(user: User) {
    fun validate(value: String,
                 fieldName: String
    ) {
        if (value.isEmpty()) {
            throw IllegalArgumentException(
                "Can't save user ${user.name}: empty $fieldName"
            )
        }
    }
    
    validate(user.name, "Name")
    validate(user.address, "Address")
}

로컬 함수는 자신이 속한 바깥 함수의 모든 파라미터와 변수를 사용할 수 있음.

6.0 데이터 압축

0n1dev — Wed, 8 Dec 2021 00:24:55 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

Kotlin In Action #1

0n1dev — Mon, 6 Dec 2021 22:17:36 +0900

Kotlin In Action #1

기본요소: 함수와 변수

Hello, World!

fun main(args: Array<String>) {
    println("Hello World!")
}

함수를 선언할 때 fun 키워드 사용.
파라메터 이름 뒤에 그 파라메터의 타입을 작성.
함수를 최상위 수준에 정의. (자바는 클래스 안에 메서드를 넣음.)
코틀린 표준 라이브러리는 여러 표준 자바 라이브러리의 메서드를 간결하게 사용할 수 있게 감싼 레퍼를 제공.
세미콜론을 붙이지 않아도 됨.

반환 값이 있는 함수

fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

코틀린에서의 if는 식(expression)이지 문(statement)가 아니다.

식은 값을 만들어 내며 다른 식의 하위 요소로 계산에 참여할 수 있음.
문은 자신을 둘러싸고 있는 가장 안쪽 블록의 최상위 요소로 존재하며 아무런 값을 만들어내지 않음.

식이 본문인 함수

fun max(a: Int, b: Int): Int = if (a > b) a else b

reaturn을 제거하면서 등호(=)를 식 앞에 붙이면 더 간결한 함수 표현이 가능.

fun max(a: Int, b: Int) = if (a > b) a else b

식이 본문인 함수의 경우 굳이 사용자가 반환 타입을 적지 않아도 됨. (타입 추론)

변수

자바와 다르게 타입 지정을 생략하거나, 변수 이름 뒤에 타입을 명시.

fun main(args: Array<String>) {
    val question = "가나다라마바사"
    val answer = 42
    val answer2: Int = 43

    println(question)
    println(answer)
    println(answer2)
}

※ 초기화 식을 사용하지 않는다면 반드시 타입을 지정해야 함

변경 가능한 변수와 변경 불가능한 변수

val(value) - 변경 불가능한 참조를 저장하는 변수. 자바로 따지면 final 키워드가 붙은 변수.
- 참조가 가리키는 객체의 내부 값은 변경될 수 있음.
var(variable) - 변경 가능한 참조. 값이 바뀔 수 있음.
- 타입은 고정되어 바뀌지 않음. ("Error: type mismatch" 오류 발생)

더 쉽게 문자열 형식 지정: 문자열 템플릿

fun main(args: Array<String>) {
    var name = if  (args.size > 0) args[0] else "Kotlin"
    println("Hello, $name")
}

문자열 리터럴의 필요한 곳에 $ 키워드와 함께 변수를 넣어 사용 가능.

복잡한 식은 ${} 중괄호를 사용해서 넣을 수 있음.

클래스와 프로퍼티

Java에서의 Person 클래스

public class Person {

    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Kotlin에서의 Person클래스

class Person (val name: String)

해당 유형의 클래스(코드가 없이 데이터만 저장하는 클래스)를 값 객체라 함.
코틀린에서의 기본 접근 제어자는 public이다.

프로퍼티

자바에서는 필드와 접근자를 묶은것을 프로퍼티라 부르고, 해당 개념을 활용하는 프레임워크가 많음.

코틀린은 프로퍼티를 언어 기본 기능으로 제공하며, 자바의 필드와 접근자 메서드를 완전히 대신함.

val로 선언한 프로퍼티는 읽기 전용. (게터만 만듬)
var로 선언한 프로퍼티는 변경도 가능. (게터, 세터 둘 다 만듬)

class Person (
    val name: String,
    var isMarried: Boolean
)

fun main(args: Array<String>) {
    val person = Person("0n1dev", true)

    println(person.name)
    println(person.isMarried)
}

커스텀 접근자

class Rectangle(val height: Int, val width: Int) {

    val isSquare: Boolean
        get() {
            return height == width
        }
}

isSquare 프로퍼티에는 자체 구현을 제공한는 게터만 존재.

복잡한 블록문 대신 get() = height == width로 작성해도 됨.

코틀린 소스코드 구조: 디렉터리와 패키지

자바의 경우 모든 클래스를 패키지 단위로 관리.

코틀린에도 비슷한 개념의 패키지가 있음.

자바와 다른점은 자바에서는 패키지와 디렉터리 계층 구조가 동일해야 함, 코틀린은 디렉터리와 상관없이 원하는 대로 소스코드 구성이 가능.

하지만 자바와 같이 패키지별로 디랙터리를 구성하는게 좋음.

선택 표현과 처리: enum과 when

enum 클래스 정의

enum class Color {
    RED, ORANGE, BLUE, GREEN, YELLOW
}

코틀린에서의 enum은 소프트 키워드라 부르는 존재.
class 앞에 있을 때는 특별한 의미를 지니지만 다른 곳에서 이름에 사용할 수 있음.
반면 class는 키워드.

enum class Color(
    val r: Int, // 프로퍼티
    val g: Int,
    val b: Int
) {
    RED(255, 0, 0), // 상수 생성시 프로퍼티 값 지정
    ORANGE(255, 165, 0),
    BLUE(0, 0, 255),
    GREEN(0, 255, 0),
    YELLOW(255, 255, 0); // 여기서는 세미콜론 필수

    fun rgb() = (r * 256 + g) * 256 + b // enum 클래스 내부의 메서드 정의
}

when으로 enum 클래스 다루기

fun getMnemonic(color: Color) =
    when (color) {
        Color.RED -> "RED"
        Color.BLUE -> "BLUE"
        Color.GREEN -> "GREEN"
        Color.YELLOW -> "YELLOW"
        Color.ORANGE -> "ORANGE"
    }

자바와 다르게 각 분기의 끝에 break를 넣지 않아도 됨.
한 분기 안에서 여러 값을 매치 패턴으로 적용할 수 있음. (콤마로 분리)
해당 enum class를 임포트 시키면 클래스 수식자 없으 사용 가능.

when과 임의의 객체를 함께 사용

switch와 다르게 분기 조건에 상수만 사용할 수 있는게 아닌 임의의 객체를 허용.

fun mix(color1: Color, color2: Color) =
    when (setOf(color1, color2)) {
        setOf(Color.RED, Color.YELLOW) -> Color.ORANGE
        else -> throw Exception("Dirth Color")
    }

이처럼 when의 분기 조건 부분에 식을 넣을 수 있기 때문에 코드를 더 간결하고 아름답게 작성할 수 있음.

하지만 해당 함수는 호출될 때마다 함수 인자로 주어진 두 색이 when의 분기 조건에 있는 다른 두 색과 같은지 비교하기 위해 여러 Set 인스턴스를 생성. (불필요한 가비지 객체가 늘어남.)

인자 없는 when 사용

fun mixOptimized(color1: Color, color2: Color) =
    when {
        (color1 == RED && color2 == YELLOW) ||
                (color1 == YELLOW && color2 == RED) ->
            ORANGE
        (color1 == YELLOW && color2 == BLUE) ||
                (color1 == BLUE && color2 == YELLOW) ->
            GREEN
        else -> throw Exception("Dirty Color")
    }

추가적으로 객체를 생성하지 않는다는 장점이 있지만 가독성이 떨어지는 단점이 있음.

스마트 캐스트: 타입 검사와 타입 캐스트를 조합

interface Expr
class Num(val value: Int): Expr // value라는 프로퍼티만 존재하는 클래스
class Sum(val left: Expr, val right: Expr): Expr // Expr 타입의 객체라면 어떤 것이나 Sum 연산자의 인자가 될 수 있음

fun main(args: Array<String>) {
    println(eval(Sum(Sum(Num(1), Num(2)), Num(4))))
}

fun eval(e: Expr): Int {
    if (e is Num) {
        val n = e as Num
        return n.value
    }

    if (e is Sum) {
        return eval(e.left) + eval(e.right)
    }

    throw IllegalArgumentException("Unknown expression")
}

is는 자바의 instanceof와 비슷함.
자바 경우 타입을 확인 후 해당 타입에 속한 멤버에 접근하기 위해서는 명시적으로 타입을 캐스팅해야 함.
코틀린에서는 프로그래머 대신 컴파일러가 캐스팅 해줌.

리팩토링: if를 when으로 변경

1차 리팩토링: return문과 중괄호 제거

fun eval(e: Expr): Int =
    if (e is Num) {
        e.value
    } else if (e is Sum) {
        eval(e.left) + eval(e.right)
    } else {
        throw IllegalArgumentException("Unknown expression")
    }

2차 리팩토링: when으로 변경

fun eval(e: Expr): Int =
    when (e) {
        is Num -> {
            e.value
        }
        is Sum -> {
            eval(e.left) + eval(e.right)
        }
        else -> {
            throw IllegalArgumentException("Unknown expression")
        }
    }

대상을 이터레이션: while과 for 루프

while은 자바와 동일.
for은 자바의 for-each 루프에 해당하는 형태만 존재.

수에 대한 이터레이션: 범위와 수열

코틀린에서는 초기값, 증가 값, 최종 값을 사용한 루프가 아닌 범위를 사용.
범위는 기본적으로 두 값으로 이뤄진 구간이며, 보통 정수 등의 숫자 타입의 값 .. 연산자로 시작 값과 끝 값을 연결해서 범위를 만듬.

val oneToTen = 1..10

정수 범위로 수행할 수 있는 가장 단순한 작업은 범위에 속한 모든 값에 대한 이터레이션.

어떤 범위에 속한 값을 일정한 순서로 이터레이션하는 경우를 수열이라 함.

fun main(args: Array<String>) {
    val oneToTen = 1..10

    for (i in oneToTen) {
        println(clapGame(i))
    }
}

fun clapGame(i: Int) =
    when {
        i % 3 == 0 -> "짝"
        i % 6 == 0 -> "짝"
        i % 9 == 0 -> "짝"
        else -> "$i"
    }

증가 값을 갖고 범위 이터레이션

    for (i in 100 downTo 1 step 2) {
        println(clapGame(i))
    }

100 dwonTo 1은 역방향 수열.
step을 붙이면 증가 값이 변경 됨.
그 외에 until도 있는데 뒤에서 배울 예정.

맵에 대한 이터레이션

import java.util.*

fun main(args: Array<String>) {
    val binaryReps = TreeMap<Char, String>()

    for (c in 'A'..'Z') {
        val binary = Integer.toBinaryString(c.code)
        binaryReps[c] = binary
    }

    for ((letter, binary) in binaryReps) {
        println("$letter = $binary")
    }
}

책에서는 Integer.toBinaryString(c.toInt())로 나와있었다.

Char.toInt()는 Kotlin 1.5부터 Deprecated 되었기 때문에 Char.code로 작성해야 함.

in으로 컬렉션이나 범위의 원소 검사

in 연산자를 사용해 어떤 값이 범위에 속하는지 검사할 수 있음.

fun main(args: Array<String>) {
    println(isLetter('q'))
    println(isNotDigit('x'))
}

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNotDigit(c: Char) = c !in '0'..'9'

when에서 in 사용하기

fun recognize(c: Char) = when (c) {
    in '0'..'9' -> "It's digit!"
    in 'a'..'z', in 'A'..'Z' -> "It's a letter!"
    else -> "I don't know.."
}

코틀린의 예외 처리

코틀린의 예외 처리는 자바나 다른 언어의 예외 처리와 비슷.

코틀린에서의 예외는 자바와 비슷하지만, new를 붙일 필요가 없음.

fun main(args: Array<String>) {
    val percentage = 1000
    
    if (percentage !in 0..100) {
        throw IllegalArgumentException("수치를 벗어남.")
    }
}

try, catch, finally

자바와 동일하게 try, catch, finally 절을 함께 사용.

자바와 다르게 함수가 던질 수 있는 예외를 명시할 필요가 없음.

try를 식으로 사용

fun readNumber(reader: BufferedReader) {
    val number = try {
        Integer.parseInt(reader.readLine())
    } catch (e: NumberFormatException) {
        null
    }
}

Kotlin In Action #0

0n1dev — Sun, 5 Dec 2021 22:12:39 +0900

Kotlin In Action #0

코틀린이란?

코틀린은 자바 플랫폼에서 돌아가는 새로운 프로그래밍 언어.

간결하고 실용적.
자바 코드와 상호운용적.
정적 타입 지정 언어.
- 프로그램 구성 요소의 타입을 컴파일 시점에 알 수 있음.
- 객체의 필드나 메서드를 사용할 때 컴파일러가 타입을 검증.
- 자바와 다르게 타입을 추론해주기 때문에 변수의 타입을 프로그래머가 직접 명시할 필요 없음.
- 정적 타입의 장점
  - 성능
    - 실행 시점에 어떤 메서드를 호출할지 알아내는 과정이 필요 없으므로 메서드 호출이 더 빠름.
  - 신뢰성
    - 컴파일러가 프로그램의 정확성을 검증하기 때문에 실행 시 프로그램이 오류로 중단될 가능성이 적음.
  - 유지 보수성
    - 코드에서 다루는 객체가 어떤 타입에 속하는지 알 수 있기 때문에 처음 보는 코드를 다룰 때도 쉬움.
  - 도구 지원
    - 정적 타입 지정을 활용하면 더 안전하게 리팩토링 할 수 있고, 도구는 더 정확한 코드 완성 기능을 제공.
Null이 될 수 있는 타입을 지원.
함수 타입.

자바를 사용중인 곳이라면 거의 대부분 코틀린 사용이 가능.

함수형 프로그래밍과 객체지향 프로그래밍

일급 객체(First-Class Citizen) 함수
- 함수를 일반 값처럼 다룰 수 있음.
- 함수를 변수에 저장할 수 있음.
- 함수를 인자로 다른 함수에 전달할 수 있으며, 새로운 함수를 만들어서 반환할 수 있음.
불변성(Immutability)
- 함수형 프로그래밍에서는 일단 만들어지고 나면 내부 상태가 절대로 바뀌지 않는 불볍 객체를 사용해 프로그램을 작성.
부수 효과(Side Effect) 없음
- 입력이 같으면 항상 같은 결과를 내놓는 순수 함수를 사용.

코틀린의 철학

실용성
- 대규모 시스템을 개발해본 다년간의 IT업계의 경험을 바탕으로 이루어짐.
- 수많은 개발자들의 사용에 잘 들어맞을 수 있게 주의 깊게 언어 특성을 선택.
- 어느 특정 프로그래밍 스타일이나 패러다임을 사용할 것을 강제로 요구하지 않음.
간결성
- 코드가 간결할수록 내용을 파악하기 쉬움.
- 설계와 각 부분의 역할을 잘 표현해주는 적절한 이름도 중요하지만 해당 언어가 얼마나 간결한 언어인지 중요.
- 자바의 게터, 세터, 생성자 파라메터를 필드에 대입하기 위한 로직 등을 코틀린은 묵시적으로 제공.
안전성
- 절대적인 오류 방지는 아님. (모든 오류를 막을 수는 없음)
- JVM을 사용한다는 것 자체가 상당한 안전성을 보장한다는 의미.
- 코틀린은 NPE를 없애기 위해 노력.
상호운용성
- 자바의 기존 라이브러리를 그대로 사용 할 수 있음.

실전! Querydsl #1

0n1dev — Sat, 4 Dec 2021 19:04:05 +0900

실전! Querydsl #1

QueryDSL 은 프로젝트 내의 @Entity 어노테이션을 선언한 클래스를 탐색하고 JPAAnnotationProcessor을 이용하여 Q클래스를 생성함.

Q클래스를 활용하면 자바 언어가 가지는 정적코드의 장점을 활용하여 안전한 쿼리문을 작성할 수 있음.

프로젝트 환경설정

강의에서는 com.ewerk.gradle.plugins.querydsl 플러그인을 활용하지만, 플러그인 방식만 있는것이 아님.

실제로 실무에서 프로젝트의 버전들을 올리는 마이그레이션 작업을 진행했는데 QueryDSL로 인해 문제가 발생한적이 있음.

플러그인 방식
Annotation Processor 방식

실전! Querydsl #0

0n1dev — Fri, 3 Dec 2021 21:23:00 +0900

실전! Querydsl #0

최신 자바 백엔드 기술은 주로 스프링 부터 + 스프링 데이터 JPA를 조합으로 사용.

해당 기술로 해결이 불가능한 부분이 있음.

복잡한 쿼리
동적 쿼리

이를 해결하는것을 도와주는게 QueryDSL이다.

QueryDSL

쿼리를 자바 코드로 작성.
문법 오류를 컴파일 시점에 체크.
동적 쿼리를 깔끔하게 해결.

JPQL vs QueryDSL

    void jpql() {
        String username = "Shin";
        String query = "select m from Member m " +
                "where m.username = :username";
        List<Member> result = em.createQuery(query, Member.class)
                .getResultList();
    }

    void querydsl() {
        String username = "Shin";

        jpaQueryFactory
                .select(member)
                .from(member)
                .where(member.username.eq(username))
                .fetch();
    }

5.4 MySQL의 격리 수준

0n1dev — Wed, 1 Dec 2021 23:12:14 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

5.4 MySQL의 격리 수준

트랜잭션의 격리 수준이란? 여러 트랜잭션이 동시에 처리될 때 특정 트랜잭션이 다른 트랜잭션에서 변경하거나 조회하는 데이터를 볼 수 있게 허용할지 말지를 결정하는 것.

격리 수준이 높아질수록 격리 정도가 높아지며, 동시 처리 성능이 떨어짐.

-> SERIALZABLE 격리 숮준이 아니라면 크게 성능의 개선이나 저하가 발생하지 않음.

격리 수준

READ UNCOMMITTED
- DIRTY READ, NON-REPEATABLE READ, PHANTOM READ
READ COMMITTED
- NON_REPEATABLE READ, PHANTOM READ
REPEATABLE READ
- PHANTOM READ(InnoDB는 X)
SERIALIZABLE

부정합

DIRTY READ
NON_REPEATABLE READ
PHANTOM READ

5.4.1 READ UNCOMMITTED

COMMIT이나 ROLLBACK 여부에 상관없이 다른 트랜잭션에서 보임.

예시

A, B 트랜잭션이 존재한다고 했을때
- A 트랜잭션이 0n1dev, 5000 이라는 값을 삽입 (아직 COMMIT 안함)
- B 트랜잭션이 5000을 조회하면 0n1dev, 5000이 조회 됨
- A 트랜잭션 COMMIT

이때, B 트랜잭션이 조회 후 A 트랜잭션에서 예외가 발생 했을때 ROLLBACK이 되어도 B 트랜잭션에서 0n1dev, 5000이 정상적인 데이터라고 판단.

-> 어떤 트랜잭션에서 처리한 작업이 완료되지 않았는데 다른 트랜잭션에서 볼 수 있는 현상을 더티 리드라 함.

5.4.2 READ COMMITTED

오라클 DBMS에서 기본으로 사용되는 격리 수준.

더티 리드는 발생하지 않음.

COMMIT이 완료된 데이터만 다른 트랜잭션에서 조회 가능.

예시

A, B 트랜잭션이 존재한다고 했을때
- A 트랜잭션이 0n1dev, 5000 이라는 값을 0n1dev, 7000으로 업데이트 (아직 COMMIT 안함)
- B 트랜잭션이 0n1dev를 조회하면 0n1dev, 5000이 조회 됨
  - 변경 된 값은 테이블에 기록되고, 이전 값은 언두 영역으로 백업 됨
- A 트랜잭션 COMMIT

-> NON-REPEATABLE READ가 발생 함. 하나의 트랜잭션 내에서 동일한 SELECT 쿼리를 실행하면 항상 같은 결과를 가져와야 함. (정합성에 어긋남)

5.4.3 REPEATABLE READ

MySQL의 InnoDB 스토리지 엔진에서 기본으로 사용되는 격리 수준.

더티 리드와 NON-REPEATABLE READ가 발생하지 않음.

READ COMMITTED와 동일하게 MVCC를 이용해 COMMIT 전 데이터를 보여줌. (언두 영역에 백업된 레코드의 여러 버전 중 몇 번째 이전 버전까지 찾아 들어가야 하느냐가 다름.)

예시

A, B 트랜잭션이 존재한다고 했을때
- B 트랜잭션이 0n1dev, 5000 조회
- A 트랜잭션이 0n1dev, 5000을 0n1dev, 7000으로 업데이트
  - 언두 로그에 변경 전 데이터 0n1dev, 5000이 남아 있음.
- A 트랜잭션 COMMIT
- B 트랜잭션 0n1dev 조회
  - 언두 로그를 통해서 0n1dev, 5000을 조회

-> PHANTOM READ가 발생.

5.4.4 SERIALIZABLE

가장 단순한 격리 수준이면서 동시에 가장 엄격한 격리 수준.

동시 처리 성능이 다른 트랜잭션의 격리 수준보다 떨어짐.

InnoDB 스토리지 엔진에서는 갭 락과 넥스트 키 락 덕분에 REPEATABLE READ 격리 수준에서도 PHANTOM READ가 발생하지 않음.

대용량 서비스를 위한 아키텍처 with Redis #0

0n1dev — Mon, 29 Nov 2021 23:00:46 +0900

Chapter 0. 대규모 서비스의 특성

대규모 서비스란?

많은 사용자 트래픽
많은 사용자 데이터
사용자 트래픽/데이터의 빠른 증가 (서비스 증가)

서비스 이용량 증가에 따른 문제점

스타트 업에서 서비스의 인기가 좋아, 트래픽이 감당할 수 없을 정도로 늘어난다면?

그로인해 몇일 동안 서비스가 안된다면 어떤 일이 벌어질까?

우리가 만드는 서비스는 트래픽/데이터의 증가에도 묹제없이 서비스가 가능할까?

대규모 서비스가 가져야 할 특성

확장성 (Elastic)
- 서비스의 가용용량을 늘이고 줄이는 것이 쉬워야 함
장애 회복성 (Resiliency)
- 서비스에 장애가 일어났을 때 가능한 메뉴얼한 처리 없이 자동적으로 회복되어야 함
자동화 (Automation)
- 배포부터 장애처리 등 대부분 자동화 되어서 버튼 클릭 한 두번 정도로 진행되어야 함
모니터링 (Monitoring)
- 서비스 상태는 항상 모니터링 되어야 함

확장성 (Elastic)

트래픽이 늘어나서 서버를 추가해야 한다면?

추가가 되어야 하는 서버의 종류는?
- Web Server
- DB Server
이런 종류의 서버들이 쉽게 추가 가능할까?

트래픽이 줄어서 서버를 줄여야 한다면?

제거가 되어야 하는 서버의 종류는?
- 잘 안쓰는 서버
이런 종류의 서버들이 쉽게 제거될 수 있을까?

장애 회복성 (Resiliency)

FailOver
Replication

서비스 중인 API서버 한, 두대가 장애가 나면 서비스는 계속 지속될 수 있을까?

서비스 데이터를 저장하는 DB서버가 장애가 나면 서비스는 계속 지속될 수 있을까?

장애 회복성을 위해서는 SPOF(Single Point of Failure)가 없어져야 함.

해당 지점에 장애가 발생하면 전체 서비스에 장애를 낼 수 있는 부분
- DB 서버가 장애가 발생하고, 해당 서버를 대체할 서버가 없으면 서비스의 동작에 문제가 생김
- 인증 서버에 장애가 발생하면 인증이 불가능하여 서비스 이용이 불가능
- 한대의 물리 서버는 무조건 SPOF가 존재
  - SPOF를 제거 하려면 모든 부분에서 최소 이중화가 되어야 함

자동화 (Automation)

서비스 운영의 많은 부분이 자동화가 되어야 함

사람이 손으로 직접 건드리는 것은 도리어 새로운 장애의 씨앗이 됨 (Human Error)

IaC(Infrastructure as code)가 중요함

5.3 InnoDB 스토리지 엔진 잠금

0n1dev — Sun, 28 Nov 2021 23:28:10 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

5.3 InnoDB 스토리지 엔진 잠금

MySQL에서 제공하는 잠금과 별개로 스토리지 엔진 내부에서 레코드 기반의 잠금 방식을 탑재하고 있음.

때문에 MyISAM보다 훨씬 뛰어난 동시성 처리를 제공할 수 있음.

최근 버전에서 InnoDB의 트랜잭션과 잠금, 그리고 잠금 대기 중인 트랜잭션의 목록을 조회할 수 있는 방법이 도입.

information_schema 데이터베이스
- INNODB_TRX
- INNODB_LOCKS
- INNODB_LOCK_WAITS

InnoDB의 잠금에 대한 모니터링도 강화되면서 Performance Schema를 이용해 InnoDB 스토리지 엔진의 내부 잠금(세마포어)에 대한 모니터링 방법도 추가 됨.

5.3.1 InnoDB 스토리지 엔진의 잠금

일반 상용 DBMS와는 조금 다르게 InnoDB 스토리지 엔진에서는 레코드 락뿐 아니라 레코드와 레코드 사이의 간격을 잠그는 갭(GAP) 락이라는 것이 존재하는데, InnoDB 스토리지 엔진의 레코드 락과 레코드 간의 간격을 잠그는 갭 락을 보여 줌.

5.3.1.1 레코드 락

레코드 자체만을 잠그는 것
다른 상용 DBMS의 레코드 락과 동일한 역할을 함
- InnoDB 스토리지 엔진은 레코드 자체가 아닌 인덱스의 레코드를 잠금
- 인덱스가 하나도 없어도 내부적으로 자동 생성된 클러스터 인덱스를 이용해 잠금을 설정
대부분의 보조 인덱스를 이용한 변경 작업은 넥스트 락 or 갭 락 사용
프라이머리 키 or 유니크 인덱스에 의한 변경 작업에서는 갭에 대해서는 잠그지 않고 레코드 자체에 대해서만 락을 걸음

5.3.1.2 갭 락

레코드와 바로 인접한 레코드 사이의 간격만 잠그는 것을 의미
레코드와 레코드 사이의 간격에 새로운 레코드가 생성(INSERT)되는 것을 제어하는 것

5.3.1.3 넥스트 키 락

레코드 락과 갭 락을 합쳐 놓은 형태의 잠금
STATEMENT 포맷의 바이너리 로그를 사용하는 MySQL 서버에서는 REPEATABLE READ 격리 수준을 사용
innodb_locks_unsafe_for_binlog 시스템 변수가 비활성되면(0으로 설정) 변경을 위해 검색하는 레코드에 넥스트 키 락 방식으로 잠금 걸림
InnoDB의 갭 락이나 넥스트 키 락은 바이너리 로그에 기록되는 쿼리가 레플리카 서버에서 실행될 때 소스 서버에서 만들어 낸 결과와 동일한 결과를 만들어내도록 보장하는 것이 주 목적

5.3.1.4 자동 증가 락

MySQL에서는 자동 증가하는 숫자 값을 추출하기 위해 AUTO_INCREMENT라는 칼럼 속성을 제공 함.

AUTO_INCREMENT 칼럼이 사용된 테이블에 동시에 여러 레코드가 INSERT되는 경우, 저장되는 각 레코드는 중복되지 않고 저장된 순서대로 증가하는 일련번호 값을 가져야 함.

innodb_autoinc_lock_mode = 0
- MySQL 5.0과 동일한 잠금 방식으로 모든 INSERT 문장은 자동 증가 락을 사용
innodb_autoinc_lock_mode = 1
- 여러 건의 레코드를 INSERT하는 SQL 중 MySQL 서버가 INSERT되는 레코드의 건수를 정확히 예측할 수 있을 때 자동 증가 락을 사용하지 않고, 훨씬 가볍고 빠른 래치를 이용해서 처리
innodb_autoinc_lock_mode = 2
- InnoDB 스토리지 엔진은 절대 자동 증가 락을 걸지 않고 경량화 된 래치를 사용.
- 이 설정에서는 하나의 INSERT 문장으로 INSERT되는 레코드라고 하더라도 연속된 자동 증가 값을 보장하지는 않음.

5.3.2 인덱스와 잠금

InnoDB의 잠금과 인덱스는 상당히 중요한 연관 관계가 있음.

InnoDB의 잠금은 레코드를 잠그는 것이 아닌 인덱스를 잠그는 방식으로 처리.

변경해야 할 레코드를 찾기 위해 검색한 인덱스의 레코드를 모두 락을 걸어야 함.

5.3.3 레코드 수준의 잠금 확인 및 해제

InnoDB 스토리지 엔진을 사용하는 테이블의 레코드 수준 잠근은 테이블 수준의 잠금보다는 조금 더 복잡함.

테이블 잠금에서는 잠금의 대상이 테이블 자체이므로 쉽게 문제의 원인이 발견되고 해결될 수 있음.

레코드 수준의 잠금은 테이블의 레코드 각각에 잠금이 걸리므로 그 레코드가 자주 사용되지 않는다면 오랜 시간 동안 잠겨진 상태로 남아 있어도 잘 발견되지 않음.

0. 시간 복잡도 & 공간 복잡도

0n1dev — Thu, 25 Nov 2021 23:04:48 +0900

0. 시간 복잡도 & 공간 복잡도

시간 복잡도

기본 연산의 실행 횟수로 수행 시간을 평가

기본 연산

데이터 입출력
산술 연산
제어 연산

시간 복잡도

Best Case
- 빅 오메가 표기
- 최선의 시나리오
Worst Case
- 빅 오 표기
- 최악의 시나리오
Average Case
- 빅 세타 표기
- 평균 시간

-> 알고리즘은 최악의 경우로 성능 파악. 즉 빅 오 표기인 Worst Case로 파악

빅 오 표기

O(1) - Constant

입력된 데이터 크기와 상관없이 항상 일정한 처리 시간이 걸림

    public void printNumber(int n) {
        System.out.println(n);
    }

O(log₂n) - Logarithmic

입력된 데이터 크기가 커질수록 연산 횟수가 log₂n에 비례해서 처리 시간 증가

        for (int i = 0; i < n; i *= 2) {
            ...
        }

O(n) - Linear

입력된 데이터 크기와 비례해서 처리 시간 증가

        for (int i = 0; i < n; i++) {
            ...
        }

O(nlog₂n) - Linear-Logarithmic

입력된 데이터 크기가 커질수록 처리 시간이 로그 배 만큼 증가

Merge Sort
Heap Sort

O(n²) - Quadratic

입력된 데이터 크기가 커질수록 처리 시간이 제곱으로 증가

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                ...
            }
        }

O(2ⁿ) - Exponential

입력된 데이터 크기가 커질수록 처리 시간이 2ⁿ으로 증가

    public int printNumber(int n) {
        if (n <= 1) {
            return n;
        }

        return printNumber(n - 1) + printNumber(n - 2);
    }

공간 복잡도

알고리즘에서 사용하는 메모리의 양

    public int printNumber(int n) {
        int a = n;
        int[] b = new int[n];

        for (int i = 0; i < n; i++) {
            b[i] = i;
        }

        return b[a];
    }

a = 4byte
b = 4byte * n

-> 4n + 4 => 데이터 크기가 증가할수록 선형적으로 증가하기 때문에 공간 복잡도는 O(n)다.

5.2 MySQL 엔진의 잠금

0n1dev — Wed, 24 Nov 2021 21:37:07 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

5.2 MySQL 엔진의 잠금

MySQL에서 사용되는 잠금은 크게 스토리지 엔진 레벨과 MySQL 엔진 레벨로 나눌 수 있음.

스토리지 엔진 레벨
- 스토리지 엔진 간 상호 영향을 미치지 않음
MySQL 엔진 레벨
- 스토리지 엔진을 제외한 나머지 부분
- 모든 스토리지 엔진에 영향을 미침
- 테이블락 (테이블 데이터 동기화)
- 메타데이터 락 (테이블 구조를 잠금)

5.2.1 글로벌 락

FLUSH TABLES WITH READ LOCK

MySQL에서 제공하는 잠금 가운데 가장 큰 범위.

한 세션에서 글로벌 락을 휙득하면 다른 세션에서 SELECT를 제외한 대부분의 DDL 문장이나 DML 문장을 실행하는 경우 글로벌 락이 해제될 때까지 해당 문장이 대기 상태로 남음.

영향을 미치는 범위는 MySQL 서버 전체. (테이블 뿐만 아니라 데이터베이스가 다르더라도 영향.)

MySQL 8.0 부터 바뀐점

InnoDB가 기본 스토리지 엔진으로 채택되면서 조금 더 가벼운 글로벌 락이 생김. (백업 락)

InnoDB 스토리지 엔진은 트랜잭션을 지원하기 때문에 일관된 데이터 상태를 위해 모든 데이터 변경 작업을 멈출 필요가 없음.

LOCK INSTANCE FOR BACKUP;
--// 백업 실행
UNLOCK INSTANCE;

특정 세션에서 백업 락을 휙득하면 모든 세션에서 다음과 같은 일을 학 수 없음.

데이터베이스 및 테이블 등 모든 객체 생성 및 변경, 삭제
REPAIR TABLE (특정 테이블 복구)과 OPTIMIZE TABLE (특정 테이블 최적화) 명령
사용자 관리 및 비밀번호 변경

-> 테이블의 데이터 변경은 허용, 백업의 실패를 막기 위해 DDL 명령이 실행되면 복제를 일시 중지 함

5.2.2 테이블 락

개별 테이블 단위로 설정되는 잠금. 명시적 or 묵시적으로 특정 테이블의 락을 획득할 수 있음.

명시적

LOCK TABLES table_name [ READ | WRITE ]
UNLOCK TABLES

-> 글로벌 락과 동일하게 온라인 작업에 상당한 영향을 미치기 때문에 특별한 상황 아니면 사용 X

묵시적

MyISAM이나 MEMORY 테이블에 데이터를 변경하는 쿼리를 실행하면 발생.

데이터가 변경되는 테이블을 잠금 설정하고 데이터를 변경한 후, 즉시 잠금을 해제하는 형태로 사용.

InnoDB는 스토리지 엔진 차원에서 레코드 기반의 잠금을 제공하기 때문에 단순 데이터 변경 쿼리로 인해 묵시적인 테이블 락이 설정되지는 않음. (DDL이 변경 될 때만 테이블 락이 설정)

5.2.3 네임드 락

GET_LOCK() 함수를 이용해 임의의 문자열에 대해 잠금을 설정.

단순히 사용자가 지정한 문자열(String)에 대해 획득하고 반납(해제)하는 잠금.

네임드 락을 사용하는 경우

데이터베이스 서버 1대에 5대의 웹 서버가 접속해서 서비스하는 상황에 5대의 웹 서버가 어떤 정보를 동기화해야 하는 상황이면 여러 클라이언트가 상호 동기화를 처리해야 할 때 네임드 락을 이용.

-- // "mylock"이라는 문자열에 대해 잠금 획득 2초 동안
SELECT GET_LOCK('mylock',2);
-- // 잠금 설정이 되어 있는지 확인 (잠금이면 0 아니면 1)
SELECT IS_FREE_LOCK('mylock');
-- // 잠금 해제 (해제한 경우 1, 아닌 경우 1 or NULL)
SELECT RELEASE_LOCK('mylock');
-- // 잠금 설정이 되어 있는지 확인 (잠금이면 0 아니면 1)
SELECT IS_FREE_LOCK('mylock');

배치와 같은 프로그램에서 한번에 많은 레코드를 변경하는 쿼리가 데드락의 원인이 됨.

프로그램의 실행 시간을 분산하거나 프로그램의 코드를 수정해서 데드락을 최소화할 수 있지만, 간단하지 않고 완전한 해결책이 아님.

동일 데이터를 변경하거나 참조하는 프로그램끼리 분류하여 네임드 락을 걸고 쿼리를 실행하면 아주 간단히 해결.

MySQL 8.0부터 바뀐점

네임드 락을 중첩해서 사용 가능
현재 세션에서 획득한 네임드 락을 한번에 모두 해제 가능 (SELECT RELEASE_ALL_LOCKS();)

5.2.4 메타데이터 락

데이터베이스 객체(대표적으로 테이블이나 뷰 등)의 이름이나 구조를 변경하는 경우 획득하는 잠금.

명시적으로 획득하거나 해제하는 것이 아닌 "RENAME TABLE tab_a TO tab_b"같이 테이블의 이름을 변경하는 경우 자동으로 획득하는 잠금.

5.1 트랜잭션

0n1dev — Mon, 22 Nov 2021 22:47:26 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

5.1 트랜잭션

트랜잭션을 지원하지 않는 MyISAM과 트랜잭션을 지원하는 InnoDB의 처리 방식 차이를 살펴보자

5.1.1 MySQL에서의 트랜잭션

트랜잭션은 꼭 여러 개의 변경 작업을 수행하는 쿼리가 조합됐을 때만 의미 있는 개념이 아님.

하나의 논리적인 작업 셋에 쿼리의 갯수와 상관없이 논리적인 작업 셋 자체가 100% COMMIT 되거나 오류가 있을 때 ROLLBACK 되는 것을 보장해주는 것.

MyISAM 엔진 환경 구성

CREATE TABLE tab_myisam (
    fdpk INT NOT NULL,
    PRIMARY KEY (fdpk)
) ENGINE=MyISAM;

INSERT INTO tab_myisam (fdpk) VALUES (3);

MyISAM 엔진 쿼리 실행

real_mysql_test> INSERT INTO tab_myisam VALUES (1), (2), (3)
[2021-11-22 22:27:10] [23000][1062] Duplicate entry '3' for key 'tab_myisam.PRIMARY'

MyISAM 엔진 결과

SELECT * FROM tab_myisam;

InnoDB 엔진 환경 구성

CREATE TABLE tab_innodb (
    fdpk INT NOT NULL,
    PRIMARY KEY (fdpk)
) ENGINE=INNODB;

INSERT INTO tab_innodb (fdpk) VALUES (3);

InnoDB 엔진 쿼리 실행

real_mysql_test> INSERT INTO tab_innodb VALUES (1), (2), (3)
[2021-11-22 22:31:16] [23000][1062] Duplicate entry '3' for key 'tab_innodb.PRIMARY'

InnoDB 엔진 결과

SELECT * FROM tab_innodb;

두 엔진 모두 Primary Key 중복 오류로 쿼리가 실패.

MyISAM 엔진은 오류에도 불구하고 '1'과 '2'가 삽입 됨, InnoDB 엔진은 트랜잭션의 원칙대로 원 상태로 ROLLBACK.

"MyISAM 처럼 트랜잭션을 지원하지 않으면 테이블 데이터의 정합성을 맞추는데 상당히 어려운 문제를 만듬."

5.1.2 주의사항

트랜잭션 또한 DBMS의 커넥션과 동일하게 꼭 필요한 최소의 코드에만 적용하는 것이 좋음. (프로그램 코드에서 트랜잭션의 범위를 최소화하라는 의미.)

- 데이터베이스 커넥션을 가지고 있는 범위와 트랜잭션이 활성화돼 있는 프로그램의 범위를 최소화

- 네트워크크 작업이 있는 경우 반드시 트랜잭션에서 배제

5. 트랜잭션과 잠금

0n1dev — Mon, 22 Nov 2021 22:46:37 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

5. 트랜잭션과 잠금

트랜잭션은 작업의 완전성을 보장해주는 것.

즉 논리적인 작업 셋을 모두 완벽하게 처리하거나, 처리하지 못할 경우 원 상태로 복구해서 작업의 일부만 적용되는 현상(Partial update)이 발생하지 않게 만들어주는 기능.

잠금(Lock)과 트랜잭션은 서로 비슷한 개념 같지만 사실 잠금은 동시성을 제어하기 위한 기능이고 트랜잭션은 데이터의 정합성을 보장하기 위한 기능

0. 실습환경

0n1dev — Mon, 22 Nov 2021 22:21:03 +0900

해당 글은 Real MySQL 8.0 책을 보고 요약한 내용입니다.

0. 실습환경

- Docker

- MySQL 8.0.27

- DataGrip

0.1 도커 이미지 다운로드 및 컨테이너 실행

docker run --name mysql8 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=xptmxm -d mysql:8.0.27

0.2 DataGrip으로 Connection

Github Profile에 Tistory RSS Feed 연결하기

0n1dev — Sun, 21 Nov 2021 20:47:38 +0900

Github Profile에 Tistory RSS Feed 연결하기

이전 글을 보면 Github와 Tistory의 연동을 고민을 하다가 Python으로 작성한 코드를 Github Actions을 통해 지속적으로 업데이트 해주는 방법을 볼 수 있었다.

2021.11.19 - [Log/이것저것] - 2021.11.19 - 블로그 시작

2021.11.19 - 블로그 시작

2021.11.19 - 블로그 시작 블로그 시작부터 큰 난관에 봉착했다. 블로그 서비스를 제공하는 플랫폼의 다양성 때문이다. 솔직하게 말하면 블로그를 시작하려한게 이번이 처음이 아니다. 네이버 블

blog.koo.gg

Python을 Java로 변경

익숙하지 않은 Python을 그대로 가져다 쓰는것 보다는 주력 언어인 Java로 변경하여 자유롭게 커스터마이징 하는게 좋을것이라 판단하여 Java로 새로 작성하였다.

https://github.com/0n1dev/0n1dev

GitHub - 0n1dev/0n1dev

Contribute to 0n1dev/0n1dev development by creating an account on GitHub.

github.com

기존 Python 코드의 불편한 점

코드 자체가 익숙하지 않아 수정이 어렵다. -> Java로 컨버팅하여 해결
원본 텍스트가 하드코딩 되어있다. -> Profile.md 파일을 읽어오는 로직으로 변경

결론

결론은 그냥 내가 편하게 바꾼것 뿐이다. 요즘 블로그 글 작성에 빠져있다. 하지만 1일 1커밋이라는 목표도 있어서 어떻게 하면 두마리의 토끼를 다 잡을수 있을까라는 고민이 있었지만 의미 없는 커밋 보다는 이렇게 블로그로 글을 남기고 Github와 연동 시키는것도 좋은 결과라고 생각이된다.

이직 성공... 그리고 회고 - 1

0n1dev — Sat, 20 Nov 2021 21:55:47 +0900

이직 성공... 그리고 회고 - 1

이 글을 작성하는 시점에는 이미 다른 회사를 다니고있다. 전 직장에서의 생각을 기반으로 작성해보겠다.

이직을 생각하는 주니어 개발자 혹은 본인 커리어에 대한 고민이 있다면 읽어봐도 좋을것 같다.

내 글은 정답이 아니다... 경험이 부족하기에 틀린 부분이 많을것이다. 하지만 누군가 도움이 된다면 좋겠다.

이직의 결심

1년 6개월 정도 다니는 시점 커리어에 대해 많은 고민이 되기 시작했다.

당시 멘토링을 듣고 있던 상황인데 멘토님과 고민에 대해 대화를 해본 결과 "이직을 해야겠다."는 생각에 확신이 생겼다.

내가 이직에 대해 고민할 때 고려한 부분이다.

Q. 내가 회사에서 아직 할 수 있는게 남아있는가?

A. 아직 경험이 부족하고, 내가 큰 기업의 문화를 평가할 수준이 아니라 생각은 들지만 나에게는 개발에 대한 열정이 있었다.

회사의 기존 레거시 코드 대부분은 PHP 코드였다. 그런말이 떠오른다....

"장인은 도구를 탓하지 않는다."

물론 나도 공감한다. PHP가 나쁜 언어라고는 생각하지 않는다. 그치만 분명 문제점도 존재한다고 생각된다.

언어 자체가 어려운 언어는 아니라 생각한다. 또, 개발자에게 높은 자유도를 준다고 생각이 든다.

하지만 이것은 양날의 검이었다.

어떤 개발 커뮤니티에서 본 기억이 있는데...

"PHP는 나쁜 언어가 아니에요... PHP로 개발하는 개발자가 나쁜거지..."

일반화 시키면 안되는 부분이지만 어느정도 공감되는 부분이 있다. 러닝커브가 낮기 때문에 나 또한 취업전에 NodeJS로 개발하다가 취업 후 바로 실무에 투입이 가능했다고 생각이된다. (회사 입장에서는 어느 누가 와도 빠르게 알려주고 일을 시키면 이득...?)

하지만 그 만큼 언어에 대한 이해도가 낮은 상태로 개발을 시작하니깐 개발을 하는건지 조금 의구심이 들기 시작했다...

또 최신 버전은 다르다고 하겠지만 회사에서는 낮은 버전의 PHP를 사용했기 때문에 Loose Typing으로 인해 흔히 말하는 Human Error가 자주 발생했다.

물론 두 가지 문제 모두 PHP의 문제는 아니라 생각한다. 개발 문화의 문제일것이다.

그래도 다른 언어인 Java를 사용하고 싶은 이유는 먼저 국내 시장의 커뮤니티다. Java와 PHP 두 진영의 커뮤니티를 비교해보면 Java 진영의 커뮤니티가 더 활발하다고 느껴진다. (PHP도 잘되어 있는곳도 있겠지만 점점 시들시들 해지는것 같다...)

아래 투표 사진을 보면 전 세계적으로 볼 때 PHP 사용자 보다 Java 사용자가 더 많을것이라 추측이 된다.

Stack Overflow&nbsp;most-popular-technologies-language-prof

그리고 두번째는 PHP 코드를 보면 프론트와 백의 경계가 무너진듯한 코드가 많다...

물론 확실하게 구분하여 코드를 작성하면 되겠지만.... 그러면 또 PHP의 그나마 있는 장점을 버리고 쓰는게 아닌가...싶다.

이러한 글을 남기면 분명 태클이 들어올것이다.

면접에서도 Java를 그렇게 쓰고 싶으면 직접 컨버팅하면 되지 않냐고 질문이 들어올것이다.

그러면 난 말할수 있다.

"이미 컨버팅했다."

또, 컨버팅 했는데 왜 이직을 하냐고 물어보면 회사에서 웹 개발자 중 95% 이상이 PHP 개발자라 생각이된다.

내가 개발한 부분에 대해 같이 고민해줄 선배 개발자의 필요성을 절실하게 느꼈다.

그래서 개발 문화의 한계점을 알게되어 이직을 결심하게 되었다.

해당 글은 시리즈다.

카카오브레인 대외활동 코테 회고

0n1dev — Sat, 20 Nov 2021 21:14:56 +0900

카카오브레인 대외활동 코테 회고

예전부터 대외활동에 참여하고 싶었고, 이전에 기업과 관계없이 진행되는 대외활동을 지원했었는데 아쉽게 기회가 없었다...

우연히 카카오브레인에서 진행하는 대외활동 패스파인더에 지원하였고, 코딩테스트를 진행하고 회고를 남겨본다.

전형의 시작 서류

카카오브레인 패스파인더 포스터?

지원 할 당시 대외활동이라는 키워드와 간접적으로 카카오 계열 특유의 개발 문화를 간접적으로 접해볼 기회라 생각했기에 채용연계형이라는 문구는 크게 신경써서 보질 않았다... (이게 후 폭풍이 올까...?)

단순하게 우수 활동자에게는 정규직 제의가 있을수 있다는 문구는 봤는데 이직 준비하는 직장인이 아니라면 채용연계형이 크게 눈에 들어올까...?

아무튼 나는 소속 무관하게 활동이 가능하다는 문구를 보고 솔깃한 마음에 부랴부랴 서류를 작성하여 제출하였다.

서류 경쟁률 100대 1?

술마시고 있는데 문자로 서류 결과가 나왔다고 연락왔다. 두근 거리는 마음으로 메일을 확인한 결과 서류 합격이라는 기쁜 소식을 받았다.

합격 메일에는 설문조사를 진행하는 폼을 같이 전달 받았는데 폼을 통해 들어가보면 아래와 같은 문구를 볼 수 있었다.

대외활동이라 서류에서 많은 사람들이 갈릴것 같지는 않았다. (솔직히 개발자를 판단하는건 대부분 코테라 생각하고 있었기 때문에 기분 좋으라는 문구라고 생각했다...)

"같이 지원한 사람들에게 확인해보니 나 빼고 다 불합격...?" 구직활동을 위한 전형도 아닌데 괜히 긴장되는 순간이다.

대망의 코딩테스트

우선 패스파인더는 1기를 시작으로 계속해서 진행될 예정이라한다. (나는 이번이 마지막 기회다.... 경력 2년 이상은 지원 불가능...)

먼저 해당 포스트에 문제 관련한 내용이 궁금해서 찾아보았다면, 뒤로가기를 눌러주길 바란다.

안내 메일에 나와있듯 법적 책임을 받는다고한다... (무섭다)

문제풀이는 해커랭크에서 진행되었으며 5문제를 5시간동안 푸는거다.

해커랭크에서 이전에 코딩테스트 진행한 경험이 있었기 때문에 대략적으로 어떤식으로 진행될지 느낌이 있었다. (해커랭크 특유의 감성이 있다...)

처음 문제를 풀때 1번 문제를 생각없이 풀다가 효율성에서 통과를 못하고 있었다.

두 문제를 풀고 4번 문제에서 효율성이랑 싸우고 있다가 시간이 없어서 다시 1번 문제를 봤더니 애초에 잘못 접근해서 문제를 풀었다는 것을 알게 되었다.

결과적으로 "3문제 통과, 1문제 테스트케이스(12/15), 1문제 못 품" 부분 점수가 있으면 3.5...? 3.8...? 정도 받은것 같다.

느낀점

대외활동이 하고싶어서 지원하게 되었지만 꼭 구직활동을 하는게 아니더라도 코딩테스트나 면접은 한번씩 보는것도 나쁘지는 않을것 같다고 생각이 들었다.

내 자신이 지금 어떤 상황에 놓여있는지 판단하는 기준이 될 것이다.

2020년 마무리 목표

0n1dev — Fri, 19 Nov 2021 22:15:16 +0900

- 주 2~3회 알고리즘 문제 풀이

- Real MySQL 1, 2권 완독

- QueryDSL 강의 완독

첫 직장 아프리카 TV의 늦은 회고

0n1dev — Fri, 19 Nov 2021 00:54:23 +0900

첫 직장 아프리카 TV의 늦은 회고

말 그대로 늦은 회고다.

2020년 1월에 입사하여 전 직장이라는 타이틀로 남겨진 회사지만 인생의 전환점을 가져다 준 회사가 아닐까 하는 생각이 들었다.

인생을 바꾼 도전

늦은 회고지만 아직도 기억이 난다.

2019년 말 처음에 가산 디지털단지에 있는 모 게임 회사에 면접을 보고 최종 합격하여 출근 일을 기다리고 있었다.

아무것도 모르는 상태로 지원하여 커리어와 연봉에 대해 크게 느껴지는게 없었다.

출근 3일 전 아프리카 TV로 부터 서류 합격 메일을 받았다.

회고를 쓰다가 생각나서 메일을 찾아보니 역시나 합격 안내 메일을 찾아 볼 수 있었다.

아직 전형의 시작인 서류합격이라 기존에 합격한 회사를 두고 면접을 보러가기 겁났지만 도전해볼 가치가 있다고 생각 되어 기존 회사는 입사를 포기하게 되었다.

포기랑 바꾼 기쁨

서류 이후 전형은 아래와 같다.

코딩 테스트 + 1차 면접 -> BtoB (신입 공채라 개인 방송 함) -> 2차 면접

순조롭게 2차 면접까지 진행 되었고, 결국 최종 합격을 할 수 있었다.

최종 결과가 12월 31일에 나와서 가족들이 전형 결과가 나올때까지 계속 걱정하고 있었던게 아직도 기억이 난다.

얻은 것과 실망한 것

정말 개발자로서 중요한 것을 얻은 회사다.

내가 앞으로 어떤 방향으로 성장해 나가야 될 지 알게 해준 동료들과 개발에 대한 열정을 좋게 봐주셔서 기회를 만들어주신 팀장님이 계셨기 때문에 크게 성장 할 수 있었다고 생각한다.

물론 결국 퇴사를 했다는 것은 내부에 불만족스러운 부분이 있었기 때문에 이직을 생각하게 되었다.

어떤 회사를 가던 외부에서 바라본 시선과 내부에서 바라보는 시선이 같을수가 없다.

그래도 어떤 상황에서도 내가 얻을 수 있는걸 얻어 내는것이 중요하다고 생각이 된다.

2021.11.19 - 블로그 시작

0n1dev — Fri, 19 Nov 2021 00:32:43 +0900

2021.11.19 - 블로그 시작

블로그 시작부터 큰 난관에 봉착했다. 블로그 서비스를 제공하는 플랫폼의 다양성 때문이다.

솔직하게 말하면 블로그를 시작하려한게 이번이 처음이 아니다.

네이버 블로그, 티스토리, Github 블로그 등 다양한 플랫폼에서 시도를 하였다.

나에게 맞는 플랫폼은?

"나에게 맞는 플랫폼은?" 이게 가장 큰 난관인듯 하다.

항상 블로그를 시작할 때 꾸준하게 하려고 하는데 늘 실패하는 듯 하여 실패의 원인을 찾아 보았다.

내가 원하는 블로그의 이상향

자유도 보장 (내가 원하는 스킨을 사용할 수 있어야 함)
글 작성 및 이미지 업로드가 편리해야 함
독자가 쉽게 접근이 가능해야 함

이 세가지 정도를 충족 시키는 플랫폼은 티스토리지만 한 가지 더 욕심이 있다.

그건 바로 Github의 1일 1커밋이다.

조졸두님 블로그에서 Github 글을 Tistory에 발행하는 것을 본적이 있었는데 어디갔는지 잘 모르겠다...

하지만 역발상으로 티스토리 글을 하루 한번씩 Github로 커밋도 가능하지 않을까? 하는 생각을 가지고 있다가 방법을 찾았다.

Python+GitHub Actions로 GitHub 프로필에 티스토리 최근 글 목록 연동하기

개요 얼마 전 GitHub에 username/username repo를 만들고 README.md에 원하는 내용을 작성하면 원하는 내용을 본인의 프로필 페이지에 표시할 수 있게 되었습니다. 티스토리 활동과 GitHub 활동 모두를 하고

blog.stdio.dev

Python과 Github Action을 사용하여 스케쥴링을 돌리는 것 같다.