코틀린 컬렉션은 자바 컬렉션과 똑같은 클래스이다. 표준 자바 컬렉션을 활용하면 자바 코드와 상호 작용하기 훨씬 더 쉽다. 각각의 언어에서 호출할 때, 컬렉션을 서로 변환할 필요가 없다.

But, 코틀린에서는 자바보다 더 많은 기능을 쓸 수 있다.

val strings = listOf ("first”, "second”, ”fourteenth")
printin (strings. last ()) // fourteenth

val numbers = setOf (1, 14, 2)
printin (numbers.max())  // 14

3.2 함수를 호출하기 쉽게 만들기

자바 컬렉션에는 기본적으로 toString 구현이 들어있다. 코틀린을 이용해서 joinTostring 함수 구현하기

// joinToString() 함수의 초기 구현
//<T> 제네릭 타입
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()
}

3.2.1 이름 붙인 인자

코틀린에서는 함수를 호출할 때, 인자에 이름을 붙여서 호출이 가능하다.

호출시 인자 중 어느 하나라도 이름을 명시한다면, 혼동을 막기 위해 그 뒤에 오는 모든 이니자의 이름을 꼭 명시해야한다.

fun main() {
    val list = listOf(1, 2, 3)
    println(joinToString(list, ";", "(", ")"))

// 이름을 붙인 인자
    println(joinToString(list, separator = ";", prefix = "(", postfix = ")"))
}

3.2.2 디폴트 파라미터 값

자바에서는 일부 클래스에서 오버로딩한 메소드가 너무 많다. 그렇기 때문에 개발자들이 반복적인 설명 주석을 달아야하는 경우가 많다.

코틀린에서는 함수를 선언할 때, 파라미터의 디폴트 값을 지정할 수 있어서, 이런 오버로드를 피할 수 있다.

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

println(joinToString(list, ";", "(", ")"))
println(joinToString(list))
println(joinToString(list, "; "))

자바에는 디폴트 파라미터 값이라는 개념이 없다. 코틀린 함수를 자바에서 호출하라 경우, 코틀린 함수가 디폴트 파라미터 값을 제공하더라고 모든 인자를 명시해야 한다.

자바에서 코틀린 함수를 자주 호출해야한다면, @JvmOverloads 애노테이션을 함수에 추가

@JvmOverloads 를 추가하면, 코틀린 컴파이리러가 자동으로 맨 마지막 파라미터부터 파라미터를 하나씩 생략한 오버로딩한 자바 메소드를 추가해준다.

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

자바에서는 모든 코드를 클래스의 메소드로 작성해야하는 데, 실전에서는 어느 한 클래스에 포함하기 어려운 코드들이 많다. 그래서 Utill 클래스를 만들기도 한다.

하지만, 코틀린에서는 이런 고민을 할 필요가 없다.

→ 함수를 직접 소스파일의 최상위 수준, 모든 다른 클래스의 밖에 위치시키면 된다.

• JVM은 새로운 클래스로 정의해주며, Java와 비교하자면 ... static 함수로 선언

package strings;

public class JoinKt {
        public static String joinToString (. . .) { ... }
}

최상위 프로퍼티

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

이런 프로퍼티 값은 정적 필드에 저장된다.

val opCount=0   // 최상위 프로퍼티 선언

fun performOperation() {
    opCount++   // 최상위 프로퍼티 값 변경
  // ...
}

fun reportOperationCount() {
  println("Operation performed $opCount times")  // 최상위 프로퍼티 값 읽기
}

const 키워드를 사용하면 java의 상수, public static final 필드로 컴파일하게 만들 수 있다. (단, primitive type과 String 타입의 프로퍼티만 가능)

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

확장함수란 ?

• 어떤 클래스의 멤버 메소드처럼 호출할 수 있지만, 클래스 밖에서 선언된 함수
• 확장함수를 만들려면 추가하려는 함수 이름 앞에 그 함수가 확잘할 클래스의 이름을 덧붙인다.
• 클래스 이름을 수신 객체 타입, 확장 함수가 호출되는 대상이 되는 값을 수신 객체

package strings
fun String.lashChar(): Char = this.get(this.length - 1)

println("Kotlin".lastChar())

String이 수신 객체 타입, “Kotlin”이 수신 객체

• 확장 함수 내부에서는 수신 객체의 메소드나 프로퍼티를 사용할 수 있다.
• but, 캡슐화는 지킨다 → 클래스 내부에서만 사용할 수 있는 private 멤버나 protected 멤버를 사용할 수 없다.

3.3.1 임포트와 확장 함수

확장 함수를 사용하기위해서는 import를 해줘야만 한다.

코틀린 문법상 확장 함수는 반드시 짧은 이름을 써야한다. import 할 때 이름을 바구는 것이 확장 함수 이름을 충돌할 수 있는 유일한 방법이다.

import strings.lastChar
// import strings.*
// import string.lastChar as last   // 별칭 사용 가능

val c = "Kotlin".lastChar()
// val c = "Kotlin".last()

3.3.2 자바에서 확장 함수 호출

확장함수는 수신 객체를 첫번째로 받는 정적 메소드이다. 이런 설계로 확장 함수를 자바에서 사용하기 편하다. 확장함수를 StringUtil.kt 파일에 정의했다면 다음과 같이 호출할 수 있다.

char c = StringUtilKt.lastChar("Java");

3.3.3 확장 함수로 유틸리티 함수 정의

joinsToString 함수 확장함수로 만들어서 코틀린 라이브러리가 제공하는 함수처럼 만들기

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

fun main() {
    val list = listOf(1, 2, 3)
    println(list.joinToString("; ", "(", ")"))
        // (1; 2; 3)
}

확장 함수는 단지 정적 메소드 호출에 대한 문법적인 편의일 뿐이다. 클래스가 아닌 더 구체적인 타입을 수신 객체 타입으로 지정할 수 있다.

따라서 문자열의 컬렉션에 대해서만 호출할려면 다음과 같이 정의하면 된다.

fun <String>.joinToString(
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
) = joinToString(separator, prefix, postfix)

fun main() {
    printin (listOf ("one", "two", "eight").join (" "))
        // (1; 2; 3)
}

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

확장함수는 정적 메소드 (static)특징을 가지고 있기 때문에 오버라이드를 할 수 없다.

3.3.5 확장 프로퍼티

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

하지만, 기존 클래스의 프로퍼티처럼 완벽한 프로퍼티의 기능을 지원하지는 못한다.

• 확장 프로퍼티는 아무런 상태를 가질 수 없다.
• 최소한의 getter는 꼭 정의해야한다.
• 초기화 코드를 쓸 수 없다.

// 확장 프로퍼티 선언
val String.lastChar: Char
    get() = get(length - 1 )

// 변경 가능한 확장 프로퍼티 선언
var StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }

val sb = StringBuilder("Kotlin?")
    sb.lastChar = '!'
    println(sb) // Kotlin!

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

3.4.1 자바 컬렉션

코틀린은 자바 컬렉션 라이브러리를 확장해서 사용한다.

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

//리스트 함수는 원하는 만큼 원소를 인자 값으로 전달할 수 있다.
val lislt = listOf(2, 3, 5, 7, 11)

fun listOf<T>(vararg values: T): List<T> {...}

자바의 가변길이 인자 → 키워드 ... ex) String ...str

코틀린의 가변길이 인자 varargs ex ) vararg values : T

이미 배열에 들어있는 원소를 가변 길이 인자로 넘길 때

자바의 경우 → 배열을 그냥 넘긴다.

코틀린의 경우 → 배열을 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 한다. 스프레드 연산자 사용 *

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

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

중위 호출 : to

수신객체 (공백) to

인자가 하나뿐인 일반 메소드, 인자가 하나뿐인 확장 함수에 중위호출 사용 가능

함수에 infix 키워드를 붙이면, 중위 호출해서 사용 가능하다.

val map = mapOf(1 to "one", 2 to "two", 3 to "three")

1.to("one")  // 'to' 메소드 일반적인 호출 방식
2.to "two"  // 'to' 메소드를 중위 호출 방식으로 호출

infix fun Any.to(other: Any) = Pair(this, other)
val (number, name) = 1 to "one"  // 구조분해

for((index, element) in collection.withIndex()){
    println("$index: $element")
}

참고 : Pair 는 코틀린의 표준 라이브러리

to 함수를 이용해서 순서쌍을 만든다음 구조 분해를 통해, 그 순서쌍을 풀었다.

출처 : (서적) Kotlin in Action 드미트리 제메로프, 스베트라나 이사코바 저자 /오현석 옮김

2.1.1 Hello, World !

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

• 함수를 선언할 때 fun 키워드 사용
• 파라미터 이름 뒤에 그 파라미터의 타입을 쓴다.
• 함수를 최상위 수준에 정의 가능/ 자바와 달리, 꼭 클래스 안에 함수를 넣을 필요가 없다.
• 배열도 일반적인 클래스, 코틀린에는 자바와 달리 배열 처리를 위한 문법이 따로 없다.
• System.out.println대신에 println 이라고 쓴다.
• 끝 줄에 세미콜론 생략 가능하다.

2.1.2 함수

✅ 문(statement)와 식(expression)의 구분

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

코틀린에서 if는 식이다. (문이 아니다.) 자바에서는 모든 제어 구조가 문(statement)이지만, 코틀린에서는 Loop를 제외하면 대부분 제어 구조가 식(expression)이다.

반면, 대입문은 자바에서는 식이었으나, 코틀린에서는 문(statement)이다.

식이 본문인 함수

// 블록이 본문인 함수
fun maxEx1(a: Int, b: Int) : Int {
    return if (a > b) a else b
}

// 식이 본문인 함수
fun maxEx2(a: Int, b:Int) : Int = if (a>b) a else b

// 반환 타입을 생략한 함수
fun maxEx3(a: Int, b:Int) = if (a>b) a else b

• 블록이 본문인 함수 : 본문이 중괄호로 둘러싸인 함수

• 식이 본문인 함수 : 등호와 식으로 이뤄진 함수

• 반환 타입을 생략할 수 있는 이유 (식이 본문인 함수의 반환 타입만 생략 가능)

  코틀린은 정적 타입 지정 언어 이므로 컴파일 시점에 모든 식의 타입을 지정해야한다. 하지만 식이 본문이니 함수의 경우, 굳이 반환 타입을 적지 않아도 컴파일러가 함수 본문 식을 분석해서 결과 타입을 함수 반환 타입으로 정해준다. → 타입 추론이 가능하다.

2.1.3 변수

// 타입 생략
val answer = 42
// 타입 명시
val answer: Int = 42

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

• val : immutable한 참조를 저장하는 변수

  val로 선언된 변수는 일단 초기화 하고 나면 재대입 불가능, java의 final과 같다.

• var : mutable 참조, 변수의 값이 바뀔 수 있다. 자바의 일반 변수에 해당

기본적으로 모든 변수는 val, 불변 변수로 선언하고 추후 필요에 따라 var 로 변경하는 것을 추천한다.

immutable한 참조와 immutable한 객체를 부수 효과가 없는 함수와 조합해 사용하면, 코드가 함수형 코드에 가까워진다.

• val 참조 자체는 불변이지만, 그 참조가 가리키는 객체의 내부 값은 변경될 수 있다.

val languages = arrayListOf("Java")   // 불변 참조를 선언
languages.add("Kotlin")   // 참조가 가리키는 객체 내부 변경

• var 키워드를 사용하면 변수 값 변경 가능, 변수 타입은 고정되어서 바뀌지 않는다.

컴파일러는 변수 선언 시점의 초기화 된 식으로부터 변수의 타입을 추론, 변수 재대입이 이뤄질 때, 이미 먼저 추론한 변수 타입으로 컴파일한다.

// Error : type mismach 발생 - 컴파일 오류
var answer = 123;
answer = "hello world"

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

// 문자열 템플릿 사용
fun main(args: Array<String>) {
    val name = if(args.size > 0) args[0] else "Kotlin"
    println("Hello, $name!")

    if(args.size > 0){
        println("Bye, ${args[0]}")   // args 배열의 원소를 넣기 위해${} 구문 사용
    }

    println("\$")  // 달려 표시 ($)를 쓸 경우에는 이스케이프(\) 사용

}

• 코틀린에서도 변수를 문자열 안에 사용할 수 있다. → 문자열 리터럴이 필요한 곳에 $변수명

• 한글과 문자 템플릿 사용할 경우 주의 점

  • 코틀린은 자바와 마찬가지로 변수 이름에 한글이 들어갈 수 있다. (모든 유니코드 문자는 변수명 사용 가능)

  • 문자열 템플릿 안에 $name님, 반가워요 처럼 “$변수명”과 한글을 붙여서 사용할 경우, 컴파일 에러가 발생한다. 코틀린 컴파일러가 영문자와 한글을 한꺼번에 식별자로 사용해서 그렇다.

    → ${name}님, 반가워요 변수 명을 {}로 감싸라, 평소에소 {}로 감싸서 사용하는 것이 가독성에 좋다.

2.2 클래스와 프로퍼티

// Java Person 클래스
public class Person {
    private final String name;

    public String getName() {
        return name;
    }

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

Java의 경우 필드가 늘어날 수록 생성자의 파라미터 개수도 늘어나게 된다. 즉 반복적으로 늘어나는 코드가 많아진다.

// 코틀린으로 변환한 Person 클래스
class Person (val name : String)

• 코틀린의 접근제어자는 기본이 public 이다. 따라서 생략 가능하다.

2.2.1 프로퍼티

자바에서는 필드와 접근자를 한데 묵어 Property라고 부른다. 코틀린 프로퍼티는 자바의 필드와 접근자 메소드를 완전히 대신한다.

class Person(
    val name: String,   // private 변수, 읽기 전용, 단순한 공개 getter만 만들어낸다.
    var isMarried: Boolean  // private 변수, 공개 getter, 공개 setter 만들어낸다.
)

val person = Person("Bob", true)  // new 키워드 사용 안하고 생성자 호출
// 프로퍼티 이름을 직접 사용해도 코틀린이 자동으로 getter 호출
println(person.name)
println(person.isMarried)

2.2.2 커스텀 접근자

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() {
            return height == width
        }
            // get() = height == width
}

isSquare 프로퍼티는 자체 구현을 제공하는 getter가 존재

클라이언트가 프로퍼티에 접근할 때, get() 에 해당하는 로직으로 프로퍼티 값을 매번 다시 계산한다.

파라미터가 없는 함수를 정의하는 방식과 커스텀 getter를 정의하는 방식은 구현이나 성능상 차이는 없다.

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

모든 코틀린 파일의 맨 앞에는 package문을 넣을 수 있다. 같은 패키지에 속해 있다면 다른 파일에서 정의한 선언일지라고 직접 사용 가능

반면, 다른 패키지에서 정의한 선언을 사용하려면 import를 통해 선언

// 클래스와 함수 선언을 패키지에 넣기
package geometry.shapes

import java.util.*

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() = height == width
}

fun createRandomRectangle(): Rectangle {
    val random = Random()
    return Rectangle(random.nextInt(), random.nextInt())
}

// 다른 패키지에 있는 함수 임포트하기
package geometry.shapes.createRandomRectangle

fun main(args: Array<String>) {
    println(createRandomRectangle().isSquare)
}

자바와 같이 패키지별로 디렉터리를 구성하는 편이 낫다. 특히, 자바와 코틀린을 함께 사용하는 프로젝트에서는 자바 방식을 따르는 게 중요하다.

2.3 선택 표현과 처리 : enum과 when

2.3.1 클래스 정의

// 간단한 enum 클래스
enum class Color {
    RED, ORANGE, YELLOW, GREEN, INDIGO, VIOLET
}

Java에서는 enum으로 선언, 코틀린에서는 enum class 로 선언

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

enum class Color(val r: Int, val g: Int, val b: Int)   // 상수 프로퍼티 정의
{  

    RED(255, 0, 0),
    ORANGE(255, 165, 0),
    YELLOW(255, 255, 0),
    GREEN(0, 255, 0),
    BLUE(0, 0, 255),
    INDIGO(75, 0, 130),
    VIOLET(238, 130, 238);    // 반드시 세미콜론으로 종료

    fun rgb() = (r * 256 + g) * 256 + b  // enum 클래스 안에 메소드 정의
}

fun main() {
    println(Color.BLUE.rgb())
}

2.3.2 when으로 enum 클래스 다루기

fun getMnemonic(color: Color) =
 when (color) {   // 함수 반환 값으로 when 식을 사용
    Color.RED -> "Rechard"
    Color.ORANGE -> "Of"
    Color.YELLOW -> "York"
    Color.GREEN -> "Grave"
    Color.BLUE -> "Battle"
    Color.INDIGO -> "In"
    Color.VIOLET -> "Vain"
}

fun getWarmth(color: Color) = when (color) {
    Color.RED, Color.ORANGE, Color.YELLOW -> "warm"
    Color.GREEN -> "neutral"
    Color.BLUE, Color.INDIGO, Color.VIOLET -> "cold"
}

fun main() {
    println(getMnemonic(Color.BLUE))
    println(getWarmth(Color.ORANGE))
}

자바와 달리 각 분기 끝에 break 를 넣지 않아도 된다.

한 분기 안에 여러 값을 매치 패턴으로 사용할 경우, 콤마(,)로 구분한다.

enum 상수 값을 import 해서 enum 클래스 수식자 없이 enum을 사용 가능하다.

import ch2.Color.*

fun getMnemonic(color: Color) = when (color) {
    RED -> "Rechard"
    ORANGE -> "Of"
    YELLOW -> "York"
    GREEN -> "Grave"
    BLUE -> "Battle"
    INDIGO -> "In"
    VIOLET -> "Vain"
}

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

자바의 swtich와 달리 코틀린 when 의 분기 조건은 임의의 객체를 허용한다.

fun mix(c1: Color, c2: Color) =
    // when 식의 인자로 아무 객체나 사용 가능, when은 받은 인자 객체가 각 분기 조건에 있는 객체와 같은지 테스트
    when (setOf(c1, c2)) {
        setOf(RED, YELLOW) -> ORANGE
        setOf(YELLOW, BLUE) -> GREEN
        setOf(BLUE, VIOLET) -> INDIGO
        // 매치되는 분기 조건이 없으면 이 문장 실행
        else -> throw Exception("Dirty color")
    }

• setOf 함수 란?

  인자로 전달받은 여러 객체를 그 객체들을 포함하는 집한인 Set 객체로 만드는 함수,

  Set은 원소가 모여있는 컬렉션으로 각 원소의 순서는 중요하지 않다.

2.3.4 인자 없는 when 사용

when에 아무 인자도 없으려면 각 분기의 조건이 불리언 결과를 계산하는 식이어야 한다.

fun mixOptimized(c1: Color, c2: Color) =
    // when 에 아무 인자가 없다.
    when {
        (c1 == RED && c2 == YELLOW) ||
                (c1 == YELLOW && c2 == RED) -> ORANGE
        (c1 == YELLOW && c2 == BLUE) ||
                (c1 == BLUE && c2 == YELLOW) -> GREEN
        (c1 == BLUE && c2 == VIOLET) ||
                (c1 == VIOLET && c2 == BLUE) -> INDIGO
        else -> throw Exception("Dirty color")
    }

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

( 1 + 2 ) + 4 와 같은 산술식을 계산하는 함수를 만들어 보자.

// 식을 위한 인터페이스
interface Expr

// value라는 프로퍼티만 존재하는 단순한 클래스, Expr 인터페이스를 구현
class Num(val value: Int) : Expr

