eomdev's blog

분산환경에서 Tsid 사용하기

Wed, 22 Oct 2025 00:00:00 +0000

대부분 데이터를 구분하기 위해서는 고유한 ID(Primary Key)를 사용하는데,
전통적인 RDB에서는 AUTO_INCREMENT 같은 단일 시퀀스로도 충분했었다.

하지만, 분산환경으로 가면서 서버가 여러 대이고, DB도 여러 개(샤딩)으로 나뉘었을 때
“어떻게 충돌 없이, 순서를 유지하는 고유 ID를 만들 수 있는가”에 대한 내용으로 등장한 것이 TSID 이다.

기존 방식의 한계

1. AUTO_INCREMENT (DB 시퀀스)

DB가 여러대로 구성되어 있는 경우 ID 충돌 위험이 있음
샤딩 후에는 각 노드가 ID 범위를 나눠서 사용해야함 -> 관리 복잡

2. UUID

충돌은 거의 없지만,

순서가 보장되지 않는다 -> 인덱스가 파편화 된다
읽기 어렵다 (ex. 550e8400-e29b-41d4-a716-446655440000)

특히, 대규모 트래픽이 예상될 때, INSERT 시 마다 디스크 쓰기의 성능이 급격하게 떨어진다.

2. TSID

TSID(Time-Sortable ID)는 “타임스탬프 기반으로 생성되는, 시간 순으로 정렬 가능한 고유 ID” 이다. 내부구조는 Timestamp(밀리초 단위 시간) + Node ID(서버 또는 샤드 식별자) + Sequence(같은 밀리초 내에서 중복방지) => Long 타입으로 표현 한 형태이다.

시간 순으로 생성되므로 정렬이 쉽다.
B-Tree 인덱스 split 최소화 -> INSERT 성능 향상
시간 순서가 중요한 데이터에 적합(특히 이벤트, 메시지, 로그 등)
각 노드(서버/샤드)가 자신의 Node ID로 구분되므로 ID 충돌이 없다

Spring Boot + JPA 에 적용 방법

build.gradle.kts 에 추가

  dependencies {
      implementation("io.hypersistence:hypersistence-utils-hibernate-60:3.5.1")
  }

Entity 에 @Tsid 추가

  @Entity
  @Table
  class User(
      val email: String,
      val nickname: String,
      ...
  ) : Audit() {
      @Id
      @Tsid // 추가
      var id: Long? = null
          protected set
    
      ...
    
  }

실제로 Entity 저장시

생성된 Tsid 768729030917065909 을 기준으로 2진수로 표현하면
0000 1010 1010 1011 0001 0010 1111 1011 0001 0000 0101 0111 1000 1100 1011 0101
이 되고, 이걸 오른쪽부터 나눠서 보면 아래와 같다.

구간	비트 수	2진수	10진수	의미
하위 12비트	12	`1100 1011 0101`	3253	Sequence
그 위 10비트	10	`0101 1110 1000`	376	Node ID
나머지 42비트	42	`0000 1010 1010 1011 0001 0010 1111 1011 0001 0000 0101`	183,279,283,265	Timestamp (2020-01-01T00:00:00Z 이후 ms)

참고로 Node ID의 생성 전략에는

설정하지 않으면 랜덤으로 생성(default)이 되므지만, 충돌 가능성을 낮추기 위해서 default 로 사용하지는 말자.

Node ID를 지정하는 방법에는 아래와 같은 것들이 있다.

시스템 프로퍼티 또는 환경변수로 지정

// JVM 인자. node bit수를 자동으로 7bit(100개에 피 ㄹ요한 최소 비트)로 줄여주고, 남은 비트는 시퀀스에 더 사용할 수 있도록 설정.
JAVA_TOOL_OPTIONS="-Dtsid.node=7 -Dtsid.node.count=100"
      
// 환경변수로 설정  
TSID_NODE=123 TSID_NODE_COUNT=100

프로그램적으로 제어

@Configuration
class TsidConfig(
  @Value("\${tsid.node:-1}") 
  private val node: Int,
        
  @Value("\${tsid.node-bits:10}") 
  private val nodeBits: Int,
) {
      
  @Bean
  fun tsidFactory(): TSID.Factory {
   return TSID.Factory.builder()
            .apply { if (nodeBits in 0..20) withNodeBits(nodeBits) }
            .apply { if (node >= 0) withNode(node) }
            .build()
  }
      
}

더 자세한 내용은 https://github.com/vladmihalcea/hypersistence-tsid 를 참고하자

Kotlin in Action - 2장 코틀린 기초

Wed, 18 Dec 2019 00:00:00 +0000

kotlin in action - 2장. 코틀린 기초를 다시 보며 정리하는 내용입니다.

1. 함수

블록({ })이 본문인 함수

본문이 중괄호 ({ })로 둘러싸인 함수를 말함
함수 선언은 fun 키워드를 사용
a:Int -> 파라미터 이름 뒤에 파라미터 타입을 선언
Int : Return Type
세미콜론 ( ; )은 사용하지 않아도 됨
아래와 같이 블록( { } )이 본문인 함수는 return 을 명시해줘야함

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

식이 본문인 함수

등호와 식으로 이뤄진 함수를 말함

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

컴파일러가 타입을 분석해 타입을 정해주는 타입추론이 가능하기 때문에 식이 본문인 함수에서는 Return Type은 생략 가능하다.
```
fun max(a:Int, b:Int) = if(a>b) a else b
```

2. 변수

코틀린에서는 타입 지정을 생략하는 경우가 흔하다(타입추론 덕분)

val answer = 42      // 타입 지정 생략. 단, 초기화 식이 있어야지만 생략이 가능하다
val answer: Int = 42 // 타입 지정

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

val(value) : 변경 불가능(immutable). 자바의 final 에 해당됨
- 블록을 실행할 때 정확히 한 번만 초기화되면 된다
```
val message: String
if (messageSend()) {
  message = "success"
} else {
  message = "Fail"
}
```
- val 참조는 불변이지만, 참조가 가리키는 객체 내부의 값은 변경될 수 있다
```
val languages = arrayListOf("Java") // 불변
languages.add("Kotlin") // 객체 내부의 값은 변경 가능
```
var(variable) : 변경 가능(mutable). 자바의 일반 변수
기본적으로 모든 변수를 val 를 사용해서 불변 변수로 선언하고, 필요한 부분만 var로 변경하자

변수사용(문자열 템플릿)

Hello, World! 출력하기

fun main(args: Array<String>) {
	val name = "World"  
	println("Hello, $name!") // $name : name의 내용이 출력됨
}

문자열 이스케이프
```
println("\$x") // $x 가 출력됨
```

복잡한 식은 중괄호( { } )로 둘러싸서 사용할 수 있다

println("Hello, ${ if (args.size > 0) args[0] else "someone" }!") // 큰 따옴표도 사용가능, 배열의 값도 사용가능, if문 사용가능

3. 클래스와 프로퍼티

Person class의 Java와 Kotlin 비교

Java

public class Person {
      
  private final String name;
      
  pubilc Person(String name) {
    this.name = name;
  }
      
  public String getName() {
    return name;
  }
      
}

Kotlin
```
class Person(val name: String)
```
- 위와 같이 코드가 없이 데이터만 저장하는 클래스를 Value Object(값 객체)라고 함
- kotlin의 기본 가시성은 public 이므로 생략

프로퍼티

val 로 선언한 프로퍼티 : 읽기 전용(getter)

var 로 선언한 프로퍼티 : 읽기/쓰기 가능

class Person (
	val name: String,  // private field, 읽기 전용이므로 kotlin은 public getter를 생성해준다
  var isMarried: Boolean // private field, 읽기/쓰기 가능하므로 kotlin은 public setter, public getter를 생성해준다
)

사용하는 방법

val person = Person("Bob", true) // new 사용하지 않고, 생성자를 호출함
println(person.name) // Bob 출력. 프로퍼티 이름을 직접 사용하면 자동으로 getter를 호출해준다
println(person.isMarried) // true 출력
person.isMarrie = false // setter를 호출해서 값을 변경할 수 있음

커스텀 접근자(Getter)

자신이 정사각형인지 아닌지를 알려주는 class

class Rectangle(val height:Int, val width: Int) {
  val isSquare: Boolean
  	get() {  // 커스텀 접근자 
      return height == width
    }
  	// 블록이 아닌 식으로도 구현 가능
  	// get() = height == width
}

코틀린의 디렉터리와 패키지

kotlin에서는 함수도 클래스처럼 임포트해서 사용할 수 있다

