Input 보단 Output

인덱스(Index) 알아보기

2022-08-23T00:00:00+00:00

인덱스(Index)란?

인덱스는 쉽게 말해 책의 목차와 같다.

매우 매우 두꺼운 책에 목차 페이지가 없다면 어떨까요?
책 안에 내용을 찾을 때 여러분은 어디를 살펴보시나요?
우리들은 항상 무언가를 찾을 때 주소, 목차를 보고 찾습니다.

DB Index도 똑같습니다.

데이터베이스는 많은 데이터를 관리해주는 매우 중요한 기술입니다.
그런 많은 데이터 안에서 찾고 싶은 내용을 어떻게 찾을까요?

그것을 도와주는 것이 바로 DB Index 입니다.

인덱스 종류

인덱스 종류론 크게 클러스터드 인덱스와 넌클러스터드 인덱스로 나눌 수 있습니다.

클러스터드 인덱스

테이블당 1개씩만 허용
PK설정시 그 컬럼으로 클러스터드 인덱스가 생성됨
책으로 비유하면 페이지 숫자를 알고 있고 바로 찾을 수 있음

넌클러스터 인덱스

테이블당 여러개 허용
클러스터 인덱스보다 검색 속도는 더 느리지만 데이터의 입력,수정,삭제는 더 빠름
인덱스 페이지를 한번 거쳐서 데이터 접근
책으로 비유하면 페이지 숫자를 몰라 목차를 찾아가 숫자를 찾은 후 이동함

DB가 데이터를 읽어오는 방법

데이터베이스는 데이터를 읽어올 때 크게 2가지 방법으로 읽어옵니다.

시퀀셜 엑세스

물리적으로 인접한 페이지를 차례대로 읽는 방식, 그렇기에 인접한 페이지를 여러개 읽을 수 있음

테이블 풀스캔이 시퀀셜 엑세스를 사용함
Multi Block I/O 방식으로 효율적이게 디스크를 읽어옴

랜덤 엑세스

정해진 순서없이 이동하는 만큼 디스크의 물리적인 움직임이 필요하고, 다중 페이지 읽기가 불가능함

Index range scan이 랜덤 엑세스를 사용함
Single Block I/O 방식으로 레코드 하나를 읽기 위해 매번 I/O가 발생함
읽을 데이터가 일정량을 넘게되면 인덱스 스캔보다 풀스캔이 유리함
인덱스는 큰 테이블에서 소량의 데이터를 검색할 때 유리
랜덤 I/O를 어떻게 줄이는지가 중요
- 스캔 범위를 줄여야함

인덱스의 탐색 과정

인덱스는 수직적 탐색과 수평적 탐색으로 나눌 수 있습니다.

수직적 탐색

시작과 끝지점을 찾는 것 학생 명부 탐색

수평적 탐색

최종 데이터를 찾는 것 직접 교실 찾아가기

수평적 탐색 중 넌클러스터드 인덱스라면 랜덤 액세스, 즉 싱글 I/O가 발생함
클러스터드 인덱스인 PK는 mysql기준으로 순차적으로 저장되어있기 때문에 시퀀셜 엑세스가 발생함
이 부분을 잘 튜닝해야 성능이 상승함

인덱스를 튜닝해보자

인덱스를 가장 쉽게 튜닝할 수 있는 방법은 mysql 워크벤치를 활용한 방법입니다.
워크벤치에서 쿼리를 작성한 후 실행계획 버튼을 눌러 이 쿼리가 어떻게 동작할 지에 대해 그림으로 표현해주는 기능을 통해 튜닝에 접근할 수 있습니다.

그리고 쿼리문 앞에 Explain 이라는 명령어를 통해 세부적인 내용도 알아볼 수 있습니다.
Explain 을 통해 나오는 세부적인 내용 중 우리가 살펴봐야 할 컬럼은 7개 입니다.

실행계획 살펴보기

id
- SQL 문이 수행되는 순서
- 위의 예시엔 id가 모두다 1이지만 2인 경우가 있다면 1→2 순서로 실행된다고 보면 됨
- id가 같은 경우는 조인을 의미함
select_type
- SIMPLE → 단순한 SELECT 문
- PRIMARY → 서브쿼리를 감싸는 외부 쿼리, UNION이 포함될 경우 첫번째 SELECT 문
- SUBQUERY → 독립적으로 수행되는 서브 쿼리 (SELECT, WHERE 절에 추가된 서브쿼리)
- DERIVED → FROM 절에 작성된 서브쿼리
- UNION → UNION, UNION ALL로 합쳐진 SELECT
- DEPENDENT SUBQUERY → 서브쿼리가 바깥쪽 SELECT 쿼리에 정의된 컬럼을 사용
- DEPENDENT UNION → 외부에 정의된 컬럼을 UNION으로 결합된 쿼리에서 사용
  
  DEPENDENT 타입은 대부분 튜닝해야함 (성능저하)
type
- ALL → 테이블 풀스캔
- range → 인덱스 레인지 스캔
- index → 인덱스 풀스캔
- eq_ref → 조인이 수행될 때 드리븐 테이블의 데이터에 PK 혹은 고유 인덱스로 단 1건의 데이터를 조회할 때
- ref → eq_ref와 같으나 데이터가 2건 이상일 경우
- const → 조회되는 데이터가 단 1건 일 때
- system → 테이블에 데이터가 없거나 한 개만 있는 경우
key
- 옵티마이저가 실제로 선택한 인덱스
rows
- SQL문을 수행하기 위해 접근하는 데이터의 모든 행 수
filtered
- 필터링 되고 남은 레코드 비율
- 스토리지 엔진이 읽어들인 데이터 중 MySQL 엔진이 필터링하고 남은 비율을 의미
- 즉, 높을 수록 디스크를 효율적으로 탐색했다는 의미
extra
- Distinct → 중복 제거시
- Using where → WHERE 절로 필터시
- Using temporary → 데이터의 중간 결과를 저장하고자 임시 테이블을 생성, 보통 DISTINCT, GROUP BY, ORDER BY 구문이 포함된 경우 임시테이블을 생성
- Using index → 물리적인 데이터 파일을 읽지 않고 인덱스만 읽어서 처리, 커버링 인덱스라고 함
- Using filesort → 정렬시