// Expr 타입의 객체라면 Sum 연산의 인자가 될 수 있다.
// 따라서, Num이나 다른 Sum이 Sum의 인자로 올 수 있다.
class Sum(val left: Expr, val right: Expr) : Expr

// Java 스타일
// if 사용해서 식 계산
fun eval(e: Expr): Int {
    if (e is Num) {
        val n = e as Num
        return n.value
    }
    if (e is Sum) {
        // 변수 e 에 대해 스마트 캐스트를 사용한다.
        return eval(e.right) + eval(e.left)
    }

    throw IllegalArgumentException("Unkown expression")
}

Expr은 식을 위한 인터페이스

Sum, Num 클래스는 Expr 인터페이스를 구현하는 클래스

코틀린에서는 is 를 사용해서 변수 타입을 검사 (Java의 instanceof 와 유사)

• 하지만 Java에서는 instanceof 로 변수타입 확인 후, 그 타입에 속한 멤버에 접근하기 위해서는 개발자가 명시적으로 타입 캐스팅이 필요
• 코틀린에서는 is 로 검사한 후, 참이면, 컴파일러가 알아서 캐스팅 해준다. → Smart Cast
• 스마트 캐스트는 is 로 변수에 든 값의 타입을 검사한 다음, 그 값이 바뀔 수 없는 경우에만 동작

명시적으로 타입 캐스팅 하려면 as 키워드를 사용 → val n = e as Num

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

코틀린의 if는 식 → 값을 반환한다. 값을 만들어 낸다.→ 따라서 자바와 달리 3항 연산자가 따로 없다.

Java의 if는 문 → 값을 반환하지 않는다.

// 값을 만들어내는 if 식

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

// if 중첩 대신 when 사용하기
fun eval(e: Expr): Int =
    when (e) {
        is Num -> e.value  // 인자 타입을 검사하는 when 분기에서 스마트 캐스트 됨
        is Sum -> eval(e.left) + eval(e.right)
        else -> throw IllegalArgumentException("Unkown expression")
    }

2.3.7 if와 when의 분기에서 블록 사용

if나 when 모두 분기에 블록 사용 가능 → 블록의 마지막 문장이 블록 전체의 결과가 된다.

fun evalWithLogging(e: Expr): Int =
    when (e) {
        is Num -> {
            println("num: ${e.value}")
            e.value   // 블록의 마지막 식이므로 e.value가 반환된다.
        }
        is Sum -> {
            val left = evalWithLogging(e.left)
            val right = evalWithLogging(e.right)
            println("sum: $left + $right")
            left + right
        }
        else -> throw IllegalArgumentException("Unkown expression")
    }

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

2.4.1 while 루프

// 조건이 참인 동안 본문 반복 실행
while(조건) {
    /*....*/
}

// 맨 처음 무조건 본문 한번 실행 후, 조건이 참인 동안 본문 반복 실행
do{
    /*....*/
} while(조건)

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

코틀린은 자바의 for 루프에 해당하는 요소가 없다.

val oneToTen = 1..10 // 양 끝 구간 포함, 1 ~ 10

fun fizzbuxx(i: Int) =
    when {
        i % 15 == 0 -> "FizzBuzz "
        i % 3 == 0 -> "Fizz "
        i % 5 == 0 -> "Buzz "
        else -> "$i "
    }

for (i in 1..100) {
        println(fizzbuxx(i))
    }

    for (i in 100 downTo 1 step 2){
        print(fizzbuxx(i))
    }

step : 증가값

downTo : 역방향

.. : 항상 범위의 끝 포함

until : 끝 값 포함 하지 않음 → for(x in 0 until size) or for (x in 0 .. size-1)

2.4.3 맵에 대한 이터레이션

// A ~ F 까지 문자 범위 이터레이션
for(c in 'A'..'F'){
    // 아스키 코드를 2진 표현으로 변경
    val binary = Integer.toBinaryString(c.toInt())
    // c를 키로 c의 2진 표현을 맵에 넣는다.
    binaryReps[c] = binary  // 자바의 map put 과 유사: binaryReps.put(c, binary)
}

// 맵에 대한 이터레이션, 맵의 Key와 Value를 두 변수에 대입
for((letter, binary) in binaryReps) {
    println("$letter = $binary")
}

val list = arrayListOf("10", "11", "1001")

// 인덱스와 함께 컬렉션을 이터레이션 한다.
for ((idx, element) in list.withIndex()){
    println("$idx: $element")
}

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

in 연산자 : 어떤 값이 범위에 속하는 지 확인

!in 연산자 : 어떤 값이 범위에 속하지 않는 지 확인

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

println(isLetter('q'))      // true
println(isNotDigit('x'))    // true

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

println(recognize('8'))     // It's a digit!

비교가 가능한 클래스(java.lang.Comparable 인터페이스를 구현한 클래스)라면 그 클래스의 인스턴스 객체를 사용해 범위를 만들 수 있다.

2.5 코틀린의 예외 처리

코틀린의 기본 예외 처리 구문은 자바와 유사

예외 인스턴스를 만들 때 new 키워드를 붙일 필요가 없다.

자바와 달리 코틀린의 throw는 식이므로, 다른 식에 포함이 가능

val percentage =
    if (number in 0..100)
        number
    else
                // throw는 식이다. -> 값을 만들어낸다.
        throw IllegalArgumentException("A percentage value must be between 0 and 100: $number")

2.5.1 try, catch, finally

fun readNumber(reader: BufferedReader): Int? {
    try {
        val line = reader.readLine()
        return Integer.parseInt(line)
    } catch (e: NumberFormatException) {
        return null
    } finally {
        reader.close()
    }
}

Java 코드와 가장 큰 차이는 throws 절에 코드가 없다는 점

• Java에서는 함수를 작성할 때, 함수 선언 뒤에 throws IOException을 붙여야한다.

  → IOException이 Checked Exception이기 때문, 자바에서는 Checked Exception을 명시적으로 처리해야한다.

  → 어떤 함수가 던질 가능성이 있는 예외나 그 함수가 호출한 다른 함수에서 발생할 수 있는 모든 예외를 모두 catch 로 처리해야 하며, 처리하지 않은 예외는 throws 절에 명시

코틀린도 다른 최신 JVM 언어 처럼 Checked Exception, UnChecked Exception을 구별하지 않는다. (자바는 Checked Exception 처리를 강제한다.)

2.5.2. try를 식으로 사용

코틀린의 try 키워드는 식이다. → 값을 만들어낸다.

따라서 try 의 값을 변수에 대입할 수 있다. try는 if와 달리 중괄호 {}로 둘러싸야한다.

fun readNumber(reader: BufferedReader) {
        // 예외가 발생하지 않으면, 이 값을 사용
    val number = try {
        Integer.parseInt(reader.readLine())
    } catch (e: NumberFormatException) {
        // return //catch 블록 다음 코드는 실행 되지 않음
        null      // 예외가 발생하면 null값을 사용
    }
    println(number)
}

출처 : (서적) Kotlin in Action 드미트리 제메로프, 스베트라나 이사코바 저자 /오현석 옮김

프로듀서가 데이터가 데이터를 전송할 때 내부적으로 처리되는 단계는 다음과 같다.         

• 1. 카프카에 쓰려는 메시지를 갖는 ProducerRecord를 생성 (전송할 토픽과 값을 포함, 선택적으로 Key 값과 파티션 지정 가능)
• 2. 메세지 객체들이 네트워크로 전송될 수 있도록 바이트 배열로 직렬화  진행, 직렬처리기(serializer)와 컴포넌트(클래스)가 처리
• 3. 해당 데이터는 파티셔너와 컴포넌트(클래스)에 전달

파티션 지정 않았다면, ProducerRecord의 키를 기준으로 파티셔너가 하나의 파티션 선택 파티션이 선택되면 해당 레코드(ProducerRecord 객체)의 메시지가 저장될 토픽과 파티션을 프로듀서가 알게됨 토픽과 파티션으로 전송될 레코드들을 모은 레코드 배치 추가, 별개의 스레드가 그 배치를 카프카 브로커에 전송

• 4. 브로커 수신된 메시지 처리 후 응답

성공 → RecodrMetadata 객체 반환(토픽, 파티션, 패티션 내부의 메시지 오프셋 제공) 실패 → 에러 반환 (에러 수신한 프로듀서는 메시지 쓰기 포기하고 에러 반환전에 몇번 더 재전송 시도 할 수 있음)

3.2 카프카 프로듀서 구성하기

• 카프카 프로듀서를 수행하는 객체는 ProducerRecord
• 카프카에 메시지를 쓰려면 ProducerRecord 객체를 먼저 생성
• ProducerRecord 은 세개의 필수 속성을 갖음 (이 외에도 원하는 속성 설정 가능)
  • bootstrap.server
    • 카프카 클러스터에 최초 연결을 위해 프로듀서가 사용하는 브로커들의 host:port 목록을 설정
  • key.serializer
  • 프로듀서가 생성하는 레코드(ProducerRecord 객체)의 메시지 키를 직렬화하기 위한 클래스 이름을 이 속성에 설정 (key 없이 값만 전송할 때도 key.serializer 설정 필요)
  • key.serializer에 설정하는 클래스는 "org.apache.kafka.common.serialization.Serializer" 인터페이스를 구현해야
  • 카프카 클라이언트 패키지에는 다음과 같은 3가지 Serializer가 포함되어 있다. ByteArraySerializer, StringSerializer,IntegerSerializer

따라서 많이 사용하는 타입들을 직렬화 할때는 따로 직렬처리기를 구현하지 않아도 됨 * value.serializer - 레코드 메시지 값 직렬화 하는 데 사용되는 클래스 이름을 여기서 설정 - 직렬화 방법은 key.serializer와 동일

private Properties kafkaProps = new Properties ();        // 1. 카프카 Properties 객체 생성
kafkaProps.put("bootstrap.servers", "brokerl:9892,broker:9892");

kafkaProps.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); //  메세지 key와 value 모두 문자열 타입 사용으로 StringSerializer 사용
kafkaProps.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); 

Producer<String, String> producer = new KafkaProducer <String, String>(kafkaProps);        // 새로운 프로듀서 객체 생성, 메세지 key, value (예시는 String)을 설정하고 Properties 객체를 생성자 인자로 전달

자세한 설정 참조 :  http://kafka.apache.org/documentation.html#producerconfigs

메세지 전송 방법에는 3가지

• Fire-and-forget(전송 후 망각)
  • send() 메서드로 메시지 전송만 (성공 여부 후속 조치 X)
  • 전송 실패할 경우, 프로듀서가 자동으로 재전송 시도
  • but, 메시지 유실 가능성 있음

• Synchronous send(동기식 전송)

  • send() 메서드로 메시지 전송하면 Java의 Future 객체 반환 → Future 객체의 get() 메소드 호출 후, 작업 완료 대기 → 브로커로부터 처리결과 반환

• Asynchronous send(비동기식 전송)

  • send() 메서드 호출할 때, callback 메서드를 구현한 객체를 매개변수로 전달(뒤에 설명)
  • 이 객체가 구현된 콜백 메서드는 카프카 브로커로부터 응답을 받을 때 자동 호출 →send()가 성공적으로 수행되었는지 확인 가능

3.3 카프카에 메시지 전송하기

ProducerRecord<String, String> record = new ProducerRecord<>("CustomerCountury", "Precision Products", "France");  // step 1

try {
    producer.send(record);      // step 2
} catch (Exception e){
    e.printStackTrace();        // step 3
}

• step 1

  • 프로듀서는 전송할 메시지를 갖는 레코드 객체를 생성 (ProducerRecord는 생성자를 여러 개 갖을 수 있음)
  • 예시에서는 데이터를 저장할 토픽 이름(항상 String type), 카프카로 전송할 key와 값(예제에서는 String type)을 인자로 받는 생성자 사용
  • key과 값 타입은 직렬처리기와 프로듀서 객체(producer)에서 사용하는 타입과 같아야 함

• step 2

  • 프로듀서 객체의 send()메서드를 사용해서 레코드 전송
  • 전송된 메시지는 버퍼(배치)에 수록된 후, 스레드에서 브로커로 전송
  • 브로커가 수신된 메시지 성공적으로 쓰면 → RecodeMetadata 반환 → send()메서드가 이를 받아서 자바의 Future 객체를 반환 (예시에서는 메서드 반환값 무시 → 메세지 전송 성공/실패 모름, 실제로는 이렇게 안함)

• step 3

  • 카프카에게 메시지 전송 전에 프로듀서에 에러가 생기면 예외 처리

3.3.1 동기식으로 메시지 전송하기

ProducerRecord<String, String> record = new ProducerRecord<>("CustomerCountury", "Precision Products", "France");

try {
    producer.send(record).get();        // step 1
} catch (Exception e){
    e.printStackTrace();        // step 2
}

• step 1

  • Future 객체의 get() 메서드를 사용해서 카프카 응답을 대기
  • ProducerRecord 객체가 전송 성공 시, RecodeMetadata 를 받게 되고, 이 객체를 사용해서 카프카에 쓴 메시지의 오프셋 (offset)을 알 수 있다.
  • ProducerRecord 객체가 전송 실패하면 예외 처리 발생

• step2

  • 예외 처리
  • 카프카 메시지 전송 전 에러
  • 전송 중 카프카 브로커가 전송 재시도 불가능 에러
  • 사용 가능한 전송 재시도 횟수 전부 소진

• 카프카 프로듀서 사용할 때 발생하는 에러

  • 재시도 가능(retriable) 에러
  • 연결 에러 : 다시 연결을 시도하여 성공하면 해결 됨
  • no lea der(리더 없음) 에러 : 해당 파티션의 새로운 리더가 선출되면 해결 됨 재시도 불가능한 에러
  • 메세지가 너무 클 때 : 카프카 프로듀서는 재시도 않고 즉시 예외 반환

3.3.2 비동기식으로 메시지 전송하기

비동기식으로 메시지 전송할 때, 에러를 처리하기 위해 프로듀서에 콜백(callback)을 추가

private class DemoProducerCallback implements Callback {        // step 1
    @Override
    public void onCompletion(RecordMetadata recordMetadata, Exception e){
        if(e != null) {
            e.printStackTrace();        // step 2
        }
    }
}

ProducerRecord<String, String> record = new ProducerRecord<>("CustomerCountury", "Biomedical Materials", "USA");        // step 3
producer.send(record, new DemoProducerCallback());      // step 4

• step 1
  • 콜백 구현 시, org.apache.kafka.clients.producer.Callback 인터페이스 상속
• step 2
  • 카프카가 에러 반환 시, onCompletion() 메서드에서 예외 처리
• step 3
  • 전송할 메세지 객체 생성
• step 4
  • send() 메서드로 메시지 전송 시, 콜백 객체에 인자 전달
  • 따라서 메시지 쓴 후, 응답을 반환할 때, 이 객체의 onCompletion() 메서드가 자동 호출

3.4 프로듀서 구성하기

프로듀서를 구성하는 다양한 매개 변수 중, 프로듀서의 메모리 사용, 성능, 신뢰성 등에 영향을 주는 매개변수에 대해 설명

acks

전송된 레코드(ProducerRecord객체)를 수신하는 파티션 리플리카(복제 서버로 동작하는 브로커)의 수

메시지 유실될 가능성에 큰 영향을 준다.

acks=0일 때 프로듀서는 브로커의 응답을 기다리지 않는다. (서버 응답 대기 없어 성능은 빠르고, 높은 처리량 필요시 사용 / 단, 메시지 유실 가능성 높음) acks=1일 때 리더 리플리카가 메시지 수신할 때, 프로듀서는 브로커로 부터 수신 성공 응답 받음 리더에 메시지를 쓸 수 없다면... → 프로듀서는 에러 응답 → 메시지 재전송 리더가 중단되어 새로운 리플리카가 리더로 선출된 경우 → 메시지 유실 가능성 acks=all 일 때 동기화된 모든 리플리카가 메시지 수신 시, 프로듀서는 브로커의 성공 응답을 받음 가장 안전, 단, 브로커의 메시지를 수신할 때 까지 기다려야 해서 느림

buffer.memory

브로커에게 전송될 메시지의 버퍼로 사용할 메모리의 양 설정

compression.type

이 매개변수 설정 시, 메시지 압축되어 전송

retries

에러가 발생하기 전에 프로듀서가 메시지를 재전송하는 횟수를 제어

retry.backoff.ms

프로듀서가 메시지 재전송 시, 기본적으로 100밀리초를 대기하는 데, 이 매개변수를 사용해서 시간 간격 조정 가능

batch.size

다수의 레코드가 전송될 때, 프로듀서가 batch에 메시지를 모으는 데, 이 매개변수를 사용해서 각 batch에 사용될 메모리양을 제어

linger.ms

현재 배치를 전송하기 전까지 기다리는 시간(밀리초)를 나타냄

client.id

어떤 클라이언트에 전송된 메시지인지 식별하기 위해 브로커가 사용하는 매개변수(문자열 가능)

max.in.flight.requests.per.connection

서버의 응답을 받지 않고, 프로듀서가 전송하는 메세지의 개수를 제어

값이 클 수록, 메모리 사용은 증가하지만 처리량은 좋아짐

단, 너무 큰 값으로 사용하면 배치 처리가 비효율 → 오히려 처리량 감소

timeout.ms / request.time.out / metadata.fetch.timeout.ms

• 동기화된 리플리카들이 메시지를 인지하는 동안, 브로커가 대기하는 시간 제어

• 데이터 전송 시 프로듀서가 서버의 응답을 대기 시간 제어

• 메타데이터 요청 시 프로듀서가 서버의 응답 대기 시간 제어

max.block.ms

프로듀서 전송 버퍼가 가능차거나, 메타 데이터를 요청했지만 사용할 수 없을 때, 해당 매개변수의 값만큼 일시 중단

max.request.size

프로듀서가 전송하는 쓰기 요청의 크기를 제어

recieve.buffer.bytes와 send.buffer.bytes

데이터를 읽고 쓸 때 소켓이 사용하는 TCP 송수신 버퍼의 크기

3.5 직렬처리기

3.5.1 커스텀 직렬처리기

• 카프카로 전송하는 객체가 단순 문자열, 정수가 아닐 때, Avro, Thrift, Protobuf 같은 범용 직렬화 라이브러리 사용해서 커스텀 직렬처리기 생성 가능

• 하지만, 범용 직렬화 라이브러리의 사용을 적극 권장

• 전송하려는 객체 필드의 타입이 변경되거나 새로 추가된다면, 기존 메세지와 새 메세지 간의 호환 유지에 문제가 생김

-> 범용직렬처리기(JSON, 아파치 Avro, Thrift, Protobuf) 사용을 권장

3.5.2 아파치 Avro를 사용해서 직렬화하기

아파치 Avro

• 언어 중립적인 데이터 직렬화 시스템
• 언어 독립적인 스키마로 데이터 구조를 표한하는 데 주로 JSON 형식
• 직렬화 역시 JSON을 지원하지만, 주로 이진 파일 사용

{
    "namespace": "customerManagement.avro",
    "type": "record",
    "name": "Customer",
    "fields": [
        {"name": "id","type": "int"},
        {"name": "name","type": "string"},
        // 스키마 변경 전 (구버전)
        // {"name": "faxNumber","type": ["null","string"],"default": "null"}]
        // 스키마 변경 후 (신버전)
        , {"name": "email","type": ["null","string"],"default": "null"}]
}

Avro가 메시지 시스템에 사용하는 데 적합한 이유

• 메시지를 쓰는 애플리케이션이 새로운 스키마로 전환하더라고, 애플리케이션은 지속해서 변경 없이 메시지 처리 가능