package com.eomdev.kotlin.basic // package 선언
  
class Rentangle(val height: Int, val width: Int) {
  val isSquare: Boolean
  	get() = height == width
}
  
fun createRandomRectangle(): Rentangle {
  val random =  Random()
  return Rentangle(random.nextInt(), random.nextInt())
}

import com.eomdev.kotlin.basic.createRandomRectangle // createRandomRectangle 함수 임포트
  
fun main(args: Array<String>) {
  println(createRandomRectangle().isSquare) // import한 함수 사용
}

kotlin에서는 한 파일에 여러 클래스를 넣을 수 있다. 파일 이름도 마음대로 정의 가능.

4. enum과 when

enum class

간단한 enum class

enum class Color { // enum class 키워드를 사용한다
  BLACK, WHITE
}

class 는 키워드이므로, 클래스를 표현하는 변수 등을 정의할 때는 clazz나 aClass 와 같은 이름을 사용한다

프로퍼티와 메소드가 있는 enum 클래스

enum class Color(
  // 상수 프로퍼티 정의
  val r: Int,
  val g: Int,
  val b: Int
) {
  
  RED(255, 0,0), // 각 상수를 생성할 때 그에 대한 프로퍼티 값
  YELLOW(255, 255, 0),
  GREEN(0, 255, 0);  // 주의!! enum 상수 목록과 메소드 정의 사이에 반드시 세미콜론을 사용해야함!!
    
  fun rgb() = (r * 256 + g) * 256 + b // 메소드 정의
}

when

java의 switch를 대신함
if와 마찬가지로 값을 만들어 내는 식 임

fun findName(color: Color) = // 식이므로 = 연산자로 사용 가능하다
	when (color) {
    Color.RED -> "Richard"
    Color.YELLOW -> "York"
    Color.GREEN -> "Gave"
  }


println(findName(Color.YELLOW))

한 when 분기 안에서 여러 값을 사용하는 방법

fun getWarmth(color: Color) = 
	when (color) {
    Color.RED, Color.YELLOW -> "warm" // , 로 구분해서 여러 값을 사용할 수 있다
    Color.GREEN -> "natural"
  }

임의의 객체와 함께 사용하기

예) 두 색을 혼합했을 때, 정해진 색을 알려주는 함수

fun mix(c1: Color, c2: Color) =
	when(setOf(c1, c2)) {						// when 식의 인자로 아무 객체나 사용 가능. 여기서는 Set객체로 만드는 setOf 함수를 사용함
    setOf(RED, YELLOW) -> ORANGE
    setOf(YELLOW, BLUE) -> GREEN
        
    else -> throw Exception("Dirty Color") // 매치되는 조건이 없는 경우
        
  }

when에 인자를 사용하지 않는 방법

코드는 읽기 어려워지지만, 성능을 향상 시키기 위한 방법

fun mix(c1: Color, c2: Color) =
	when {					// 인자가 없음
    (c1 == RED && c2 == YELLOW) ||
    (c1 == YELLOW && c2 == RED) ->
    	ORANGE
  
    (c1 == YELLOW && c2 == BLUE) ||
    (c1 == BLUE && c2 == YELLOW) ->
    	GREEN
      
    else -> throw Exception("Dirty Color") // 매치되는 조건이 없는 경우
      
  }

when 에 블록문을 사용할 수 도 있다

fun mix(c1: Color, c2: Color) =
	when(setOf(c1, c2)) {		
    setOf(RED, YELLOW) -> {
      ...
      ORANGE // 블록의 마지막 식이 반환된다
    } 
    setOf(YELLOW, BLUE) -> {
     ....
      GREEN
    }
      
    else -> throw Exception("Dirty Color")
      
  }

스마트 캐스트(타입검사 + 타입캐스트)

자바의 경우

if (c instanceof MessageDummyService) {
  MessageDummyService messageService = (MessageDummyService)c;
  messageService.send();
}

kotlin의 경우

if (c is MessageDummyService) { // kotlin은 is가 자바의 instanceof와 비슷하다
    messageService.send(); // java에서는 타입변환을 해줘야하지만, kotlin에서는 컴파일러가 자동으로 캐스팅을 해준다. 이것을 스마트 캐스트라고 한다.
}

스마트 캐스트 조건
- is 로 타입을 검사한 다음에 값이 바뀔 수 없는 val 이어야함
- 커스텀 접근자를 사용하지 않아야 함
명시적으로 타입 캐스팅을 위해서는 as 키워드를 사용해야한다
```
val n = e as Num
```

수에 대한 이터레이션

range

val oneToTen = 1..10 // .. 연산자를 사용. 1 ~ 10 까지

피즈버즈 게임(3,5로 나누어 떨어지면 피즈버즈, 3으로 나누어떨어지면 피즈, 5로 나누어 떨어지면 버즈)

fun fizzBuzz(i: Int) =  when {
  i % 15 == 0 -> "FizzBuzz"
  i % 3 == 0 -> "Fizz"
  i % 5 == 0 -> "Buzz"
  else - "$i "
}
    
// for..in 루프문 사용
for( i in 1..100) {
  println(fizzBuzz(i))
}
    

증가 값 있는 for

downTo : 감소

for ( i in 100 downTo 1 step 2) { // 100부터 1까지 감소하는데, 2씩 감소시킨다
  println(fizzBuzz(i))
}

map 이터레이션

val list = arrayListOf("10", "11", "1001")
for ((index, element) in list.withIndex()) {
  println("$index: $element")
}

in을 사용해서 컬렉션이나 범위의 원소 검사하기

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z' // in
fun isNotDigit(c: Char) = c !in '0'..'9' // !in 사용해서 범위에 속하지 않은지 검사
"Kotlin" in setOf("Java", "Scala") // Set에 Kotlin은 없다. false

출처 : Kotlin in Action http://acornpub.co.kr/book/kotlin-in-action

Kotlin 기본 타입

Thu, 22 Aug 2019 00:00:00 +0000

1. Numbers

자바와 같이 long은 suffix로 L 또는 l을 붙인다

  val one = 1 // Int
  val threeBillion = 3000000000 // Long
  val oneLong = 1L // Long
  val oneByte: Byte = 1

Float와 Double

  val pi = 3.14 // 아무것도 사용하지 않으면 Double
  val e = 2.7182818284 // Double
  val eFloat = 2.7182818284f // f를 붙여서 사용하면 Float, actual value is 2.7182817

자동 타입 변환에 대해서

  val x:Byte = 1  // 더 작은 타입인 Byte에 저장되어 있는 값을
  val y:Int = x   // 더 큰 타입인 Int에 저장하려고 하면 오류가 난다

2. Literal constants

Decimal : 123
Long : 123L
hex(16진수) : 0x0F
_ 언더스코어 지원 : 1_000_000_000
binary : 0b101010
45919.toString(2) : 10진수 45919를 2진수로 변환

3. Explicit conversions

서로 타입이 다른 Int와 Long의 값을 비교할 수 있는가?

없다. 사이즈가 작은 타입을 큰 타입으로 변경해주어야 한다

val x:Int = 10
val y:Long = 100000000
x == y // 비교할 수 없다

x.toLong() == y // 이런식으로 직접 타입을 변경해서 사용해야 한다

타입변환시 사용 가능한 메소드
- toByte(): Byte
- toShort(): Short
- toInt(): Int
- toLong(): Long
- toFloat(): Float
- toDouble(): Double
- toChar(): Char

하지만, 산술연산에서는 자동으로 타입 변환이 이루어진다

  val l = 1L + 3 // Long + Int => Long 정상으로 계산이 된다

bit 연산
- shl(bits) – signed shift left
- shr(bits) – signed shift right
- ushr(bits) – unsigned shift right
- and(bits) – bitwise and
- or(bits) – bitwise or
- xor(bits) – bitwise xor
- inv() – bitwise inversion
```
  0b10000000.shl(1)
  // 결과 : 256
```

4. Characters

Characters문자는 바로 Number로 변경할 수 없다

5. Booleans

true, false, ||, &&, !

6. Arrays

    arrayOf(1,2,3,4,5) // 배열 생성하는 방법 1.
    val x = Array<Int>(10) {println(it); it*it} // 배열 생성하는 방법 2
    x[9] // 출력은 81

    arraysOfNulls<Int>(10) // 요소를 null으로 채워서 생성하는 방법

다중 배열

  fun main() {
    val x = arrayOf(
          arrayOf(0,1,2),
          arrayOf(3,4,5),
          arrayOf(6,7,8)
      )

      println(x[0][0])    // 0
      println(x[2][1])    // 7
  }