그래서 어떻게 하는게 좋은 튜닝인가요?

위 사진의 select_type, type, extra 3부분만 신경써서 튜닝해도 꽤나 좋은 성능을 낼 수 있을 것입니다.

정리

간단하게 인덱스의 정의, 종류, 탐색과정, 튜닝까지 알아보았습니다.
세부적인 내용과 구현 및 실습까지 진행하기엔 분량이 너무 많을 것 같아 핵심적인 내용만 추려 정리해보았습니다.
백문이불여일타 직접 SQL을 작성하여 DB의 인덱스를 추가했다 뺏다하여 테스트해보시면 더욱더 쉽게 이해가기 때문에 꼭! 워크벤치의 실행계획을 사용해보세요!

그럼 이만 끝!

Reference

Real MySQL
우아한 테크캠프 Pro - 안정적인 서비스 만들기

이펙티브 자바 톺아보기 - 아이템 1. 생성자 대신 정적 팩터리 메서드를 고려하라

2022-08-14T00:00:00+00:00

핵심 정리

장점

이름을 가질 수 있다. (동일한 시그니처의 생성자를 두개 가질 수 없다.)

public static Order createForPrime(boolean prime, Product product) {
    Order order = new Order();
    order.prime = prime;
    order.product = product;
    return order;
}

public static Order createForUrgent(boolean urgent, Product product) {
    Order order = new Order();
    order.urgent = urgent;
    order.product = product;
    return order;
}

호출될 때마다 인스턴스를 새로 생성하지 않아도 된다. (Boolean.valueOf)

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

// main
Boolean.valueOf(false);

반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다. (인터페이스 기반 프레임워크, 인터페이스에 정적 메소드)
입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다. (EnumSet)
정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다. (서비스 제공자 프레임워크)

public interface HelloService {
    String hello();
}

public class ChineseHelloService implements HelloService {

    @Override
    public String hello() {
        return "Ni Hao";
    }
}

@Bean
public HelloService helloService() {
    return new ChineseHelloService();
}

// main
ServiceLoader<HelloService> loader = ServiceLoader.load(HelloService.class);
Optional<HelloService> helloServiceOptional = loader.findFirst();
helloServiceOptional.ifPresent(h -> {
    System.out.println(h.hello()); // Ni Hao
});

단점

상속을 하려면 public이나 protected 생성자가 필요하니 정적 팩터리 메서드만 제공하면 하위 클래스를 만들 수 없다.
정적 팩터리 메서드는 프로그래머가 찾기 어렵다.

완벽 공략

p9, 열거 타입은 인스턴트가 하나만 만들어짐을 보장한다.
p9, 같은 객체가 자주 요청되는 상황이라면 플라이웨이트 패턴을 사용할 수 있다.
p10, 자바 8부터는 인터페이스가 정적 메서드를 가질 수 없다는 제한이 풀렸기 때문에 인스턴스화 불가 동반 클래스를 둘 이유가 별로 없다.
p11, 서비스 제공자 프레임워크를 만드는 근간이 된다.
p12, 서비스 제공자 인터페이스가 없다면 각 구현체를 인스턴스로 만들 때 리플렉션을 사용해야 한다.
p12, 브리지 패턴
p12, 의존 객체 주입 프레임워크

완벽 공략 1. 열거 타입

Enumeration

상수 목록을 담을 수 있는 데이터 타입.
특정한 변수가 가질 수 있는 값을 제한할 수 있다. 타입-세이프티 (Type-Safety)를 보장할 수 있다. 싱글톤 패턴을 구현할 때 사용하기도 한다.
질문1) 특정 enum 타입이 가질 수 있는 모든 값을 순회하며 출력하라.

Arrays.stream(OrderStatus.values())
      .forEach(orderStatus1 -> System.out.println("orderStatus1 = " + orderStatus1));

질문2) enum은 자바의 클래스처럼 생성자, 메소드, 필드를 가질 수 있는가?

public enum OrderStatus {
    PREPARING(0), SHIPPED(1), DELIVERING(2), DELIVERED(3);

    private int number;

    OrderStatus(int number) {
        this.number = number;
    }
}

질문3) enum의 값은 == 연산자로 동일성을 비교할 수 있는가?

Order order = new Order();
if (order.orderStatus == OrderStatus.DELIVERED) { // enum
    System.out.println("order = " + order);
}

질문4) enum을 key로 사용하는 Map을 정의하세요.

EnumMap<OrderStatus, String> enumMap = new EnumMap(OrderStatus.class);
enumMap.put(OrderStatus.PREPARING, "PRE");
enumMap.put(OrderStatus.DELIVERING, "DEL");
enumMap.put(OrderStatus.SHIPPED, "SHIPP");
enumMap.put(OrderStatus.DELIVERED, "DELIVERED");

for (Map.Entry<OrderStatus, String> orderStatusStringEntry : enumMap.entrySet()) {
    System.out.println("orderStatusStringEntry.getKey() = " + orderStatusStringEntry.getKey());
    System.out.println("orderStatusStringEntry.getValue() = " + orderStatusStringEntry.getValue());
}