• 팩스번호를 없애고 email 필드 추가할 경우 → 스키마 변경 전, 후의 애플리케이션 모두 카프카 이상없이 사용하는 방법 고려 필요

• 업그레이드 이전 데이터를 읽는 애플리케이션

  • getName(), getId(), getFaxNumber() 메서드 존재 / 신버전의 스키마를 사용해서 쓴 메시지를 읽으면 getFaxNumber()는 null을 반환할 것

• 업그레이드 이후 데이터를 읽는 애플리케이션

  • getFaxNumber()는 없고 getEmail() 메서드 존재 / 구버전의 스키마를 사용해서 쓴 메시지를 읽으면 getEmail()은 null을 반환할 것

• _즉, 데이터를 읽는 모든 애플리케이션 변경 X, 기존 데이터 변경 X

주의사항

데이터를 쓰는 데 사용되는 스키마와 읽는 애플리케이션에서 기대하는 스키마가 호환되어야 함 역직렬처리기는 데이터를 쓸 때 사용되었던 스키마를 사용해야 한다

3.5.4 카프카에서 Avro 레코드 사용하기

스키마 전체를 레코드에 담기에는 크기 부담

따라서, 카프카에서 사용되는 모든 스키마를 레지스트리에 저장 → 스키마 레지스트리를 사용

모든 데이터는 레지스트리에 저장, 카프카 레코드에는 사용하는 스키마의 식별자 (id)만 저장하면 된다.

컨슈머는 해당 식별자(id)를 이용해서 스키마 레지스트리의 스키마를 가져온 후, 이를 맞춰서 데이터를 역직렬화 가능

이때 모든 작업은 직렬처리기와 역직렬처리기에서 수행된다.

카프카에 데이터를 쓰는 코드에서 스키마 레지스트리 관련 코드를 추가하지 않고, 직렬처리기를 사용하듯이 Avro를 사용하면 된다.

Avro 사용 방법 참고 : http://avro.apache.org/docs/current

스키마 레지스트리란?

• 카프카 클라이언트 사이에서 메시지의 스키마를 저장하고 관리하는 웹 애플리케이션

등장배경

• 다수의 프로듀서가 존재할 때, 컨슈머 입장에서는 어떤 프로듀서가 메시지를 보냈는 지 모른다.
• 또한, 프로듀서의 쓰기 작업은 메시지 큐의 가장 말단에서만 실행 중간에 수정 작업을 진행할 수 없다.

만약, 다수의 프로듀서 중, 하나의 프로듀서가 스키마를 변경하여 메시지를 발행 → 토픽에 순차적으로 쌓이면...

• 컨슈머는 변경된 스키마에 대해 적절히 대응하지 못한다.

스키마 레지스트리의 목적

• 토픽별로 메시지 key와 value 스키마 버전 관리
• 스키마 호환성 규칙 강제
• 스키마 버전 별 호환성을 강제하여, 스키마가 변경되어도 컨슈머 입장에서 메시지를 적절하게 구독할 수 있게 한다.

스키마 버전 조회

             (그림, 스키마 저장 및 검색을 위한 Confluent Schema Registry)

스키마 레지스트리는 스키마 생성, 조회, 관리에 대한 HTTP API를 제공

API 상세는 https://docs.confluent.io/home/overview.html 에서 참조

참고 ) https://docs.confluent.io/platform/current/schema-registry/index.html#schemas-subjects-and-topics

3.6 파티션

기본 파티션

• ProducerRecord 객체는 토픽 이름과 key, 값을 포함 (대부분)

• 카프카 메시지는 key와 값의 쌍으로 구성되지만, 기본값이 null로 설정된 키와 함께 토픽과 값만 갖는 ProducerRecord 객체도 생성이 가능

• key의 목적

  • 메시지를 식별하는 추가 정보를 가짐
  • 메시지를 쓰는 토픽의 여러 파티션 중 하나를 결정하는 역할
  • 같은 key를 가진 모든 메시지는 같은 파티션에 저장됨

기본 파티셔너의 특징

• 키가 null이고, 카프카의 기본 파티셔너를 사용하면
  • 사용 가능한 토픽의 파티션들 중 하나가 무작위로 선택됨
  • 각 메시지에 저장된 메시지 개수의 균형을 맞추기 위해 라운드 로빈 알고리즘을 사용함
• 키가 있고 기본 파티셔너를 사용하면
  • 카프카에서 key의 해시값을 구한 후, 그 값에 따라 특정 파티션에 메시지 저장

3.7 구버전의 프로듀서 API들

이 장에서는 org.apache.kafka.client 패키지에 포함된 자바 프로듀서 클라이언트에 대해 알아봤지만 여전히 스칼라 언어로 작성된 구버전 프로듀서가 존재

• kafka.producer 패키지와 핵심 카프카 모듈(SyncProducers, AsyncProducer)에 포함

  • SyncProducers 메시지 추가 전송하기 전에 이미 전송된 메시지가 서버에서 인지되는 것을 기다림
  • AsyncProducer 백그라운드로 실행되어 메시지 수집 후, 별도 스레드에서 전송, 전송 성공여부 프로듀서 클라이언트에 알려주지 않음

• 하지만, 현재 버전의 카프카에서 SyncProducers, AsyncProducer 모두 지원

// Int? = null 널이 될 수 있는 타입 (Int?) 과 파라미터 디폴트 값
data class Person(val name: String, val age: Int? = null)

fun main() {

    val persons = listOf(Person("영희")
        , Person("철수", age=29))

        // :? 엘비스 연산자 -> null 일 경우 0을 리턴 
    val oldest = persons.maxOf { i -> i.age ?: 0}
    println("나이가 가장 많은 사람 : $oldest")

}

1.2 코틀린의 주요 특성

1.2.1 대상 플랫폼

서버, 안드로이드 등 자바가 실행되는 모든 곳에서 사용

1.2.2 정적 타입 지정

• 코틀린은 타입추론 (Type inference)가 가능 → 모든 변수의 타입을 프로그래머가 직접 명시할 필요 없음

• 자바와 마찬가지로 코틀린도 정작 타입 지정 언어

• 정적 타입 지정이란 ?

  • 모든 프로그램 구성 요소의 타입을 컴파일 시점에 알 수 있고, 프로그램 안에서 객체의 필드나 메소드를 사용할 때 마다 컴파일러가 타입을 검증해준다.

• 정적 타입 지정의 장점

  • 성능 : 성능 시점에 어떤 메소드 호출할 지 알아내는 과정이 필요 없어서 메소드 호출이 빠르다.
  • 신뢰성 : 컴파일러가 프로그램 정확성 검증하기 때문에 프로그램 오류 중단 가능성이 적어짐
  • 유지보수성
  • 도구 지원 : 더 안전하게 리팩토링이 가능함

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

일급시민 함수 (First Class 함수)

함수를 일반 값처럼 다룰 수 있다. 함수를 변수에 저장, 함수를 아규먼트로 다른 함수에 전달 가능, 새로운 함수 만들어서 반환 가능

불변성

immutable 객체를 사용해서 프로그램 작성

Side Effect 없음

입력이 같으면 항상 같은 출력을 반환

다른 객체의 상태를 변경하지 않으며, 함수 외부나 다른 바깥 환경과 상호작용하지 않는 순수한 함수 사용

함수형 프로그래밍의 장점

• 간결성 : 명령형 코드에 비해 더 간결하고 우아하다.
• 다중스레드를 사용해도 안전하다. (thread-safe 하다)
• 함수형 프로그램은 테스트 하기 쉽다.

1.2.4 무료 오픈소스

• 무료 오픈소스, 주요 IDE와 빌드시스템 완전 지원

1.3 코틀린 응용

1.3.1 코틀린 서버 프로그래밍

• 브라우저에서 HTML 페이지를 반환하는 웹 애플리케이션 개발 가능
• 모바일 애플리케이션에서 HTTP 를 통해 JSON API를 제공하는 백엔드 애플리케이션 개발 가능
• RPC 프로토콜을 통해 서로 통신하는 MSA 가능

1.3.2 코틀린 안드로이드 프로그래밍

1.4 코틀린의 철학

자바와 상호운영성에 초점을 맞추고 실용적, 간결, 안전한 언어

안정성

• NPE를 없애기 위해 노력
• ClassCaseException 방지
• 어떤 객체를 다른 타입으로 cast 하기 전에 미리 검사하지 않으면, ClassCaseException이 발생할 수 있다.
• Java에서는 귀찮아서 타입 검증을 생략하는 경우가 많은데, 코틀린은 타입검사와 cast가 연산자에 의해 이루어 진다.

if(value is String)   // 타입 검사
    println(value.toUpperCase())   // 해당 타입의 메소드를 사용

상호운용성

• 코틀린의 클래스나 메소드를 일반적인 자바 클래스나 메소드와 똑같이 사용 가능, 자바와 코틀린 코드를 프로젝트에서 섞어서 사용이 가능하다.
• 기존 Java에서 사용하는 라이브러리 그대로 사용 가능

출처 : (서적) Kotlin in Action 드미트리 제메로프, 스베트라나 이사코바 저자 /오현석 옮김

peek()

중간처리 looping 메소드, 중간처리 단계에서 전체 요소를 루핑을 돌면서 추가적인 작업을 위해 사용

마지막에 최종 처리 메소드가 실행되지 않으면 동작하지 않는다.

forEach()

최종처리 looping 메소드

파이프라인 마지막에 루핑하면서 요소를 하나씩 처리

forEach가 최종처리 메소드이기 때문에 이후에 또다른 최종처리 메소드를 호출하면 안된다.

import java.util.Arrays;

public class LoopingExample {
    public static void main(String[] args) {

        int[] intArr = {1, 2, 3,4,5,6};

        System.out.println("peek은 중간처리 메소드 - peek을 마지막에 호출한 경우, 동작하지 않음");
        Arrays.stream(intArr)
                .filter(a -> a%2 ==0)
                .peek(n-> System.out.println(n));

        // 최종 처리 메소드 sum()을 마지막에 호출하면 peek 동작함
        int total = Arrays.stream(intArr)
                .filter(a -> a%2 ==0)
                .peek(n-> System.out.println(n))
                .sum();
        System.out.println("total = " + total);

        System.out.println("forEach()는 최종처리 루핑 메소드 - 마지막에 호출한 경우, 동작함");
        Arrays.stream(intArr)
                .filter(a -> a%2 ==0)
                .forEach(n-> System.out.println(n));
    }
}

8. Matching (allMatch(), anyMatch(), noneMatch())

최종 처리 단계에서 요소들이 특정 조건에 맞는 지 확인할 수 있도록 matching 메소드를 지원한다.

allMatch()

모든 요소들이 매개값으로 주어진 predicate 값이 조건을 만족하는 지 조사한다.

anyMatch()

최소한 한개 이상의 요소가 매개값으로 주어진 predicate 값이 조건을 만족하는 지 조사한다.

noneMatch()

모든 요소가 매개값으로 주어진 predicate 값이 조건을 만족하지 않는 지 조사한다.

import java.util.Arrays;

public class MatchExample {
    public static void main(String[] args) {
        int[] intArray = {1, 2, 3, 4, 5};

        boolean result = Arrays.stream(intArray)
                .allMatch(a -> a % 2 == 0);
        System.out.println("모두 2의 배수인가 ? = " + result);

        result = Arrays.stream(intArray)
                .anyMatch(a -> a % 3 == 0);
        System.out.println("3의 배수인 요소가 하나라도 있나 ? = " + result);

        result = Arrays.stream(intArray)
                .noneMatch(a -> a % 7 == 0);
        System.out.println("모든 요소가 7의 배수가 아닌가? = " + result);

    }
}

9. 기본 집계 (sum(), count(), average(), max(), min())

집계는 최종 처리 기능으로 요소들을 처리한다.

카운팅, 합계, 평균값, 최댓값, 최솟값 등 하나의 값을 산출한다.

집계는 대량의 데이터를 가공해서 축소하는 리덕션(Reduction) 이라고 볼 수 있다.

스트림이 제공하는 기본 집계 함수

import java.util.Arrays;

public class AggregateExample {

    public static void main(String[] args) {
        int[] intArr = {1, 2, 3, 4, 5, 6, 7};

        long count = Arrays.stream(intArr)
                .filter(a -> a % 2 == 0)
                .count();
        System.out.println("2의 배수 개수 : " + count);

        long sum = Arrays.stream(intArr)
                .filter(n -> n % 2 == 0)
                .sum();
        System.out.println("2의 배수인 요소들의 합 : " + sum);

        double avg = Arrays.stream(intArr)
                .filter(n -> n % 2 == 0)
                .average()
                .getAsDouble();
        System.out.println("2의 배수인 요소들의 평균, double 타입 : " + avg);

        int max = Arrays.stream(intArr)
                .filter(n -> n % 2 == 0)
                .max()
                .getAsInt();
        System.out.println("2의 배수인 요소들의 최댓값, double 타입 : " + max);

        int first = Arrays.stream(intArr)
                .filter(n -> n % 3 == 0)
                .findFirst()
                .getAsInt();
        System.out.println("3의 배수인 요소들 중에서 가장 첫 요소 : " + first);
    }
}

Optional 클래스

Optional 클래스는 단순히 집계 값만 저장하는 것이 아니라, 집계 값이 존재하지 않을 경우(null 일 경우), 디폴트 값을 설정할 수 있고 집계 값을 처리하는 Cunsumer도 등록할 수 있다.

importjava.util.ArrayList;
importjava.util.List;
importjava.util.OptionalDouble;

public classOptionalExample {

public static voidmain(String[] args) {
        List<Integer> list =newArrayList<>();

//  java.util.NoSuchElementException발생한다.
        //요소 값이 null이기 떄문 !
//        double avg = list.stream()
//                .mapToInt(Integer::intValue)
//                .average()
//                .getAsDouble();

        // 1. isPresent()사용
OptionalDouble optionalAvg = list.stream()
                .mapToInt(Integer::intValue)
                .average();

if(optionalAvg.isPresent()){
            System.out.println("isPresent() 사용 : " + optionalAvg);
        }else{
            System.out.println(0.0);
        }

// 2. orElse
doubleavg = list.stream()
                .mapToInt(Integer::intValue)
                .average()
                .orElse(0.0);

        System.out.println("orElse() 사용 = " + avg);

// 3. ifPresent람다식
list.stream()
                .mapToInt(Integer::intValue)
                .average()
                .ifPresent(a -> System.out.println("ifPresent() 사용 : " + a));

    }
}

10. 커스텀 집계(reduce())

기본 집계 메소드 외에도 프로그램화해서 다양한 집계 결과물을 만들 수 있도록 reduce() 메소드를 제공한다.

각 인터페이스에는 매개타입으로 XXXOperator, 리턴 타입으로 OptionalXXX, int, longm double 을 가지는 reduce() 메소드가 오버로딩 되어 있다.

스트림 요소가 없을 경우, 디폴트 값으로 identity 가 리턴된다.

XXXOperator 매개값은 집계 처리를 위한 람다식을 대입한다.

import java.util.Arrays;
import java.util.List;

public class ReductionExample {

    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("홍길동", 20, Person.MALE)
                , new Person("김미미", 21, Person.FEMALE)
                , new Person("JHJ", 22, Person.FEMALE));

        int sum1 = personList.stream()
                .mapToInt(Person::getAge)
                .sum();

        int sum2 = personList.stream()
                .map(Person::getAge)
                .reduce((a, b) -> a + b)
                .get();

        int sum3 = personList.stream()
                .map(Person::getAge)
                .reduce(0, (a, b) -> a + b);

        System.out.println("sum1 = " + sum1);
        System.out.println("sum2 = " + sum2);
        System.out.println("sum3 = " + sum3);
    }
}

출처 : 이것이 자바다 (저자 : 신용권, 출판사 : 한빛미디어)

스트림(Stream) 이란?

스트림(Stream)은 Java 8 버전 이후부터 추가되었으며, Collection과 배열의 저장요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 도와주는 반복자

Stream vs Iterator

Java 7 이전에는 Collection의 저장 요소를 참조하기 위해서 Iterator를 사용하였다.

Java 8 이후에는 Stream을 사용해서 저장 요소를 하나씩 참조가 가능하며, forEach() 메소드와 같은 Consumer 함수 인터페이스를 이용해서 람다식으로 사용이 가능하다.

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

public class IteratorAndStreamExample {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("사과", "바나나", "포도");

        // Java 7 이전, Iterator 사용
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String fruit = iterator.next();
            System.out.println("fruit-iterator = " + fruit);
        }

        // Java8 이후, Stream 사용
        Stream<String> stream = list.stream();
        stream.forEach(fruit -> System.out.println("fruit-stream = " + fruit));
    }
}

스트림의 특징

람다식으로 요소 처리 코드를 제공

Stream이 제공하는 대부분의 메소드들은 함수적 인터페이스를 매개 타입으로 가진다. 따라서 람다식 또는 메소드 참조를 이용해서 컬렉션의 요처들을 매개값으로 전달이 가능하다.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class LamdaExpressionExample {

    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
                new Person("홍길동", 20),
                new Person("JHJ", 20));

        Stream<Person> stream = list.stream();
        stream.forEach(p -> {
            System.out.println("이름 :  " + p.getName() + ", 나이 : " + p.getAge());
        });
    }
}

public class Person{
    String name;
    int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

내부 반복자를 사용하므로 병렬처리가 쉽다.

• 외부 반복자 : 개발자가 코드로 직접 컬렉션의 요소를 가져오는 패턴 (index를 활용한 for문, iterator, while문 등)
• 내부 반복자 : 컬렉션 내부에서 요소들을 반복시키고 개발자는 요소당 처리해야할 코드만 제공하는 패턴

• 내부 반복자를 사용하면 컬렉션 내부에서의 요소를 어떻게 반복 시킬지는 컬렉션에 맡겨 둔다. 개발자는 요소 처리에만 집중할 수 있다.
• 멀티코어 CPU를 최대한 활용하기 위해 요소들을 분배시켜 병렬작업을 도와주기 때문에 하나씩 처리하는 순차적인 외부 반복자보다는 내부 반복자를 사용하는 것이 좀 더 효율적이다.
• 병렬처리란 ? 한가지 작업을 서브 작업으로 나누고, 서브 작업들을 분리된 스레드에서 병렬적으로 처리하는 것 런타임시 하나의 작업을 여러개의 작업으로 나눠서 처리 후, 결과를 자동으로 결합

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class ParallelExample {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "coconut", "grape");

        // 순차처리
        Stream<String> stream = list.stream();
        stream.forEach(ParallelExample::print);

        // 병렬처리 : 병렬 스트림으로 스트림 선언
        Stream<String> parallelStream = list.parallelStream();
        parallelStream.forEach(ParallelExample::print);
    }

    private static void print(String s) {
        System.out.println(s + " : " + Thread.currentThread().getName());
    }
}

// 결과
apple : main
banana : main
coconut : main
grape : main
coconut : main
grape : main
banana : ForkJoinPool.commonPool-worker-5
apple : ForkJoinPool.commonPool-worker-19

스트림은 중간처리와 최종 처리를 할 수 있다.

컬렉션 요소에 대해서 중간처리 (매핑, 필터링, 정렬)를 한 후, 최종 처리 (반복, 카운팅, 평균, 총합 등)의 집계처리가 가능하다.

import java.util.Arrays;
import java.util.List;

public class MapAndReduceExample {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("홍길동", 20),
                new Person("김OO", 21),
                new Person("JHJ", 21));

        double ageAvg = personList.stream()
                .mapToInt(Person::getAge)
                .average()
                .getAsDouble();

        System.out.println("평균 나이 = " + ageAvg);
    }
}