7. Primitive type arrays

    val x: IntArray = intArrayOf(1, 2, 3)
    x[0] = x[1] + x[2]

8. Strings

  fun main() {
    val s = "abc" + 1
    println(s + "def")  // 결과 : abc1def. 1을 toString()해서 연산한 결과로 보여준다
  }

data 라는 형식의 class를 정의해서 테스트 해 본 경우

  data class Data(val x:Int)

  fun main() {
      val str = "abc" + Data(100)
    println(str) // 결과 : abcData(x=100)
  }

triple quote(“””)

      fun main() {
        val str = """
        줄맞춤
        하는 역할을 하는 듯합니다.
        하하하
        """
        println(str)
    
        val text = """
        |Tell me and I forget.
        |Teach me and I remember.
        |Involve me and I learn.
        |(Benjamin Franklin)
        """
    
        println(text)
        println(text.trimMargin())
      }
    
  // 실행 결과
      줄맞춤
      하는 역할을 하는 듯합니다.
      하하하
        
      |Tell me and I forget.
      |Teach me and I remember.
      |Involve me and I learn.
      |(Benjamin Franklin)
        
  Tell me and I forget.
  Teach me and I remember.
  Involve me and I learn.
  (Benjamin Franklin)

$ 를 사용하는 방법

  fun main() {
    println("\$abc")         // $abc
    println("${'$'}abc")     // $abc
    println("${"$"}abc")     // $abc
  }

출처

Hyunsok Oh님의 [코틀린 기초] 2. 기본 타입 - 수타입, 불리언, 문자, 문자열, 배열 타입 : https://www.youtube.com/watch?v=aO-reo747Bc&t=1s

kotlin 레퍼런스 문서 : https://kotlinlang.org/docs/reference/basic-types.html

Kotlin 기본 문법

Wed, 21 Aug 2019 00:00:00 +0000

jetbrains이 만들었다는 부분부터 매력으로 느끼고 있었는데(사랑합니다 jetbrains), 어느 순간부터 Spring 레퍼런스 문서에 Java 코드를 코틀린으로도 작성할 수 있다고 보여주기 시작하더니, Gradle 5.0에서도 Gradle Kotlin DSL을 지원하기 시작했다.

코틀린에 대해서 지속적인 관심은 가지고 있었으나, 어디서부터 어떻게 시작해야할지 몰라서, 다른것 하기도 바빠서라는 등등의 핑계로 시작은 못하고 “아 하긴 해야되는데..”하는 생각만 마음 한 구석에 불편하게 자리 잡고 있었는데…

오늘 6시간 전에 토비님이 페이스북에 게시하신 글이 있었으니..

감사합니다. 정말 감사합니다. 구독, 좋아요, 알림설정 모두 진행했어요 엉엉 ㅠㅠ

영상이 쌓이면 나중에 볼 엄두가 안날 것 같아서 가능하면 밀리지 않도록 바로 보고, 학습하고, 정리해놓으려고 한다.

아래는 첫 번째 영상을 보고 정리한 내용이다.

Basic Syntax

1. import

Java와 같다. 다른점은 static import는 따로 존재하지 않고, 똑같이 import로 사용하면 된다
```
  package my.demo

  import kotlin.text.*
```

2. Program entry point

main 함수에 대한 내용. 아래와 같이 선언해서 사용하면 된다.
```
  fun main() {
    println("Hello world!")
  }
```

3. Functions

functions 선언 및 사용

  fun sum(a: Int, b: Int): Int { // java와 다르게 fun sum(파라미터이름: 타입) 리턴타입 형태이다
      return a + b
  }

  fun main() {
      print("sum of 3 and 5 is ")
      println(sum(3, 5))
  }

아래와 같이 줄여서 반환해야하는 값의 식을 바로 사용할 수도 있다.
```
  fun sum(a: Int, b: Int) = a + b
```

자바에서의 void에 해당되는 키워드는 Unit 이다

  fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
  }

위의 Unit은 생략 가능하다

  fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
  }

4. Variables

변수 정의에 대한 내용

val : 재정의가 불가능한 상수(constant)에 해당. 자바의 final. immua

  fun main() {
    val a: Int = 1  // 즉시 할당해서 사용하는 경우
    val b = 2   // `Int` type 유추
    val c: Int  // Local 변수로 사용할 때는 초기화는 바로 하지 않아도 된다
    c = 3       // 하지만, 사용하기 전에는 반드시 값을 설정해줘야 한다
    println("a = $a, b = $b, c = $c")
}

var : 값을 재할당 가능한 변수

  fun main() {
    var x = 5 // `Int` type 유추
    x += 1
    println("x = $x")
}

함수(fun)안에 함수를 정의 가능하다

  class A {

  }

  val PI = 3.14
  var x = 0

  fun incrementX() { 
      fun bar() { println("함수안에 함수 정의하는 것이 가능함") } // 가능하다
      bar();
      x += 1 
  }

  fun main() {
      println("x = $x; PI = $PI")
      incrementX()
      println("incrementX()")
      println("x = $x; PI = $PI")
  }
    
  // 출력 결과
  x = 0; PI = 3.14
  함수안에 함수 정의하는 것이 가능함
  incrementX()

5. Comments

주석은 자바와 같다

  // This is an end-of-line comment

  /* This is a block comment
     on multiple lines. */

6. String templates

    fun main() {
        var a = 1
        // simple name in template:
        val s1 = "a is $a"  // 변수에 저장된 값은 $a로 사용할 수도 있고,
        println(s1)

        val s3 = "a is ${a}" // ${a}와 같이 사용할 수도 있다.
        println(s3)

        a = 2
        // 메소드는 ${} 을 사용해야 한다
        val s2 = "${s1.replace("is", "was")}, but now is $a"
        println(s2)
    }

7. Conditional expressions

if문은 아래와 같다

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

  fun main() {
      println("max of 0 and 42 is ${maxOf(0, 42)}")
  }

또는 아래와 같이 줄여서 사용할 수도 있다

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

  fun main() {
      println("max of 0 and 42 is ${maxOf(0, 42)}")
  }

8. Nullable values and null checks

return type 에 ? 가 붙으면, null이 return 될 수 있다는 의미이므로 null check를 해줘야한다.

  fun parseInt(str: String): Int? {
      return str.toIntOrNull()
  }

  fun printProduct(arg1: String, arg2: String) {
      val x = parseInt(arg1)
      val y = parseInt(arg2)

      // Using `x * y` yields error because they may hold nulls.
      if (x != null && y != null) {
          // x and y are automatically cast to non-nullable after null check
          println(x * y)
      }
      else {
          println("'$arg1' or '$arg2' is not a number")
      }    
  }


  fun main() {
      printProduct("6", "7")
      printProduct("a", "7")
      printProduct("a", "b")
  }

또는 아래와 같이 null일 경우 ?:를 사용해서 대체할 수 있는 값을 정의해줄 수도 있다

  fun parseInt(str: String): Int? {
      return str.toIntOrNull()
  }

  fun printProduct(arg1: String, arg2: String) {
      val x = parseInt(arg1)
      val y = parseInt(arg2)

      // x and y are automatically cast to non-nullable after null check
      println((x?:0) * (y?:0)) // x가 null이면 0으로, y가 null이면 0으로 대체해준다.
  }

  fun main() {
      printProduct("6", "7")
      printProduct("a", "7")
      printProduct("99", "b")
  }
    
  // 결과
  42
  0
  0

9. Type checks and automatic casts

    fun getStringLength(obj: Any): Int? {
        if (obj is String) { // obj가 String Type인지 검사를 하고 나면,
            // `obj`는 자동으로 String으로 변환된다. java에서는 (String)obj.length 형식으로 사용했었음
            return obj.length
        }

        // `obj` is still of type `Any` outside of the type-checked branch
        return null
    }

    fun getStringLength(obj: Any): Int? {
        if (obj !is String) return null // obj가 String이 아닌것을 검사하고 나면

        // `obj`는 String 이므로 자동으로 cast 된다 
        return obj.length
    }

10. for loop

자바에 존재하던 전통적인 for loop는 존재하지 않는다

  for(int i=0; i<3; i++) // 코틀린에는 존재하지 않음

대신 아래와 같이 사용함 ```java val items = listOf(“apple”, “banana”, “kiwifruit”) for (item in items) { println(item) }

// items.forEach({item -> println(item)}) 도 사용 가능

  
  
* 컬렉션의 경우 `indices`를 사용해서 index 정보를 알 수 있다
  
  ```kotlin
    val items = listOf("apple", "banana", "kiwifruit")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
    
    // 출력
    item at 0 is apple
    item at 1 is banana
    item at 2 is kiwifruit

