• [ ] 🔥목표

  Spring Boot + JPA + Kafka with Kotlin

• [ ] 🐳Dockerizing를 통한 쉬운 배포와 테스트 환경구성

1. 코틀린이란?

   JetBrain에서 낳은 새로운 프로그래밍 언어이다. 특징으로는 Java 플랫폼에서 사용이 가능하며 Java를 대체할 수 있는 언어이다.

   1. 장점
      • 간결하고 실용적이다.
      • Java와 상호운용이 가능하다.
      • 다양한 플랫폼과 호환이 가능하며, JVM이 있는 곳이라면 어디서든 실행이 가능하다.
      • 안정성이 높다(치명적인 NullPointerException Error를 피할 수 있다.)
   2. 단점?

2. 코틀린의 철학

   • 실용성

     코틀린은 혁신적이고 새로운 기술로 만들어진 언어가 아니다. 기존에 우리가 사용하고 있고 성공한 프로그래밍 언어에서 채택한 이미 성공적으로 검증된 해법과 기능에 의존해서 만들어졌다. 그렇기 때문에 베이스가 된 언어(Java)를 잘 알고 있으면 빠르게 습득할 수 있다.

     그리고 어느 특정 프로그래밍 스타일이나 패러다임을 사용할 것으로 강제로 요구하지 않는다. 처음에는 Java에서 사용해 온 익숙한 기법을 사용하겠지만, 코틀린에 익숙해지고 강력한 특징을 발견하고 습득하게 되면 강력하게 좋은 간결한 코드를 탄생 시킬 수 있다.

     또한 코틀린을 세상에 낳은 사람들은 도구(IDE)를 만드는 사람들이기 때문에 도구에도 코틀린을 사용하는데 있어 편리성이 피팅되어 있다.

   • 간결성

     간결하다라는 의미는 그 언어로 작성된 코드를 읽을 때 의도를 쉽게 파악할 수 있는 구문 구조를 제공하고, 그 의도를 달성하는 방법을 이해할 때 방해가 될 수 있는 부가적인 준비 코드(ex. 클래스의 Getter, Setter, Constructor)가 적다는 뜻이다.

   • 안정성

     JVM에서 실행할 수 있다는 것부터가 안정성이 있다. 자바와 동일하게 정적 타입 지정 언어로 애플리케이션의 타입 안정성을 보장한다. 하지만 자바 보다 더 적은 비용으로 타입 안정성을 사용할 수 있다. 코틀린은 타입 추론(Type inference)을 이용해서 사용자가 타입을 지정하지 않아도 컴파일가 자동으로 데이터 타입을 추론하기 때문에 직접 타입 정보를 지정할 필요가 없다.

     코틀린은 NullPointerException을 없애기 위해 많은 노력을 한다. 컴파일 시점 검사를 통해 오류를 배제하고, null이 될 수 없는 값을 추척하며, 실행 시점에 NullPointerException이 발생할 수 있는 연산을 사용하는 코드를 금지한다.

   • 상호운용성

     코틀린은 자바와 상호운용이 가능하며, 변환 작업 없이 사용이 가능하다. 그리고 코틀린에서 자바의 API를 호출하여 사용가능하며 자바에서 유용하게 많이 사용되는 API의 경우 wrapper로 감싸 코틀린 방식대로 제공한다.(ex. 자바의 System.out.println()의 경우 println()로 제공한다.)