질문5) enum을 담고 있는 Set을 만들어 보세요.

EnumSet<OrderStatus> allOfOrderStatuses = EnumSet.allOf(OrderStatus.class);
System.out.println("allOfOrderStatuses = " + allOfOrderStatuses);

EnumSet<OrderStatus> noneOfOrderStatuses = EnumSet.noneOf(OrderStatus.class);
System.out.println("noneOfOrderStatuses = " + noneOfOrderStatuses);

EnumSet<OrderStatus> ofOrderStatuses = EnumSet.of(OrderStatus.SHIPPED, OrderStatus.PREPARING);
System.out.println("ofOrderStatuses = " + ofOrderStatuses);

HashMap vs EnumMap

HashMap은 key를 bucket에 저장하고 각 bucket이 linked list를 참조 하고 있음. (LinkedList에는 hash(key)가 같은 element가 들어감)
EnumMap의 경우 key로 사용할 값이 제한되어 있으므로, 그 갯수만큼 길이를 가진 array를 선언함. 해당 index에 값을 넣으면 됨.

HashSet vs EnumSet

HashSet은 HashMap과 같은데 map의 value가 있다 없다를 표현하는 지시자 같은 값이 들어감.
EnumSet은 값이 있다 없다만 표시하면 되니까 EnumMap처럼 array로 구현하지 않고 10101011 같은 bit vector로 구현이 가능.

완벽 공략 2. 플라이웨이트 패턴

Flyweight (가벼운 체급)

객체를 가볍게 만들어 메모리 사용을 줄이는 패턴.
자주 변하는 속성(또는 외적인 속성, extrinsit)과 변하지 않는 속성(또는 내적인 속성, intrinsit)을 분리하고 재사용하여 메모리 사용을 줄일 수 있다.

완벽 공략 3. 인터페이스에 정적 메소드

자바 8과 9에서 주요 인터페이스의 변화

기본 메소드(default method)와 정적 메소드를 가질 수 있다.

기본 메소드
- 인터페이스에서 메소드 선언 뿐 아니라, 기본적인 구현체까지 제공할 수 있다.
- 기존의 인터페이스를 구현하는 클래스에 새로운 기능을 추가할 수 있다.
정적 메소드
- 자바 9부터 private static 메소드도 가질 수 있다.
- 단, private 필드는 아직도 선언할 수 없다.
질문1) 내림차순으로 정렬하는 Comparator를 만들고 List<Integer>를 정렬하라.

List<Integer> numbers = new ArrayList();
numbers.add(10);
numbers.add(100);
numbers.add(20);
numbers.add(44);
numbers.add(3);

Comparator<Integer> desc = (o1, o2) -> o2 - o1;
numbers.sort(desc);

질문2) 질문1에서 만든 Comparator를 사용해서 오름차순으로 정렬하라.

numbers.sort(desc.reversed());

완벽 공략 4. 서비스 제공자 프레임워크

확장 가능한 애플리케이션을 만드는 방법

주요 구성 요소
- 서비스 제공자 인터페이스 (SPI)와 서비스 제공자 (서비스 구현체)
- 서비스 제공자 등록 API (서비스 인터페이스의 구현체를 등록하는 방법)
- 서비스 접근 API (서비스의 클라이언트가 서비스 인터페이스의 인스턴스를 가져올 때 사용하는 API)
다양한 변형
- 브릿지 패턴
- 의존 객체 주입 프레임워크
- java.util.ServiceLoader
  - https://docs.oracle.com/javase/tutorial/sound/SPI-intro.html
  - https://docs.oracle.com/javase/tutorial/ext/basics/spi.html

완벽 공략 5. 리플렉션

reflection

클래스로더를 통해 읽어온 클래스 정보(거울에 반사된 정보)를 사용하는 기술
리플렉션을 사용해 클래스를 읽어오거나, 인스턴스를 만들거나, 메소드를 실행하거나, 필드의 값을 가져오거나 변경하는 것이 가능하다.
언제 사용할까?
- 특정 애노테이션이 붙어있는 필드 또는 메소드 읽어오기 (JUnit, Spring)
- 특정 이름 패턴에 해당하는 메소드 목록 가져와 호출하기 (getter, setter)
https://docs.oracle.com/javase/tutorial/reflect/

이펙티브 자바 톺아보기 - 아이템 2. 생성자에 매개변수가 많다면 빌더를 고려하라

2022-08-14T00:00:00+00:00

핵심 정리

정적 팩토리와 생성자에 선택적 매개변수가 많을 때 고려할 수 있는 방안

대안1: 점층적 생성자 패턴 또는 생성자 체이닝

매개변수가 늘어나면 클라이언트 코드를 작성하거나 읽기 어렵다.

// 코드 2-1 점층적 생성자 패턴 - 확장하기 어렵다! (14~15쪽)
public class NutritionFacts {
    private final int servingSize;  // (mL, 1회 제공량)     필수
    private final int servings;     // (회, 총 n회 제공량)   필수
    private final int calories;     // (1회 제공량당)       선택
    private final int fat;          // (g/1회 제공량)       선택
    private final int sodium;       // (mg/1회 제공량)      선택
    private final int carbohydrate; // (g/1회 제공량)       선택

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts(10, 10);
    }
}

대안2: 자바빈즈 패턴

완전한 객체를 만들려면 메서드를 여러번 호출해야 한다. (일관성이 무너진 상태가 될 수도 있다.)
클래스를 불변으로 만들 수 없다.

// 코드 2-2 자바빈즈 패턴 - 일관성이 깨지고, 불변으로 만들 수 없다. (16쪽)
public class NutritionFacts {
    // 필드 (기본값이 있다면) 기본값으로 초기화된다.
    private int servingSize = -1; // 필수; 기본값 없음
    private int servings = -1; // 필수; 기본값 없음
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;
    private boolean healthy;