11. while loop

컬렉션에 size 를 사용할 수 있고, while loop는 자바와 똑같이 사용할 수 있다.

  val items = listOf("apple", "banana", "kiwifruit")
  var index = 0
  while (index < items.size) {
      println("item at $index is ${items[index]}")
      index++
  }

12. when expression

자바의 switch 문에 해당되는 내용이다. 조건 -> 결과 형태로 사용할 수 있으며 결과에 해당되는 타입은 모두 똑같아야 한다.

  fun describe(obj: Any): String =
      when (obj) {
          1          -> "One"             // 상수 비교
          "Hello"    -> "Greeting"        // 문자열 비교
          is Long    -> "Long"            // 타입 비교
          !is String -> "Not a string"    // 타입 비교
          else       -> "Unknown"         // java switch문의 default에 해당
      }

13. Ranges

range 안에 포함인지 확인하는 경우

  val x = 10
  val y = 9
  if (x in 1..y+1) {  // .. 이 의미하는 것은 양쪽 다 포함한다는 뜻. 즉, x는 1<= x <=10 이라는 의미이다.
      println("fits in range")
  }

out of range, range안에 포함되지 않는지 확인하는 경우

    val list = listOf("a", "b", "c")

    if (-1 !in 0..list.lastIndex) {    // !in 을 사용한다
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range, too")
    }

step과 downTo

  for (x in 1..10 step 2) { // x는 1부터 2씩 증가하여 10까지 
      print(x) // 출력 : 13579
  }
  println()
  for (x in 9 downTo 0 step 3) { // x는 9부터 3씩 감소하여 0까지
      print(x) // 출력 : 9630
  }

13. Collections

컬렉션에는 list와 map이 존재한다

list에는 immutable list와 mutable list가 존재한다

  fun main() {
      // immutable list는 그냥 listOf 를 사용하면 된다
      val items = listOf("apple", "banana", "kiwifruit")
      for (item in items) {
          println(item)
      }
        
      val immutableItems = listOf(1, 2, 3)
      println(immutableItems)  // 결과 : [1, 2, 3]

      // mutable list는 mutableListOf를 사용해야 한다     
      val mutableItems = mutableListOf(1, 2)
      println(mutableItems)     // 결과 : [1, 2]
      mutableItems += 3         // mutable 이므로 변경 가능
      println(mutableItems)     // 결과 : [1, 2, 3]
        
      // var를 사용해서 immutable List를 생성하면 변경할 수 있다
      var items2 = listOf("apple", "banana", "kiwifruit")
      items2 += "strawberry"
      println(items2)           // 결과 : [apple, banana, kiwifruit, strawberry]
        
  }

자바의 스트림처럼 사용 가능

  val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
  fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }

14. Creating basic classes and their instances

    fun main() {
        val rectangle = Rectangle(5.0, 2.0) //no 'new' keyword required
        val triangle = Triangle(3.0, 4.0, 5.0)
        println("Area of rectangle is ${rectangle.calculateArea()}, its perimeter is ${rectangle.perimeter}")
        println("Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}")
    }

    abstract class Shape(val sides: List<Double>) { // class를 정의하면서 List<Doulbe> sides 파라ㅣ터를 갖는 생성자도 동시에 정의함.
        val perimeter: Double get() = sides.sum()
        abstract fun calculateArea(): Double
    }

    // interface
    interface RectangleProperties {
        val isSquare: Boolean
    }

    
    // class
    class Rectangle(
        var height: Double,
        var length: Double
    ) : Shape(listOf(height, length, height, length)), RectangleProperties {
        override val isSquare: Boolean get() = length == height
        override fun calculateArea(): Double = height * length
    }

    class Triangle(
        var sideA: Double,
        var sideB: Double,
        var sideC: Double
    ) : Shape(listOf(sideA, sideB, sideC)) { // : Shape의 의미는 Shape를 상속받는다는 의미.
        override fun calculateArea(): Double {
            val s = perimeter / 2
            return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
        }
    }

출처

Hyunsok Oh님의 [코틀린 기초] 1. 시작하며 - 프로그래밍에 필요한 기본 문법 정리 : https://www.youtube.com/watch?v=oVk2y26JCyk&t=6s

토비(이일민)님 페이스북 글 : https://www.facebook.com/tobyilee/posts/10216483380811617

kotlin 레퍼런스 문서 : https://kotlinlang.org/docs/reference/basic-syntax.html

도메인 모델에 set 메소드 사용하지 않기

Tue, 20 Aug 2019 00:00:00 +0000

DDD Start! - 도메인 주도 설계 구현과 핵심 개념 익히기 (지은이 최범균)의 Chapter1에 해당 되는 내용을 다시 한 번 보면서 정리한 내용이다

Domain 모델을 생성할 때, 예전(DDD를 적용하지 않았던 시절..)에는 기계적으로 Lombok의 @Getter, @Setter를 사용했었다. 이렇게 도메인 모델에 public set method를 추가하게 되면, 의도하지 않은 곳에서 의도하지 않은 용도로 setter method를 사용하는 경우가 많이 생겼고, 리팩토링시 또는 기능 수정시 문제가되거나 불편한점들이 있었다.

set 메소드를 사용하지 않고 어떻게 처리해야되는지, 어떻게 처리하고 있는지 간단하게 기록해두려고 한다.

1. 객체를 생성하는 경우

아래와 같이 set 메서드로 필요한 값을 전달하는 것은 지양하고 있다.

    User user = new User();
    user.setTeam(team);

대신에 생성자를 통해서 필요한 데이터들을 모두 받아서 처리해야 한다.

User user = new User(team, username, password);

또는 builder 패턴을 사용해서 객체를 생성할 수도 있다.

@Entity
@Table(name = "mt_user")
@EqualsAndHashCode(callSuper = false, of = "id")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
public class User {
    
    @Id
    @Column(name = "id")
    @GenericGenerator(name = "system-uuid", strategy = "uuid2")
    @GeneratedValue(generator = "system-uuid")
    private String id;
    private String username;
    private String password;
    private String phoneNumber;
    
    @OneToOne
    @JoinColumn(name = "team_id")
    private Team team;
    
    @Builder(builderClassName = "ByCreateBuilder", builderMethodName = "ByCreateBuilder")
    public User(String username, String password, Team team) {
      Assert.notNull(username, "username must not be null"); // 안저한 객체 생성을 위하여 객체 생성시 필수값들은 체크해 준다.
      Assert.notNull(password, "password must not be null");
      Assert.notNull(team, "team must not be null");
      this.username = username;
      this.password = password;
      this.team = team;
    }
    
}

 @Test
 @DisplayName("builder 패턴으로 User객체가 정상적으로 생성되어야 한다")
  public void createUser_test() {
    final User user = User.ByCreateBuilder()
        .username("eomdev")
        .password("123123")
        .team(team)
        .build();
    assertThat(user.getUsername()).isEqualTo("eomdev");
    assertThat(user.getPassword()).isEqualTo("123123");
  }

2. 도메인 모델 내부에서만 사용할 수 있도록 private set 메서드는 허용하고 있다.

도메인 모델에 외부에서는 접근할 수 없도록 private 접근자를 사용하여 set 메서드를 생성하여 내부에서만 사용하는 것까지는 허용하고 있다. 최소한 외부에서 다른 의도로 set 메소드를 사용하는 경우는 막을 수 있으므로.

하지만, 메서드의 이름에 set을 붙이는 것보다는 의미있는 이름을 지어주는 것이 좋다고 생각하고 있다.

3. 불변 밸류 타입에는 set 메서드를 통해서 값을 변경하는 것보다는 새로운 밸류 객체를 생성하자

Address 또는 Money와 같은 불변 밸류 타입은 새로운 밸류 객체를 생성하는 것이 불변 타입을 사용해서 얻는 이점인 안전한 코드를 작성할 수 있다는 부분을 챙길 수 있다.

public class Money {
    
    private int alue;
    
    public Money add(Money money) {
        return new Money(this.value + money.value);
    }
    
}

4. Lombok의 @Setter 사용을 강제적으로 제한할 수도 있다.

현재 새로 진행하는 프로젝트들은 가능하면 Set method를 쓰지 않기 위해서 프로젝트 내에 lombok.config 을 생성해서 아래와 같이 설정해서 사용하고, 진행해보고 있다.

lombok.setter.flagUsage=ERROR

참고

DDD Start! - 도메인 주도 설계 구현과 핵심 개념 익히기 (지은이 최범균)