3. Hello Kotlin

   1. Statement(문장)과 Expression(표현식)의 구분

      코틀린에서 if는 표현식이지 문장이 아니다. 표현식은 값을 만들어 내며 다른 식의 하위 요소로 계산에 참여 할 수 있다. 반면 문장은 자신을 둘러싸고(중괄호{}) 있는 가장 안쪽 블록의 최상위 요소로 존재하며 아무런 값을 만들어내지 않는다는 차이 있다.

      아래 코드를 보면서 이야기해보자. 아래의 첫번째 코드는 코틀린의 if식이다. 자바와 다르게 제어 구조처럼 동작하는 것이 아니라 값을 만들어 낸다. 자바의 삼항 연산자와 유사하다.

      /* Kotlin if expression */
      fun main(args: Array<String>){
      	fun max(x: Int, y: Int){
      		return if(x > y) x else y
      }
      

      /* Java if statement */
      public int max(int x, int y){
        int result = 0;
      	if(x > y){
      		result = x;
      	}else{
      		result = y;
      	}
      }
      

   변수

   1. 변수선언

      val variableName: dataType = value
      val variableName = value 
      val variableName: dataType
      var variableName: dataType = value
      var variableName = value
      var variableName: dataType
      

      ---

      var과 val 두 키워드를 이용하여 변수를 선언할 수 있다. 이 둘의 차이점은 var의 경우 값을 할당한 후에 재할당이 가능하나, val를 재할당이 불가능하다.

      변수를 초기화하는 경우 타입을 정의하지 않아도 된다. 컴파일 시점에 컴파일러가 타입을 추론하여 타입을 지정한다.

      초기화 식(Expression)을 사용하지 않는다면 무조건 타입을 정적으로 지정해야 한다.

      // 주석처리는 Java의 문법과 동일하다.
      // var 변수이름: 데이터타입(대문자) = 값
      // var 변수이름 = 값
      var number: Int
      var number: Int = 42
      val number = 42
      var isBoolean: Boolean = true
      var ch: Char = 'C'
      val question = "삶, 우주, 그리고 모든 것에 대한 궁극적인 질물"
      val stringText = "Hello Kotlin"
      

   2. 타입 추론

      위에 예제 코드 중 stringText변수 처럼 변수 정의 시, 데이터 타입을 생략한다면 컴파일 시 할당된 값의 유형을 기반으로 타입을 추론할 수 있습니다.(Python의 데이터 타입 추론과 비슷한 것으로 보여집니다.)

      var k = "Hello Kotlin"
      println(k.toUpperCase()) // output: HELLO KOTLIN
      println(k is String)     // output: true
      

   3. Null 안전

      일부 다른 언어에서는 변수 선언 시, 초기 값을 명시적으로 제공하지 않고 참조형으로 변수를 선언할 수 있다. 그렇게 되면 기본적으로 null 값이 할당되는데 Kotlin 변수는 기본적으로 null 값 할당이 불가능하다. 그렇기때문에 NullPointerException이 발생하지 않는다.

      그러나, Null 값으로 할당을 해야하는 경우가 있다. 이때 우리는 nullable type의 변수를 사용하면 된다. 문법의 형식은 아래의 예제처럼 변수명 뒤에 ?(물음표, 엘비스)연산자를 붙여서 선언하면 nullable type으로 변수를 선언 할 수 있다.

      var notNullAble = null // Fails to compile
      var nullAble? = null // Success to compile
      

함수(Function)

코틀린답게 함수 정의하기

• 이름 있는 인자
  • println(joinToString(list,separator=";",prefix="(", postfix=")"))
• 디폴트 파라미터 값
  • separator: String =', ', prefix: String = '', postfix: String = '',

이름 있는 인자와 디폴트 파라미터를 사용하면 오버로딩(Overloading)을 더 적게 사용할 수 있다. 그렇게 되면 중복을 더욱더 많이 제거 할 수 있고 가독성을 높일 수 있다.

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()
}

val list = listOf(1,2,3)
println(joinToString(list,separator=";",prefix="(", postfix=")"))

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

정적인 유틸리티 클래스란? 우리가 프로젝트 진행 시 공통으로 자주 사용하는 기능을 모아서 정의하는 클래스를 말한다. 보통 Utils라는 클래스를 이름 갖는다.

코를린에서는 이런 무의미한 클래스가 필요 없다. 대신 함수를 직접 소스 파일의 최상위 수준, 모든 다른 클래스의 밖에 위치시키면 된다.