    public NutritionFacts() {
    }

    public void setServingSize(int servingSize) {
        this.servingSize = servingSize;
    }

    public void setServings(int servings) {
        this.servings = servings;
    }

    public void setCalories(int calories) {
        this.calories = calories;
    }

    public void setFat(int fat) {
        this.fat = fat;
    }

    public void setSodium(int sodium) {
        this.sodium = sodium;
    }

    public void setCarbohydrate(int carbohydrate) {
        this.carbohydrate = carbohydrate;
    }

    public void setHealthy(boolean healthy) {
        this.healthy = healthy;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts();
        cocaCola.setServingSize(240);
        cocaCola.setServings(8);
        cocaCola.setCalories(100);
        cocaCola.setSodium(35);
        cocaCola.setCarbohydrate(27);
    }
}

권장하는 방법: 빌더 패턴

// 코드 2-3 빌더 패턴 - 점층적 생성자 패턴과 자바빈즈 패턴의 장점만 취했다. (17~18쪽)
public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static void main(String[] args) {
        NutritionFacts cocaCola = new Builder(240, 8)
                .calories(100)
                .sodium(35)
                .carbohydrate(27).build();
    }

    public static class Builder {
        // 필수 매개변수
        private final int servingSize;
        private final int servings;

        // 선택 매개변수 - 기본값으로 초기화한다.
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

점층적 생성자보다 클라이언트 코드를 읽고 쓰기가 훨씬 간결하고, 자바빈즈 보다 훨씬 안전하다.
플루언트 API 또는 메서드 체이닝을 한다. (this를 리턴하기 때문)
계층적으로 설계된 클래스와 함께 사용하기 좋다.

// 코드 2-4 계층적으로 설계된 클래스와 잘 어울리는 빌더 패턴 (19쪽)
// 참고: 여기서 사용한 '시뮬레이트한 셀프 타입(simulated self-type)' 관용구는 빌더뿐 아니라 임의의 유동적인 계층구조를 허용한다.
public abstract class Pizza {
    public enum Topping {HAM, MUSHROOM, ONION, PEPPER, SAUSAGE}

    final Set<Topping> toppings;

    abstract static class Builder<T extends Builder<T>> {
        EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

        public T addTopping(Topping topping) {
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        abstract Pizza build();

        // 하위 클래스는 이 메서드를 재정의(overriding)하여 "this"를 반환하도록 해야 한다.
        protected abstract T self();
    }

    Pizza(Builder<?> builder) {
        toppings = builder.toppings.clone(); // 아이템 50 참조
    }
}

// 코드 2-6 칼초네 피자 - 계층적 빌더를 활용한 하위 클래스 (20~21쪽)
public class Calzone extends Pizza {
    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
        private boolean sauceInside = false; // 기본값

        public Builder sauceInside() {
            sauceInside = true;
            return this;
        }

        @Override
        public Calzone build() {
            return new Calzone(this);
        }

        @Override
        protected Builder self() {
            return this;
        }
    }

    private Calzone(Builder builder) {
        super(builder);
        sauceInside = builder.sauceInside;
    }

    @Override
    public String toString() {
        return String.format("%s로 토핑한 칼초네 피자 (소스는 %s에)",
                toppings, sauceInside ? "안" : "바깥");
    }
}

// 계층적 빌더 사용 (21쪽)
public class PizzaTest {
    public static void main(String[] args) {
        Calzone calzone = new Calzone.Builder()
                .addTopping(HAM)
                .sauceInside()
                .build();

        System.out.println(calzone);
    }
}

@Builder <- 롬복의 빌더로 코드의 양을 줄일 순 있지만, 두가지 차이점이 존재한다.

모든 매개변수를 받는 생성자가 생성됨

@AllArgsConstructor(access = AccessLevel.PRIVATE) 로 외부에서 호출을 막게 할 수 있다.

 // 코드 2-3 빌더 패턴 - 점층적 생성자 패턴과 자바빈즈 패턴의 장점만 취했다. (17~18쪽)
 @Builder
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class NutritionFactsLombok {
     private final int servingSize;
     private final int servings;
     private final int calories;
     private final int fat;
     private final int sodium;
     private final int carbohydrate;

     public static void main(String[] args) {
         NutritionFactsLombok cocaCola = NutritionFactsLombok.builder() // 롬복 빌더는 필수 매개변수 설정을 할 수 없다.
                 .servingSize(240)
                 .servings(8)
                 .calories(100)
                 .sodium(35)
                 .carbohydrate(27)
                 .build();
     }
 }

필수 값을 설정할 수 있는 방법이 없음

완벽 공략

p15, 자바빈즈, 게터, 세터
p17, 객체 얼리기 (freezing)
p17, 빌더 패턴
p19, IllegalArgumentException
P21, 가변인수 (varargs) 매개변수를 여러 개 사용할 수 있다.

완벽 공략 6. 자바빈(JavaBean)이란?

재사용 가능한 소프트웨어 컴포넌트 (주로 GUI에서)

java.beans 패키지 안에 있는 모든 것
그 중에서도 자바빈이 지켜야 할 규약
args 없는 기본 생성자 getter 와 setter 메소드 이름 규약 Serializable 인터페이스 구현
- 대표적으로 @RequestBody에서 사용되는 ObjectMapper가 기본생성자로 객체를 생성하고 자바빈 규약에 맞게 설정된 getter를 찾아 필드를 바인딩한다.
하지만 실제로 오늘날 자바빈 스팩 중에서도 기본생성자와 getter, setter가 주로 쓰는 이유는?
- JPA나 스프링과 같은 여러 프레임워크에서 리플렉션을 통해 특정 객체의 값을 조회하거나 설정하기 때문입니다.

완벽 공략 7. 객체 얼리기 (freezing)

임의의 객체를 불변 객체로 만들어주는 기능. (javascript)

Object.freeze()에 전달한 객체는 그뒤로 변경될 수 없다.
- 새 프로퍼티를 추가하지 못함
- 기존 프로퍼티를 제거하지 못함
- 기존 프로퍼티 값을 변경하지 못함
- 프로토타입을 변경하지 못함
strict 모드에서만 동작함
비슷한 류의 펑션으로 Object.seal()과 Object.preverntExtensions()가 있다.
java 진영에서 구현하려면 freeze 상태를 구분할 수 있는 필드값을 놓고 다른 필드를 수정할 때마다 freeze 상태를 체크하는 로직으로 구현
- 하지만 거의 쓰지 않음
- 그 이유는 가변객체에서 freezing을 하고 불변객체를 만드는 것인데, 언제 오퍼레이션이 됐는지 확인하기 어렵고 매우 이해하기 힘든 구조가될 가능성 높음

완벽 공략 8. 빌더 패턴

동일한 프로세스를 거쳐 다양한 구성의 인스턴스를 만드는 방법.

복잡한 객체를 만드는 프로세스를 독립적으로 분리할 수 있다.

빌더 인터페이스

public interface TourPlanBuilder {
    TourPlanBuilder nightsAndDays(int nights, int days);

    TourPlanBuilder title(String title);

    TourPlanBuilder startDate(LocalDate localDate);

    TourPlanBuilder whereToStay(String whereToStay);

    TourPlanBuilder addPlan(int day, String plan);

    TourPlan getPlan();
}

빌더 구현체

public class DefaultTourBuilder implements TourPlanBuilder {
    private String title;
    private int nights;
    private int days;
    private LocalDate startDate;
    private String whereToStay;
    private List<DetailPlan> plans;

    @Override
    public TourPlanBuilder nightsAndDays(int nights, int days) {
        this.nights = nights;
        this.days = days;
        return this;
    }

    @Override
    public TourPlanBuilder title(String title) {
        this.title = title;
        return this;
    }

    @Override
    public TourPlanBuilder startDate(LocalDate startDate) {
        this.startDate = startDate;
        return this;
    }

    @Override
    public TourPlanBuilder whereToStay(String whereToStay) {
        this.whereToStay = whereToStay;
        return this;
    }

    @Override
    public TourPlanBuilder addPlan(int day, String plan) {
        if (this.plans == null) {
            this.plans = new ArrayList<>();
        }

        this.plans.add(new DetailPlan(day, plan));
        return this;
    }

    @Override
    public TourPlan getPlan() {
        return new TourPlan(title, nights, days, startDate, whereToStay, plans);
    }
}

빌더 디렉터

public class TourDirector {
    private TourPlanBuilder tourPlanBuilder;

    public TourDirector(TourPlanBuilder tourPlanBuilder) {
        this.tourPlanBuilder = tourPlanBuilder;
    }

    public TourPlan cancunTrip() {
        return tourPlanBuilder.title("칸쿤 여행")
                .nightsAndDays(2, 3)
                .startDate(LocalDate.of(2020, 12, 9))
                .whereToStay("리조트")
                .addPlan(0, "체크인하고 짐 풀기")
                .addPlan(0, "저녁 식사")
                .getPlan();
    }

    public TourPlan longBeachTrip() {
        return tourPlanBuilder.title("롱비치")
                .startDate(LocalDate.of(2021, 7, 15))
                .getPlan();
    }
}

디렉터 사용 코드

public class App {
    public static void main(String[] args) {
        TourDirector director = new TourDirector(new DefaultTourBuilder());
        TourPlan cancunPlan = director.cancunTrip();
        TourPlan longBeachPlan = director.longBeachTrip();
    }
}

완벽 공략 9. IllegalArgumentException

잘못된 인자를 넘겨 받았을 때 사용할 수 있는 기본 런타임 예외

if (deliveryDate.isBefore(LocalDate.now())) {  
    throw new IllegalArgumentException("deliveryDate can't be earlier than " + LocalDate.now());  
}

질문1) checked exception과 unchecked exception의 차이?
- 클라이언트에게 꼭 확인해서 처리하라는 메세지를 남기는 것이 checked
- 런타임 중 날 수 있는 익셉션이 unchecked
  - 매우 많은 예외가 존재하기 때문에 모두 다 체크할 수 없음