Builder 기반으로 객체를 안전하게 생성하는 방법 : https://cheese10yun.github.io/spring-builder-pattern/

Spring Cloud Bus

Mon, 01 Apr 2019 00:00:00 +0000

Spring Cloud Bus에 대해서 알아봅니다.

관련 예제는 Github에 있습니다.

이 전 Spring Cloud Config에서도 이야기 했듯이, Spring Cloud Config Server를 사용하면 Config Client(MSA) 애플리케이션을 수정하거나 재시작 하지 않아도 변경된 환경설정 정보들을 적용할 수 있습니다. 하지만, 변경된 환경설정 정보를 다시 적용시키기 위해서는 각각의 Config Client 인스턴스들에게 각각 Actuator의 /refresh를 호출을 해줘야한다는 단점이 있었습니다.

1. Spring Cloud Bus?

위에서 이야기한 각각의 Config Client 인스턴스마다 /actuator/refresh를 호출해줘야하는 단점은 Spring Cloud Bus를 통해서 하나의 메시지 브로커(여기서는 RabbitMQ)에 모든 인스턴스들을 연결해서 해결할 수가 있습니다.

개념은 위의 그림과 같고, 간단하게 설명하자면 아래와 같습니다.

개발자가 변경할 프로퍼티를 수정하고, 변경된 Config-Repo를 Git Repository에 push 합니다.
만약 Git Repository로 Github와 같은 저장소를 사용하고 있다면, Git Repository에 변경이 일어났을 때 webhook 으로 특정 url을 호출할 수 있습니다. 이 때 Config-Server의 /actuator/bus-refresh를 POST로 호출하도록 해주면 되는데, 여기서는 webhook을 사용하지 않고 직접 Config-Server에 url을 호출해주도록 하겠습니다.
/actuator/bus-refresh를 통해서 변경되었음을 통보받은 Config-Server는 변경된 환경설정 정보를 다시 갱신합니다.
Spring Cloud Bus가 변경된 정보가 있다고 RabbitMQ에게 메시지를 발행합니다.
메시지를 구독받은 Config Client들은 환경설정 정보가 변경되었음을 알게 되고, 각각 환경설정 정보를 업데이트 합니다.

2. Config Server 수정

Config-Server 프로젝트에 Spring Cloud Bus를 사용하기 위해서 spring-cloud-starter-bus-amqp 디펜던시를 추가해주어야 합니다.

dependencies {
    ...
    implementation 'org.springframework.cloud:spring-cloud-starter-bus-amqp' // 추가
}

그리고 application.yml에 RabbitMQ 정보와 actuator의 /bus-refresh를 사용가능하도록 노출시켜 주기 위해서 management.endpoints.web.exposure.include에 등록해줍니다.

spring:
  profiles:
    active: native
server:
  port: 8888
---
spring:
  profiles: native
  cloud:
    config:
      server:
        native:
          search-locations: file://${user.home}/IdeaProjects/study/blog-samples/config-repo
  rabbitmq:                   # rabbitmq와 관련된 부분 추가
    host: 192.168.99.100
    username: guest
    password: guest
management:
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: ['bus-refresh'] # actuator의 bus-refresh endpoint 노출시켜줍니다
---
spring:
  profiles: dev
  cloud:
    config:
      server:
        git:
          uri: https://github.com/umsh86/blog-samples.git
          search-paths: config-repo

3. Config Client 수정

Config-Server와 마찬가지로 Spring Cloud Bus를 사용하기 위해서 디펜던시를 아래와 같이 추가해줍니다.

dependencies {
    ...
    implementation 'org.springframework.cloud:spring-cloud-starter-bus-amqp' // 추가
}

그리고 이번에는 Config-Repo의 api.yml에 RabbitMQ 정보를 수정해주고, 테스트를 위해서 server.port를 삭제해줍니다(Config Client를 로컬에 2개 띄울 예정이며, -Dserver.port옵션으로 port 중복을 회피하기 위해서 입니다).

spring:
  profiles: dev
  rabbitmq:       # RabbitMQ 정보 수정
    host: 192.168.99.100   
    port: 5672
    username: guest
    password: guest
# server:
#   port: 9998
custom:
  message: Hello, api-dev!
---
...

4. 테스트

위의 내용을 모두 수정했으면, 우선 Config-Server를 실행시켜 줍니다. 애플리케이션이 정상적으로 실행되고 나면 RabbitMQ managerment > Exchanges 에 springCloudBus가 추가된 것을 볼 수 있습니다.

그리고 이번에는 Config-Client프로젝트를 빌드하고, 생성된 jar 파일을 각각 9999와 9998 포트로 실행합니다.

$ java -jar -Dserver.port=9999 config-client-0.0.1-SNAPSHOT.jar
$ java -jar -Dserver.port=9998 config-client-0.0.1-SNAPSHOT.jar

정상적으로 실행이 되면, 각각의 Config-Client 인스턴스에서 custom.message가 정상적으로 나오는지 http://localhost:9999/config와 http://localhost:9999/config 을 호출해서 확인해봅니다.

Hello, api-dev!라는 메시지가 정상적으로 나오는 것을 확인할 수 있습니다.

그리고 local Config-Repo의 api.yml에서 custom.message의 내용을 변경해줍니다.

spring:
  profiles: dev
  rabbitmq:
    host: 192.168.99.100
    username: guest
    password: guest
custom:
  message: Hello, api-dev! Cloud Bus Test!! # Cloud Bus Test!! 메시지를 추가했습니다.

그리고 Config-Server의 /actuator/bus-refresh를 POST로 호출해줍니다. 저는 InteliiJ의 Http Client를 사용해서 호출해주었습니다.

POST http://localhost:9998/actuator/bus-refresh

HTTP/1.1 204 
Date: Fri, 29 Mar 2019 05:56:22 GMT

<Response body is empty>

Response code: 204; Time: 970ms; Content length: 0 bytes

아래는 Config Server의 console 로그 입니다.

2019-03-29 14:56:22.028  INFO 11736 --- [nio-8888-exec-6] trationDelegate$BeanPostProcessorChecker : Bean 'org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration' of type [org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration$$EnhancerBySpringCGLIB$$38bc02b3] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2019-03-29 14:56:22.154  INFO 11736 --- [nio-8888-exec-6] o.s.boot.SpringApplication               : The following profiles are active: native
2019-03-29 14:56:22.174  INFO 11736 --- [nio-8888-exec-6] o.s.boot.SpringApplication               : Started application in 0.491 seconds (JVM running for 1888.348)
2019-03-29 14:56:22.471  INFO 11736 --- [nio-8888-exec-7] o.s.c.c.s.e.NativeEnvironmentRepository  : Adding property source: file:///Users/sheom/IdeaProjects/study/blog-samples/config-repo/api.yml (document #0)
2019-03-29 14:56:22.529  INFO 11736 --- [nio-8888-exec-6] o.s.cloud.bus.event.RefreshListener      : Received remote refresh request. Keys refreshed []

아래는 Config Client의 로그입니다.

2019-03-29 14:56:22.486  INFO 11833 --- [7e5Xfw4e8qNZg-1] o.s.boot.SpringApplication               : The following profiles are active: dev
2019-03-29 14:56:22.524  INFO 11833 --- [7e5Xfw4e8qNZg-1] o.s.boot.SpringApplication               : Started application in 0.611 seconds (JVM running for 806.562)
2019-03-29 14:56:22.828  INFO 11833 --- [7e5Xfw4e8qNZg-1] o.s.cloud.bus.event.RefreshListener      : Received remote refresh request. Keys refreshed [custom.message]
2019-03-29 14:56:22.924  INFO 11833 --- [7e5Xfw4e8qNZg-1] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [192.168.99.100:5672]
2019-03-29 14:56:22.948  INFO 11833 --- [7e5Xfw4e8qNZg-1] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory.publisher#35b2d39c:0/SimpleConnection@41f917fb [delegate=amqp://guest@192.168.99.100:5672/, localPort= 64087]

그리고 각각의 Config-Client 인스턴스에서 /config를 호출해 보면 둘 다 Hello, api-dev! Cloud Bus Test!!메시지가 나오는 것을 확인할 수 있습니다.

이렇게 해서 Config Server의 /actuator/bus-refresh만을 호출해서 구독하고 있는 모든 Config Client 인스턴스들에게 한 번에 변경된 환경설정 정보를 변경할 수 있다는 것을 확인할 수 있었습니다.

실제로는 Github의 Webhook을 사용해서 자동으로 호출하게 할 수 있으므로 직접 /actuator/bus-refresh를 호출해주는 작업도 필요하지 않습니다.

