람다는 익명 함수를 표현하기 위해 사용하는 문법입니다. 이를 활용하여 메서드 자체를 메서드의 매개변수로 전달할 수 있습니다.

Java에서의 람다

Java는 함수를 2급시민으로 취급합니다. 즉, 변수에 직접 할당하거나 파라미터로 전달할 수 없습니다. 그렇기 때문에 아래와 같이 함수형 인터페이스를 활용해야 합니다.

함수형 인터페이스 종류

• Predicate&ltT> : 조건 검사 (true/false 반환)
• Function&ltT,R&gt : 입력 → 출력 변환
• Consumer&ltT&gt : 입력 소비 (리턴 없음)
• Supplier&ltT&gt : 값 제공 (입력 없음)

Kotlin에서의 람다

Kotlin에서는 함수를 1급시민으로 취급합니다. 즉, 함수 자체를 변수에 할당하거나 파라미터로 전달할 수 있고, 별도의 함수형 인터페이스가 필요하지 않습니다. 함수형 인터페이스를 활용해 전달받는 Java와 달리 아래와 같이 파라미터 타입과 반환 타입을 통해 전달받을 수 있습니다.

이는 아래와 같이 변수에 할당하지 않고 바로 선언하는 형태로 변형될 수 있습니다.

중괄호와 화살표를 활용하는 형태의 함수의 경우 함수를 받는 파라미터가 마지막에 위치해 있다면 다음과 같은 형태도 가능합니다.

파라미터에 들어가야 할 파라미터 타입 추론도 가능하기 때문에 타입 생략이 가능하고, Kotlin에서는 파라미터가 1개인 경우 It 키워드를 사용하여 다음과 같이 형태로도 변형할 수 있습니다.

Closure

Closure는 람다가 실행되는 시점에 사용하고 있는 외부 변수를 포획하여, 해당 변수가 원래의 스코프를 벗어난 이후에도 계속 접근할 수 있도록 만들어주는 개념입니다.

Java에서의 Closure

Java는 final 혹은 effectively final(사실상 값이 변하지 않는) 변수만 캡처할 수 있습니다. 아래와 같이 변경되는 외부 변수는 람다 표현식 내부에서 사용 불가합니다.

Kotlin에서의 Closure

Kotlin은 Java와 달리 외부 변수를 자유롭게 캡처할 수 있고, 심지어 값 변경도 가능합니다. 아래와 같이 변경되는 외부 변수도 람다 표현식 내부에서 사용 가능합니다.

왜 필요할까요?

대부분의 Java 라이브러리는 Java로 작성되어 있습니다. 하지만 Kotlin 개발자는 val과 var, Null-Safety 등 Kotlin의 장점을 유지한 채 Java 라이브러리를 활용하고 싶어합니다. 그러나 기존 Java 클래스에 기능을 추가하려면 상속이나 헬퍼 클래스를 사용해야 하며, 이는 번거롭고 유지보수에 불리합니다. 이 한계를 넘어 원본 수정 없이 Kotlin 스타일로 기능을 확장하기 위해 등장한 것이 확장 함수입니다.

그래서, 확장 함수는 뭔가요?

확장 함수는 기존 클래스의 소스를 수정하지 않고도, 마치 원래부터 그 클래스에 있던 메서드처럼 호출할 수 있게 해주는 함수입니다. 이를 통해 Kotlin과 Java의 상호 운용성을 높이고, 코드 가독성과 유지 보수성을 개선할 수 있습니다.

어떻게 쓰나요?

예시

아래와 같이 String은 원래 trimmedLength() 메서드를 가지고 있지 않지만, 확장 함수를 통해 마치 원래부터 있었던 것처럼 호출할 수 있습니다.

참고 사항

• 수신 객체의 private 함수를 가져오면 캡슐화가 깨지지 않나요?

  • 확장 함수는 수신 객체의 private, protected 멤버에는 접근할 수 없습니다. 이는 캡슐화를 깨뜨리지 않고, 오직 public 범위 내에서만 동작함을 의미합니다.

• 멤버 함수와 확장 함수의 시그니처가 같을 경우 무엇이 호출되나요?

  • Kotlin에서는 멤버 함수가 항상 우선합니다. 즉, 동일한 시그니처를 가진 멤버 함수와 확장 함수가 동시에 존재하면, 확장 함수는 무시되고 멤버 함수가 호출됩니다.

• 확장 함수를 오버라이드한 경우 무엇이 호출되나요?

  • 호출되는 확장 함수는 변수의 현재 타입 즉 정적인 타입에 의해 결정됩니다.

중위 함수

중위 함수는 infix 라는 키워드를 활용하여 변수.함수이름(인자) 대신 변수 함수이름 인자 형태로 호출할 수 있게 해주는 함수입니다. 아래와 같이 활용할 수 있습니다.

인라인 함수

인라인 함수는 함수가 호출되는 대신 함수를 호출한 지점에 함수 본문을 그대로 복사/붙어넣기 할 수 있게 해주는 함수입니다. 아래와 같이 자바 코드로 변환된 결과를 보면, 함수를 호출하지 않고 덧셈 로직 자체가 복사/붙어넣기가 수행된 것을 알 수 있습니다.

지역 함수

지역 함수는 함수 안에 선언되어 있는 함수를 말합니다. 아래와 같이 활용할 수 있습니다.

직렬화란?

직렬화는 자바 객체를 바이트 스트림으로 변환하는 과정입니다. 이 과정 덕분에 객체를 파일로 저장하거나, 네트워크로 전송할 수 있습니다.

동작 방식