2. 스트림의 종류

Java 8 부터 java.util.stream 패키지에 스트림(Stream) API 들이 포함되어 있다.

부모 인터페이스 : BaseStream

자식 인터페이스 : Stream, IntStream, LongStream, DoubleStream

3. 스트림 파이프 라인

리덕션(Reduction)이란?

대량의 데이터를 가공해서 축소하는 것 (데이터의 합계, 평균값, 카운팅, 최대값, 최소값 등)

하지만, 컬렉션의 요소를 바로 리덕션화해서 집계할 수 없을 경우, 집계하기 좋도록 필터링, 매핍, 정렬, 그룹피이 등 중간처리가 필요

중간처리와 최종 처리

스트림은 데이터의 필터링, 매핑, 정렬, 그룹핑 등의 중간처리와 합계, 평균, 카운팅, 최대값, 최소값 등의 최종 집계 처리를 파이프라인으로 해결한다.

파이프라인은 여러개의 스트림이 연결되어 있는 구조를 말하는 데, 최종 처리를 제외하고 모두 중간처리 스트림이다.

중간 스트림이 생성될 때, 바로 중간처리를 진행하는 것이 아니라, 최종처리가 시작되기 전까지 중간처리는 Lazy 된다. 최종 처리가 시작되면 그때 컬렉션 요소들이 중간 스트림에서 처리 → 최종 처리

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamPipelineExample {

    public static void main(String[] args) {
        List<Person> list = Arrays.asList(new Person("홍길동", 20, Person.MALE),
                new Person("김미미", 20, Person.FEMALE),
                new Person("김호호", 25, Person.MALE));

//    중간처리
//    Stream<Person> maleFemaleStream = list.stream();
//    Stream<Person> maleStream = maleFemaleStream.filter(m-> m.getGender() == Person.MALE);
//    IntStream ageStream = maleStream.mapToInt(Person::getAge);
//    최종 처리
//    OptionalDouble optionalDouble = ageStream.average();
//    double ageAge = optionalDouble.getAsDouble();

        double ageAge = list.stream()
                .filter(m -> m.getGender() == Person.MALE)
                .mapToInt(Person::getAge)
                .average()   // 최종처리
                .getAsDouble();

        System.out.println("ageAge = " + ageAge);

    }
}

4. 필터링 (distinct(), filter())

필터링은 중간 처리 기능으로 요소를 걸러내는 역할

모든 스트림이 공통으로 가지고 있다.

distinct()

Stream의 경우, Object.equals()가 true이면 동일한 객체로 판단해서 중복 제거

IntStream, LongStream, DoubleStream은 동일값이면 중복 제거

filter()

매개값으로 주어진 Predicate가 true를 리턴하는 요소만 필터링

import java.util.Arrays;
import java.util.List;

public class FilteringExample {

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("사과", "바나나", "포도", "귤", "사과", "포도", "포도송이", "포도알");

        // 중복제거
        fruits.stream()
                .distinct()
                .forEach(f-> System.out.println(f));

        // 필터링
        fruits.stream()
                .filter(f-> f.startsWith("포도"))
                .forEach(f-> System.out.println(f));

        // 중복 제거 후, 필터링
        fruits.stream()
                .distinct()
                .filter(f-> f.startsWith("포도"))
                .forEach(f-> System.out.println(f));
    }
}

5. 매핑 (flatMapXXX(), mapXXX(), asXXXStream(), boxed())

mapping은 중간 처리 기능으로 스트림의 요소를 다른 요소로 대체하는 것을 말한다.

flatMapXXX()

flatMap은 스트림의 각 값을 다른 스트림으로 만든 다음에 모든 스트림을 하나의 스트림으로 연결하여 새로운 스트림을 리턴한다.

flatMap 메소드 종류

import java.util.Arrays;
import java.util.List;

public class FlatMapExample {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("hello world", "good-bye world");
        list.stream()
                .flatMap(data -> Arrays.stream(data.split(" ")))
                .forEach(word -> System.out.println(word));

        List<String> list2 = Arrays.asList("10, 20, 30","40, 50, 60");
        list2.stream()
                .flatMapToInt(data -> {
                    String[] strArr = data.split(",");
                    int[] intArr = new int[strArr.length];

                    for (int i = 0; i < strArr.length; i++) {
                        intArr[i] = Integer.parseInt(strArr[i].trim());
                    }
                    return Arrays.stream(intArr);
                })
                .forEach(number -> System.out.println("number = " + number));

    }
}

mapXXX() 메소드

map 메소드는 요소를 대체하는 요소로 구성된 새로운 스트림을 반환한다.

map의 메소드 종류

import java.util.Arrays;
import java.util.List;

public class MapExample {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(
                new Person("홍길동", 20, Person.MALE),
                new Person("김미미", 25, Person.FEMALE),
                new Person("JHJ", 23, Person.FEMALE)
        );

        personList.stream()
                .mapToInt(Person::getAge)
                .forEach(age -> System.out.println("age = " + age));
    }
}

asDoubleStream(), asLongStream(), boxed() 메소드

asDoubleStream() 메소드는 IntStream의 int 요소 또는 LongStream의 long 요소를 double 타입으로 반환해서 DoubleStream을 생성한다.

asLongStream() 메소드는 IntStream의 int 요소를 long 타입으로 변환해서 LongStream을 생성한다.

boxed() 메소드는 int, long, double 요소를 Integer, Long, Double 요소로 박싱해서 Stream을 생성한다.

import java.util.Arrays;
import java.util.stream.IntStream;

public class AsDoubleBoxedExample {
    public static void main(String[] args) {

        int[] intArr = {1, 2, 3, 4, 5};

        IntStream intStream = Arrays.stream(intArr);
        intStream
                .asDoubleStream()
                .forEach(d -> System.out.println(d));

        intStream = Arrays.stream(intArr);
        intStream
                .boxed()
                .forEach(obj -> System.out.println(obj.intValue()));
    }
}

6. 정렬 (sorted)

중간단계에서 스트림 요소를 정렬하여 최종 처리 순서를 변경할 수 있다.

요소 정렬 메소드

객체 요소를 정렬할 때

객체 요소일 경우, 클래스에 Comparable 를 구현하지 않으면, sorted() 메소드 호출했을 때 ClassCastException 발생한다. 그렇기 때문에 Comparable 인터페이스를 상속받으면, Comparable를 구현한 요소에서만 sorted() 메소드를 사용해야 한다.

public class Person implements Comparable<Person>{
    public static int MALE = 0;
    public static int FEMALE = 1;

    String name;
    int age;
    int gender;

    public Person(String name, int age, int gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getGender() {
        return gender;
    }

    @Override
    public int compareTo(Person o) {
        // age < o.age 음수 리턴
        // age == o.age 0 리턴
        // age > o.age 양수 리턴
        return Integer.compare(age, o.age); 
    }
}

Comparable을 구현한 객체의 기본 비교 (Comparable) 와 반대 비교

// 기본비교 ex) 오름차순
sorted();
sorted((a, b)-> a.compareTo(b));
sorted(Comparator.naturalOrder());

// 반대비교 ex) 내림차순
sorted((a, b)-> b.compareTo(a));
sorted(Comparator.reverseOrder());

만약 객체 요소가 Comparable를 구현하지 않았다면, Comparator를 매개값으로 갖는 sorted() 메소드를 사요하면 된다.

// a가 작으면 음수, 같으면 0, a가 크면 양수
sorted((a, b) -> {....})

정렬 예제

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;

public class SortingExample {
    public static void main(String[] args) {

        IntStream intStream = Arrays.stream(new int[] {5, 2, 1, 3, 4, 6});

        // 숫자 오름차순으로 정렬
        intStream
                .sorted()
                .forEach(n -> System.out.println(n));

        // 객체 요소일 경우
        List<Person> personList = Arrays.asList(
                new Person("홍길동", 20, Person.MALE),
                new Person("김미미", 25, Person.FEMALE),
                new Person("JHJ", 23, Person.FEMALE)
        );

        // 나이 내림차순으로 정렬
        personList
                .stream()
                .sorted(Comparator.reverseOrder())
                .forEach(p -> System.out.println(p.getAge()));

        // 나이 오름차순
        personList
                .stream()
                .sorted((a, b) -> a.compareTo(b))
                .forEach(p -> System.out.println(p.getAge()));
    }
}

출처 : 이것이 자바다 (저자 : 신용권, 출판사 : 한빛미디어)

AOP(Aspect-Oriented-Programming)

OOP를 보완하는 수단으로 흩어진 Aspect를 모듈화 할 수 있는 프로그래밍 기법

흩어진 관심사 (Crosscutting Concerns)

Concerns는 여러 클래스들에 걸쳐서 나타나는 비슷한 코드들, Filed 주입들을 말한다..

ex ) Transaction 처리, 성능관련 로깅 등

AOP를 적용하면...

⇒ 이처럼 공통된 로직, 코드들을 모듈화하여 묶어서 개발할 수 있따.

AOP의 주요 개념

• Aspect와 Target
  • Aspect는 모듈을 묶음화 한 것
  • Target은 적용 대상
• Advice
  • 모듈이 해야할 일들
• Joint point와 Pointcut
  • joint point는 합류점을 의미한다. 어떤 메소드, 클래스, filed값 접근시점, 실행시점에 이 Advice를 끼워 넣어라
  • Pointcut은 이 모듈을 어디에 적용하는 지를 의미한다.

AOP의 구현체

• AOP는 꼭 Spring, Java에만 국한된 것이 아니다.
• 참고 : https://ko.wikipedia.org/wiki/관점_지향_프로그래밍
• AspectJ는 자바, 스프링은 Spring AOP(극한적인 기능만 존재)

AOP 적용 방법

• 컴파일 시점
  • Java를 .class 파일로 컴파일하는 시점에 조작된 바이트 코드를 실행시킨다. 로드, 런타임은 따로 안들지만, 별도의 컴파일 과정이 필요하다.
• 로드 타임
  • 클래스 파일을 로딩하는 시점에 weaving, load time weaving
  • 클래스 로딩 시간 증가, load time weaver를 Java agent 에 설정해줘야 함
  • 다양한 Aspect 사용 가능
• 런타임
  • Proxy 객체로 감싸는 것, 최초의 Bean 설정 시간이 증가한다.

⇒ 컴파일 시점, 로드타임에 AOP 적용 방법은 주로 Aspect에서 사용

⇒ 런타임 시점에 AOP 적용은 주로 Spring AOP에서 사용한다.

스프링 AOP : 프록시 기반 AOP

스프링 AOP 특징

• Proxy 기반의 AOP 구현체
• Spring Bean에만 AOP를 적용할 수 있다.
• 모든 AOP 기능을 제공하는 것이 목적이 아니라, 스프링 IoC와 연동해서 Enterprise Application에서 가장 흔한 문제에 대한 해결책을 제공하는 것이 목적이다.

Proxy Pattern

• 프록시 패턴을 사용하는 이유
  • 기존 코드 변경없이 접근 제어, 부가기능을 추가하기 위해서
  • 클라이언트는 기존 코드를 건드리지 않고, 인터페이스 타입의 프록시 객체를 사용할 수 있다.

• 프록시 패턴의 문제점

  • 매번 프록시 캘르스를 작성해야 한다.

  • 여러 클래스, 여러 메소드에 적용하려면 객체들과의 관계도가 복잡해진다.

    ex )

    
    // interface
    public interfaceEventService {
    
      voidcreateEvent();
    
      voidpublishEvent();
    
      voiddeleteEvent();
    }
    
    // Proxy
    @Primary
    @Service
    public class ProxySimpleEventService implements EventService{
    
      @Autowired
      SimpleEventService simpleEventService;
    
      @Override
      public void createEvent() {
          long begin = System.currentTimeMillis();
          simpleEventService.createEvent();
          System.out.println(System.currentTimeMillis()-begin);
      }
    
      @Override
      public void publishEvent() {
          long begin = System.currentTimeMillis();
          simpleEventService.publishEvent();
          System.out.println(System.currentTimeMillis()-begin);
    
      }
    
      @Override
      public void deleteEvent() {
          simpleEventService.deleteEvent();
      }
    }
    
    // Real Subject
    @Service
    public class SimpleEventService implements EventService{
    
      @Override
      public void createEvent() {
          long begin = System.currentTimeMillis();
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("create an evnet");
    
          // Crosscutting concern : 각 메소드 마다 공통된 모듈 
          System.out.println(System.currentTimeMillis()-begin);
      }
    
      @Override
      public void publishEvent() {
          long begin = System.currentTimeMillis();
    
          try {
              Thread.sleep(2000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("Published an event");
    
          System.out.println(System.currentTimeMillis()-begin);
      }
    
      public void deleteEvent(){
          System.out.println("Delete event");
      }
    }

⇒ 그래서 Spring AOP 등장

Spring AOP

• 스프링 IoC 컨테이너가 제공하는 기반 시설과 Dynamic 프록시를 사용해서 여러 복잡한 문제를 해결한다.
• Dynamic Proxy : 동적으로 프록시 객체를 생성하는 방법
  • 자바가 제공하는 방법은 인터페이스 기반 프록시 생성
  • CGlib은 클래스 기반 프록시도 지원
• 스프링 IoC : 기존 빈을 대체하는 동적 프록시 빈을 만들어서 등록시켜준다.
  • 클라이언트 입장에서 코드 변경이 없다.
  • AbstractAutoProxyCreator는 BeanPostProcessor를 상속받는다.
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/aop/framework/autoproxy/AbstractAutoProxyCreator.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanPostProcessor.html

스프링 AOP : @AOP

애노테이션 기반의 스프링 @AOP

사용하기 위해서는 spring-boot-starter-aop 의존성 필요

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
 </dependency>

Aspect 정의

• Aspect에서는 Advice(해야할 일)과 Point-cut(어디에 적용할 것인가, 적용시점)를 정의해야 한다.
• Aspect로 사용할 클래스는 Bean으로 등록되어야 한다.
• @Around 애노테이션을 이용해서 Point-cut을 적용할 수 있다.

@Aspect
@Component
public class PerfAspect {

    // createEvent, publlishEvent 메소드에 적용될 aop 이다.
    // @Around에 Pointcut을 정의할 수 있다. 즉 적용시점을 정의할 수 있다.
   // @Around("execution(* me.jhjhj..*.EventService.*(..))")
   // @Around("bean(simpleEventService)")
    @Around("@annotation(PerfLogging)")
    public Object logPerf(ProceedingJoinPoint pjp) throws Throwable{
        long begin = System.currentTimeMillis();
        Object retVal = pjp.proceed();
        System.out.println(System.currentTimeMillis() - begin);
        return retVal;
    }

    // 메소드 실행 이전에
    @Before("bean(simpleEventService)")
    public void hello(){
        System.out.println("hello");
    }
}

// RetentionPolicy에도 다양한 스코프가 존재, 
// RetentionPolicy.CLASS : 이 애노테이션을 class 파일까지만 적용하겠다.
@Documented
@Retention(RetentionPolicy.CLASS)
public @interface PerfLogging {
}

Point-Cut 정의

• @Pointcut(표현식)
• 주요 표현식
  • execution : 패키지 경로 (패키지 경로에 해당하는 대상들 모두가 aop 에 적용)
  • @annotation : 별도의 애노테이션 정의 후, aop로 사용하고 싶은 메소드, 클래스만 적용이 가능하다.
  • bean : bean 이름 기재
• Point-Cut 조합
  • &&, ||, !

Advice 정의

• @Before
• @AfterReturning
• @AfterThrowing
• @Around

✅ Spring AOP 공식 레퍼런스 : https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-pointcuts

• 객체의 그래프를 조작하고 조회하는 기능을 제공
• 문법은 EL (Unified EL)과 비슷하지만, 메소드 호출 및 문자열 템플릿 기능 등 추가적인 기능을 제공한다.
• OGNL, MVEL, JBoss EL 등의 Java에서 사용할 수 있는 여러 EL이 있지만, SpEL은 모든 Spring 프로젝트에 전반에 걸쳐 사용할 EL로 만들어졌다.
• Spring 3.0 부터 지원한다.

SpEL의 구성

• ExpressionParser parser = new SpelExpressionParser()

  • ExpressionParser 인터페이스는 문자열 표현을 파싱한다ㅏ.

    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression("'Hello World'");
    String message = (String) exp.getValue();

• Expression expression = parser.parseExpression(“SpEL 표현식”)

• StandardEvaluationContext context = new StandardEvaluationContext(bean)

  • EvaluationContext 인터페이스는 프로퍼티, 메서드, 필드를 처리하고 타입변환을 수행하는 표현식을 평가할 때 EvaluationContext 인터페이스를 사용한다.
  • StandardEvaluationContext는 setRootObject() 메서드나 생성자에 루트객체를 전달해서 평가에 사용할 루트객체를 지정하는 곳이다.

• String value = expression.getvalue(context, String.class)

SpEL 문법

• #{표현식}
• ${”프로퍼티”}
• 표현식 안에 프로퍼티를 쓸 수 있지만, 반대는 안됨
  • #{${my.data(프로퍼티명) + 1}}
• 레퍼런스에 더 자세히 기재되어 있음

// SpEL #, 표현식을 참고하는 방법
    @Value("#{1 + 1}")
    int value;

    @Value("#{'hello' + 'worlld'}")
    String greeting;

    @Value("#{1 eq 1}")
    boolean trueOrFalse;

    @Value("test")
    String test;

    // property를 참고하는 방법
    @Value("${my.value}")
    int myValue;

    @Value("#{${my.value} eq 100}")
    boolean isMyValue100;

    @Value("#{sample.data}")
    int sampleData;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("value = " + value);
        System.out.println("greeting = " + greeting);
        System.out.println("trueOrFalse = " + trueOrFalse);
        System.out.println("test = " + test);
        System.out.println("myValue = " + myValue);
        System.out.println("isMyValue100 = " + isMyValue100);
        System.out.println("sampleData = " + sampleData);

        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("2 + 100");
        Integer value = expression.getValue(Integer.class);
        System.out.println("value = " + value);

    }

사용하는 곳

• @Value 애노테이션
• @ConditionalOnExpression 애노테이션
• Spring Security
  • 메소드 시큐리티, @PreAuthorize, @PostAuthorize, @PreFilter, @PostFillter
  • XML Intercepter URL 설정
• Spring Data
  • @Query 애노테이션
• Thymeleaf

출처 : [인프런 강의] 백기선 - 스프링 프레임워크 핵심기술 참고 : https://blog.outsider.ne.kr/997

org.springframework.validation.Databinder

데이터 바인딩이란 ?

Property 값을 타겟 객체에 설장하는 기능이다.

사용자의 입력 값을 Model 값에 동적으로 변환해서 넣어주는 기능이다.

사용하는 이유

사용자가 입력하는 값은 대부분 문자열, 숫자 일 것이다. 그 값을 객체가 가지고 있는 속성 타입이나 도메인 타입으로 변환해서 넣어주기 위해 사용한다.

PropertyEditor

• Spring 3.0 이전까지 Databind가 변환 작업을 사용하던 interface (고전적인 방법이다.)
• Thread-Safe 하지 않다.
  • statefulll 하다.
  • 상태 정보를 저장하고 있기 때문에 싱글톤 객체로 등록하여 사용하는 것은 금한다.
  • Object와 String 간의 변환만 가능, 제한적인 사용

@RestController
public class EventController {

    @InitBinder
    public void init(WebDataBinder webDataBinder){
        webDataBinder.registerCustomEditor(Event.class, new EventEditor());
    }

    @GetMapping("/event/{event}")
    public String getEvent(@PathVariable Event event){
        System.out.println("event = " + event);
        return event.getId().toString();
    }
}

// Thread-Safe 하지 않는다.
// 절대로 proportyEditor 절대로 싱글톤 빈으로 등록해서 사용하면 안됨
// thread-scope의 빈 일 경우에는 그나마 가능
public class EventEditor extends PropertyEditorSupport {

    @Override
    public String getAsText() {
        Event event = (Event) getValue();
        return event.getId().toString();
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        setValue(new Event(Integer.parseInt(text)));
    }
}

2. 데이터 바인딩 추상화 : Converter와 Formatter

Converter

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/convert/converter/Converter.html

• Source 타입을 Target 클래스로 변환할 수 있는 인터페이스
• 상태 정보를 저장하지 않음
  • stateless, Thread-Safe 하다.
• ConverterRegistry에 등록하여 사용한다.

public class EventConverter {

    @Component
    public static class StringToEventConverter implements Converter<String, Event> {
        @Override
        public Event convert(String source) {
            return new Event(Integer.parseInt(source));
        }
    }

    @Component
    public static class EventtoStringConverter implements Converter<Event, String> {

        @Override
        public String convert(Event source) {
            return source.getId().toString();
        }
    }

}

Formatter

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/format/Formatter.html

• PropertyEditor와 유사
• Object와 String 간의 변환을 담당하는 인터페이스
• 문자열을 Locale에 따라 다국화(i18n) 기능도 제공
• FormatterRegistry에 등록하여 사용한다.
• 👉  보통 Web과 관련된 데이터 바인딩을 진행할 경우, Formatter 사용을 추천 (보통 String to Object 이기 때문)

@Component
public class EventFormatter implements Formatter<Event> {

    @Override
    public Event parse(String text, Locale locale) throws ParseException {
        return new Event(Integer.parseInt(text));
    }

    @Override
    public String print(Event object, Locale locale) {

        return object.getId().toString();
    }
}

ConversionService

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/convert/ConversionService.html

• ConversionService에서 Converter와 Formatter를 등록해준다.
• Spring MVC, Bean 설정, SpEL에 사용한다.
• DefaultFormattingConversionService 클래스에서 FormatterRegistry, ConversionService 인터페이스를 다 구현한다.
• 상속 구조

SpringBoot에서는...

• 웹 애플리케이션인 경우에는 DefaultFormattingVonversionService 를 상속하여 만든 WebConversionService를 빈으로 등록해준다.

• Formatter와 Converter 로 사용할 클래스를 빈으로 등록하면, 자동으로 Formatter와 Converter 역할로 등록해준다.

• SpringBoot에 등록되어 있는 Formatter와 Converter 를 확인하는 방법

    @Component
    public class AppRunner implements ApplicationRunner {
  
        @Autowired
        private ConversionService conversionService;
  
        @Override
        public void run(ApplicationArguments args) throws Exception {
            System.out.println(conversionService);
        }
  
    }

테스트 코드

• MockMvcTest 사용 시 기본적인 spring web 관련 빈들만 생성하여 테스트를 진행한다.
• 따라서 @WebMvcTest({EventFormatter.class, EventController.class}) 와 같이 Bean으로 등록된 클래스들을 추가하여 테스트 할 수 있다.

출처 : [인프런 강의] 백기선 - 스프링 프레임워크 핵심기술

org.springframework.core.io.Resource

특징

• java.net.URL을 추상화했다. → java.net.URL을 Spring core io Resource로 감싼 것

추상화 한 이유는 ?

• 기존 java.net.URL 에는 classpath를 기준으로 리소스를 읽어오는 기능이 없었다.
• 기존 java.net.URL 에는 ServletContext를 기분으로 상대 경로를 읽어오는 기능이 없었다.

구현체

• AbstractFileResolvingResource
• AbstractResource
• ByteArrayResource
• ClassPathResource : 지원하는 prefix : classpath
• DefaultResourceLoader.ClassPathContextResource
• DescriptiveResource
• FileSystemResource
• FileUrlResource
• InputStreamResource
• PathResource
• ServletContextResource : 웹 애플리케이션 루트에서 상대 경로로 리소스를 찾는다. (가장 많이 사용)
• TransformedResource
• TransformedResource
• UrlResource
• VfsResource

소스 읽어오기

Resource의 타입은 location 문자열과 ApplicationContext 타입에 따라 결정된다.

• 예시

  • ClassPathXmlApplicationContext -> ClassPathResource
  • FileSystemXmlApplicationContext -> FileSystemResource
  • WebApplicationContext -> ServletContextResource

• 리소스 로더에 prefix classpath:/ 가 있을 때

  • 리소스 로더의 타입은 AnnotationConfigServletWebServerApplicationContext

  • 해당 리소스 타입은 ClassPathResource

      @Autowired
          ApplicationContext resourceLoader;
    
          @Override
          public void run(ApplicationArguments args) throws Exception {
                      // 리소스 로더 타입은 class org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
              System.out.println("resourceLoader.getClass() : " + resourceLoader.getClass());
    
              Resource resource = resourceLoader.getResource("classpath:/test.txt");
              // 리소스 타입은 class org.springframework.core.io.ClassPathResource
                      System.out.println("resource.getClass() = " + resource.getClass());
          }

• 리소스 로더를 prefix 없이 받을 때

  • 리소스 로더의 타입은 AnnotationConfigServletWebServerApplicationContext

  • 해당 리소스 타입은 ServletContextResource → 디폴트로 ServletContextResource로 받는다.

    @Autowired
      ApplicationContext resourceLoader;
    
      @Override
      public void run(ApplicationArguments args) throws Exception {
                  // 리소스 로더 타입은 class org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
          System.out.println("resourceLoader.getClass() : " + resourceLoader.getClass());
    
          Resource resource = resourceLoader.getResource("test.txt");
          // 리소스 타입은 class org.springframework.core.io.ServletContextResource
                  System.out.println("resource.getClass() = " + resource.getClass());
      }

• 따라서 Resource의 경로를 작성할 때는 Prefix를 사용하는 것을 권장한다. (명시적이고 가시성 좋음)

📕 https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-as-dependencies

2. Validation 추상화

org.springframework.validation.Validator

객체를 검증하기 위해 사용하는 인터페이스 이다.

애노테이션을 사용하여 객체를 검증한다.

인터페이스

• boolean* supports(Class<?> clazz) : 어떤 객체를 검증할 것인지 정의

• void validate(Object target, Errors errors) : 실제 검증 로직을 구현

  • ValidationUtils 사용하면 편함

• Springboot 2.0.5 이상 버전

  • LocalValidatorFactoryBean 으로 자동 등록
  • 참고
    • https://beanvalidation.org/
    • https://docs.jboss.org/hibernate/beanvalidation/spec/1.1/api/

  
  
  

출처 : [인프런 강의] 백기선 - 스프링 프레임워크 핵심기술

ApplicationContext는 EnvironmentCapable이라는 인터페이스를 상속받는다.

getEnvironment() 함수로 컴포넌트와 연관된 Environment 를 리턴한다.

Profile 이란 ?

• Bean들의 그룹
• Environment 의 역할은 Active할 Profile을 확인하고 설정한다.

Profile UseCase

• Test 환경에서 A라는 Bean을 사용하지만, Release 환경에서는 B 라는 Bean을 사용하고 싶을 때
• 사용 환경에 따라 Bean의 등록 및 사용 유무를 설정하고 싶을 때

Profile 정의하기

• Class에 정의
  • @Configuration @Profile(”test”)
  • @Component @Profile(”test”)
• 메소드에 정의
  • @Bean @Profile(”test”)

Profile 설정하기

• VM Option에 설정 : -DSpring.profiles.active=”test”
• @ActiveProfiles (테스트용)

Profile 표현식

Profile 표현식에 논리연산자를 사용할 수 있다.

ex ) @Profile(”!prod”) → prod 환경이 아닐 때 bean 사용