다음에는 Config Server의 고가용성에 대한 이야기를 정리해보겠습니다.

5. Config Server 고가용성 적용

Config Server의 고가용성 확보를 위한 아키텍처는 아래와 같습니다.

그리고 config Server를 구성할 때 고가용성에 대해서 고려해야하는 부분은 총 3가지로 Config Server, RabbitMQ, Config-Repo(Git Repository)입니다.

5.1 Config Server

Config Server에 장애가 발생하면 환경설정 정보를 읽어서 사용하는 Config Client서비스들이 정상적으로 실행될 수 없으므로, 고가용성이 필요합니다.

하지만, Config Server에 장애가 발생하더라도 Config Client가 이미 정상적으로 작동되고 있는 상태라면 로컬에 캐시해둔 환경설정 정보를 기준으로 동작하기 때문에 크게 문제가 되지 않습니다(물론 새로 애플리케이션이 실행된다면 문제…).

다만, Config Client의 bootstrap.yml에서 spring.cloud.config.uri는 하나만 설정할 수 있으므로, 다수의 Config Server에 대한 정보는 로드 밸런서와 같은 곳에 저장돼야 합니다.

그래서 위의 아키텍처에서는 Config Client들이 ELB를 통해 Config Server를 호출하는 형태입니다.

5.2 RabbitMQ

RabbitMQ의 경우에도 고가용성이 적용되야하지만, RabbitMQ에 장애가 발생하더라도, 각각의 마이크로서비스 인스턴스의 /actuator/refresh를 직접 호출해서 변경된 환경설정 정보를 가져올 수 있으므로 크게 문제는 되지 않습니다.

5.3 Git Repository

Git Repository의 경우에도 로컬의 파일 기반의 Repository를 사용하는 것보다는 고가용성이 확보된 Git 서비스를 기반으로 운영돼야 합니다.

6. 정리

이렇게 해서 지난 번에 Spring Cloud Server, Spring Cloud Client에 대해서 다뤘고, 이번에는 Spring Cloud Bus와 고가용성에 대해서 정리를 해보았습니다.

참고 : 스프링 5.0 마이크로서비스 2/e (에이콘출판사)

Spring Cloud Config

Thu, 21 Mar 2019 00:00:00 +0000

Spring Cloud Config Server에 대해서 알아봅니다.

관련 예제는 Github에 있습니다.

1. Spring Cloud Config Server?

일반적인 Spring Boot Application 이라면 환경설정과 관련된 부분들은 해당 프로젝트에 함께 포함되어 있는 yml이나 properties 파일들을 읽어서 사용을 했었습니다.

하지만 이 경우에 어떤 이유에서 환경설정 정보가 변경된다면(예를 들어, 환경설정 정보에 저장되어 있는 rabbitmq의 host와 password가 변경되어 spring.rabbitmq.host와 spring.rabbitmq.password 정보를 수정해야되는 경우), 애플리케이션 전체를 다시 빌드를 해야된다는 문제점이 있습니다.

그래서 사실 dev, st, prod 환경에서는 아래와 같이 애플리케이션 배포 패키지에서 분리해서 외부화하기 위해서 환경설정 파일의 위치를 직접 지정해주면서 실행시켜서 사용하고 있었습니다.

$ java -jar application.jar --spring.config.location=<file location>

하지만 이 방법도 서버에 마운트돼 있는 로컬이나 공유된 파일 시스템에 의존하게 되고, 대규모 배포에서는 더 강력한 중앙 집중형 환경설정 정보 관리 솔루션이 필요합니다.

그것이 바로 환경설정 서버인데, Spring Cloud Project에서 환경설정 서버를 만들 수 있도록 지원하고 있는 것들이 Config Server, ZooKeeper Configuration, Consul Configuration이 존재하는데, 여기에서는 Config Server 만 알아볼 예정입니다.

Spring Config Server의 아키텍처는 아래와 같습니다.

Config Server는 환경설정 정보들을 Git Repository(SVN도 가능)에 저장되어 있는 환경설정 정보 파일들(yml 또는 properties)들을 읽습니다.

그리고 각각의 마이크로서비스 애플리케이션들(Config Client)은 필요한 환경설정 정보들을 Config Server에서 읽어서 가져오며, 로컬에 캐시해둡니다. 여기에서 Config Server는 환경설정 정보가 변경되면(위의 예제처럼 rabbitmq의 host와 password가 변경되면) Config Server를 바라보고 있는 모든 마이크로서비스에게 변경 사항들을 전파하고, 변경 사항을 로컬 캐시에 반영하게 됩니다.

2. Git Repository 구성

그러면 우선 Config Server가 읽어서 사용할 Git Repository를 생성해주어야 합니다.

config-repo라는 새로운 디렉토리를 생성하고 그 하위에 아래와 같은 작업을 진행해주었습니다.

우선 Config Server가 직접 사용할 환경설정 정보를 추가해줍니다. 파일명은 application.yml 입니다.

spring:
  rabbitmq:
    host: 192.168.99.100
    port: 5672
    username: guest
    password: guest
    virtual-host: vhost01

그리고 마이크로서비스1, 2, 3이 dev, st, prod 에서 사용할 api-dev.yml, api-st.yml, api-prod.yml 을 각각 생성해줍니다

# api-dev.yml
spring:
  rabbitmq:
    host: dev.eomdev.com
    port: 5672
    username: devUser
    password: devPassword
    virtual-host: vhost01
server:
  port: 9998    
custom:
  message: Hello, api-dev!

# api-st.yml
spring:
  rabbitmq:
    host: st.eomdev.com
    port: 5672
    username: stUser
    password: stPassword
    virtual-host: vhost02
server:
  port: 9999
custom:
  message: Hello, api ST!


# api-prod.yml
spring:
  rabbitmq:
    host: eomdev.com
    port: 5672
    username: user
    password: password
    virtual-host: vhost03
custom:
  message: Hello, api prod!

또는 아래와 같이 하나의 api.yml을 생성해서 profile 별로 분리를 시켜줄 수도 있습니다

spring:
  profiles: dev
  rabbitmq:
    host: dev.eomdev.com
    port: 5672
    username: devUser
    password: devPassword
    virtual-host: vhost01
server:
  port: 9998    
custom:
  message: Hello, api-dev!
---
# api-st.yml
spring:
  profiles: st
  rabbitmq:
    host: st.eomdev.com
    port: 5672
    username: stUser
    password: stPassword
    virtual-host: vhost02
server:
  port: 9999
custom:
  message: Hello, api ST!
---
# api-prod.yml
spring:
  profiles: prod
  rabbitmq:
    host: eomdev.com
    port: 5672
    username: user
    password: password
    virtual-host: vhost03
custom:
  message: Hello, api prod!

그리고 해당 디렉토리를 초기화해주고 git remote repository로 push해 줍니다.

$ git init
$ git add . 
$ git commit -m "first commit"
$ git remote add origin <Remote Repository 주소>
$ git push -u origin master

3. Spring Config Server 생성

Config Server와 Actuator를 추가해서 config-server 프로젝트를 새로 만들어 줍니다

아래와 같이 Application.java 에 @EnableConfigServer를 추가해줍니다

@SpringBootApplication
@EnableConfigServer      // 추가
public class ConfigServer {
  public static void main(String[] args) {
    SpringApplication.run(ConfigServer.class, args);
  }
}

3.1 local 개발 환경 설정

local에서 개발시에는 자유롭게 properties 들을 추가, 수정, 삭제하면서 개발하기 위해서 remote git repository를 바라보는 것이 아니라, 로컬에 존재하는 환경설정 파일을 바라보게 설정해줘야 합니다.

이렇게 하기 위해서는 application.yml에 읽어 올 Config file 의 위치를 spring.cloud.config.server.native.searchLocations의 값으로 설정해주고, local에 존재하는 해당 환경설정 파일을 읽어올 수 있도록 native Profile을 활성화 해야 합니다.

즉, 아래와 같이 설정해 줍니다.

spring:
  profiles:
    active: native # file system에서 Config file을 읽어 올 수 있도록 native profile을 활성화시켜야 합니다.
---
spring:
  profiles: native
  cloud:
    config:
      server:
        native:
          search-locations: file://${user.home}/IdeaProjects/study/blog-samples/config-repo # config file의 위치. 윈도우의 경우에는 "/"가 추가로 필요합니다.(file:///${user.home}/...)
server:
  port: 8888

그리고 실제로 Config Server에게 http://localhost:8888/api/dev 를 호출해서 api-dev.yml의 환경설정 정보를 가져왔다는 것을 아래와 같이 확인할 수 있습니다.