질문2) 간혹 메소드 선언부에 unchecked exception을 선언하는 이유는?
- 런타임 중 나는 것 중 꼭 확인했으면 하는 것들을 throws 한다.
질문3) checked exception은 왜 사용할까?
- 이 메서드를 호출할 때 꼭 check 하라는 의미

완벽 공략 10. 가변인수

여러 인자를 받을 수 있는 가변적인 argument (Var+args)

public void printNumbers(int... numbers) {  
    System.out.println(numbers.getClass().getCanonicalName());  
    System.out.println(numbers.getClass().getComponentType());  
    Arrays.stream(numbers).forEach(System.out::println);  
}  
  
public static void main(String[] args) {  
    VarargsSamples samples = new VarargsSamples();  
    samples.printNumbers(1, 20, 20, 39, 59);  
}

가변인수는 메소드에 오직 하나만 선언할 수 있다.
가변인수는 메소드의 가장 마지막 매개변수가 되어야 한다.
빌더패턴의 메소드 체이닝 방식으로 가변인수를 여러개 받을 수 있다.

public SampleBuilder strings(String... strings){
    this.strings = strings;
    return this;
}

public SampleBuilder numbers(int... numbers){
    this.numbers = numbers;
    return this;
}

// main
public static void main(String[] args) {  
    new SampleBuilder()
        .strings("1","2","3")
        .numbers(1,2,3,4,5,6)
        .build();
}