• ! (not)
• & (and)
• | (or)

7. Environment 2부. 프로퍼티(Property)

Property 란?

• 개발 환경 구성에 필요한 설정값들, 다양한 방법으로 정의가 가능
• Environment 의 역할은 Property 소스 설정 및 Property 값 가져오기

Property의 우선순위

• StandardServletEnvironment의 우선순위
  • ServeltConfig의 매개변수
  • ServletContext의 매개변수
  • JNDI (java.comp/env)
  • JVM 시스템 Property(-Dkey=”value”)
  • JVM 시스템 환경변수 (운영체제 환경변수)

@PropertySource

• Environment 를 통해 Property를 추가하는 방법이다.
• 사용 방법 : @PropertySource("classpath:/com/jhj/app.properties")
  • 소스코드 상 Config 파일에 애노테이션을 추가
  • property 파일에 기재된 설정 값들은 @Value(${...}) 형태로 주입받아 사용이 가능하다. → BeanPostProcessor에 의해서 처리되기 때문에BeanPostProcessor나 BeanFactoryPostProcessor 내에서는 사용할 수 없다.

8. MessageSource

국제화 기능(i18n) 기능을 제공하는 인터페이스 → 메세지를 다국화 하는 기능

• ApplicationContext는 MessageSource를 상속받는다.

• SpringBoot를 사용하면, 다른 설정 없이 messages.properties 파일로 메세지 다국화 기능 사용이 가능하다.

  • messages.properties

  • messages_ko_KR.preporties

  • messages_en_US.properties

  • Local.getDefault() : 운영체제의 기본으로 설정되니 국가의 값을 가져옴 (ref. ttps://docs.oracle.com/javase/7/docs/api/java/util/Locale.html#getDefault)

      messageSource.getMessage("greeting", new String[]{"jhjhj"}, Locale.getDefault());
      messageSource.getMessage("greeting", new String[]{"jhjhj"}, Locale.KOREA);
      messageSource.getMessage("greeting", new String[]{"jhjhj"}, Locale.US);

Reloading 기능이 있는 메세지 소스

캐시 설정을 이용해서 메세지 reload가 가능하다.

@Bean
    public MessageSource messageSource(){
        var messageSource =  new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:/messages_ko_KR");
        messageSource.setDefaultEncoding("UTF-8");
        messageSource.setCacheSeconds(3);

        return  messageSource;
    }

9. ApplicationEventPublisher

ApplicationContext extend ApplicationEventPublisher

이벤트 프로그래임에 필요한 Interface를 제공한다. Observer Pattern (옵저버 패턴) 의 구현체이다.

Event 만들기

• 이벤트로 만들 클래스는 ApplicationEvnet 클래스( `org.springframework.context.ApplicationEvent`)를 상속받는다.
• Spring 4.2 버전 이후부터 이 클래스를 상속받지 않아도 이벤트로 사용할 수 있다. → 이벤트 핸들러로 사용될 클래스를 빈으로 등록하고 핸들러 메소드에 @EventListener 애노테이션을 붙이면 된다.

Event 발생 시키는 방법

ApplicationEventPublisher.publishEvent(new Evnet);

Event 처리하는 방법

1. ApplicationListener<이벤트> 로 구현한 클래스를 생성 후, Bean으로 등록한다.
2. Spring 4.2 버전부터는 @EventListener 애노테이션을 메소드에 사용해서 이벤트 리스너 메소드로 사용할 수 있다.
3. 기본적으로 동기 (synchronized) 이다. 비동기로 사용하고 싶다면 @Async 애노테이션을 클래스에 사용하면 된다.
4. 이벤트 발생 순서를 정하고 싶다면, 이벤트 리스너에 @Order 애노테이션을 사용하고, 우선순위에 따라 옵션값을 설정하면 된다.

스프링이 기본으로 제공하는 Event

• ContextClosedEvent
• ContextRefreshedEvent
• ContextStartedEvent
• ContextStoppedEvent
• RequestHandledEvent

10. ResourceLoader

Resource를 읽어오는 기능을 제공하는 Interface 이다.

ApplicationContext가 ResourceLoader를 상속받는다.

• ApplicationContext extends ResourceLoader

Resource 읽어오는 방법

• 파일 시스템에서 읽어오기
• classpath에서 읽어오기 (/target/classes가 root)
• URL 로 읽어오기
• 상대/절대 경로로 읽어오기

→ 자세한 방법은 공식 레퍼런스 참조

출처 : [인프런 강의] 백기선 - 스프링 프레임워크 핵심기술

Inversion Of Control (제어의 역전)

• 객체에 대한 제어 흐름을 직접 제어하는 게 아니라, 외부에서 관리하는 것
  → 스프링 IoC 컨테이너를 사용 가능 (꼭 Spring 에서만 사용되는 것이 아니라, 일반 POJO에서도 코드로 구현 가능하다.)

Dependency Injection (의존 관계 주입)

• 어떤 객체가 사용하는 의존 객체를 개발자가 직접 코드로 구현하는 것이 아니라, 외부에서 주입받아 사용하는 방법을 말한다.
  

Spring IoC 컨테이너

• BeanFactory : 스프링 컨테이너 가장 최상단의 인터페이스 (reference docs 참고)
• Bean 설정 소스부터 Bean의 정의를 읽어들여 Bean을 구성하고 제공한다.
  

Bean

• Spring IoC 컨테이너가 관리하는 객체

• Bean으로 등록이 되어 있어야 Spring IoC 컨테이너에 의해 의존성 주입이 가능하다.

• Spring IoC 컨테이너가 Bean의 LifeCircle 관리

• 기본적인 Scope은 싱글톤이다. (싱글톤 : 인스턴스 1개 / 프로토타입 : 매번 다른 인스턴스 생성)

  
  → 기본적으로 싱글톤으로 생성되기 때문에 메모리 관점, 런타임시 성능 최적화에도 효율적임

  
  

ApplicationContext

• BeanFactory 인터페이스를 상속 받는 인터페이스

• 가장 많이 사용하는 인터페이스

• 메시지 소스 처리 기능 (i18n, internationalization, 메세지 다국화)

• 이벤트 발행 기능

• Resource 로딩 기능 등... reference docs 참고

🖊 참고

BeanFactory (Spring Framework 5.0.8.RELEASE API) ApplicationContext (Spring Framework 5.0.8.RELEASE API)

2. ApplicationContext와 다양한 빈 설정 방법

Spring IoC 컨테이너의 역할

• Bean Instance 생성

• 의존 관계 설정

• Bean을 제공
  
  

  ApplicationContext 설정 방법

• ClassPathXmlApplicationContext(XML) → 과거 방법

  ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");       // xml 기반으로 bean 설정

• AnnotationConfigApplicationContext(Java) → Spring 2.5 버전부터 annotation 기반

• @Configuration 어노테이션을 통해, Config 파일 안에 있는 @Bean들을 빈을 등록

  ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);   // java Config 파일을 기반으로 bean 설정

  
  
  

  @SpringBootApplication