{
  "name": "api",
  "profiles": [
    "dev"
  ],
  "label": null,
  "version": null,
  "state": null,
  "propertySources": [
    {
      "name": "file:///Users/eomdev/IdeaProjects/study/blog-samples/config-repo/api.yml (document #0)",
      "source": {
        "spring.profiles": "dev",
        "spring.rabbitmq.host": "dev.eomdev.com",
        "spring.rabbitmq.port": 5672,
        "spring.rabbitmq.username": "devUser",
        "spring.rabbitmq.password": "devPassword",
        "spring.rabbitmq.virtual-host": "vhost01",
        "server.port": 9998,
        "custom.message": "Hello, api-dev!"
      }
    }
  ]
}

Config Server에게 url을 요청해서 환경설정 정보를 가져오는 전략에 대해서는 아래 3.3 Config Server URL 설명에서 다루겠습니다.

3.2 Remote Git Repository 설정

dev, st, prod 에서는 Remote Git Repository(여기에서는 Github)를 바라보고 사용하도록 설정해주면 됩니다

Config Server 애플리케이션의 application.yml에 아래 내용을 추가해줍니다

spring:
  profiles:
    active: native
server:
  port: 8888
---
spring:
  profiles: native
  cloud:
    config:
      server:
        native:
          search-locations: file://${user.home}/IdeaProjects/study/blog-samples/config-repo
---
spring:
  profiles: dev
  cloud:
    config:
      server:
        git:
          uri: https://github.com/umsh86/blog-samples.git
          search-paths: config-repo # 저는 환경설정 파일들이 /blog-samples/config-repo 하위에 있어서 search-paths를 설정해주었습니다.
#          username: # private-repo라면 접근권한이 있는 username, password를 설정해주면 됩니다
#          password: #

그리고 spring.profiles.active=dev로 변경해서 실행하거나, 아래와 같이 옵션을 사용해서 애플리케이션을 실행합니다.

$ gradle bootRun -Dspring.profiles.active=dev

$ java -jar -Dspring.profiles.active=dev ./api.jar

그리고 Remote Git Repository에서 정상적으로 환경설정 파일을 가져왔는지 Config Server의 http://localhost:8888/api/dev 를 호출해서 확인해줍니다.

{
  "name": "api",
  "profiles": [
    "dev"
  ],
  "label": null,
  "version": "8a736c7b1e061366fb12ba38ecd6eb61ddeeeeae",
  "state": null,
  "propertySources": [
    {
      "name": "https://github.com/umsh86/blog-samples.git/config-repo/api.yml (document #0)",
      "source": {
        "spring.profiles": "dev",
        "spring.rabbitmq.host": "dev.eomdev.com",
        "spring.rabbitmq.port": 5672,
        "spring.rabbitmq.username": "devUser",
        "spring.rabbitmq.password": "devPassword",
        "spring.rabbitmq.virtual-host": "vhost01",
        "server.port": 9998,
        "custom.message": "Hello, api-dev!"
      }
    }
  ]
}

3.3 Config Server URL 설명

위에서 Config Server에서 url을 호출해서 환경설정 정보를 확인하기 위해 http://localhost:8888/api/dev 를 호출했는데, 이 부분은 http://localhost:8888/{application}/{profile}/{label} 형태 입니다.

{application} : Config Client에서 설정되어 있는 spring.application.name 속성으로 지정된 애플리케이션의 이름을 의미합니다. 여기에서는 spring.application.name=api으로 설정하여, api.yml에 있는 정보들을 사용할 예정입니다.
{profile} : Config Client에 설정되어 있는 spring.profiles.active 의 값이고, comma(,)로 구분되어 있는 여러 개의 값일 경우 마지막 값이 적용 됩니다. 기본 profile 값은 default 입니다.
{label} : 필수가 아닌 옵션이며, git branch의 이름을 나타냅니다. 기본 값은 master입니다.

이 {application}, {profile}, {lable}의 값을 가지고 아래와 같은 방법으로도 Config Server에게 환경설정 정보 값들을 확인 할 수 있습니다.

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

4. Config Client(샘플 애플리케이션) 생성

Config Client(샘플 애플리케이션)을 만들고, 필요한 환경설정 정보들을 Config Server에 요청해서 가져오는 부분입니다.

우선 Spring Initializr로 Config Client, Web, Actuator, lombok를 선택해서 프로젝트를 생성해줍니다.

4.1 bootstrap.yml 설정

Spring Boot Application은 일반적으로 applicatin.yml 이나 application.properties를 사용합니다. 하지만 Config Client는 bootstrap.yml 파일을 사용하며, 여기에 설정된 내용은 application.yml보다 먼저 로드됩니다.

bootstrap.yml을 생성해주고 아래와 같이 설정해줍니다

spring:
  profiles:
    active: dev
  application:
    name: api # /{application}/{profile}/{label}을 생각해서 애플리케이션 이름을 정해줍니다.

management:
  endpoints:
    web:
      base-path: /actuator 
      exposure:
        include: ['refresh'] # actuator의 refresh를 사용할 수 있게 해줍니다. 뒤에서 설명합니다.
---
spring:
  profiles: dev
  cloud:
    config:
      uri: http://localhost:8888 # config server의 uri를 설정해줘야합니다
---
spring:
  profiles: st
  cloud:
    config:
      uri: http://stapi.eomdev.com
---
spring:
  profiles: prod
  cloud:
    config:
      uri: http://api.eomdev.com

그리고 실제로 설정된 환경설정 값을 확인하기 위해서 custom.message만 읽어서 확인할 수 있도록 아래의 2개 class를 생성해줍니다.

@Component
@ConfigurationProperties(prefix = "custom")
@RefreshScope
@Getter @Setter
public class ConfigProperties {

  private String message;

}

@RestController
public class ConfigController {

  @Autowired
  private ConfigProperties configProperties;

  @GetMapping("/config")
  public ResponseEntity getConfig() {
    return ResponseEntity.ok(configProperties.getMessage());
  }

}

@RefreshScope로 선언해주면 Actuator의 /refresh 호출을 통해서 해당 Bean의 값이 변경됩니다.

그리고 애플리케이션을 실행하면 아래와 같이 console log를 통해서 Config Server에서 환경설정 정보들을 가져왔다는 것을 확인할 수 있습니다.

# config server localhost:8888에서
2019-03-20 17:51:30.046  INFO 25096 --- [           main] c.c.c.ConfigServicePropertySourceLocator : Fetching config from server at : http://localhost:8888

# 아래의 environment 정보로
2019-03-20 17:51:30.376  INFO 25096 --- [           main] c.c.c.ConfigServicePropertySourceLocator : Located environment: name=api, profiles=[dev], label=null, version=null, state=null

# 실제로 환경설정 정보 파일을 가져왔는지 확인할 수 있습니다.
2019-03-20 17:51:30.376  INFO 25096 --- [           main] b.c.PropertySourceBootstrapConfiguration : Located property source: CompositePropertySource {name='configService', propertySources=[MapPropertySource {name='file:///Users/sheom/IdeaProjects/study/blog-samples/config-repo/api.yml (document #0)'}]}

실제로 /config로 요청해보면 Hello, api-dev! 메시지가 정상적으로 나오는 것을 확인할 수 있습니다.

5. 테스트

실제로 값이 제대로 변경되는지 테스트를 하기 위해서 Config-Repo의 api.yml에서 값을 변경해줍니다.

spring:
  profiles: dev
  rabbitmq:
    host: dev.eomdev.com
    port: 5672
    username: devUser
    password: devPassword
    virtual-host: vhost01
server:
  port: 9998
custom:
  message: Hello, api-dev! Test!!!  # Test!!! 를 추가해주었습니다.
  
  ...

그리고 Config-Client애플리케이션에게 변경된 정보를 가져오라고 알려주기 위해서 Actuator의 /refresh를 POST로 호출해줘야 합니다.

$ curl localhost:8080/actuator/refresh -d {} -H "Content-Type: application/json"
["custom.message"] # custom.message가 바뀌었음을 알려줌

그리고 다시 한번 /config를 호출하면 Hello, api-dev! Test!!!로 변경된 값이 정상적으로 출력되는 것을 확인해볼 수 있습니다.

6. 정리

이렇게 Config Server를 사용하면 애플리케이션을 재시작하지 않고도 환경설정 정보를 변경할 수 있습니다. 하지만, 변경된 내용을 적용하기 위해서는 각각의 Config Client인스턴스에서 /refresh를 호출해줘야하는 불편한점이 있습니다.