이펙티브 자바 톺아보기 - 아이템 3. 생성자나 열거 타입으로 싱글턴임을 보증하라

2022-08-14T00:00:00+00:00

핵심 정리

private 생성자 + public static final 필드를 사용하는 방법

장점 1. 간결하고 싱글턴임을 API에 들어낼 수 있다

public class Elvis {
  
    /**  
     * 싱글톤 오브젝트  
     */  
    public static final Elvis INSTANCE = new Elvis();  
    private Elvis(){}
}

단점 1. 싱글톤을 사용하는 클라이언트를 테스트하기 어려워진다

싱글톤을 사용하는 클라이언트 객체를 테스트하기 위해 싱글톤 객체를 항상 호출해야한다.
테스트 하기위한 mock 객체를 주입하기 어려움

// 싱글톤 객체를 사용하는 클라이언트 객체
public class Concert {  
    private boolean lightsOn;  
    private boolean mainStateOpen;  
    private Elvis elvis;
  
    public Concert(Elvis elvis) {  
        this.elvis = elvis;  
    }  
  
    public void perform() {  
        mainStateOpen = true;  
        lightsOn = true;  
        elvis.sing(); // 싱글톤 객체
    }
}

단점 2. 리플렉션으로 private 생성자를 호출할 수 있다

public class Elvis implements Serializable {  
  
    /**  
     * 싱글톤 오브젝트  
     */  
    public static final Elvis INSTANCE = new Elvis();  
    private static boolean created; // 인스턴스 생성 flag 값 체크
  
    private Elvis() {  
        if (created) {  
            throw new UnsupportedOperationException("can't be created by constructor.");  
        }  
  
        created = true;  
    }
}

단점 3. 역직렬화 할 때 새로운 인스턴스가 생길 수 있다

// 역직렬화로 여러 인스턴스 만들기  
public class ElvisSerialization {   
    public static void main(String[] args) {  
        try (ObjectOutput out = new ObjectOutputStream(new FileOutputStream("elvis.obj"))) {  
            out.writeObject(Elvis.INSTANCE);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
  
        try (ObjectInput in = new ObjectInputStream(new FileInputStream("elvis.obj"))) {  
            Elvis elvis3 = (Elvis) in.readObject();  
            System.out.println(elvis3 == Elvis.INSTANCE); // False -> readResolve() 선언시 True
        } catch (IOException | ClassNotFoundException e) {  
            e.printStackTrace();  
        }  
    }  
  
}

public class Elvis implements Serializable {  
  
    /**  
     * 싱글톤 오브젝트  
     */  
    public static final Elvis INSTANCE = new Elvis();  
    private static boolean created;  
  
    private Elvis() {  
    }

    // 역직렬화시 새로운 인스턴스를 생성하지 않고 readResolve() 메서드를 실행함
    private Object readResolve() {
        return INSTANCE;  
    }
}  

private 생성자 + 정적 팩터리 메서드를 사용하는 방법

장점 1. API를 바꾸지 않고도 싱글턴이 아니게 변경할 수 있다

장점 2. 정적 팩터리를 제네릭 싱글턴 팩터리로 만들 수 있다

장점 3. 정적 팩터리의 메서드 참조를 공급자(Supplier)로 사용할 수 있다

단점은 public static final 필드를 사용하는 방법과 동일하다

lombok의 @Builder를 추가했더니 잭슨에서 에러가?

2022-08-14T00:00:00+00:00

문제 발생

한가로운 오후 개발환경에 api 응답 에러가 난다고 문의가 들어왔습니다.
ES에 에러 로그를 확인해보니 이러한 에러 로그가.. 줄줄..
(실제 환경을 포스팅할 수 없어 예제 코드를 작성하여 에러를 유도함)

Resolved [org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot construct instance of `com.example.lomboktest.SampleDto` (although at least one Creator exists): cannot deserialize from Object value (no delegate- or property-based Creator); 
nested exception is com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot construct instance of `com.example.lomboktest.SampleDto` (although at least one Creator exists): cannot deserialize from Object value (no delegate- or property-based Creator)<EOL> at [Source: (org.springframework.util.StreamUtils$NonClosingInputStream); line: 2, column: 5]]

문제가 발생한 dto를 확인해봅시다.

@Getter
public class SampleDto {
    @Builder.Default
    private String test = "tesT";