• 해당 어노테이션이 붙어있는 클래스의 package를 기반으로 Bean 등록 → SpringBoot

  @Target({ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Inherited
  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan

  
  
  

  Bean 설정

• Bean 에 대한 명세 및 정의를 담고 있다.

  • 이름, 클래스, Scope, constructor argument, property 등
    
    

    ComponentScan

• 설정 방법

  • XML 설정 (과거) : context:component-scan
  • 자바 설정 : @ComponentScan

3.@Autowired

@Autowired 애노테이션을 이용해서 필요한 의존 객체의 타입과 이름에 해당하는 빈을 찾아 주입한다.

required 옵션 : default가 true, false는 optional의 개념

사용할 수 있는 위치

Constructor (Spring 4.3 부터는 생략 가능)

@Autowired
    public BookService(BookRepository bookRepository){
        this.bookRepository = bookRepository;
    }

Setter

@Autowired(required = false)
    public void setBookRepository(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

Field

@Autowired(required = false)
    BookRepository bookRepository;

같은 타입의 Bean이 여러개 있다면 ?

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

• @Primary : Bean으로 만들고 싶은 클래스에 해당 애노테이션을 사용, (기본 값으로 사용하겠다는 의미)

• @Qualifier : Bean으로 주입받는 곳에 해당 애노테이션과 Bean이름 주입 (첫글자가 소문자인 카멜 케이스 이름, Spring Container가 최초에 빈 등록할 때의 이름 형식임) → TypeSafe 하지 않음

• 해당 타입의 Bean 이름을 모두 주입 받기

• 인스턴스 이름으로 구분 (정말 비추)

    // BookRepository 인터페이스를 상속받는 여러 클래스 중
    // MyBookResitory.class를 사용하겠다.
    @Autowired
    BookRepository myBookResitory;    

  • Spring IoC의 최상단 인터페이스 BeanFactory의 LifeCycle을 보면 알 수 있다.
  • BookRepository가 myBookResitory를 사용할 것이라는 것은 Initialization 전에 해준다.
    ( ref. postProcessBeforeInitialization methods of BeanPostProcessors)

4. Component와 컴포넌트 스캔

@ComponentScan은 Spring 3.1부터 적용이 되었다. @ComponentScan은 basePackages(String Type) 패키지 이름으로 컴포넌트 스캔을 하는 데, String값으로 패키지 이름을 받는 것은 TypeSafe하지 않다.
그래서 TypeSafe한 방법으로 basePackageClasses 라는 옵션을 사용한다. basePackageClasses 을 사용하면, 해당 옵션에 전달된 클래스가 있는 패키지를 기준으로 컴포넌트 스캔을 시작한다. → SpringBoot에서 @SpringBootApplication 애노테이션은 @ComponentScan을 포함하고 있다.
따라서, @SpringBootApplication이 붙은 클래스의 Package와 다른 상속 Package에 있는 클래스들은 ComponetScan이 되지 않는다.

컴포넌트 스캔 주요 기능

• 스캔 위치를 설정한다.
• filter : 어떤 애노테이션을 스캔할 지 or 스캔하지 않을 지
  • excludeFilters → TypeExcludeFilter.class, AutoConfigurationExcludeFilter.class
    

ComponentScan의 대상

• @Repository
• @Service
• @Controller
• @Configuration
  

function을 이용한 Bean 등록

• Bean 등록 시, ComponentScan 에 해당되지 않는 빈들을 등록할 수 있다.
• 성능을 높일 수 있다. (하지만, 필요에 따라 사용해야 한다. 무조건 사용은 비추)

// MyBean.class / ComPonentScan 외에 있는 bean을 function을 이용해서 등록이 가능하다. 
public static void main(String[] args) {
    new SpringApplicationBuilder()
            .sources(Demospring51Application.class)
            .initializers((ApplicationContextInitializer<GenericApplicationContext>)
        applicationContext -> {
            applicationContext.registerBean(MyBean.class);
    })
    .run(args);
}

5. 빈의 스코프

Scope

singleton

• (Spring의 디폴트) 전체 application 내 해당 빈의 인스턴스가 오직 1개

prototype

인스턴스를 여러개로 만들 수 있다.

• Request: request에 따라
• Session : 세선에 따라
• WebSocket : 웹 소켓에 따라

prototype의 bean이 singleton을 참조하면 ?

참조하는 싱글톤은 늘 인스턴스가 1개이기 때문에 개발자의 의도대로 사용이 된다.

Singleton의 bean이 prototype의 bean을 참조하면 ?

• 프로토타입의 빈이 변경이 안된다. → 싱글톤 빈이 최초 인스턴스화 될 때, 처음으로 만들어졌던 프로토타입의 인스턴스만을 참조하기 때문
• 업데이트 하려면 ?
  • @Scope*(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS) : 프로토타입 클래스의 선언부에 다음과 같이 설정한다.
    • 해당 클래스를 Proxy로 감싸라. → 싱글톤 객체가 프로토타입 객체를 접근할 때 proxy를 거쳐서 참조하도록
    • 기존 JVM에 있는 proxy는 interface 기준으로만 proxy를 만들어 주는 데, 이 방법을 사용하면 CGLib을 사용하여 class도 proxy가 되도록 만들어준다.
  • ObjectProvider
  • Provider

출처 : [인프런 강의] 백기선 - 스프링 프레임워크 핵심기술

도메인 특화 언어에 산술 표현식을 다루는 라이브러리가 필요하다고 가정해보다

예시의 첫단계는 입력 데이터를 정의하는 것 문제를 간단히 하기 위해 변수와 숫자, 단항/이항 연산자로 이뤄진 산술식

abstract class Expr        
case class Var (name: String) extends Expr
case class Number (name: Double) extends Expr
case class UnOp (operatot: String, arg : Expr) extends Expr
case class BinOp (operatot: String, left: Expr, right: Expr) extends Expr

• 추상 기본 클래스 하나
• 그 클래스를 상속한 4개의 서브 클래스, 각 서브클래스는 식의 한종류를 표현
• 모든 클래스의 내용은 비어있음

케이스 클래스

class 선언 앞에 case가 붙어있으면 케이스 클래스라고 부른다.

case 클래스의 편리한 기능

1. 컴파일러는 클래스 이름과 같은 이름의 팩토리 메소드를 추가
   • 팩토리 메소드는 중첩해서 객체를 생성할 때 좋음
     • ex ) new Var("x") 대신 Var("x")를 사용해서 Var 객체 생성 가능

scala> val v = Var("x")
v: Var = Var(x)

2. 케이스 클래스의 파라미터 목록에 있는 모든 인자에 암시적으로 val 접두사를 붙인다. 각 파라미터가 클래스의 필드도 된다.

3. 스칼라 컴파일러는 케이스 클래스에 toString, hashCode, equals 메소드의 일반적인 구현을 추가

4. 스칼라 컴파일러는 케이스 클래스에서 일부를 변경한 복사본을 생성하는 copy 메소드를 추가

   • 기존 인스턴스에 하나 이상의 속성을 바꾼 새로운 인스턴스를 생성할 때 유용 (copy 메소드 8.8절 참조)

패턴 매치

// 패턴 매치를 사용하는 simplifyTop 함수
def simplifyTop(expr: Expr) : Expr = expr match {
    case UnOp("-", UnOp("-", e)) => e       // 부호를 두 번 반전
    case BinOp("+", e, Number(0)) => e      // 0을 더함
    case BinOp("*", e, Number(1)) => e      // 1을 곱함
}

def simplifyTop(expr: Expr): Expr

scala> simplifyTop(UnOp("-", UnOp("-", Var("x"))))
val res0: Expr = Var(x)

• 스칼라는 다음과 같은 형식으로 패턴 매치를 사용 셀렉터 match { 대안들 } 참고) 자바의 스위치문 switch (셀렉터) { 대안들 }

• 셀렉터(selector)는 match 표현식에서 사용이 되는 값
• 패턴 매치에는 case 키워드로 시작하는 여러 대안(alternative)들이 들어간다.
• 각각의 대안에서는 패턴과 셀렉터가 일치하였을 때 계산되는 하나 이상의 표현식을 포함한다.
• 패턴과 표현식을 분리하는 것은 화살표(=>)이다.
• 따라서, match를 통해서 패턴을 하나씩 검사하게 되면 이 중 첫 번째로 일치한 패턴을 선택해서 화살표 뒤의 표현식을 실행하게 된다.

패턴 형식

1. 상수 패턴

• "+" 문자열이나 1과 같은 상수 패턴은 ==을 적용해서 매치

2. 변수만 사용한 패턴

• e와 같이 오른쪽에 있는 표현식에 변수가 있으면 그 변수는 매치된 값을 가르킨디ㅏ.

3. 와일드카드 패턴

• case+ => expr와 같은 형태
• 언더스코어(_)를 활용하면 모든 값 매치 가능
• but, 해당 값에 이름을 붙이지 않기 때문에 표현식에서는 사용 X

4. 생성자 패턴

• case UnOp("-", UnOp("-", e)) => e 와 같은 형태
• 어떤 값의 타입이 UnOp이고, 첫 번째 인자가 "-"이며, 두 번째 인자를 e에 매치시킬 수 있다면 해당 생성자 패턴과 매치 가능

switch와 match 비교

• match식은 자바 스타일 switch를 일반화

• 하지만 switch와 다르게 주의할 점 3가지

  • 스칼라의 match는 표현식, 따라서 항상 결과값을 내놓는다.

  • 스칼라의 대안 표현식은 다음 케이스로 빠지지 않는다.

  • switch에서 각 case에 대해 break가 있다는 전제로 생각하면 된다.

  • 매치에 성공하지 못한 경우, MatchError 예외 발생 따라서 default 케이스는 반드시 추가해야한다. case _ => // default case

패턴의 종류

와일드카드 패턴

expr match {
    case BinOp(_, _, _) => println(expr + " is a binary operation")
    case _ => println("It's something else")
}

• 와일드카드패턴은 (_) 어떤 객체라도 매치 가능
• default case로 사용하거나 BinOp에 대한 인자로 사용 가능

상수 패턴

x match {
    case 5 => "five"
    case true => "truth"
    case "hello" => "hi!"
    case Nil => "the empty list"
    case _ => "something else"
}

• 상수 패턴은 자신과 똑같은 값과 매치, 어떤 리터럴이든 상수로 사용 가능
• val이나 싱글톤 객체도 상수로 사용 가능. ex) Nil은 오직 빈 리스트에만 매치시킬 수 있는 패턴

변수 패턴

// 변수 패턴을 사용한 패턴 매치
expr match {
  case 0 => "zero"
  case somethingElse => "not zero: " + somethingElse
}

• 와일드카드 패턴처럼 변수 패턴은 어떤 객체와도 매치 됨
• 하지만 변수 패턴은 와일드카드 패턴과 아래와 같은 점들이 다르다.
  • 언더스코어 (_)가 아닌 변수에 객체를 바인딩한다.
  • 변수를 표현식에서 활용할 수 있다.

변수 또는 상수 ?

상수 패턴이 기호로 이뤄진 이름일 수도 있다. ex) Nil

scala> import math.{E, Pi}
import math.{E, Pi}

scala> E match {
         case Pi => "strange math? Pi = " + Pi
         case _ => "OK"
       }
res11: String = OK

컴파일러는 Pi가 셀럭터와 매치시킬 변수가 아니라, scala.math 로 부터 import 한 상수인지 알 수 있을 까?

소문자로 시작하는 간단한 이름은 패턴 변수로 취급하고 다른 모든 참조는 상수로 간주한다.

scala> val pi = math.Pi
pi: Double = 3.141592653589793

scala> E match {
         case pi => "strange math? Pi = " + pi
       }
res12: String = strange math? Pi = 2.718281828459045

※ 소문자 이름을 상수 패턴으로 사용하고 싶으면 두 가지 방법

• 상수가 어떤 객체의 필드인 경우에는 지정자(qualifier)를 앞에 붙일 수 있다.

• 역따옴표(｀)를 사용한다.

생성자 패턴

expr match {
    case BinOp("+", e, Number(0)) => println("a deep match")
    case _ =>
}

• 깊은 매치(deep match)를 지원
• 어떤 패턴이 제공받은 최상위 객체를 매치시킬 뿐만 아니라, 추가적인 패턴으로 객체의 내용에 대해서도 매치를 시도 ex)
  • 최상위 객체가 BinOP인지 검사
  • BinOP 객체의 세번째 생성자 인자가 Number 타입의 객체인지 확인
  • Number 타입 객체의 값 필드가 0인지 확인
• 실제로는 객체 트리 구조를 세 단계 내려가면서 패턴을 매치

시퀀스 패턴

배열이나 리스트 같은 시퀀스 타입에 대해서도 매치가 가능

expr match {
    case List(0, _, _) => println("found it")
    case _ =>
}

• 0부터 시작하여 오직 세 원소만 가진 리스트 검사

// 길이와 관계 없이 매치할 수 있는 시퀀스 패턴
expr match {
    case List(0, _*) => println("found it")
    case _ =>
}

• 리스트 길이가 한정적이지 않을 떄는 마지막 원소를 _*로 표시

튜플 패턴

expr match {
    case (a, b, c)  =>  println("matched " + a + b + c)
    case _ =>
}

• 튜플도 패턴 매치 가능, 각 튜플에 맞는 원소들을 extract하여 표현식에서 활용 가능

타입 지정 패턴

val x : Any = ...

x match {
    case s: String => s.length
    case m: Map[_, _] => m.size
    case _ => -1
}

• 타입 검사나 타입 변환을 간편하게 하기 위해 타입 지정 패턴 사용
• s나 x 모두 동일한 값 참조하지만, x는 Any 타입, s는 String 타입 -> 모든 String 인스턴스와 매치 가능
• Map[_,_]은 와일드 카드를 활용한 타입 지정 패턴
  • 키와 값의 타입과 관계없이 Map 타입의 값과 매치
  • m은 그 값을 가리킨다.

변수 바인딩

// (@ 기호를 사용한) 변수 바인딩이 있는 패턴
expr match {
    case UnOp("abs", e @ UnOp("abs", _)) => e
    case _ =>
}

• 패턴 매칭에 성공하면 변수 e에는 UnOp("abs", _)) 구문에서 생성된 객체가 할당

그 외 기타

Option type

def optionsPatternMatching(option: Option[String]): String = {
  option match {
    case Some(value) => s"I'm not an empty option. Value $value"
    case None => "I'm an empty option"
  }
}

정규식 패턴 사용

def regexPatterns(toMatch: String): String = {
  val numeric = """([0-9]+)""".r
  val alphabetic = """([a-zA-Z]+)""".r
  val alphanumeric = """([a-zA-Z0-9]+)""".r

  toMatch match {
    case numeric(value) => s"I'm a numeric with value $value"
    case alphabetic(value) => s"I'm an alphabetic with value $value"
    case alphanumeric(value) => s"I'm an alphanumeric with value $value"
    case _ => s"I contain other characters than alphanumerics. My value $toMatch"
  }
}

패턴 가드

문법적인 패턴 매치만으로 case에 대한 구분이 부족할 때, 패턴 가드를 사용 case 문을 좀 더 구체화하고 명확하게 하기 위한 boolean 표현식 이라고 생각

• 패턴 가드는 패턴 뒤에 오고 if로 시작 어떤 불리언 표현식이든 가드가 될 수 있음.

  // 패턴 가드가 있는 match 표현식
  scala> def simplifyAdd(e: Expr) = e match {
         case BinOp("+", x, y) if x == y =>
           BinOp("*", x, Number(2))
         case _ => e
       }
  simplifyAdd: (e: Expr)Expr

패턴 겹침

패턴 매치는 코드에 있는 순서를 따른다. 그래서 case 문에 대한 순서가 굉장히 중요하다. 아래 예시를 보면 알 수 있다.

// case의 순서가 중요함을 보여주는 match 표현식
def simplifyAll(expr: Expr): Expr = expr match {
    case UnOp("-", UnOp("-", e)) => simplifyAll (e)  // Double negation
    case BinOp("+", e, Number(0)) => simplifyAll (e)     // Adding zero
    case BinOp("*", e, Number(1)) => simplifyAll (e) // Multiplying by one
    case UnOp(op, e) => UnOp(op, simplifyAll(e))
    case BinOp(op, 1, r) => BinOp(op, simplifyAll(1), simplifyAll(r))
    case _ => expr
}

def simplifyTop(expr: Expr): Expr = expr match {
   case UnOp("-", UnOp("-", e))  => e   // Double negation
   case BinOp("+", e, Number(0)) => e   // Adding zero
   case BinOp("*", e, Number(1)) => e   // Multiplying by one
   case _ => expr
}

• simplifyAll 함수는 이전에 정의된 simmplifyTop과 달리 산술식의 최상위 위치뿐 아니라 식의 모든 곳에 간소화 규칙을 적용

• simplilfyTop 함수에서 2가지의 케이스를 추가하였다.

  • case UnOp(op, e) => UnOp(op, simplifyAll(e))
    • 모든 단항 연산과 매치
  • case BinOp(op, 1, r) => BinOp(op, simplifyAll(1), simplifyAll(r))
    • 모든 이항 연산과 매치

• 마지막으로 모든 경우를 처리하는 case 문이 더 구체적인 규칙 다음에 온다는 점이 중요

• 만약 순서를 바꾸게 되면 구체적인 매치는 시도 자체를 하지 않을 것

  scala> def simplifyBad(expr: Expr): Expr = expr match {
         case UnOp(op, e) => UnOp(op, simplifyBad(e))
         case UnOp("-", UnOp("-", e)) => e
       }
  <console>:21: warning: unreachable code
         case UnOp("-", UnOp("-", e)) => e
                                         ^
  simplifyBad: (expr: Expr)Expr

  봉인된 클래스

  패턴 매치를 작성할 때, 모든 경우를 다 다뤘는 지 확인할 필요가 있다. 그래서 default 케이스를 추가해서 할 수 도 있지만, 이는 합리적인 디폴트 케이스가 있을 때만 가능 -> 만약 디폴트 동작이 없다면 ??

• 아무곳에서 케이스 클래스를 정의할 수 있기 때문에, 컴파일러에게 놓친 패턴 조합을 찾아달라고 요청할 수 없음...

• 패턴 매치를 작성할 때 match 식에서 놓친 패턴 조합을 찾을 수 있는 방법은 sealed 키워드를 활용

• 즉, 패턴 매치에서 셀렉터에 대한 타입을 sealed 클래스로 정의하고 매치를 하는 클래스는 모두 sealed 클래스를 상속받은 클래스로 정의하는 것이다.

// 봉인된 케이스 클래스 계층
sealed abstract class Expr
case class Var(name: String) extends Expr
case class Number(num: Double) extends Expr
case class UnOp(operator: String, arg: Expr) extends Expr
case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

• sealed 클래스를 대상으로 패턴 매치를 하게 되면 상속받은 나머지 클래스에 대하여도 모두 case 구문을 만들어줘야 함
• 하지만 아래와 같이 패턴 매치를 하게 되면 warning이 발생한다. 컴파일러의 경고, 몇가지 가능한 패턴(UnOp, BinOp)을 처리하지 않았기 때문에 예외 발생

• 나머지 case 구문을 언더스코어(_)로 처리하여도 문제는 없지만 이상적이진 않으므로 추천은 하지 않는다.
• 또 다른 방법으로 셀렉터에 @unchecked 어노테이션을 추가 그러면 컴파일러는 그 match 문의 case 문이 모든 패턴을 다 다루는지 검사하는 일을 생략

def describe(e: Expr): String = e match {
    case Number(_) => "a number"
    case Var(_) => "a variable"
}

// 컴파일러의 경고
warning: match is not exhaustive!
missing combination UnOp
missing combination BinOp

// 셀렉터에 @unchecked 어노테이션을 추가
// 컴파일러는 그 match 문의 case 문이 모든 패턴을 다 다루는지 검사하는 일을 생략
def describe(e: Expr): String = (e: @unchecked) match {
    case Number(_) => "a number"
    case Var(_) => "a variable"
}

Option 타입

• 스칼라에서는 Option이라는 표준 타입 존재
• 이 타입은 선택적인 값을 표현하며, 두 가지 형태가 있다.
  • x가 실제 값이라면 Some(x) 라는 형태로 값이 있음을 표현할 수 있다.
  • 반대로 값이 없으면 None이라는 객체가 된다.
• 스칼라 컬렉션의 몇몇 표준 연산에서는 Option이라는 선택적인 값을 생성한다. 그 중 Map의 get 메소드를 예시로 들 수 있다.

scala> val capitals =  Map("France"->"Paris", "Japan"->"Tokyo")
capitals: scala.collection.immutable.Map[String,String] = Map(France -> Paris, Japan -> Tokyo)

scala> capitals get "France"
res23: Option[String] = Some(Paris)

scala> capitals get "North Pole"
res24: Option[String] = None

• java에서는 값이 없을 경우, null을 주로 사용하는 데, 스칼라에서 Option을 활용하면 다음과 같은 장점이 있다.
  • Option[String] 타입의 변수가 null이 될 수도 있는 String 타입의 변수보다 선택적인 String이라는 사실을 더 명확하게 드러내준다

Option[String] 타입의 변수가 null이 될 수도 있는 String 타입의 변수보다 선택적인 String이라는 사실을 더 명확하게 드러내준다.

패턴은 어디에나

독립적인 match 표현식뿐 아니라, 스칼라의 여러 곳에서 패턴을 사용할 수 있다.

변수정의에서 패턴 사용하기

val이나 var 정의할 때, 단순 식별자 대신 패턴 사용 가능

scala> val myTuple = (123, "abc")
myTuple: (Int, String) = (123,abc)

scala> val (number, string) = myTuple
number: Int = 123
string: String = abc

case를 나열해서 부분 함수 만들기

함수 리터럴이 쓰일 수 있는 곳이라면, 중괄호 사이에 case를 나열한 표현식 작성 가능 본질적으로 case의 나열도 함수의 리터럴 값

• 각각의 case가 함수의 진입점이고, 패턴은 파라미터를 명시한다.
• 각 진입점에 따른 함수의 본문은 case의 오른쪽 (화살표 =>의 오른쪽)

val withDefault: Option[Int] => Int = {
    case Some(x) => x
    case None => 0
}

아래 예시는 아카 엑터(Akka actors) 라이브러리에서 사용하는 receive 메소드

var sum = 0

 // case의 나열은 부분 함수 이다.
def receive = {
    case Data(byte) =>
        sum += byte
    case GetChecksum(requester) =>
        val checksum = ~(sum & OxFF) + 1
        requester ! checksum
}

• case 나열의 부분 함수에서 그 함수가 처리하지 않는 값을 전달해서 호출하면 실행 시점에서 예외가 발생

scala> val second: List[Int] => Int = {
     |   case x :: y :: _ => y
     | }
                                      ^
       warning: match may not be exhaustive.
       It would fail on the following inputs: List(_), Nil
val second: List[Int] => Int = $Lambda$1061/638249818@4f6e663b

scala> second(List(5,6,7))
val res3: Int = 6

scala> second(List())
scala.MatchError: List() (of class scala.collection.immutable.Nil$)
  at $anonfun$second$1(<console>:1)
  at $anonfun$second$1$adapted(<console>:1)
  ... 32 elided

• 처리하지 않는 값을 전달하여 예외가 발생시에 처리 방법

  • 예외를 던져서 호출자에게 전달한다.

  • 스칼라의 Option이나 Either 등을 사용하여 정상적인 값과 그렇지 않은 값을 처리할 수 있다.

  • 부분 함수를 사용하여 처리하지 않는 값에 대하여는 작업을 하지 않도록 할 수 있다.

  • 여기선, 처리하지 않는 값을 다루기 위해서 부분 함수를 포함하는 타입인 PartitionFunction을 이용한다.

    • PartitionFunction 클래스는 isDefinedAt 함수를 사용함으로써 파라미터가 case 구문에 속해있는지 먼저 확인을 할 수 있다.
    • 아래 예시에서 second는 PartitionFunction 타입의 객체로서 정수형 리스트를 받아서 정수 값을 반환한다.

      scala> val second : PartialFunction[List[Int], Int] = {
      |   case x :: y :: _ => y
      | }
      val second: PartialFunction[List[Int],Int] = <function1>
      