자바에서는 ObjectOutputStream 클래스를 사용하여 아래와 같이 직렬화를 수행합니다.

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializationExample {

    static class FileDto implements Serializable {        // 반드시, Serializable 구현 필요
        private static final long serialVersionUID = 1L;    // 클래스 버전 관리 (역직렬화 시 호환성 보장)
        private transient String password;    // transient 키워드가 선언된 필드는 직렬화 제외 (static도 해당)
        private String name;
        private int size;

        public FileDto(String name, int size) {
            this.name = name;
            this.size = size;
        }
    }

    public static void main(String[] args) {
        try {
            // 직렬화 대상
            FileDto dto = new FileDto("example.txt", 1024);

            // 직렬화 수행
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.dat"));

            // writeObject()는 자바 객체를 바이트 스트림으로 변환 후
            // 해당 스트림을 연결된 출력 대상에 기록
            // - 클래스 메타데이터, serialVersionUID 저장
            // - transient, static은 제외
            // - 참조 타입이 있을 경우, 재귀적으로 직렬화
            oos.writeObject(dto);
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

static 변수는 왜 (역)직렬화하지 않나요?

static 필드는 Method Area에서 관리되는 상태로, 인스턴스의 상태가 아닌 클래스 전체가 공유하는 상태입니다. 즉, static 필드를 굳이 각 객체에 저장할 필요가 없다는 것을 의미합니다.

역직렬화란?

역직렬화는 바이트 스트림을 다시 자바 객체로 변환하는 과정입니다. 이 과정을 통해 파일이나 네트워크에서 받은 데이터를 원래의 객체 상태로 복원할 수 있습니다.

동작 방식

자바에서는 ObjectInputStream 클래스를 사용하여 아래와 같이 역직렬화를 수행합니다.

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;

public class DeserializationExample {
    static class FileDto implements Serializable {    // 반드시, Serializable 구현 필요
        private static final long serialVersionUID = 1L;    // 클래스 버전 관리 (역직렬화 시 호환성 보장)
        private transient String password;    // transient 키워드가 선언된 필드는 역직렬화 제외 (static도 해당)
        private String name;
        private int size;

        public FileDto(String name, int size) {
            this.name = name;
            this.size = size;
        }

        @Override
        public String toString() {
            return "FileDto{name='" + name + "', size=" + size + "}";
        }
    }

    public static void main(String[] args) {
        try {
            // 역직렬화 수행
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.dat"));

            // readObject()는 obj.dat에 저장된 바이트 스트림을 읽어
            // 클래스 메타데이터와 serialVersionUID를 확인한 후 객체 복원
            // - 복원 과정에서 기본 생성자 호출 X
            // - serialVersionUID가 일치하지 않으면 InvalidClassException 발생
            FileDto dto = (FileDto) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

@RequestBody는 HTTP 요청 본문(Body)의 JSON 등 데이터를 자바 객체로 변환한 뒤, 해당 객체를 Controller 메서드의 파라미터로 주입하는 어노테이션입니다. 동작 과정은 아래와 같습니다.

@RequestParam

@RequestParam은 HTTP 요청의 Query String 또는 폼 데이터 값을 추출해 바인딩한 뒤, 변환된 값을 Controller 메서드의 파라미터로 주입하는 어노테이션입니다. 동작 과정은 아래와 같습니다.

@ModelAttribute

@ModelAttribute는 HTTP 요청의 Query String 또는 폼 데이터 값을 자바 객체의 필드에 바인딩하고, 변환된 객체를 Controller 메서드 파라미터로 주입합니다. 또한, 해당 객체를 Model에 자동 등록하여 뷰 렌더링 시에도 사용할 수 있게 합니다. 동작 과정은 아래와 같습니다.

정리

격리 수준이란 동시에 실행되는 트랜잭션이 서로에게 얼마나 영향을 미치지 않도록 할지를 결정하는 정도를 말합니다. 즉, 트랜잭션 간의 동시성과 정합성의 균형을 조절하는 설정입니다.

왜, 필요할까요?

데이터베이스는 기본적으로 여러 사용자가 동시에 접근할 수 있습니다. 만약, 격리 수준이 낮으면 성능은 좋지만 예상치 못한 결과가 나올 수 있습니다. 또한, 격리 수준이 너무 높아도 Lock 경합으로 인해 성능이 저하될 수 있습니다. 즉, 트랜잭션을 사용하는 목적에 따라 정합성과 성능의 균형을 맞추기 위해 필요합니다.

종류

격리 수준에는 4가지 종류가 존재합니다.

READ UNCOMMITTED

Read Uncommitted는 커밋되지 않은 데이터까지 읽을 수 있는 수준으로 정합성 낮으나 성능은 제일 높습니다.

READ COMMITED

Read Committed는 커밋된 데이터까지 읽을 수 있는 수준으로 대부분 DB에서 기본 격리 수준으로 사용합니다. 특정 레코드를 읽는 동안 다른 트랜잭션이 해당 레코드를 수정하지 못하도록 공유락을 설정하여 정합성을 유지합니다.

REPEATABLE READ

Repeatable Read는 트랜잭션 내에서 조회한 레코드에 대한여 동일한 결과값이 나오는 것을 보장하는 수준으로 MySQL의 기본 격리 수준입니다. 처음으로 레코드를 조회할 때 스냅샷을 생성하여 정합성을 유지합니다.

왜, MySQL은 REPEATABLE READ를 기본으로 선택했을까요?

MySQL은 데이터의 무결성을 우선시하도록 설계된 DB이며, 이유는 다음과 같습니다.

• MySQL의 InnoDB는 MVCC를 사용
  • MVCC는 스냅샷을 이용해 트랜잭션 시작 지점의 데이터를 계속 읽을 수 있음
• Gap Lock과 Next-Key Lock을 사용해 Phantom Read 방지 가능
  • InnoDB에서는 Repeatable Read 수준에서 거의 Serializable 수준의 정합성 확보

SERIALIZABLE

Serializable은 모든 트랜잭션이 순차적으로 처리하도록 보장하는 수준으로 가장 정합성은 높으나 성능은 제일 낮습니다. 범위락을 걸어서 다른 트랜잭션이 범위 내에 읽기/쓰기를 불가하도록 하여 정합성을 유지합니다.

이상 현상

격리 수준이 낮을수록 데이터 정합성 또한 낮습니다. 이로 인해, 3가지 이상 현상이 발생할 수 있습니다.

Dirty Read

Dirty Read는 커밋되지 않은 데이터를 읽을 수 있는 현상으로 Read Uncommitted 수준에서 발생하는 이상 현상입니다.

Non-Repeatble Read

Non-Repeatble Read는 동일한 트랜잭션 내에서 같은 행을 두 번 읽었을 때 결과가 다를 수 있는 현상으로 Read Committed 수준에서 발생하는 이상 현상입니다.

Phantom Read

Phantom Read는 특정 범위에 대한 조회 쿼리를 수행한 결과가 가지는 행의 갯수가 다를 수 있는 현상으로 Repeatable Read에서 발생하는 이상 현상입니다.

Kotlin과 Java의 배열은 구조적으로는 유사하지만, 문법적으로 배열을 순회하는 방식에서 아래와 같이 큰 차이가 존재합니다

Collection

가변과 불변을 구분하자

Kotlin에서는 Collection을 생성할 때 아래와 같이 불변인지, 가변인지를 명확히 결정해야 합니다.

반면, Java는 기본적으로 ArrayList, HashMap 등 가변 Collection을 사용합니다. 불변 Collection을 만들려면 명시적으로 Collections.unmodifiableList() 또는 List.of() 등의 메서드를 사용해야 합니다.

Kotlin의 Collection은 기본 구현체가 존재

Java와 달리 Kotlin에서는 List, Set, Map 등의 Collection에 대한 기본 구현체가 존재하며, 아래와 같습니다.

불변

가변

Collection 사용 방법은 무엇이 다를까?

List

Kotlin에서는 아래와 같이 List를 을 사용할 수 있습니다.

Set

Kotlin에서는 아래와 같이 Set을 사용할 수 있습니다.

Map

Kotlin에서는 아래와 같이 Map을 사용할 수 있습니다.

Null 가능성

? 위치에 따른 Null 가능성

? 위치에 따라 아래와 같이 Null 가능성을 구분할 수 있습니다.

Java와 Kotlin이 혼용된 코드에서 Collection 사용시 주의할 점

Kotlin으로 작성된 Collection을 Java에서 사용할 때

Java에서 Kotlin의 Collection을 사용할 경우 아래와 같은 2가지 경우를 조심해야 합니다.

• Java는 Collection에 대한 가변(읽기 전용)과 불변(변경 가능)을 구분하지 않음

  • Immutable Collection에 대한 수정 작업을 수행할 수 있고, 이로 인해 Kotlin에서 오동작 발생 가능

• Java는 nullable과 non-nullable 타입을 구분하지 않음

  • non-nullable Collection에 null을 리스트에 추가할 수 있고, 이로 인해 Kotlin에서 오동작 발생 가능

이러한 문제를 예방하기 위해, Kotlin에 정의한 Collection이 Java에서 호출될 수 있다면 작업 이후 방어 로직을 작성하여 처리하거나 Java에도 존재하는 Collections.unmodifableXXX()를 활용하여 변경이 불가능하도록 해야합니다.

Java로 작성된 Collection을 Kotlin에서 사용할 때

Kotlin에서 Java의 Collection을 사용할 경우 플랫폼 타입을 조심해야 합니다.

플랫폼 타입이란?

플랫폼 타입은 다른 프로그래밍 언어에서 잔달되어 nullable 여부를 알 수없는 타입을 말합니다.

Kotlin에서는 Java에서 가져온 Collection이 List<Int?>, List<Int?>?, List<Int>? 인지 알 수 없습니다. 이 경우는 Java 코드를 보며 맥락을 확인하고, 가져오는 지점을 wrapping해서 영향 범위를 최소화해야 합니다.

Kotlin에서는 data라는 지시어를 Class 앞에 명시하여 DTO Class를 매우 간결하게 정의할 수 있습니다.

아래는 Java로 작성된 DTO Class입니다. Getter, Constructor, Equlas 등으로 인해 코드가 장황하고, 이를 보완하기 위해선 Lombok 어노테이션을 선언하는 추가적인 조치가 필요합니다.

하지만, Kotlin에서는 data 키워드를 명시하면 eqauls, hashCode, toString 등을 자동으로 만들어주기 때문에 아래와 같이 간결하게 작성할 수 있습니다.

또한, Kotlin은 아래와 같이 Named Argument를 지원하기 때문에 Builder 패턴까지 활용하는 것 같은 효과를 받을 수 있습니다.

Enum Class

Kotlin에서의 Enum Class는 코드 작성에 있어서는 Java와 별 다른 차이가 없습니다.

하지만, Enum을 활용한 코드에 대한 가독성 측면에서는 차이가 존재합니다. Kotlin에서는 아래와 같이 when을 사용하면 컴파일러가 Enum Class에 대한 모든 타입을 알고 있기 때문에, 다른 타입에 대한 예외 처리 로직(else 문) 작성이 불필요합니다.

또한, Kotlin에서는 아래와 같이 Enum Class에 열거 상수 이름을 추가한 후 반영하지 않은 경우 warning을 주지만 Java는 그렇지 않습니다.

Sealed Class

Sealed Class는 상속을 위한 추상 클래스를 정의했을 때, 이를 외부에서도 상속 받아 활용하는 것을 막기 위해 만들어진 Class입니다. 즉, 외부에서 추상 클래스를 상속하는 것을 막고자 '우리가 작성한 클래스만 하위 클래스가 될 수 있도록 봉인한 것'입니다. 이에 따른 Sealed Class의 특징은 다음과 같습니다.

• 컴파일 타임에 하위 클래스의 타입을 모두 기억하여 런타임에서 클래스 타입이 추가 불가
• 하위 클래스는 같은 패키지에 존재해야 함

아래는 Sealed Class 작성 예시입니다.

또한, Sealed Class는 컴파일 타임 때 하위 클래스 타입을 모두 기억하고 있다는 특징이 있기 때문에 아래와 같이 when과 같이 활용활 때 매우 유용합니다.

Java에서의 중첩 클래스는 아래와 같이 여러 종류로 나뉩니다.

일반적으로 중첩 클래스를 지칭할 땐 static을 사용하는 증첩 클래스와, Inner Class를 지칭하고, 아래와 같은 특징을 가지고 있습니다.

• static을 사용하는 중첩 클래스
  • 외부 클래스 직접 참조 불가
• static을 사용하지 않는 중첩 클래스
  • Inner Class : 외부 클래스 직접 참조 가능

이를 Java 코드로 살펴보면 아래와 같습니다.

Inner Class 사용을 지양하자

Effective Java에 따르면 Inner Class에 대하여 아래와 같이 설명하고 있으며, 중첩 클래스를 사용할 경우 static class를 사용하는 방법을 권장합니다.

• 숨겨진 외부 클래스 정보를 가지고 있어, 참조 해지가 불가한 경우 메모리 누수 발생
• 직렬화 형태가 명확하게 정의되지 않아 직렬화에 있어 제한됨

Kotlin에서의 중첩 클래스와 내부 클래스

Kotlin에서의 중첩 클래스는 아래와 같이 기본적으로 외부 클래스에 대한 직접 참조를 하지 않습니다.

만약, 외부 클래스에 대한 직접 참조가 필요할 경우 inner 키워드를 활용하여 다음과 같이 작성하면 됩니다.

Companion Object

Kotlin에서는 Java와 달리 static 키워드가 존재하지 않고, 아래와 같이 companion object 키워드를 사용합니다.

또한, companion object는 하나의 객체로 간주되기 때문에 Java의 static과 달리 아래와 같이 이름을 명시할 수 있으며 interface를 구현할 수 있습니다.

const

const 키워드는 컴파일 단계에서 변수에 값을 할당하도록 하는 지시어입니다. const를 명시하지 않은 경우 컴파일 단계에서는 기본값을 할당한 후, 런타임 단계에서 값을 할당니다.

@JvmStatic

Java에서 Kolin에 작성된 companion object를 Java의 static처럼 사용하기 위해선 아래와 같이 @JvmStatic을 명시해야 합니다.

Singleton

Kotlin에서는 object 키워드를 사용하여 아래와 같이 간단하게 Singleton 클래스를 생성할 수 있습니다.

익명 Class

Kotlin에서 익명 Class를 사용할 경우 new Type() { ... }을 통해 Java와 달리 object : Type { ... } 을 통해 익명 Class를 사용할 수 있습니다.

Kotlin과 Java의 접근 제한자는 아래와 같습니다.

Kotlin에서는 default 키워드가 사라지고, internal이 추가 되었습니다. 이는 Kotlin에서는 패키지를 namespace를 관하기 용도로만 사용하고 가시성 제어로는 사용하지 않기 때문입니다. 또한, Java의 경우 defaul를 기본 접근 제한자로 사용하지만, Kotlin은 public을 기본 접근 제한자로 사용하고 있습니다.

파일의 접근 제어

Kotlin에서는 파일 내에 아래와 같이 변수, 함수, 클래스 등을 즉시 정의할 수 있습니다.

하지만, 파일 최상단에 정의한 변수, 함수, 클래스 등에는 아래와 같이 protected는 사용할 수 없습니다.

다양한 구성요소의 접근 제어

Constructor

Constructor에 접근 제한자를 사용하기 위해선 아래와 같이 constructor 키워드를 반드시 명시해야 합니다.

Property

Property에 선언된 접근 제한자는 Getter, Setter에도 적용됩니다. 두 함수에 동일한 접근 제한자를 적용하는 경우 아래와 같이 선언하면 됩니다.

하지만, 두 함수의 가시성을 별도로 제어하기 위해선 아래와 같은 방법으로 접근 제한자를 선언해야 합니다.

Java로 작성한 Abstract Class(Animal)와 이를 상속하는 하위 Class(Cat, Penguin)를 Kotlin으로 변환하는 과정을 통해, Java와 다른점은 무엇이 있을지 살펴보겠습니다.

사용할 Java 코드는 다음과 같습니다.

extends가 아닌 : 사용하라

Java에서는 상속을 위해 extends 키워드를 사용합니다. 하지만, Kotlin은 아래와 같이 :을 사용하며, 반드시 상위 Class에 대한 생성자를 호출해야 합니다.

override 지시어를 반드시 사용하자

Java에서는 부모 Class가 가진 Abstract 함수를 재정의할 때, @Override 어노테이션을 사용하며 반드시 명시할 필요가 없습니다. 하지만, Kotlin에서는 override라는 키워드가 별도로 존재하며 반드시 명시해야합니다.

Property를 override 하기 위해선 open을 명시하자

Kotlin에서는 상위 Class에 자동으로 생성된 Getter를 Override하여 Custom Getter를 정의하기 위해선 부모 Class의 Property에 open 키워드를 반드시 명시해야 합니다.

Interface

Java로 작성한 Interface(Swimable, Flyable)을 Kotlin으로 변환하는 과정을 통해, Java와 다른점은 무엇이 있을지 살펴보겠습니다.

Default 키워드 생략 가능

Java에서는 Interface에서 함수를 정의할 경우 default 키워드를 명시하지만, Kotlin에서는 명시하지 않고도 default 함수를 정의할 수 있습니다.

implements 키워드가 아닌 :를 사용하자

Java에서는 Interface를 사용할 때 Implements를 사용하지만, Kotlin에서는 :를 사용합니다.

상위 Inteface의 함수를 호출할 때 <>를 사용하자

Java에서는 상위 Interface의 함수를 호출할 때 Interface.super.method()를 사용지만, Kotlin에서는 super<Interface>.method()를 사용합니다.

Property 정의가 가능

Kotlin에서는 Interface에 Property 또한 미리 정의할 수 있습니다.

상속할 때 주의할 점

일반적인 Class를 상속해야 할 경우 open 키워드를 명시하자

Kotlin은 Abstract, Interface가 아닌 Class를 상속해야 할 경우, 반드시 해당 Class에 open 키워드를 명시해야 가능합니다.

상위 Class의 Constructor 또는 Init에서 사용하는 Property에 open 사용 금지

Kotlin에서 상위 Class를 설계할 때 생성자 또는 초기화 블록에 사용하는 Property에는 open을 사용하는 것을 조심해야 합니다. 그 이유는 아래 예시를 통해 살펴보겠습니다.

아래와 같이 2개의 Class(Base, Derived)가 있습니다.

Derived Class를 생성할 경우 다음과 같은 결과를 볼 수 있습니다.

왜, 100이나 300이 아닌 0이 출력되었을까요? 그 이유는 상위 Class인 Base의 init 블록에서 접근하는 number는 하위 Class의 number이기 때문입니다. 아래와 같이 상위 Class의 생성자가 먼저 호출이 되고, 그 시점엔 아직 하위 Class인 Derived의 생성자가 호출되지 않아 number가 초기값을 가지고 있는 상태입니다. 즉, 인자로 전달받은 300을 아직 하위 Class가 가지고 있는 number에 주입하기 전이기 때문에 초기값인 0을 출력하게 됩니다.

이러한 상황이 발생할 수 있기 때문에, 상위 Class에서 Constructor 또는 Init 블록에서 Property를 사용할 경우 open 키워드를 명시하면 안됩니다.

Class

Java의 경우 일반적으로 아래와 같은 형태의 Class 구조를 가집니다.

위 코드를 Kotlin으로 작성할 시 아래와 같이 Constructor, Getter, Setter 추가로 정의할 필요가 없습니다.

Property

Kotlin에서는 아래와 같은 Constructor의 인자들을 Property라고 하는데, 이는 Field와 Getter, Setter를 모두를 포함하는 요소라는 의미를 지닙니다.

즉, Kotlin에서는 Field만 정의해주어도 Getter와 Setter를 자동으로 생성해주기 때문에, Java처럼 별도의 메소드를 생성하지 않아도 아래와 같이 작성할 경우 Getter, Setter 메소드와 동일한 동작을 수행하게 됩니다.

Init과 Constructor

Init

Java의 경우 일반적으로 아래와 같이 Constructor에서 유효성 검증을 수행합니다. 반면, Kotlin에서는 Constructor 호출 시 한 번만 수행되는 init 블록을 활용하여 Property에 대한 유효성 검증을 수행합니다.

이러한 동작을 Kotlin에서는 아래와 같이 작성하여 동일하게 구현할 수 있습니다.

Constructor

Java의 경우 Constructor의 인자 일부에 고정값을 주입하기 위해 Constructor Overloading를 활용합니다. 반면, Kotlin에서는 아래와 같이 Secondary Custructor를 활용하여 동일한 기능을 수행합니다.

추가로, Kotlin에서는 아래와 같이 Default Value를 활용하여 동일한 동작을 수행할 수 있으며, 여러 개의 Constructor를 정의하기 보다 아래와 같은 방법을 더 권장하고 있습니다.

Custom Getter와 Setter

Kotlin에서는 커스텀 Getter와 Setter는 함수가 아닌 Class의 Property로 표현할 때 사용하는 방법입니다.

예를 들어, Java에서는 Person이라는 Class에서 age를 활용하여 성인 여부를 확인하기 위해선 아래와 같은 함수를 정의해야 합니다.

하지만, Kotlin에서는 아래와 같이 get()을 활용하여 함수가 아닌 Property처럼 구현할 수 있습니다.

Custom Setter는 아래와 같이 활용할 수 있습니다.

Backing Field

Kotlin에는 자기 자신을 가리키는 보이지 않는 Field인 Backing Field라는 개념이 존재합니다.field라는 예약어를 통해 사용할 수 있고, Custom Getter/Setter를 정의할 때 무한루프를 방지하기 위해 사용합니다.

아래는 name을 조회할 때 대문자로 출력하도록 Custom Getter를 정의한 코드입니다.

Kotlin에서는 변수명.프로퍼티명, 프로퍼티명을 호출한 경우 Getter 호출해 값을 얻어옵니다. 즉, 아래와 같이 name을 호출하면 다시 또 Getter를 호출하게 되면서 무한루프가 발생합니다.

이러한 상황에서 아래와 같이 자기 자신을 가리키는 Backing Field를 활용하여 무한루프를 방지하고 원하는 동작을 수행할 수 있습니다.

Kotlin에서는 함수가 하나의 결과값을 반환하는 경우, 아래 예시와 같이 블록({ .. })를 제거하고 =를 대신 사용할 수 있습니다.

위와 같이 형태의 함수는 반환값의 타입이 명확한 경우 반환 타입을 생략할 수 있으며 if-else문의 중괄호도 생략 가능합니다. 예시는 아래와 같습니다.

Default Parameter

Kolit에서는 Parameter에 기본값을 설정할 수 있습니다. 문자열을 반복 출력하는 함수를 예시로 이를 어떻게 활용할 수 있는지 살펴보겠습니다.

우선, 아래와 같이 메시지와 반복 횟수 그리고 개행 추가 여부를 받는 문자열 반복 함수가 존재합니다.

이 함수를 호출할 때 높은 비율로 반복 횟수를 3, 개행 추가 여부를 true로 사용하는 상황이라면 매번 이를 입력해주는 것은 불편할 수 있습니다. Java에서는 이를 Overloading을 통해 아래와 같이 해결할 수 있습니다.

하지만, 3개의 함수를 만드는 것은 조금 비효율적이라 생각이 들 수 있습니다. Kotlin은 아래와 같이 기본값을 활용하여 Parameter가 전달되지 않을 경우 기본적으로 사용할 값을 지정할 수 있습니다. 이를 활용하여, 1개의 함수만으로 동일한 기능을 더욱 간단하게 구현할 수 있습니다.

그리고 활용 예시를 보여주기 위해 기본값을 사용했지만, Kotlin도 Java와 동일하게 Overloading 기능을 지원합니다.

Named Argument

Kotlin은 Named Argument를 지원하기에 Parameter를 명시하여 값을 지정할 수 있습니다. 이 기능은 Parameter를 명시하여 값을 주입하는 방식이므로 Builder를 직접 만들지 않고도 Builder의 장점을 가질 수 있습니다. 단, Java 코드로 작성된 함수를 호출할 경우 기능을 활용할 수 없습니다.

활용 예시는 아래와 같습니다.

가변 인자

Kotlin에서 Java와 달리 가변 인자를 사용하기 위해선 vararg 키워드를 인자명 옆에 명시하고, 배열을 바로 인자로 전달할 수 없고 반드시 스프레드 연산자(*)를 명시해야 합니다. 예시는 아래와 같습니다.

For

Kolin에서 for문을 사용하는 방법은 아래와 같습니다. 증감 연산자를 활용하여 인덱스를 조작하는 Java와 달리 in, .., downTo, step 등의 연산자를 활용합니다.

For-Each

Kotlin에서 for-each문을 사용하는 방법은 아래와 같습니다. :를 사용하는 Java와 달리 in 연산자를 활용합니다.

While

Kotlin과 Java의 While문 사용 방법은 동일합니다.

예외

Try-Catch-Finally

Kotlin과 Java의 try-catch-finally문 사용 방법은 동일합니다.

Checked Exception / Unchecked Exception

Kotlin은 Checked Exception과 Unchecked Exception을 구분하지 않습니다. 아래를 보면 Java의 경우 IOException에 의해 오류가 발생하는 것을 볼 수 있지만, Kotlin의 경우 그렇지 않은 것을 볼 수 있습니다.

Try-With-Resources

Kotlin은 try-wiht-resouces문이 사라졌습니다. 대신, 아래와 같이 use라는 inline 확장 함수를 사용하여 동일하게 동작할 수 있습니다.

Kotlin에서의 If문은 Java와 작성 방법은 동일하지만, Kotlin의 경우 아래와 같이 작성하는 것도 가능합니다.

왜냐하면, Java의 경우 If문은 Statement이기 때문이지만, Kotlin의 경우 If-Else문을 하나의 값으로 도출될 수 있는 Expression으로 취급하기 떄문입니다. 이러한 차이로 인해, Kotlin에서는 삼항 연산자가 존재하지 않습니다.

Switch

Kotlin에는 Switch문이 사라진대신 When문을 사용합니다. 이를 Java의 Switch문과 Kotlin의 When문 비교를 통해 살펴보겠습니다.

기본적인 차이점은 아래와 같습니다.

이에 추가로, When문은 아래와 같이 조건부에 단순 일치 여부외에도 범위 조건, 다중 조건 등 다양한 분기 조건을 만들 수 있습니다.

또한, (value)를 생략하여 Early Return처람 동작하도록 만들 수 있습니다. 아래와 같이 작성할 경우, 첫 번째 조건을 만족하게 되면 수행 후 나머지 분기들은 수행하지 않습니다.

Kotlin에서 단항 연산자(++, --), 산술 연산자(+, -, /, %), 산술 대입 연산자의 사용 방법은 Java와 동일합니다.

비교 연산자

Kotlin과 Java의 비교 연산자(>, >=, <=, <)의 사용 방법은 Java와 동일하지만, 한 가지 차이점이 존재합니다. 이는 Kotlin의 경우 비교 연산자를 사용하면 자동으로 재정의한 compareTo() 메서드를 호출해 활용한다는 점 입니다. 이게 무엇을 의미하는지 코드를 예시로 살펴보겠습니다.

아래와 같이 클래스에 재정의한 compareTo() 메서드가 존재합니다.

일반적으로 Java의 경우 아래와 같이 재정의한 메서드를 직접 호출하여 비교를 수행합니다.

하지만, Kotlin은 아래와 같이 비교 연산자 사용시 자동으로 재정의한 compareTo() 메서드를 활용해 비교 연산을 수행합니다.

Kotlin에서의 동등성과 동일성

• 동등성 : 두 객체의 값이 같은가?
  • Java는 equals() 메서드를 활용하지만, Kotlin은 == 연산자 활용
  • Kotlin에서는 == 연산자를 사용하면 간접적으로 equls() 메서드를 호출
• 동일성 : 두 객체의 주소가 같은가?
  • Java는 == 연산자를 활용하지만, Kotlin은 === 연산자 활용

논리 연산자

Kotlin에서 논리 연산자(&&, ||, !) 사용 방법 및 Lazy 연산 수행 등 사용 방법은 Java와 동일합니다.

Kotlin에 있는 특이한 연산자

Kotlin에는 in, !in, a..b 등 Java에 존재하지 않는 특이한 연산자가 존재합니다. 각 연산자가 수행하는 동작은 아래와 같습니다.

• in, !in
  • 컬렉션이나 범위에 포함되어 있는지 (or 없는지)
• a..b
  • a부터 b까지 범위를 가지는 객체를 생성

연산자 오버로딩

Kotlin에서는 operator 키워드를 활용해 객체마다 연산자를 직접 정의할 수 있습니다. 이는 예시를 통해 살펴보겠습니다.

아래와 같이 operator 키워드를 활용해 + 역할을 수행하는 메서드를 정의한 클래스가 있습니다.

2개의 Money 클래스 가진 값에 대한 더하기 연산을 수행하기 위해선 Java의 경우 아래와 같이 코드를 작성합니다.

하지만, Kotlin에서는 아래와 같이 + 연산자를 활용해도 자동으로 plus() 메서드를 호출하여 동일한 동작을 수행합니다.

Kotlin은 Java와 동일하게 Byte, Short, Int, Long, Float, Double 등을 기본 타입으로 가지고 있습니다. 하지만, 크기의 대소에 따라 기본 타입간 형변환시 암묵적으로 수행할 수 있는 Java와 달리 Kotlin은 명시적으로 수행해야 합니다.

Java는 아래와 같이 크기가 더 작은 int(4Byte) 자료형을 더 큰 자료형인 long(8byte)으로 변환할 경우, 별도로 명시할 필요가 없습니다.

하지만, Kotlin에서 동일한 기능을 수행하기 위해선 아래와 같이 toXXX()를 활용해야합니다.

타입 캐스팅

Kotlin은 타입 캐스팅을 수행할 때 as, is 등을 사용합니다. Java에서 사용했던 instanceOf와 무엇이 다른지 한 번 살펴보겠습니다.

아래와 같이 타입 캐스팅을 수행하는 Java 코드가 있습니다.

이를 Kotlin으로 작성시 아래와 같습니다.

여기서 하나의 차이가 더 있습니다. Kotlin은 is 연산자를 통해 특정 클래스임을 확실히 할 경우, 별도의 형변환 없이 아래와 같이도 작성 가능합니다.

추가로, 아래와 같이 !is 연산자를 사용해 동일한 클래스가 아닌지 또한 쉽게 알 수 있습니다.

Kotlin의 3가지 특이한 타입

Any

Any 타입은 Java의 Object와 동일한 역할을 수행합니다. 즉, 모든 객체의 최상위 타입을 의미합니다. 즉, Kotlin에서는 Primitive Type과 Reference Type을 구분하지 않기에 두 Type의 최상위 타입은 Any 입니다.

Unit

Unit 타입은 Java의 void와 동일한 역할을 수행합니다. 한 가지 다른점이 있다면, Java의 void와 다르게 Unit은 그 자체로 타입 인자로 사용할 수 있습니다. Java의 경우 Generic 문법에서 void를 사용할 경우 Void 클래스를 사용해야 하지만, Unit은 그렇지 않습니다.

Nothing

Nothing 타입은 '함수가 정상적으로 끝나지 않았다'는 사실을 표현하는 역할을 수행합니다. 아래와 같이 무조건 예외를 반환하거나 무한 루프가 발생하는 함수에 명시합니다.

String Interpolation / String Indexing

String Interpolation

Kotlin은 문자열 내 변수를 삽입할 때 ${변수}를 사용해 수행할 수 있습니다. Java에서는 String.format() 또는 StringBuilder를 활용하기 때문에 가독성 측면에서 불편하다고 생각했는데, Kotlin으로 작성할 경우 다음 예시와 같이 보다 편하게 작성할 수 있습니다.

추가로, Kotlin의 경우 여러 줄에 걸친 문자열을 작성할 때 아래와 같이 """와 trimIndent()를 사용하면, StringBuilder를 활용하는 것 보다 쉽게 작성할 수 있 습니다.

String Indexing

Kotlin은 문자열에서 특정 문자를 가져올 때 배열처럼 가져오고 싶은 위치를 인덱스로 사용하여 가져올 수 있습니다. 즉, Java의 charAt(int index) 수행 결과와 Kotlin의 string[index]가 동일한 것을 의미합니다. 아래는 예시입니다.

함수의 파라미터로 전달되는 값에 null 값이 들어올 수 있을때, Java의 경우는 IF문을 활용해야 합니다. 반면, Kotlin은 Safe Call과 Elvis 연산자를 지원하기 때문에 보다 간단하게 이를 수행할 수 있습니다.

Safe Call

Safe Call은 null이 아니면 실행하고, 맞으면 실행하지 않도록 하는 기능입니다. 아래와 같은 활용 예시를 통해 어떻게 동작하는지 살펴보겠습니다.

우선, Safe Call을 사용하지 않고 Java 코드를 변환한 결과입니다.

여기에 함수를 실행하는 주체에 ?를 명시하여 Safe Call을 적용해보면 아래와 같습니다.

적용 결과를 보면 IF문을 사용 코드보다 더 간결하게 작성된 것을 볼 수 있습니다. 그런데, 여기서 1번과 3번 코드는 오류가 발생하는 것을 발견할 수 있습니다. 이는 Safe Call의 경우 null 값이 들어올 경우 null을 반환하기 때문입니다. 그럼 이는 어떻게 해결할까요? 그 방법은 Elvis 연산자에서 알아보도록 하겠습니다.

Elvis

Elvis(?:) 연산자는 앞의 연산 결과가 null일 경우, 선언한 값을 사용하도록 하는 기능입니다. 이 연산자는 Safe Call 를 사용할 경우 null 값이 들어오면 null이 반환되는데, null이 아닌 선언한 값을 반환시키고 싶을 때 다음과 같이 사용할 수 있습니다.

위 결과를 보면, 1번과 3번 함수의 경우 null일 때 null이 아닌 값을 반환하도록 명시했기 때문에, 반환 타입에 ?를 명시하지 않아도 정상적으로 작동하는 것을 볼 수 있습니다.

!! 연산자

!! 연산자는 '이 변수는 절대 null이 아니야!' 라고 컴파일러에게 강제로 알려주는 용도로 사용됩니다. 하지만, 아래와 같이 실제로 null이 들어오면 NullPointerException이 발생하기 때문에 안전하지 않은 연산입니다.

Platform Type

Platform Type은 Kotlin이 null 관련 정보를 알 수 없는 Type을 말합니다. 아래와 같이 Java 코드로 작성된 Person 클래스를 Kotlin 코드에서 사용하게 될 경우 name에 null이 발생할 수 있지만 컴파일러는 이를 알 수 없습니다.

그렇기 때문에, Kotlin에서 Java로 작성된 Class를 사용할 경우 아래와 같이 반드시 컴파일러가 null 발생 여부를 판단할 수 있도록 어노테이션을 활용하여 관련 정보를 명시해주어야 합니다.

Kotlin은 변수를 선언할 때 반드시 var 또는 val 키워드를 선언해야 합니다. 그렇다면, 이 두 키워드의 차이는 무엇일까요? 이 둘의 차이를 코드를 통해 알아보겠습니다.

아래와 같이 2줄의 변수를 선언하는 Java 코드 작성되어 있습니다. 작성된 2줄의 코드 중 1번은 가변성을, 2번은 불변성을 가집니다. 이를 Kotlin 코드로 변환할 경우 오른쪽과 같습니다.

결과를 살펴보면, 가변성을 가지는 1번은 var 키워드를, 불변성을 가지는 2번은val 키워드가 사용되고 있습니다. 즉, var(variable)는 변수의 가변성을 의미하고, val(value)은 변수의 불변성을 의미하는 것을 알 수 있습니다.

타입 추론

Kotlin은 명시적으로 자료형을 선언하지 않아도 정상 작동합니다. 이는 컴파일러가 변수의 자료형을 유추하는 타입 추론(type inference) 기능을 제공하기 때문입니다. 아래 예시처럼 1번과 2번 코드는 동일한 역할을 수행합니다.

단, 타입을 생략할 경우 반드시 초기값이 필요합니다. 이는 초기값이 없으면 타입 추론이 불가하기 때문입니다. 실제로, 초기값과 타입 모두 명시하지 않을 경우 아래와 같이 컴파일 오류가 발생합니다.

Primitive Type

Java의 경우 사용 목적에 따라 Primitive Type과 Reference Type을 구분하여 사용하지만, Kotlin은 구분 없이 사용합니다. 실제로, Kotlin Docs의 Basic Types를 살펴보면 아래와 같은 내용이 존재합니다.

해석해보면 "런타임에서 특정 타입(숫자, 문자, 불리언 등)은 성능을 최적화하기 위해 내부적으로 원시 값으로 표현될 수 있지만, 개발자 관점에서는 일반 클래스처럼 보이고 동작합니다." 라고 명시되어 있습니다.

즉, Kotlin은 타입을 클래스처럼 작성해도 실제 컴파일 시에는 성능을 고려해 primitive 타입으로 변환됩니다. 이러한 동작을 실제로 확인하기 위해, Kotlin 코드를 Java로 Decompile해보면 long으로 선언된 것을 확인할 수 있습니다.

Nullable

Kotlin은 Java와 달리 Primitive Type과 Reference Type을 구분하지 않습니다. 하지만, 여기서 중요한 차이가 하나 있습니다. Java의 Reference Type은 null을 가질 수 있지만, Primitive Type은 그렇지 않습니다.

이 차이를 보완하기 위해, Kotlin에서는 null을 허용하려면 아래 예시와 같이 자료형 뒤에 ?를 명시해야 합니다.

Kotlin은 이처럼 ?를 통해 null 가능성을 명시적으로 표현함으로써, NullPointerException을 예방하고 컴파일 타임에 안정성을 확보하는 장점을 제공합니다.

Instance

Java에서는 클래스를 인스턴스화할 때 반드시 new 키워드를 사용해야 합니다. 하지만, Kotlin은 new 키워드를 사용하지 않고 클래스 이름을 함수처럼 호출하여 인스턴스를 생성합니다.

시스템 설계 면접을 진행하는 과정에서 때로는 시스템 용량이나 성능 요구사항을 개략적으로 추정해 보라는 요구를 받기도 합니다. 이를 효과적으로 수행하기 위해선 규모 확장성을 표현하기 위한 기본기에 능숙해야 합니다. 2장에서는 기본기인 2의 제곱수, 응답지연 값, 고가용성 관련 수치 등을 알아보는 챕터입니다.

2의 제곱수

분산 시스템에서 다루는 데이터 양은 엄청나게 커질 수 있지만, 계산법은 기본을 크게 벗어나지 않습니다. 제대로 된 계산 결과를 얻으려면 데이터 볼륨의 단위를 2의 제곱수로 표현하면 어떻게 되는지를 우선 알아야 합니다. 최소 단위는 1바이트(8비트)로 구성되며, ASCII 문자 하나가 차지하는 메모리 크기가 1바이트입니다.

흔히 사용하는 데이터 볼륨 단위들에 대한 정보는 다음과 같습니다.

• 1KB
  • 2의 제곱수 : $2^{10}$
  • 근사치 : 1천
• 1MB
  • 2의 제곱수 : $2^{20}$
  • 근사치 : 1백만
• 1GB ($2^{30}$)
  • 2의 제곱수 : $2^{30}$
  • 근사치 : 10억
• 1TB
  • 2의 제곱수 : $2^{40}$
  • 근사치 : 1조
• 1PB
  • 2의 제곱수 : $2^{50}$
  • 근사치 : 1000조

모든 프로그래머가 알아야 하는 응답지연 값

구글의 제프 딘은 2010년에 통상적인 컴퓨터에서 구현된 연산들의 응답지연 값을 공개한 바 있습니다. 이들 가운데 몇몇은 HW의 발전으로 유효하지 않게 되었지만, 아직도 이 수치들은 컴퓨터 연산 처리 속도를 짐작할 수 있도록 도와줍니다.

연산명과 그에 대한 응답지연 값의 정보는 다음과 같습니다.

• L1 캐시 참조 : $1\mathrm{ns}$
• 분기 예측 오류 : $3\mathrm{ns}$
• L2 캐시 참조 : $4\mathrm{ns}$
• 뮤텍스 락/언락 : $17\mathrm{ns}$
• 주 메모리 참조 : $100\mathrm{ns}$
• Zippy로 1KB 압축 : $2,000\mathrm{ns} = 2\mu\mathrm{s}$
• 메모리에서 1MB 순차적 Read : $3,000\mathrm{ns} = 3\mu\mathrm{s}$
• 디스크 탐색 : $2,000,000\mathrm{ns} = 2\mathrm{ms}$
• 디스크에서 1MB 순차적 Read : $825,000\mathrm{ns} = 825\mu\mathrm{s}$
• 네트워크에서 1MB 순차적 Read : $10,000,000\mathrm{ns} = 10\mathrm{ms}$
• 일반 상용 네트워크에서 2KB 전송 : $44,000\mathrm{ns} = 44\mu\mathrm{s}$
• 동일 데이터 센터 내에서의 패킷 왕복 지연시간 : $500,000\mathrm{ns} = 500\mu\mathrm{s}$
• 한 패킷이 캘리포니아로부터 네덜란드까지의 왕복 지연시간 : $150,000,000\mathrm{ns} = 150\mathrm{ms}$

위 수치들을 분석하면 다음과 같은 결론을 낼 수 있습니다.

• 메모리는 빠르지만 디스크는 아직 느리다.
  • 메모리에서 1MB 데이터를 읽는데 $3\mu\mathrm{s}$가 소요되는 반면
  • 디스크에서는 $825\mu\mathrm{s}$가 소요
• 디스크 탐색은 가능한 피해야한다.
  • 디스크 탐색에서의 응답 지연은 무려 $2\mathrm{ms}$
• 단순 압축 알고리즘은 빠르다.
  • Zippy로 1KB를 압축하기 위한 지연시간은 $2\mu\mathrm{s}$
  • 즉, 데이터를 인터넷으로 전송하기 전에 가능하면 압축하는 것이 좋음
• 데이터 센터는 보통 여러 지역에 분산되어 있고, 센터들 간 데이터를 주고받는 데는 시간이 소요된다.

가용성에 관계된 수치들

고가용성은 시스템이 오랜 시간 동안 지속적으로 중단 없이 운영될 수 있는 능력을 말합니다. 고가용성을 표현하는 값은 퍼센트로 표현하는데, 100%는 시스템이 단 한 번도 중단된 적이 없었음을 의미합니다. 대부분의 서비스는 99% 이상을 유지하고 있습니다.

SLA는 서비스 사업자가 보편적으로 사용하는 용어로, 서비스 사업자와 고객 사이에 맺어진 합의를 의미합니다. 이 합의에는 서비스의 가용시간이 공식적으로 기술되어 있습니다. 가용시간의 경우 관습적으로 숫자 9를 사용해 표시하는데, 9가 많을수록 좋다고 볼 수 있습니다.

9의 개수와 시스템 장애 시간 사이에 대한 관계는 다음과 같습니다.

예제: 트위터 QPS와 저장소 요구량 측정

가정

• MAU(월간 능동 사용자)는 3억 명입니다.
• 매일 50%의 사용자가 트위터를 사용합니다.
• 평균적으로 각 사용자는 매일 2건의 트윗을 수행합니다.
• 미디어를 포함하는 트윗의 비율은 10% 입니다.
• 데이터는 5년간 보관됩니다.

추정

• QPS 추정치

  • DAU(일간 능동 사용자) = MAU X 사용량 = 3억 X 50% = 1.5억
  • QPS = DAU(1.5억) X 트윗 수행 개수(2) / 24시간 / 60분 / 60초 = 약 3,500
  • 최대 QPS = 2 X QPS = 약 7,000

• 미디어 저장을 위한 저장소 요구량

  • 일당 저장소 요구량
    • DAU(1.5억) X 평균 트윗 개수(2) X 미디어 포함 비율(10%) X 미디어 크기(1MB) = 30TB/일
  • 5년간 저장소 요구량
    • 일당 저장소 요구량(30TB) X 365 X 5 = 약 55PB