이 부분은Spring Cloud Bus를 사용하면, Config-Repo에서 환경설정 정보가 변경되면 Config-Client에게 변경되었다고 전파해서 자동으로 변경되도록 할 수 있다고 합니다.

관련 내용은 다음에 정리해보도록 하겠습니다.

Spring Cloud?

Wed, 06 Mar 2019 00:00:00 +0000

블로그에 Spring Cloud라는 카테고리를 새로 만들었습니다. 앞으로 Spring Cloud와 관련된 것들을 공부하고 글을 작성해보려고 합니다. Spring Cloud에 대해서 공부하고 블로그에 글을 남겨봐야겠다는 생각이 갑자기 든 이유는 아래와 같습니다.

Dropbox에 있는 문서들을 정리하다가 현재 다니고 있는 회사에 지원했을 때 작성했던 이력서를 보게되었습니다. 2016년도 초반에 작성된 이력서 였는데, 아래와 같이 관심사, 앞으로 경험해 보고 싶은 것들에 대해 적어놓은 부분이 있었습니다.

2016년도에 이직을 준비하면서 이러한 관심사를 가지고 있는 사람들이 있는 회사로 이직을 했으면 좋겠고, 같은 관심사를 가지고 있는 개발자들과 함께 더 나은 서비스 개발을 위해 노력하고 경험해보고 싶은 마음에서 작성했던 것 같습니다.

그리고 현재 2019년이 되어 작성했던 이력서들을 처음부터 자세히 읽어보니, 그 당시에 마음먹었던 것들, 특히 관심을 가지고 경험해보고자 했던것들을 정복(?)하지 못했다는 생각이 들었습니다.

지금이라도 하나씩 정복(?)을 해보자는 생각이 들었고, 첫번째로 MSA에 대한 부분을 타겟으로 잡았습니다.

저도 아직 실무에 사용해본적은 없어서 자세한 내용은 모르지만, 간단하게 Spring Cloud에 대해서 이야기를 하자면 아래와 같습니다.

Spring Cloud는 Spring Cloud Reference 에 설명되어 있는것 처럼 분산 시스템 개발에 필요한 공통적인 패턴들을 모아서 사용하기 쉬운 스프링 라이브러리 형태로 제공하는 것들입니다.

예를 들면 환경설정 외부화와 관련이 있는 Config Server, Routing과 관련이 있는 Zuul이나 Gateway, 서비스를 등록하고 탐색하는 Discovery 역할을 하는 Eureka 등이 존재한다고 알고 있습니다.

우선은 환경설정(일반적으로 Config, Properties, Yml들을 말합니다)과 관련된 정보들을 외부화된 환경설정 서버로 따로 두는 Spring Cloud Config Server와 이 Config Server를 사용하는 애플리케이션인 Config Client에 대해서 실습해보고 정리해보려고 합니다.

관련 내용은 실습, 정리하는대로 다음 글에 작성해보겠습니다.

DDD와 Setter, Default Constructor에 대해서

Sun, 17 Feb 2019 00:00:00 +0000

회사에서 진행하고 있는 프로젝트에 DDD(Domain-Driven Design)를 적용하고, 코드리뷰를 진행하면서 몇 분들이 궁금해했던 내용에 대해서 정리를 해두려고한다.

1. JPA를 사용하는 Domain class에서 Setter 메소드를 만들지 않아도 되는가?

결론은 만들지 않아도 된다이다. JPA는 필드와 메서드 2가지 방식으로 매핑처리를 할 수 있다. 명시적으로 Domain에 @Access(AccessType.FIELD)을 써주지 않는다면 @Id나 @EmbbededId가 어디(필드 또는 get메소드)에 위치해 있느냐에 따라서 접근 방식을 결정한다. 그래서 명시적으로 @Access(AccessType.FIELD)를 써주거나, 필드에 @Id 애노테이션만 붙어있으면 Setter 메소드는 필요하지 않는다.

2. 기본생성자가 protected로 하면 오류가 발생하지 않는가?

기본생성자가 필요한 이유는 하이버네이트와 같은 JPA프로바이더는 DB에서 데이터를 읽어와 매핑된 객체를 생성할 때 기본생성자를 사용해서 객체를 생성하기 때문에 기본생성자는 꼭 추가해주어야 한다. 하지만, 기본 생성자를 다른 코드에서 사용하면 값이 없는 온전하지 못한 객체를 만들게 되므로, 다른 코드에서 기본 생성자를 사용하지 못하도록 proteced로 해주었다.

또 하이버네이트는 클래스를 상속한 프록시 객체를 이용해서 지연로딩을 구현하는데, 이 경우에 프록시 클래스에서 상위 클래스의 기본 생성자를 호출할 수 있어야 하므로 지연 로딩 대상이되는 @Entity, @Embeddable의 기본생성자는 private이 아닌 proteced로 지정해주어야한다.

출처 : DDD Start! - 도메인 주도 설계 구현과 핵심 개념 익히기 (지은이 최범균)

IntelliJ의 Http Client 사용하기

Mon, 21 Jan 2019 00:00:00 +0000

IntelliJ에서 제공하는 Http Client가 생각보다 편리해서 간단하게 사용하는 법만 정리해놓는다. 더 자세한 내용은 https://www.jetbrains.com/help/idea/http-client-in-product-code-editor.html 를 참고하면 될 것 같다.

1. actuator 추가하기

IntelliJ 2018.1 버전부터 추가된 기능인데, Controller의 @RequestMapping 기반으로 http 테스트를 자동으로 실행해주는 기능이 있다.

이 기능을 사용하기 위해서는 Spring Boot의 Actuator를 추가해주어야 한다.(Http Client 사용 자체는 Actuator를 추가하지 않아도 사용할 수 있다.)

gradle 기반으로 프로젝트를 생성했기 때문에 아래와 같이 build.gradle에 추가해주었다.

dependencies {
    ...
    compile('org.springframework.boot:spring-boot-starter-actuator')
}

그리고 Spring Boot 애플리케이션을 실행시키고 Controller에 들어가면 아래와 같이 왼쪽에 Run icon들이 생긴 것을 볼 수 있다.

2. Http Client 사용하기

사용하는 방법은 간단하다. 위에 생긴 초록색 Run icon을 클릭하면, 위의 이미지와 같이 3가지를 사용할 수 있다.

Run HTTP Request : 바로 실행이 되고, 결과는 아래와 같이 바로 볼 수 있다.
Open in HTTP Request Editor : 아래와 같이 HTTP Request Editor를 열어서 필요한 부분들을 추가, 수정하여 사용할 수 있다. 여기서는 새로운 Account를 저장하는 부분을 테스트하기 위해서 Content-Type하고, Request Body를 추가해서 실행하였고, 결과는 바로 아래에 보는 것과 같이 정상적으로 추가되었음을 알 수 있다.
Open in Browser : 브라우저에서 바로 실행한다.
File > New > HTTP Request 파일을 선택해서 .http 파일을 생성해서 직접 작성해 줄 수도 있다.

3. Http Client에 environment variables 사용하기

local, dev, st 환경에서 번갈아가면서 테스트할 때 꽤나 유용했다. http-client.env.json 파일을 생성하고, 아래와 같이 local, dev, st, production 등에서 사용할 정보들을 입력해준다

{
  "local": {
    "apiAddress" : "http://localhost",
    "username" : "localUser01",
    "password" : "password01"
  },

  "dev": {
      "apiAddress" : "http://dev.xxxxx.com",
      "username" : "devUser01",
      "password" : "password01"
    },
    
    ...
}	

그리고 Request Editor에서 아래와 같이 변경해주고 실행하게 되면, 사용할 environment를 선택할 수 있다.

그리고 응답을 받은 데이터를 .http의 변수에 저장하고, 다른 테스트에서 변수에 저장된 값을 사용할 수 있다. 예를 들면, 위의 /authorizationKey 요청을 통해서 아래와 같은 응답을 받는다고 가정해보자

{
  "returnCode": "200",
  "returnData": {
    "authorizationKey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"    
  }
}

이 응답에 존재하는 authorizationKey를 아래와 같이 변수에 저장할 수 있다.

authorizationKey 변수를 사용해서 다른 요청을 하는 방법은 아래와 같다.

4. file upload(2019.02.18 추가)

### file upload
POST http://localhost:8080/upload
Content-Type: multipart/form-data; boundary=WebAppBoundary

--WebAppBoundary
Content-Disposition: form-data; name="file"; filename="test.png"

< /Users/eomdev/Desktop/test.png
--WebAppBoundary--