자바의 경우, 무조건 클래스 내부에 함수나 프로퍼티를 선언해야하지만, 코틀린은 그렇지 않아도 된다. Javascript 문법과 유사하게 파일 최상위 수준에 선언을 할 수 있다. 그렇게 하므로써 필요하지 않는 클래스를 선언하지 않을 수 있다.

함수

문법

fun 키워드를 사용해서 함수이름을 정의하고 파라미터와 리턴 타입을 선언해주면 된다.

fun FUNCTION_NAME(params1: paramsType, params2: paramsType, ... )
	: RETURN_TYPE {
	// Functino Body
}

순수 함수

항상 동일한 결과 값을 return하는 함수

고차 함수

인자(or 매개변수)로 함수(function or lambda function)를 전달받는 함수

람다 함수

익명함수 or 이름이 없는 함수

람다는 기본적으로 다른 함수에 널길 수 있는 작은 코드 조각을 뜻한다. 람다를 사용하면 쉽게 공통 코드 구조를 라이브러리 함수로 뽑아낼 수 있다.

수신 객체 지정 람다(Lambda with receiver)

일련의 동작을 변수에 저장하거나 다른 함수에 넘겨야 하는 경우가 자주 있다. 함수형 프로그래밍에서는 함수를 값처럼 다루는 접근 방법을 택함으로써 이 문제를 해결한다. 클래스의 인스턴스를 함수에 넘기는 대신 함수를 직접 다른 함수에 전달할 수 있다. 이렇게 람다를 사용하면 코드가 더욱 더 간결해진다.

람다식 문법

위에서도 말했지만, 람다는 값처럼 여기저기 전달할수 있는 동작의 모음이다. 람다를 따로 선언해서 변수에 저장할 수 있다. 하지만, 함수에 인자로 넘기면서 바로 람다를 정의하는 경우가 대부분이다.

람다식 선언방법

람다 식은 항상 중괄호({ Lambda Expression })로 둘러싸여 있다. 인자 목록 주변에 괄호가 없다는 사실을 기억해라. 화살표(Arrow) 키워드가 함수의 인자와 본문을 구분해준다. 그리고 아래의 예제처럼 람다 식의 본문이 한 줄일 경우, 그 줄이 람다의 결과 값이 된다. 만약 여러 줄이 있다면 맨 마지막에 있는 식이 람다의 결과 값이 된다.

인자가 있는 람다 함수 : { x: Int, y: Int -> x + y }

람다를 정의 할 때는 인자에 소괄호를 쓰지 않지만, 인자로 함수를 받는 함수를 정의하는 경우에는 소괄호를 붙여서 정의를 해야한다.

아래 예제 코드를 보면, 람다 식을 인자로 받아서 앞서 할당받은 인자의 값을 처리하는 방식이다. 아마도 이런 식으로 코드를 작성한다면 “계산기” 코드가 더 심플해질 수 있지 않을까 싶다.

fun calculated(a: Int, b: Int, block: (Int, Int) -> Int) {
	block(a, b)
}
calculated(1, 2) { x, y -> x + y }

람다를 정의하고 바로 호출해야하는 경우, 람다 본문을 직접 실행하는 편이 낫고, 코드의 일부분을 블록으로 둘러싸 실행할 필요가 있다면 run 함수를 사용하자.

run는 인자로 받은 람다를 실행해 해주는 kotlin의 라이브러리 함수 이다.