    @Builder
    public SampleDto(String test) {
        this.test = test;
    }
}

음.. 생성자를 선언하고 빌더를 선언하였는데 무엇이 문제일까?
에러 로그를 자세히 확인해봅시다.

JSON parse error:
Cannot construct instance of `com.example.lomboktest.SampleDto` 
(although at least one Creator exists): 
cannot deserialize from Object value (no delegate- or property-based Creator);

직역하자면, JSON 파싱 에러 SampleDto를 생성할 수 없다. (최소 한개의 생성자가 존재하지만)
객체값으로부터 역직렬화를 할 수 없다. (delegate 또는 property 기반의 생성자가 없음)

~~사실 딱 보자마자 알아봤다. 하지만 지식은 output을 해야 오래 기억에 남는법.. 그래서 정리하며 포스팅한다.~~

생성자가 존재하는데, 왜?

눈치채신분들은 아시겠지만, spring은 기본적으로 직렬화/역직렬화에 잭슨 라이브러리를 기본으로 사용하고 있고 그 잭슨 라이브러리는 기본생성자가 없으면 동작하지 않습니다.

자, 에러 메세지를 출력한 클래스를 추적해봅시다.

protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
            DeserializationContext ctxt) throws IOException
{
    final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
    if (delegateDeser != null) {
        final Object bean = _valueInstantiator.createUsingDelegate(ctxt,
                delegateDeser.deserialize(p, ctxt));
        if (_injectables != null) {
            injectValues(ctxt, bean);
        }
        return bean;
    }
    if (_propertyBasedCreator != null) {
        return _deserializeUsingPropertyBased(p, ctxt);
    }
    // 25-Jan-2017, tatu: We do not actually support use of Creators for non-static
    //   inner classes -- with one and only one exception; that of default constructor!
    //   -- so let's indicate it
    Class<?> raw = _beanType.getRawClass();
    if (ClassUtil.isNonStaticInnerClass(raw)) {
        return ctxt.handleMissingInstantiator(raw, null, p, 
"non-static inner classes like this can only by instantiated using default, no-argument constructor");
    }
    return ctxt.handleMissingInstantiator(raw, getValueInstantiator(), p, 
"cannot deserialize from Object value (no delegate- or property-based Creator)");
}

에러로그를 전달하는 메서드 이름이 deserializeFromObjectUsingNonDefault 요놈이다.
이름부터 심상치않다.

좀더 찾아보자.

/*
/**********************************************************
/* Public API implementation; instantiation from JSON Object
/**********************************************************
 */

@Override
public Object createUsingDefault(DeserializationContext ctxt) throws IOException
{
    if (_defaultCreator == null) { // sanity-check; caller should check
        return super.createUsingDefault(ctxt);
    }
    try {
        return _defaultCreator.call();
    } catch (Exception e) { // 19-Apr-2017, tatu: Let's not catch Errors, just Exceptions
        return ctxt.handleInstantiationProblem(_valueClass, null, rewrapCtorProblem(ctxt, e));
    }
}

메서드를 꾸준히 따라가다보니 문제 발생 근원지를 찾을 수 있었다.