scala> second.isDefinedAt(List(5,6,7)) val res5: Boolean = true

scala> second.isDefinedAt(List()) val res6: Boolean = false

scala> second(List(5,6,7)) res0: Int = 6

// 하지만, PartitionFunction에서도 예외가 발생하는 것은 여전하다. scala> second(List()) scala.MatchError: List() (of class scala.collection.immutable.Nil$) at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:259) at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:257) at $anonfun$1.applyOrElse(:11) at $anonfun$1.applyOrElse(:11) at scala.runtime.AbstractPartialFunction.apply(AbstractPartialFunction.scala:38) ... 28 elided

## for 표현식에서 패턴 사용하기
* for 표현식 안에 패턴을 사용할 수 있다.

*  아래 예시는 capitals 맵에서 모든 키/값 쌍을 가져온다.
* 각 튜플은 country와 city 변수가 있는 패턴과 매치된다.
* 두 번째 예시는 튜플 패턴과 정확히 매치하지 않을 경우에 해당 값을 버리는 경우에도 사용된다.

``` java
scala> for ((country, city) <- capitals)
         println("The capital of " + country + " is " + city)
The capital of France is Paris
The capital of Japan is Tokyo

• 튜플 패턴과 정확히 매치하지 않을 경우에 해당 값을 버리는 경우에도 사용

  scala> val results = List(Some("apple"), None, Some("orange"))
  results: List[Option[String]] = List(Some(apple), None, Some(orange))
  

scala> for (Some(fruit) <- results) println(fruit) apple orange

```

결론

• 스칼라의 케이스 크랠스와 패턴 매치를 활용하면 보통의 객체지향 언어에서 지원하지 않는 간결한 표현법의 이점이 있다.
• 어떤 클래스에 대해 패턴 매치를 사용하고 싶지만, 케이스 클래스처럼 클래스 필드를 외부에 노출하고 싶지 않다면, 26장의 익스트렉터(Extractor)를 사용할 수 있다.

여러 기본 클래스를 어떻게 구현했는가?

바닥에 있는 타입

자신만의 값 클래스 정의

추상클래스

파라미터 없는 메소드 정의

클래스 확장

메소드와 필드 오버라이드

파라미터 필드 정의

슈퍼클래스의 생성자 호출

override 수식자 사용

다형성과 동적 바인딩

final 멤버 선언

상속과 구성 사용

above, beside, toString 구현

팩토리 객체 정의

높이와 너비 조절

한데 모아 시험해보기

클라이언트 코드 단순하게

커링

새로운 제어 구조 작성

이름에 의한 호출 파라미터

지역 함수

1급 계층 함수

간단한 형태의 함수 리터럴

위치 표시자 문법

부분 적용한 함수

클로저

특별한 형태의 함수 호출

꼬리 재귀

명령형 언어 스타일

var filename = "default.txt"
  if (!args.isEmpty)
    filename = args(0)

if 표현식에서 조건 결과가 참일 여부에 따라 분기 중 하나를 실행

스칼라 스타일

val filename = if (!args.isEmpty) args(0) else "default.txt"

스칼라 if 표현식은 결과로 값을 내놓는다.

var 대신 val로 선언하면 좋은 점

• 변수가 사용되는 범위 내에서 값의 변화 여부를 판단하기 위해 모든 코드 살펴볼 필요 X
• 동일성 추론 : 해당 표현식에 사이드 이펙트가 존재하지 않기 때문에 값과 동일시하여 사용 가능

// 예시
println(filename) → println(if (!args.isEmpty) args(0) else "default.txt")

while 루프

• while과 do-while은 표현식이 아니라, loop라고 부름
• loop의 결과 타입은 Unit이다. 그래서 어느정도의 side effect가 발생할 수 있음
• Unit 타입에는 Unit value 밖에 없고, 이 값을 빈 괄호()로 표기

  // 최대 공약수 구하기
  def gcdLoop(x: Long, y: Long): Long = {
    var a = x
    var b = y
    while (a != 0) {
        val temp = a
        a = b % a
        b = temp
    }
    b
  }
  

// 결과 scala> gcdLoop(10, 20) val res0: Long = 10

scala> gcdLoop(4, 6) val res1: Long = 2

* ()은 값이 존재한다는 점에서 자바의 void와 다른 의미이다.
```java
scala> def greet() = { println("hi") }
def greet(): Unit

scala> () == greet()
hi
val res10: Boolean = true

greet는 결과 타입이 Unit인 프로시저라고 한다. (결과 값이 있으면 함수, 결과 값이 없으면 프로시저라고 부른다.)

• ()은 당연히 ()를 반환할 것이고, greet() 또한 Unit 함수이기 때문에 ()를 반환하므로 서로 동일하다.

• 다음과 같이 일반적인 형태로 while 루프를 스칼라에서 사용하면 문제가 생긴다.

scala> while ((line = scala.io.StdIn.readLine()) != "")
     |   println("Read: " + line)
                                                 ^
       warning: comparing values of types Unit and String using `!=` will always yield true
Read: ddd
Read: ddd
Read:
Read:

• 위의 readLine 함수는 Unit 타입으로 정의되어 있다. => 결과 값은 ()일 것이고 해당 값은 빈 문자열인 ""와 같을 수 없을 것이다.

• 자바에서는 위와 관련된 I/O 함수가 실행되었을 때 line 이라는 변수에 값이 할당이 되겠지만 스칼라는 해당 함수가 Unit 타입이면 항상 ()를 반환한다.

이를 해결 하기 위해서...

scala> while({line = scala.io.StdIn.readLine(); line != ""})
     |   println("Read: " + line)

for 표현식

여러가지 방법으로 조합해서 다양한 반복 작업을 처리할 수 있다. 연속적인 정수에 대해 작업을 처리하는 것도 간략하게 가능하며, 여러 종류 컬렉션을 대상으로 조건에 맞는 요소를 가려내고 새로운 컬렉션을 만들 수 있다.

컬렉션 이터레이션

val filesHere = (new java.io.File(".")).listFiles
val filesHere: Array[java.io.File] = Array(.\fsc, .\fsc.bat, .\scala, .\scala.bat, .\scalac, .\scalac.bat, .\scaladoc, .\scaladoc.bat, .\scalap, .\scalap.bat)

 scala> for (file <- filesHere) {
     |   println(file)
     | }
.\fsc
.\fsc.bat
.\scala
.\scala.bat
.\scalac
.\scalac.bat
.\scaladoc
.\scaladoc.bat
.\scalap
.\scalap.bat

• 자바 API를 사용해서 디렉토리 내의 모든 파일을 출력하는 코드
• file <- filesHere 은 제너레이터(generator)라고 부른다. 각 단계마다 file 이라는 val 원소 값으로 초기화 한다.
• 컴파일러는 files가 Array[File] 타입이기 때문에 file의 타입도 File을 추론할 수 있다.

필터링

컬렉션 모든 원소 접근 않고 일부만 사용하고 싶은 경우, for 문에 if 사용 가능하다.

var filesHere = (new java.io.File(".")).listFiles
var filesHere: Array[java.io.File] = Array(.\fsc, .\fsc.bat, .\scala, .\scala.bat, .\scalac, .\scalac.bat, .\scaladoc, .\scaladoc.bat, .\scalap, .\scalap.bat)


 for (file <- filesHere if file.getName.endsWith(".bat")) {
     |   println(file)
     | }
.\fsc.bat
.\scala.bat
.\scalac.bat
.\scaladoc.bat
.\scalap.bat

• 위 예제는 if 문을 활용해서 조건 별로 file들을 대상으로 명령 수행 가능

  for 표현식은 사용하기 위한 값을 결과로 내놓는다.

try 표현식

Scala도 try 를 이용해서 예외를 처리하거나 종료할 수 있다.

예외 발생시키기

스칼라에서 예외를 발생시키는 방법은 throw 키워드를 사용해 생성한 예외를 던지면 된다.

스칼라에서는 throw가 결과 타입이 있는 표현식이다.

val half =
    if (n%2==0)
        n/2
    else
        throw new RuntimeException("n must be even")

n이 짝수이면, half에는 n의 반에 해당하는 값이 할당 n이 짝수가 아니면, 어떤 값으로도 초기화하지 않고 그 전에 예외를 발생 따라서, else 부분에서 어떤 예외를 던지더라도 이를 원하는 타입으로 다뤄도 문제 없다. 기술적으로 예외는 Nothing이라는 타입을 갖는다.

• Nothing 타입은 모든 타입의 서브타입, 값을 도출해내는 과정에서 예외가 있더라도 타입 에러에 관한 문제는 없다.

발생한 예외 잡기

try-catch 구문 사용, 다른 언어와 마찬가지로 예외가 발생하면 catch 구분에서 예외처리 시도 throws 선언하지 않고, 예외 메소드만 명시 가능 => @throws 어노테이션 명시 가능

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

try {
    val f = new FileReader("input.txt") // 파일을사용하고닫는다.
} catch {
    case ex: FileNotFoundException => // 파일을못찾는경우 처리
    case ex: IOException => // 그 밖의 10 오류 처리
}

finally 절

항상 실행하고 싶은 코드가 있을 경우에 finally로 감싸서 사용

import java.io.FileReader

val file = new FileReader("input.txt")
try {
  // 파일을사용한다.
} finally {
    file.close() // 파일을확실히 닫는다.
}

값 만들어내기

try-catch-finally의 결과는 값이다. 예외가 발생하지 않을 경우 -> 전체 결과는 try 절의 수행결과가 전체 결과 예외가 발생하여 예외를 잡은 경우 -> catch절의 수행 결과가 전체 결과 finally 절에 결과 값이 있다면 버려진다. finally 절은 파일을 닫는 등 정리 작업을 수행하므로, try 절, catch 절의 결과를 수정하지 않아야한다.

import java.net.URL
import java.net.MaiformedURLException

def urlFor(path: String) = 
  try {
    new URL(path)
  } catch {
    case e: MaiformedURLException =>
        new URL("http://www.scala-lang.org")
  }

match 표현식

스칼라의 match 표현식은 switch문과 유사하지만, 다음과 같은 차이점 존재

• java의 case 문에는 enum 값이나, 정수 type의 값 또는 문자열 값만 쓸 수 있지만, 스칼라는 어떤 종류의 상수도 사용 가능
• break 구문이 없다. 따라서 코드가 짧고 실수로 break을 넣지 않았을 때의 발생하는 오류를 막을 수 있다.
• match 표현식은 결과가 곧 값이다.
• case _ 는 switch 문에서 default 문과 비슷한 역할을 한다.
• _는 placeholder로 완전히 알려지지 않은 값을 표시하기 위해서 사용

  val firstArg = if(!args.isEmpty)
                    args(0)
                else
                      ""
  

val friend = { firstArg match { case "salt" => "paper" case "chips" => "salsa" case "eggs" => "bacon" case _ => "huh?" }

println(friend) }

# break, continue 문 없이 살기
break, continue는 스칼라에서 자주 쓰이는 함수형 리터럴과 어울리지 않기 때문에 많이 사용되지 않는다.
break, continue를 사용하지 않고 프로그램을 제저할 수 있다.

* 모든 continue 문을 if로, 모든 break 문을 boolean 변수로 대체한다.
* 재귀함수를 이용한다.

```javascript
var i = 0
var foundIt = false

while(i<args.length && !foundIt) {
    if(!args(i).startsWith("-")) {
        if(args(i).endsWith(".scala"))
            foundIt = true
    }
    i = i+1
}

foundIt 변수가 boolean 변수의 역할을 하고 있다. 중첩 if문 내에서 continue로 인해 pass되는 코드들이 존재한다.

def searchFrom(i: Int): Int = {
    if(i>=args.length) -1
    else if(args(i).startsWith("-")) searchFrom(i+1)
    else if(args(i).endsWith(".scala")) i
    else searchFrom(i+1)   
}

varl i = searcmFrom(0)

• 스칼라 컴파일러는 위 코드에 대해서 재귀함수를 만들지 않는다.
• 모든 재귀 호출은 꼬리 재귀 호출이기 떄문에 컴파일러는 while 루프와 비슷한 코드를 만들어내어 최적화를 한다.

변수 스코프

자바와 스칼라의 스코프 규칙이 자바와 거의 동일 한가지 차이점 -> 스칼라의 내부 스코프에서 동일한 이름의 변수를 정의해도 된다.

자바는 바깥 스코프에 존재하는 변수와 동일한 이름의 변수를 안쪽 스코프에 선언하지 못한다. 하지만, 스칼라에서는 동일한 이름의 변수를 선언하면, 안쪽 스코프에서 바깥쪽 스코프에 있는 동일한 이름의 변수가 보이지 않는 것 처럼 동작 -> 안쪽 변수가 바깥 스코프의 변수를 가렸다. (shadow)라고 표현

명령형 스타일 코드 리펙토링

// 명령형 스타일로 코딩
def printMultiTable() = {
        var i = 1
        while(i<=10) {
          var j = 1
          while(j<=10) {
            val prod = (i*j).toString
            var k = prod.length
            while(k<4) {
              print(" ")
              k += 1
            }
            print(prod)
            j += 1
          }
          println()
             i += 1
        }
      }


// 함수형 스타일로 코딩
def makeRowSeq(row:Int) = {
        for(col <- 1 to 10) yield {
          val prod = (row * col).toString
          val padding = " " * (4 - prod.length)
          padding + prod
        }
      }

변경 불가능한 객체의 장단점

장점

• 객체 생명주기 동안 상태가 변하지 않기 때문에 객체의 내부 값을 추론하기 쉽다.
• 내부 상태 변경이 불가능하기 때문에 메소드 인자로 전달을 자유롭게 할 수 있다.
• 내부 상태 변경이 불가능하기 때문에 여러 스레드에서 접근할 수 있다. (동기화 문제를 고려X)
• 변경 불가능한 객체는 안전한 해시 테이블 키로 사용될 수 있다. ( HashSet에 변경 가능한 객체를 키로 설정하고, 상태를 변경하게 되면 HashSet에서 해당 객체를 찾을 수 없는 경우가 발생한다. )

단점

• 상태를 변경하기 위해서는 각 상태마다 새로운 객체를 만들어야 된다. 만약 객체 생성 비용이 높다면 성능상의 병목이 발생할 수 있다.

분수 클래스 명세

• 분수(rational number)는 n과 d가 정수, d>0 일 때, n/d로 표시
• n은 분자, d는 분모
• 분수의 사칙연산을 보면, 수학의 분수에는 변경 가능한 상태가 없음을 알 수 있다. (각각의 피연산자들을 연산하면, 새로운 분수가 결과값으로 나온다.) 원래 있던 두 분수 자체를 변경한 것은 아니다.

따라서 피연산자가 되는 각 분수는 서로 다른 Rational 객체이다. 어떤 두 Rational 객체를 더하면, 그 합에 해당하는 새로운 Rational 객체가 생긴다.

이번 장을 마치면, Rational 클래스를 사용해 다음과 같은 일을 할 수 있다.

scala〉 val oneHalf = new Rational(l, 2)
oneHalf: Rational = 1/2

scala〉 val twoThirds = new Rational(2, 3)
twoThirds: Rational = 2/3

scala> (oneHalf / 7) + (1 - twoThirds)
resO: Rational = 17/42

Rational 생성

Rational 객체는 변경 불가능한 객체라고 결정하였다. 변경 불가능한 객체는 인스턴스에 필요한 정보(분수 객체라면 분자,분모 값)를 생성 시점에 모두 제공하여 설계한다. → 생성한 다음에 값을 수정할 수 있게 되면 변경 가능한 객체가 된다.

class Rational(n: Int, d:Int)    // n, d는 클래스 파라미터

◼️ 스칼라 컴파일러는 내부적으로 두 클래스 파라미터를 종합해서 클래스 파라미터와 같은 두 인자를 받는 주 생성자 (Primary Constructor)를 만든다.

◼️ Java에서는 클래스에 인자를 받는 생성자가 있지만, 스칼라에서는 클래스가 바로 인자를 받는다. 이러한 스칼라의 표기는 클래스 내부에서 파라미터를 바로 사용할 수 있어서 좀 더 간결하다.

필드를 정의하고 생성자의 인자를 필드로 복사하는 할당문 없어도 됨(자바와 다르게 따로 생성자를 만들지 않아도 된다. )

◼️ 스칼라 컴파일러는 클래스 내부에 있으면서 필드나 메소드 정의에 들어 있지 않은 코드를 주 생성자 내부로 밀어 넣는다. 예를 들면, 디버깅용 메시지를 출력하는 코드로 작성할 수 있다.

class Rational(n: Int, d:Int){
    println("Created " + n + "/" + d)
}

====================
scala > new Rational(1, 2)
Created 1/2
res0: Rational = Rational02591e0c9

• 스칼라 컴파일러는 println을 호출하는 이 코드를 Rational 클래스의 주 생성자에 넣는다. 따라서 Rational 인스턴스를 새로 생성할 때 마다 println을 통해 디버그 메시지 출력

toString 메소드 다시 구현하기

기본적으로 Class는 java.lang.Object 클래스에 있는 toString 메소드를 호출하게 되는데, toString은 클래스 이름,

@ 표시, 16진수 숫자를 출력한다. ex) Rational@2591e0c9

이러한 메소드들은 override 수식자를 통해 재정의 할 수 있다.

class Rational(n: Int, d: Int) {
    override def toString = n + "/" + d
}

선결 조건 확인

분수의 분모는 0일 수 없다. 따라서 객체를 생성할 때 정보가 유효한지 확인이 반드시 필요 선결 조건을 정의해서 해결 가능

• 선결조건이란 ? 메소드나 생성자가 전달받은 값에 대한 제약 호출하는 이가 지켜야할 요구 조건

require 문을 통해 선결 조건을 만들 수 있다.

class Rational(n: Int, d: Int) {
    require(d != 0)     // d == 0 이라면 IllegalArgumentException 예외 발생
    override def toString = n + "/" + d
}

필드 추가

덧셈기능

Rational이 변경 불가능한 객체이기 때문에 add 메소드가 객체 자체의 값을ㄹ 변경해서는 안된다. 따라서 더한 결과값을 담는 새로운 Rational 객체를 반환해야 한다.

// 아래 코드는 컴파일 에러가 발생한다.
class Rational(n: Int, d: Int) {
    require(d != 0)
    override def toString = n + "/" + d

    def add(that: Rational): Rational =
        new Rational( n * that.d + that.n * d, d * that.d )
}

• 클래스 파라미터 n,d는 자신의 클래스 내부에서만 접근 가능
• add 메소드와 같이 다른 객체의 클래스 파라미터에서는 접근 불가

따라서 변경 불가능한 객체의 클래스 파라미터에 접근하기 위해서는 필드를 따로 선언해줘야한다.

class Rational(n: Int, d: Int) {
    require(d != 0)
    val numer: Int = n
    val denom: Int = d
    override def toString = numer + "/" + denom

    def add(that: Rational): Rational =
        new Rational( numer * that.denom + that.numer * denom, denom * that.denom )
}

자기 참조

현재 실행중인 메소드의 호출 대상 인스턴스에 대한 참조를 자기 참조(self reference) 라고 한다. 생성

class Rational(n: Int, d: Int) {
    require(d != 0)
    val numer: Int = n    // 분자
    val denom: Int = d    // 분모
    override def toString = numer + "/" + denom

    def add(that: Rational): Rational =
        new Rational( numer * that.denom + that.numer * denom, denom * that.denom )

     // 인자로 받은 Rational과 비교해 더 작은지 여부를 확인
     // 자기 스스로를 참조한다.
    def lessThan(that: Rational) =
        this.numer * that.denom < that.numer * this.denom