run({ prinlnt(42) }
/* Or */
run { println(42) }

람다의 기본적인 문법에 대해서 알아봤다. 이제 람다 식을 더 심플하게 사용할 수 있는 문법 관습을 알아보자.

1. 인자의 타입을 명시하지 않아도 된다. → 컴파일러가 람다 식의 파라미터도 추론 할 수 있다.
2. 람다의 파라미터 이름을 디폴트 이름인 it으로 사용할 수 있다. → 인자가 단 하나뿐이고, 컴파일러가 타입을 추론 할 수 있다면 디폴트명(it)을 사용할 수 있다.
3. 함수 호출 시 맨 뒤에 있는 인자가 람다 식이라면 그 람다를 괄호 밖으로 빼낼 수 있는 문법 관습이 있다.

최종 람다식을 이용한 예제

모든 컬렉션에 대해 maxByOrNull 함수를 호출할 수 있다. 해당 함수는 가장 큰 원소를 찾기 위해 비교에 사용할 값을 돌려주는 함수를 인자로 받는다.

중괄호로 둘러싸인 코드 { it.age } 는 바로 비교에 사용할 값을 리턴해주는 함수이다. 이 코드는 컬렉션의 원소를 인자로 받아서 비교에 사용할 값을 리턴한다.

data class Person(val name: String, val age: Int)
fun main(args: Array<String>) {
    val people = listOf(Person("Jin ho Yoo", 33), Person("Yeji Lim", 29))
    val maxAge = people.maxByOrNull { it.age }
    /*
    * people.maxByOrNull({p: Person -> p.age})
    *  */
    println("Max Age is $maxAge")
}

클로저(Closuer)

람다를 실행 시점에 표현하는 데이터 구조는 람다에서 시작하는 모든 참조가 포함된 닫힌(Closed) 객체 그래프를 람다 코드와 함께 저장해야 한다. 그런데 데이터 구조를 클로저(Closure)라고 부른다. 함수를 쓸모 있는 1급 시민으로 만들려면 포획한 변수를 제대로 처리해야하 고, 포획한 변수를 제대로 처리하려면 클로저가 꼭 필요하다.

확장 함수

말 그대로 확장(extend)하는 함수.

클래스 정의 밖에서 선언된 클래스에 함수(Member Method)를 새롭게 추가한 함수를 말한다. 이 개념? 규칙?을 통해서 기존 자바의 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 자유롭게 사용할 수 있다.

코틀린 문법의 가장 핵심적인 요소 중 하나이며, 자바 보다 더 아름답게 코드를 작성할 수 있는 요소 중 하나라고 생각된다.

클래스 이름을 수신 객체 타입이라 부르며, 확장함수가 호출되는 대상이 되는 값(객체, Object)은 수신 객체(Receiver Object)라고 부른다.

확장함수를 선언하면 해당 클래스의 멤버 메소드로 정의되면 확장함수 내부에서 다른 멤버 메서드를 호출할 수 있다. 단, 클래스의 프로퍼티 캡슐화는 깰 수 없다. 클래스 내부에서만 접근이 허용되는 private이나 protected member에는 접근이 불가능하다.

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

가변 길이 인자

• vararg 키워드를 사용하면 인자(Arguments) 개수가 달라질 수 있는 함수를 정의 할 수 있다.

  • 컬렉션 중 List 객체를 생성하는 listOf() 함수로 예시 코드를 작성해보자. 라이브러리에서 이 함수의 정의를 다음 과 같다. fun listOf<T> (vararg values: T): List<T> { ... } 자바의 문법과 다른 점은 파라미터 앞에 vararga 변경자를 붙이는게 다른 점이다.

    val strings: List<String> = listOf("first", "second", "third")
    

  • 만약 가변 인자로 배열(Array)를 전달하는 경우 스프레드 연산자를 이용해서 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 해야한다. 문법은 실제로 전달하려는 배열 앞에 *를 붙이기만 하면 된다.

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

중위 함수

• 중위 함수 호출 구문을 사용하면 인자가 하나뿐인 메소드를 간편하고 아름답게 호출할 수 있다.

  val map_full = mapOf(1.to("one") ...);
  
  // 중위함수 표현
  val map = mapOf(1 to "one", 2 to "two", 3 to "three");
  

구조 분해 선언(destructuring declaration)

• 복합적인 값을 분해해서 여러 변수에 나눠서 담을 수 있다.

  val (key, value) = 1 to "one"
  print(key, value) // output key is 1 value is one