if (_defaultCreator == null) { // sanity-check; caller should check

이 부분이 바로 기본생성자가 null 인지 확인하고 null이면 super.createUsingDefault(ctxt); 메서드가 호출될 것이고 에러로그가 출력된 곳으로 바인딩되어 실제 에러로그가 출력될 것입니다.

반대로 기본생성자가 있다면 호출되는 _defaultCreator.call(); 를 들어가보면 기본생성자를 사용하는지 살펴보면 확실히 알 수 있을 것 같네요.

@Override
public final Object call() throws Exception {
    // 31-Mar-2021, tatu: Note! This is faster than calling without arguments
    //   because JDK in its wisdom would otherwise allocate `new Object[0]` to pass
    return _constructor.newInstance((Object[]) null);
}

그렇다면 에러로그에 있던 no delegate- or property-based 는 뭐지?

우리가 지나쳐온 코드에 답이 존재합니다.
위의 코드 중 에러메세지 출력된 메서드를 확인해볼까요?

protected Object deserializeFromObjectUsingNonDefault(JsonParser p,
            DeserializationContext ctxt) throws IOException
{
    final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
    if (delegateDeser != null) {
        final Object bean = _valueInstantiator.createUsingDelegate(ctxt,
                delegateDeser.deserialize(p, ctxt));
        if (_injectables != null) {
            injectValues(ctxt, bean);
        }
        return bean;
    }
    if (_propertyBasedCreator != null) {
        return _deserializeUsingPropertyBased(p, ctxt);
    }
    // 25-Jan-2017, tatu: We do not actually support use of Creators for non-static
    //   inner classes -- with one and only one exception; that of default constructor!
    //   -- so let's indicate it
    Class<?> raw = _beanType.getRawClass();
    if (ClassUtil.isNonStaticInnerClass(raw)) {
        return ctxt.handleMissingInstantiator(raw, null, p, 
"non-static inner classes like this can only by instantiated using default, no-argument constructor");
    }
    return ctxt.handleMissingInstantiator(raw, getValueInstantiator(), p, 
"cannot deserialize from Object value (no delegate- or property-based Creator)");
}

deserializeFromObjectUsingNonDefault 메서드명을 살펴보면 기본생성자 없이 역직렬화하는 메서드입니다.

이 메서드가 탔다면 바로 에러를 찍어야하는데 세부 로직을 보면

final JsonDeserializer<Object> delegateDeser = _delegateDeserializer();
if (delegateDeser != null) {
    final Object bean = _valueInstantiator.createUsingDelegate(ctxt,
            delegateDeser.deserialize(p, ctxt));
    if (_injectables != null) {
        injectValues(ctxt, bean);
    }
    return bean;
}

delegateDeser != null delegate가 존재한다면 createUsingDelegate 메서드를 통해 객체를 생성하는 로직이 들어가 있습니다.
지금 저의 상황은 delegateDeser == null 이기 때문에 마지막 구문의 에러로그가 출력된 것을 볼 수 있습니다.

또한 그 밑의 로직인

if (_propertyBasedCreator != null) {
    return _deserializeUsingPropertyBased(p, ctxt);
}

_propertyBasedCreator 도 아니기 때문에 저런 에러가 찍힌것입니다.

정리

결국, 저의 문제는 Controller에서 API 요청 스펙을 전달하는 DTO의 객체로써 기본생성자가 없었기에 나타난 문제였습니다.
간단히 기본생성자를 추가해서 에러를 해결할 수 있었습니다.
롬복의 @builder는 기본생성자를 생성해주지 않기에 이런 상황이 발생하였습니다.. 😱

우리 모두 하나만 기억합시다.
잭슨의 object mapper는 기본생성자를 필요로한다! (기본생성자는 private 이어도 된다! 리플렉션)
번외로 @JsonProperty, @JsonAutoDetect 등을 사용하는 프로퍼티 기반 객체 or 생성자를 위임한 경우라면 필요하지 않다!

끝.

우아한 테크캠프 Pro 2기 회고

2021-08-18T00:00:00+00:00

재직자 대상으로 진행하는 우아한 테크캠프 Pro..!
약 9주 동안의 미션을 겨우겨우 완수했다…
미션을 진행하면서 회사업무와 이직을 병행하느라 죽을맛이었지만, 정말 9주 동안 원없이 개발만 하면서 살았더니 우리의 포비님께서 선물을 주셨다.

감사합니다. 재성님 🙏

특별한 상황이 아니라면 매년 교육을 진행하는 것 같으니 본인이 주니어 백엔드 개발자라면 주저하지말고 도전하는 것을 적극 추천합니다!!
여담이지만, 우수수료생으로 선발되면 면접의 기회가 주어집니다. ~~(제일 중요한거)~~

지원 동기

지원동기는 남들과 크게 다르지 않았습니다.
남들처럼 개발을 잘하고 싶었고, 흔히들 말하는 네카라쿠배 사람들의 코드리뷰를 받아보고 싶은게 가장 큰 이유였습니다.
그들은 어떻게 일하고, 어떻게 생각하는지도 궁금했습니다. 🤔
그리고 더 나아가 면접의 기회까지 주어진다고하니 큰 고민하지 않고 지원하게 되었습니다.

과정

우선 듣고 싶다고해서 다 들을 수 있는건 아닙니다.

일종의 선발 과정이 있는데 제 기수는 TDD로 자동차 게임을 구현하는 과제를 받아서 진행하였습니다.
주어진 요구사항에 맞게 TDD로 구현하는 과제인데, 주니어 개발자라면 ~~쉽게?~~ 할 수 있는 과제입니다.
하지만, TDD에 익숙하지 않았던 저는 선발 과제부터 난항이었습니다..

TDD에 관심이 많고 잘 아시는 여러분들은 쉽게 진행하실 수 있을 거에요. 👍

교육생에 최종 선발되면 총 9주차의 강의 일정과 선발 과제로 진행했던 자동차 게임 구현 과제 피드백 시간을 갖게 됩니다.
제가 교육받은 9주차의 과정은 이러합니다.

클린코드를 통해 유지보수하기 좋은 코드를 구현하는 경험
JPA 기반으로 웹 애플리케이션을 개발하는 경험
단위, 인수 테스트를 기반으로 웹 애플리케이션을 개발하는 경험
레거시 코드를 안정적으로 리팩터링하는 경험
시스템 아키텍처를 설계하고 운영하는 경험
대용량 데이터에 대해 최적화할 대상을 살펴보고, 서버를 튜닝하는 경험
이력서와 면접을 리팩토링하는 경험

교육은 총 9번의 강의와 7번의 네트워킹 데이로 이뤄지며, 하나의 미션당 3~5개의 Step이 존재하기 때문에 절대적으로 시간이 부족합니다..
방심하는 순간 쌓여가는 미션을 보게 될 겁니다. 😮‍💨

좋았던 점

가장 좋았던 점은 제가 바라고 바랬던 넥스트스텝의 리뷰어님들과 의견을 주고받는 코드리뷰 과정이었습니다.
미션을 진행하면서 궁금했던 것들이나 평소 생각해오던 기술에 대한 생각을 여과없이 소통할 수 있는 소중한 시간이 가장 좋았습니다.
하지만, 미션을 진행하면서 시간에 압박받다보니 지치기도 한답니다..

미션 속 하나의 Step 일 뿐인데도 25번의 대화가 오고가곤 합니다.
이 자리를 빌어 부족한 저의 코드를 봐주시고 리뷰해주신 리뷰어님들 정말 감사드립니다! 🙏

아쉬웠던 점

아쉬웠던 점은 절대적인 시간이 부족하여 후반으로 갈수록 깊이있게 공부하지 못했던 부분들이 아쉬웠습니다.
미션을 완수해야한다는 압박감과 동시에 개인적인 문제가 겹쳐 굉장히 힘들었습니다…
시간이 조금만 더 여유있었더라면 더 깊게 생각하며 미션을 진행해 나갈 수 있었지 않았을까하는 아쉬움이 남습니다.. 😭
미션의 난이도는 사람마다 차이가 있겠지만, 저는 굉장히 시간이 부족했었습니다.. 😂

총평

무조건 강!추!
본인이 개발에 관심이 많고, 네카라쿠배 같은 트래픽이 많은 서비스 회사에서 필요로 하는 기초 역량을 쌓을 수 있는 과정이라고 생각합니다.
클린 코드와 리팩토링의 중요성을 일깨워 주고, 테스트 코드의 힘을 알게 해준 과정입니다.
백엔드 개발자가 소홀할 수 있는 인프라 분야도 경험할 수 있는 과정이니 무조건 들으세요!

앞으로

새로운 회사에 이직하게 되었으니 여기서 배운 것들을 단계적으로 전파할 예정입니다.
레거시 코드 중 Fat한 서비스 레이어 코드 -> Fit한 서비스 레이어 코드로 리팩토링하는 작업을 진행하기 위해 설득 중에 있지만, 쉽진 않네요.. 😂
유지보수하기 편한 코드, 테스트하기 편한 코드로 나아가기 위한 필수적인 단계임으로 포기하지 않고 진행하려합니다.
저를 성장시켜 준 넥스트스텝 관계자분들께 감사를 표하며..