    def max(that: Rational) =
        if (this.lessThan(that)) that else this
}

• this.numer는 lessThan 메소드가 속한 객체의 분자를 나타낸다.

• this를 생략할 수 없는 경우...

  • max 함수에서 첫번째 this는 불필요한 중복 → this.lessThan(that) 을 lessThan(that)으로 변경해도 무방
  • 하지만 두번째 this는 if 수행 결과가 false 일 경우 수행 결과로 반환할 값이다. 이건 생략하면 안됨(반환값이 사라짐)

보조 생성자

하나의 클래스에 여러 생성자가 필요한 경우 → 보조생성자 사용 ex ) 분모는 1로 미리 정해져 있고, 분자만을 인자로 받는 생성자

• 스칼라의 보조 생성자는 def this(...)로 시작

class Rational(n: Int, d: Int){

    require(d!=0)
    val numer : Int = n
    val denom: Int = denom


    def this(n: Int) = this(n, 1)       // 보조 생성자

    override def toString = numer + "/" + denom
    def add(that: Rational) : Rational = 
        new Rational(
            numer * that.denom + that.numer * denom,
            denom * that.denom
        )
}

scala> val y = new Rational(3)
y: Rational = 3/1

비공개 필드와 메소드

비공개 필드와 메소드가 있는 Rational 클래스

• 비공개 변수 g
• 비공개 메소드 gcd

스칼라 컴파일러는 Rational 클래스의 필드 3개와 관련된 초기화 코드를 소스코드에 나온 순서대로 주 생성자에 위치 시킴 → g의 초기화 코드 gcd(n.abs, d,abs)는 다른 두 초기화 코드보다 먼저 수행됨

class Rational(n: Int, d: Int){

    require(d!=0)
    private val g = gcd(n.abs, d,abs)       // 비공개 변수
    val numer : Int = n / g
    val denom: Int = denom / g


    def this(n: Int) = this(n, 1)       // 보조 생성자

    override def toString = numer + "/" + denom
    def add(that: Rational) : Rational = 
        new Rational(
            numer * that.denom + that.numer * denom,
            denom * that.denom
        )

    override def toString = numer + "/" + denom

    private def gcd(a: Int, b:Int): Int =       // 비공개 메소드
        if(b == 0) a else gcd(b, a%b)
}

연산자 정의

수학 기호로 기존의 add 메소드를 대체할 수 있다. 즉, 연산자를 재정의할 수 있다.

class Rational(n: Int, d: Int){

    require(d!=0)
    private val g = gcd(n.abs, d,abs)       // 비공개 변수
    val numer : Int = n / g
    val denom: Int = denom / g


    def this(n: Int) = this(n, 1)       // 보조 생성자

    override def toString = numer + "/" + denom

    def + (that: Rational) : Rational = 
        new Rational(
            numer * that.denom + that.numer * denom,
            denom * that.denom
        )        // + 연산자 정의

    def * (that: Rational) : Rational = 
        new Rational(numer * that.numer, denom * that.denom)        // * 연산자 정의

    override def toString = numer + "/" + denom

    private def gcd(a: Int, b:Int): Int =       // 비공개 메소드
        if(b == 0) a else gcd(b, a%b)
}

scala> val x = new Rat onal(l, 2)
x: Rational = 1/2

scala> val y = new Rat onal(2, 3)
y: Rational = 2/3

scala> x + y
res7: Rational = 7/6

스칼라의 식별자

• 영숫자 식별자
  • 문자나 밑줄(_)로 시작, 두 번째 글자부터는 문자, 숫자, 밑줄 모두 사용 가능
  • 특수문자 $ 도 문자로 취급, 하지만 예약문자이기 떄문에 사용 X
  • 자바의 관례에 따라 Camel-Case로 표기한다. ( ex) toString, HashSet )
  • 필드, 메소드 인자, 지역 변수, 함수는 소문자로 시작
  • 클래스는 대문자로 시작
  • 상수는 첫 글자만 대문자로 표기 (자바의 관례와 다르다)
  • 스칼라에서는 상수를 첫 글자만 대문자로 표기한다. X_OFFSET 같은 자바 스타일의 상수 표기는 스칼라에서는 XOffset처럼 Camel-Case를 사용하는 것이 관례

• 연산자 식별자

  • 하나 이상의 연산자 문자로 이루어짐
  • 스칼라 컴파일러는 내부적으로 $를 사용해 연산자 식별자를 해체하여 적합한 자바 식별자로 다시 만드는 작업을 수행
  • 식별자 :-> 는 내부적으로 $colon$minus$greater로 바뀐다.

• 혼합 식별자

  • 영문자와 숫자로 이뤄진 식별자의 뒤에 밑줄이 오고, 그 뒤에 연산자 식별자가 온다.
  • unary_+는 단항 연산자인 +를 정의하는 메소드의 이름

• 리터럴 식별자

  • 역따옴표｀...｀로 둘러싼 임의의 문자열
  • 런타임이 인식할 수 있는 어떤 문자열이라도 역따옴표 사이에 넣을 수 있다.
  • 스칼라 예약어조차도 리터럴 식별자로 정의할 수 있다. ex ) yield는 스칼라의 예약어이므로 자바의 Thread 클래스에 있는 정적 메소드 yield에 접근하고 싶을 때, Thread.yield()와 같이 사용할 수 없다. Thread.｀yield()｀ 처럼 메소드 이름을 지정하면 사용할 수 있다.

메소드 오버로드

오버로드한 여러 메소드를 추가한 Rational 클래스 메소드 호출 시점에 컴파일러는 오버로드한 메소드 중 인자의 타입이 일치하는 메소드를 선택 (자바와 유사)

class Rational(n: Int, d: Int){

    require(d!=0)
    private val g = gcd(n.abs, d,abs)       // 비공개 변수
    val numer : Int = n / g
    val denom: Int = denom / g


    def this(n: Int) = this(n, 1)       // 보조 생성자

    override def toString = numer + "/" + denom

    def + (that: Rationa): Rational = 
    new Rational(numer * that.denom + that.numer * denom, denom * that.denom)

    def + ( : Int): Rational =
    new Rational(numer + i * denom, denom)

    def - (that: Rational): Rational =
     new Rational(numer * that.denom - that.numer * denom, denom * that.denom)

    def - ( : Int): Rational =
    new Rational(numer - i * denom, denom)

    def * (that: Rational): Rational =
    new Rational(numer * that.numer, denom * that.denom)

    def * ( : Int): Rational =
    new Rat onal(numer * i, denom)

    def / (that: Rational): Rational =
    new Rational(numer * that.denom, denom * that.numer)

    def / (i: Int): Rational =
    new Rational(numer, denom * i)
    override def toString = numer + "/" + denom

    private def gcd(a: Int, b:Int): Int =       // 비공개 메소드
        if(b == 0) a else gcd(b, a%b)
}

암시적 타입 변환

val x = new Rational(2, 3)
x * 2   // Int를 인자로 받는 * 메소드를 정의하였기 때문에 사용가능
2 * x   // Error 발생

• 2 * x는 2.*(x)와 같기 때문에 결국 Int의 메소드를 호출해 문제가 발생
• 스칼라는 필요할 경우 암시적 타입 변환을 지정해 문제를 해결 가능

// int를 Rational로 변환하는 메소드 정의
// implicit 수식자는 컴파일러에서 몇몇 상황에 해당 메소드를 활용해 변환을 수행하라고 알려줌
implicit def inToRational(x: Int) = new Rational(x)

val r = new Rational(2,3)
println(2 * r)
===========================================
4/3

• 암시적 타입 변환이 동작하기 위해서는 해당 스코프 안네 변환 메소드가 존재해야함

• 만약, 암시적 타입 변환 메소드를 Rational 클래스 내부에 정의하였다면, 메소드를 호출한 스코프에는 존재하지 않으므로 변환이 이뤄지지 않음

• java.lang 패키지에 있는 String 을 제외하면 모든 타입은 scala 패키지의 멤버

  5.2 리터럴

• 기본 타입은 모두 리터럴(literal)로 적을 수 있다.

  정수 리터럴

• Int, Long, Short, Byte에 사용
• 10진수, 16진수 리터럴이 있다.

부동소수점 리터럴

• 0~9 로 이루어져있다.
• 소수점이 있을 수 있으며, 마지막에 E나 e 다음에 지수 부분(exponent)이 있을 수 있다. ex ) 1.2345e1은 1.234에 10^1 을 곱한 12.345 이다.

문자 리터럴

• 작음따옴표 안에 유니코드 문자를 넣어서 만든다.

  scala> val a = 'A'
  a: Char = A
  

scala> val d = '\u0041' d: Char = A scala〉 val f = '\u0044' f: Char = D

![](https://images.velog.io/images/dev_jhjhj/post/634f7274-4850-43c2-8911-b4d5831ab53d/image.png)

##### 문자열리터럴
문자열 리터럴은 큰따옴표 두개("")로 둘러싼 문자

scala> val escapes = "\"'" escapes: String = V"

println("""Welcome to Ultamix 3000. Type "HELP" for help.""")

Welcome to Ultamix 3000. Type "HELP" for help.

// stripMargin을 문자열에 넣으면 println("""|Welcome to Ultamix 3000. |Type "HELP" for help.""")

// 다음과 같이 출력된다. Welcome to Ultamix 3000. Type "HELP" for help.

##### 심볼 리터럴
* 심볼(Symbol)은 작은 따옴표 + 문자열로 표현한다. ex) 'ident
* 작음 따옴표 뒤에 오는 식별자는 알파벳, 숫자 혼합 아무거나 가능
* 심볼 리터럴을 scala.Symbol이라는 클래스의 인스턴스로 매핑

* 스칼라에서는 선언하지 않은 필드 식별자를 메소드에 전달해 연산을 수행할 수 없다.
* 대신에, 심볼 리터럴을 넘기면 거의 비슷하게 표현 가능하다.

```scala
def updateRecordByName(r: Symbol, value: Any) = {
    // 코드
    println(r.name)
}

// Symbol을 사용하지 않은 경우 Error
// updateRecordByName(favoriteAlbum, "OK Computer")

// Symbol을 사용하는 경우
updateRecordByName('favoriteAlbum, "OK Computer")

===================================================
favoriteAlbum

// 같은 Symbol 리터럴을 2번 이상 사용하면, 사용된 Symbol은 서로 완전 동일한 객체를 참조한다.(Intern)

val a = 'hi
val b = 'hi
println(a eq b)
================
true

불리언 리터럴

Boolean 타입의 리터럴에는 true와 false

5.3 문자열 인터폴레이션

스칼라는 문자열 인터폴레이션을 위한 유연한 메커니즘을 포함

• 문자열 리터럴 내부에 표현식을 내장시켜 간결하고 읽기 쉬운 코드 작성 가능

val name = "reader"
println(s"Hello, $name!")           // "Hello, " + name + "!"
println(s"The answer is ${6*7}."    // "The answer is " + "42" + "."
===============================
Hello, reader!
The answer is 42.

• 문자열 인터폴레이터 사용 방법 : 문자열 시작하는 따옴표 직전 s를 붙인다.
• s 인터폴레이터는 내장된 각 표현식( ${} 내부식 )을 평가하고 내장된 표현식을 toString의 결과로 대치해준다.

스칼라는 raw와 f라는 두 가지 인터폴레이터 추가 제공

• raw 문자열 인터폴레이터

    * s처럼 작동하지만, 문자열 이스케이프 시퀀스 인식 못함

• f 문자열 인터폴레이터

    * 내장된 표현식에 대해 printf 함수 스타일의 형식 지정을 사용 가능
    ex) 내장시킨 식 바로 다음에 %를 넣고, 그 뒤에 형식 지정 명령 추가

println(raw"No\\\\escape!")
println(f"${math.Pi}%.5f")
===============================
NO\\\\escape!
3.14159

5.4 연산자는 메소드

기본 타입의 풍부한 연산자 제공 예를들어, 1+2는 1.(2)와 같다. 다시 말해, Int 클래스에는 Int를 인자로 받아 Int를 결과로 돌려주는 +라는 이름의 메소드가 있다.

// + 연산자
val sum = 1+2
val sumMore = 1.+(2)
=======================
3
3

오버로드를 통해 파라미터 타입을 다르게 한 메소드가 다소 존재 ex ) Int에는 Long을 받고 Long 타입을 반환하는 + 메소드가 존재

// 연산자 오버로드
def +(x: Byte): Int
def +(x: Short): Int
def +(x: Char): Int
def +(x: Int): Int
def +(x: Long): Long
def +(x: Float): Float
def +(x: Double): Double

모든 메소드는 연산자가 될 수 잇다. 스칼라에서 연산자는 문법적으로 특별한 것이 아니다. 어떤 메소드든 연산자가 될 수 있다. 메소드가 연산자 역할을 할지 여부는 프로그래머가 메소드를 사용하는 방법에 따라 결정된다.

스칼라는 중위(infix) 연산자, 전위(prefix), 후위(postfix) 연산자 존재 전위와 후위는 중위에 다르게 피연산자가 하나이다. 이는 단항(unary) 연산자를 뜻한다. 단항 연산자도 실제로 메소드 호출을 간략하게 한 것

// 단항연산자
print(-7)   // 스칼라는 7.unary_-를 호출한다.
=======================
-7

• 전위 연산자로 쓰일 수 있는 식별자는 (+, -, !, ~) 4가지 뿐

  // 전위 연산자
  def main(args: Aarray[String]): Unit = {
    val test = new Test(5)
    println(+test)
    println(-test)
    println(*test)  // not found Error
  }
  class Test(val num: Int) {
    def unary_+(): Int = if(num > 0) num else -num
    def unary_-(): Int = if(num > 0) -num else num
    def unary_*(): Int = num * num
  }

• 후위 연산자는 인자를 취하지않는 메소드를 '.'이나 괄호 없이 호출하는 경우 스칼라에서는 메소드 호출 시 빈 괄호 생략

val s = "Hello, world!!"
println(s)
println(s.toLowerCase)  // 괄호 생략
println(s toLowerCase)  // (.) 생략
=================================
Hello, world!!
hello, world!!
hello, world!!

5.5 산술 연산

• 모든 수 타입에 대해 더하기(1), 빼기(-)，곱하기(★)，나누기(/)，나머지(%)를 중위 연산자 를 사용 가능

5.6 관계 연산과 논리 연산

• 수 타입을 크다(〉)，작다(<)，크거나 같다(>=)，작거나 같다(이라는 관계 연산자를 사용 해 비교 가능, 각 연산자는 Boolean 값을 결과로 내놓고, '!' 연산자를 사용해 Boolean 값을 반전시킬 수 있다.

• 논리 연산으로는 논리곱 ( &&, & ), 논리합( ||, | )이 있다. 각각은 두 Boolean 피연산자를 취하며 Boolean 결과값을 반환한다.

  • 논리연산은 Java와 마찬가지로 숏 서킷 연산이다. 논리연산자로 구성된 표현식은 결과를 결정하기 위해 필요부분만 값을 계싼

  ex ) && 연산에서 왼쪽의 표현식이 false이면, 리턴값을 false이기 때문에 오른쪽 표현식은 계산 X

def main(args: Aarray[String]): Unit = {
    left() && right()   // 이미 left()에서 false라는 결과가 도출되었기 때문에 right() 메소드는 호출되지 않는다.
    left() & right()    // 좌항의 값과 관계없이 우항의 표현식을 항상 평가하고 싶다면, &와 |를 대신 사용하면 된다.
}
def left() = {
    println("left")
    false
}
def right() = {
    println("right")
    true
}
=======================================
left
left
right

참고 ) 스칼라 메소드에는 인자 계산을 미루는 기능이 있어 쇼트 서킷 연산을 수행할 수 있다. 심지어 사용할 필요가 없으면 인자를 전혀 계산하지 않을 수도 있다. 이런 기능을 이름에 의한 호출 ( call by name ) 파라미터라 부르며, 9.5절에서 설명한다.

5.7 비트 연산

• 비트 연산자는 비트곱(&), 비트합(|), 비트 배타합(^)이 있다.
• 단항 비트 반전 연산자(~)는 피연산자의 각 비트의 0과 1을 반대로 바꾼다.
  
• 스칼라의 shift 메소드 3가지 제공 (왼쪽 시프트나 부호 없는 오른쪽 시프트는 시프트를 하면서 비트가 밀려난 빈 자리에 0을 채워 넣음)

    -  왼쪽 쉬프트  <<
    -  오른쪽 쉬프트  >>
    -  부호없는 오른쪽 쉬프트 >>>

println(1&2)    // 1(0001) 2(0010) -> 0(0000)
println(1|2)    // 1(0001) 2(0010) -> 3(0011)
println(1^3)    // 1(0001) 3(0011) -> 2(0010)
println(~1)     // 1(0001) -> 11111111111111111111111111111110
println(-1 >> 31) // -1을 오른쪽으로 31비트만큼 이동한다.
println(-1 >>> 31) // -1을 오른쪽으로 시프트하면서 0을 채워넣는다.
=======================================
0
3
2
-2
-1
1

5.8 객체 동일성

두 객체가 같은 지 비교 ==, != 스칼라는 == 를 사용하면, 먼저 좌항이 null인지 검사, 좌항이 null이 아니라면 해당 객체의 equals 메소드를 호출

println(1==2)
println(1!=2)
println(List(1,2,3) == List(1,2,3))     // 모든 객체에 적용할 수 있다.
println(List(1,2,3) == List(4,5,6))
println(1==1.0)     // 타입이 각기 다른 두 객체도 비교할 수 있다.
println(List(1,2,3) == "hello")
println(List(1,2,3) == null)    // null 객제와도 비교할 수 있다.
=======================================
false
true
true
false
true
false

스칼라의 ==는 자바와 어떻게 다른가 ?

자바에서 ==는 참조타입과 원시타입 비교 가능 - 자바의 ==은 원시타입에서 값이 같은지 비교, 참조 타입은 참조가 같은지(즉, heap) 메소리에서 같은 객체를 가리키고 있는지 비교 스칼라의 참조 동일성 검사 기능은 eq, 그 역은 ne 이다. 하지만 eq와 ne는 자바 객체에 직접 맵핑한 객체에만 사용 가능

5.9 연산자 우선순위와 결합 법칙

위의 표는 메소드 첫 글자에 따른 연산자의 우선순위를 높은 쪽부터 낮은 쪽으로 보여준다. (같은 줄에 있는 연산자는 우선순위가 같다.)

print(2 << 2 + 2)  // 2 << (2+2)
print(2 + 2 << 2)  // (2+2) << 2
===============================
32
16

우선순위 규칙의 한가지 예외는 할당 연산자(=)이다. 어떤 연산자가 등호로 끝나고, 그 연산자가 비교 연산자( <=, >=, ==, != )가 아니면 해당 연산자의 우선순위는 다른 모든 연산자보다 우선순위가 낮다.

val x *= y+1    // x *= (y+1)

• 우선순위가 같은 연산자가 표현식에서 나란히 나올 경우 결합법칙을 통해 어떻게 연산자를 묶을지 결정한다.

• 메소드 이름이 ':'으로 끝나면 오른쪽부터 왼쪽으로, ':'이 아닌 글자로 끝나면 왼쪽에서 오른쪽으로 짝을 이어간다. a ::: b ::: c → a ::: ( b ::: c ) a * b * c → ( a * b ) * c

• 괄호를 사용하여 명확하게 해주는 것이 가장 좋다.

5.10 풍부한 래퍼