해당 포스팅은 인프런에서 제공하는 최태현 님의 '자바 개발자를 위한 코틀린 입문'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

try catch finally

fun parseIntOrThrow(str : String): Int {
    try {
        return str.toInt()
    } catch (e : NumberFormatException) {
        throw IllegalArgumentException("${str}은 숫자가 아닙니다.")
    }
}

위의 예제와 같이 Java에서의try-catch문과 큰 차이는 없다. 단 타입이 뒤에 위치하고, new 키워드를 사용하지 않는다는 차이가 존재한다.

fun parseIntOrThrow(str : String): Int? {
    return try {
        str.toInt()
    } catch (e : NumberFormatException) {
        null
    }
}

또한 try-catch문 또한 표현식(expression)이기 때문에 구문 자체를 return할 수 있다.

Checked Exception & Unchecked Exdception

Kotlin에는 throws 구문이 없다. Checked Exception과 Unchecked Exception을 구분하지 않고 모든 예외를 Unchecked Exception으로 간주하기 때문이다.

try with resources

Kotlin에는 try with resources구문이 존재하지 않고 use라는 inline 확장 함수를 사용해야 한다. use함수 사용시 close는 내부에서 처리해준다.

fun readFile(path: String) {
    BufferedReader(FileReader(path)).use { reader -> 
        println(reader.readLine())
    }
}

그래프는 노드(데이터를 표현하는 단위)와 에지(노드를 연결하는 선)로 구성된 집합이다. 그래프를 구현하는 방법은 크게 세 가지가 존재한다.

1. 에지 리스트

에지를 중심으로 그래프를 표현하는 방법이다. 배열에 출발 노드, 도착 노드를 저장하여 에지를 표현하거나 출발 노드, 도착 노드, 가중치를 저장하여 가중치가 있는 에지를 표현한다.

가중치가 없는 그래프

가중치가 없는 그래프는 출발 노드와 도착 노드만 표현하기 때문에 배열의 행은 2개면 충분하다. 노드는 여러 자료형을 사용할 수 있다.

가중치가 있는 그래프

가중치가 있는 그래프는 행을 3개로 늘려 3번째 행에 가중치를 저장한다.

에지 리스트는 구현하기 쉽지만 특정 노드와 관련되어 있는 에지를 탐색하기 쉽지 않다. 에지 리스트는 벨만-포드나 크루스칼 알고리즘에 사용되며, 노드 중심 알고리즘에는 잘 사용하지 않는다.

2. 인접 행렬

인접 행렬은 2차원 배열을 자료구조로 이용하여 그래프를 표현한다. 에지 리스트와는 다르게 노드 중심으로 그래프를 표현한다.

가중치가 없는 그래프

아래 그림과 같이 에지를 A행 B열에 1을 저장하는 방식으로 표현한다. 1을 저장하는 이유는 가중치가 없기 때문이다.

가중치가 있는 그래프

가중치가 있는 그래프는 앞의 가중치가 없는 그래프에서 에지의 위치에 가중치를 기록한다.

인접 행렬의 구현은 쉽고, 두 노드를 연결하는 에지의 여부와 가중치 값을 배열에 직접 접근하여 바로 확인할 수 있다는 장점이 있다.

그러나 노드와 관련되어 있는 에지를 탐색하기 위해서 N번 접근해야 하며, 노드 개수에 비해 에지가 적을 때 공간 효율성이 떨어진다. 또한 노드 개수가 많은 겨우 2차원 배열 선언 자체를 할 수 없는 결함도 있다.(노드 개수가 3만개가 넘을 경우 Java 힙 스페이스 에러 발생)

3. 인접 리스트

인접 리스트는 ArrayList로 그래프를 표현한다. 노드 개수만큼 ArrayList를 선언하고, 알맞는 자료형을 사용한다.

가중치가 없는 그래프

인접 리스트에는 N번 노드와 연결되어 있는 노드를 배열의 위치 N에 연결된 노드 개수만큼 배열을 연결하는 방식으로 표현한다.

가중치가 있는 그래프

가중치가 있는 경우 자료형을 클래스로 사용한다. Node 클래스를 선언하여 ArrayList에 사용한다.

다른 방법들에 비해 인접 리스트를 이용한 그래프 구현은 복잡한 편이지만, 노드와 연결되어 있는 에지를 탐색하는 시간이 매우 뛰어나며, 노드 개수가 커도 공간 효율이 좋아 메모리 초과 에러도 발생하지 않는다.

그래프 표현 구현

백준 1707 - 이분 그래프

import java.util.*;
import java.io.*;

class Main {

    static ArrayList<Integer>[] A ;  // 그래프 데이터 저장 인접 리스트
    static int[] check;              // 이분 그래프 체크 배열
    static boolean[] visited;        // 방문 기록 저장 배열
    static boolean isEven;           // 이분 그래프 여부

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int testCase = Integer.parseInt(br.readLine());

        for (int t = 0; t < testCase; t++) {
            String[] s = br.readLine().split(" ");
            int v = Integer.parseInt(s[0]);    // 노드 개수
            int e = Integer.parseInt(s[1]);    // 에지 개수

            A = new ArrayList[v + 1];    // 노드는 무조건 1번 부터 시작
            visited = new boolean[v + 1];
            check = new int[v + 1];
            isEven = true;

            for (int i = 1; i <= v; i++) {
                A[i] = new ArrayList<Integer>();
            }

            // 에지 데이터 저장
            for (int i = 0; i < e; i++) {
                s = br.readLine().split(" ");
                int start = Integer.parseInt(s[0]);
                int end = Integer.parseInt(s[1]);
                A[start].add(end);
                A[end].add(start);
            }

            // 모든 노드에서 DFS 실행
            for (int i = 1; i <= v; i++) {
                if (isEven) {
                    DFS(i);
                } else {
                    break;
                }
            }

            if (isEven)  System.out.println("YES");
            else         System.out.println("NO");
        }
    }

    public static void DFS(int start) {
        visited[start] = true;
        for (int i : A[start]) {    // 인접 리스트로 받아서 start에서 연결된 모든 노드 탐색
            if (!visited[i]) {
                check[i] = (check[start] + 1) % 2;
                DFS(i);
            } else {
                if (check[start] == check[i]) {
                    isEven = false; 
                }
            }
        }
    }
}

유니온 파인드

그래프에서의 유니온 파인드는 그래프의 사이클이 생성되는지 판별하는 알고리즘이다.

위상 정렬

사이클이 없고, 방향이 있는 그래프를 정렬하는 알고리즘으로 그 결과가 한 개 이상일 수 있다.

다익스트라

최단거리 알고리즘으로, 시작점이 있고 다른 모든 노드로 가는 최단거리를 구하는 알고리즘이다. 단, 음수간선이 존재하면 안된다.

벨만-포드

최단거리 알고리즘으로, 시작점이 있고 다른 모든 노드로 가는 최단거리를 구하는 알고리즘이다. 음수간선이 존재해도 구할 수 있다. 음수 사이클이 존재하는지 체크하는데 많이 사용된다.

노드 수를 V, 에지 수를 E라고 했을 때 O(VE)의 시간 복잡도를 갖는다.

핵심 이론

1. 에지 리스트로 그래프 구현 후 최단 경로 리스트 조회

벨만-포드 알고리즘은 에지를 중심으로 동작하기 때문에 그래프를 에지 리스트로 구현한다. 또한 최단 경로 리스트를 출발 노드는 0, 나머지 노드는 무한대(적당히 큰 수)로 초기화 한다.

2. 모든 에지를 확인하며 정답 리스트 업데이트

최단 거리 리스트에서 업데이트 반복 횟수는 노드 개수 -1이다.(이 이상일 경우 무조건 사이클이 생긴다.) 업데이트 반복 횟수가 K번이라면 해당 시점에 정답 리시트의 값은 시작점에서 K개의 에지를 사용했을 때 각 노드에 대한 최단 거리이다.

업데이트 조건과 방법

시작점의 값 != ∞이며, 도착점의 값 > 시작점의 값 + 가중치일 때 도착점의 값 = 시작점의 값 + 가중치로 리스트 값을 업데이트한다.

음수 사이클이 없을 때 N - 1번 에지 사용 횟수를 반복하면 출발 노드와 모든 노드 사이의 최단 거리를 구할 수 있다. 이렇게 완성된 정답 리스트를 통해 해당 그래프에 음수 사이클이 존재하는지 여부를 확인해야 한다.

3. 음수 사이클 유무 확인

음수 사이클 유무를 확인하기 위해 모든 에지를 한 번씩 다시 사용해 업데이트되는 노드가 발생하는지 확인한다. 업데이트되는 노드가 있다면 음수 사이클이 존재한다는 의미이며, 최단 거리를 찾을 수 없는 그래프라는 뜻이 된다.(음수 사이클이 존재할 경우 무한하게 돌며 가중치가 감소하므로 구할 수 없다.)

플로이드-워셜

시작점이 존재하지 않고, 어느 노드에서 시작해도 최단거리를 구할 수 있는 알고리즘으로, 음수 가중치 에지가 있어도 수행할 수 있지만 음수 사이클이 존재하면 안된다. 단 시간복잡도가 좋지 않다.(O(노드의 수³))

핵심 이론

플로이드-워셜의 핵심 원리는 A 노드에서 B 노드까지 최단 경로를 구했다고 가정했을 때 최단 경로 위에 K 노드가 존재한다면 그것일 이루는 부분 경로 역시 최단 경로라는 것이다.

플로이드-워셜 점화식

D[S][E] = Math.min(D[S][E], D[S][K] + D[K][E])

1. 리스트 선언 후 초기화

D[S][E]는 노드 S에서 노드 E까지의 최단 거리를 저장하는 리스트라 정의한다. S와 E의 값이 같은 칸은 0, 다른 칸은 무한대로 초기화 한다. 여기서 S == E는 자기 자신에게 가는데 걸리는 최단 경로값을 의미하기 때문이다.

2. 최단 거리 리스트에 그래프 데이터 저장

출발 노드는 S, 도착 노드는 E, 가중치 W일 때 D[S][E] = W로 에지의 정보를 리스트에 입력한다.(인접 행렬)

3. 점화깃으로 리스트 업데이트

기존에 구했던 점화식을 3중 for문의 형태로 반복하면서 리스트의 값을 업데이트한다.

for 경유지 K에 관해 (1 ~ N)
    for 출발 노드 S에 관해 (1 ~ N)
        for 도착 노드 E에 관해 (1 ~ N)
            D[S][E] = Math.min(D[S][E], D[S][K] + D[K][E])

최소 신장 트리

그래프의 모든 노드를 연결하는데 사용된 에지들의 가중치의 합을 최소로 하는 트리이다. 크루스칼 알고리즘과 프림 알고리즘을 사용할 수 있다.

사이클이 포함되면 가중치의 합이 최소가 될 수 없기 때문에 사이클을 포함하지 않으며, N개의 노드가 있으면 최소 신장 트리를 구성하는 에지의 개수는 항상 N-1 개이다.

핵심 이론

1. 에지 리스트로 그래프를 구현한 후 유니온 파인드 리스트 초기화

최소 신장 트리는 데이터를 노드가 아닌 에지 중심으로 저장하기 때문에 인접 리스트가 아닌 에지 리스트로 저장한다. 일반적으로 노드 변수 2개와 가중치 변수로 구성되며, 사이클 처리를 위한 유니온 파인드 리스트도 함께 초기화 한다. 리스트의 인덱스는 해당 자리의 값으로 초기화한다.

2. 가중치 기준으로 그래프 정렬

에지 리스트에 담긴 그래프 데이터를 가중치 기준으로 오름차순 정렬한다.

3. 가중치가 낮은 에지부터 연결 시도

가중치가 낮은 에지부터 순서대로 연결을 시도하며 바로 연결하는 것이 아닌 이 에지를 연결했을 때 그래프에 사이클 형성 유무를 find 연산을 이용해 확인한 후 사이클이 형성되지 않을 때만 union연산을 이용해 두 노드를 연결한다.

4. 앞의 단계 3을 반복

전체 노드의 개수가 N개이면 연결한 에지의 개수가 N-1이 될 때까지 과정 3을 반복한다.

5. 총 에지 비용 출력

에지의 개수가 N-1이 되면 알고리즘을 종료하고, 완성된 최소 신장 트리의 총 에지 비용을 출력한다.

최소 신장 트리는 다른 그래프 알고리즘과 달리 에지 리스트의 형태를 이용해 데이터를 담는다. 또한 사이클이 존재하면 안되기 때문에 사이클 판별을 위한 유니온 파인드 알고리즘을 내부에 구현해야 한다.

소수를 구하는 대표적인 판별법으로 에라토스테네스의 체가 있다. 에라토스테네스의 체 원리는 다음과 같다.

에라토스테네스의 체 핵심 원리

1. 구하고자 하는 소수의 범위만큼 1차원 배열을 생성
2. 2 부터 시작하여 현재 숫자가 지워지지 않을 때, 현재 선택된 숫자의 배수에 해당하는 수를 배열에서 끝까지 탐색하며 지운다. 이 때 처음으로 선택된 수는 지우지 않는다.
3. 배열의 끝까지 두 번째 단계를 반복한 후 배열에서 남아 있는 모든 수를 출력

에라토스테네스의 체를 사용할 때 시간 복잡도는 최적화 정도에 따라 다르지만, 일반적으로 O(Nlog(logN))이다.

소수 구하기 구현

백준 1929번 - 소수 구하기

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);    
        int m = sc.nextInt();
        int n = sc.nextInt();
        int[] a = new int[n + 1];

        for (int i = 1; i <= n; i++) {
            a[i] = i;
        }

        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (a[i] == 0) continue;
            for (int j = i+i; j <= n; j += i) {
                a[j] = 0;
            }
        }

        for (int i = m; i <= n; i++) {
            if (a[i] > 1) {
                System.out.println(a[i]);
            }
        }
    }
}

오일러 피

오일러 피 함수 P[N]의 정의는 1 부터 N까지의 범위에서 N과 서로소(공약수가 1이외에 없는 수)인 자연수의 개수를 뜻한다.

오일러 피 핵심 이론

1. 구하고자 하는 오일러 피의 범위만큼 자기 자신의 인덱스값으로 초기화
2. 2 부터 시작하여 배열의 값과 인덱스가 같으면(소수일 때) 현재 선택된 수(K)의 배수에 해당하는 수를 배열에 끝까지 탐색하여 P[i] = P[i] - P[i]/k 연산 수행
3. 배열의 끝까지 두 번째 단계를 반복하며 오일러 피 함수를 완성

유클리드 호제법

두 수의 최대 공약수를 구하는 알고리즘으로, 소인수 분해를 이용한 공통된 소수들의 곱으로 표현하는 것 보다 좀 더 간단한 방법을 제시한다.

유클리드 호제법 핵심 이론

유클리드 호제법을 수행하기 위해서는 먼저 최대 공약수를 구하는데 사용할 MOD 연산(두 값을 나눈 나머지를 구하는 연산 - 10 % 4 = 2)을 이해하고 있어야 한다.

MOD 연산을 통해 구현하는 유클리드 호제법

1. 큰 수를 작은 수로 나누는 MOD 연산 수행
2. 이전 단계에서의 작은 수와 MOD 연산의 결과값으로 MOD 연산 수행
3. 두 번째 단계를 반복하며 나머지가 0이 되는 순간의 작은 수를 최대 공약수로 선택

그리디 알고리즘은 현재 상태에서 선택할 수 있는 선택 중 최선의 선택지가 전체 선택지 중 최선의 선택지라고 가정하는 알고리즘이다.

핵심 이론

1. 해 선택 : 현재 상태에서 가장 최선이라고 생각되는 해를 선택
2. 적절성 검사 : 현재 선택한 해가 전체 문제의 제약 조건에 벗어나지 않는지 검사
3. 해 검사 : 현재까지 선택한 해 집합이 전체 문제를 해결할 수 있는지 검사, 전체 문제를 해결하지 못한다면 1로 돌아가 같은 과정을 반복 수행

그리디 알고리즘 구현

백준 11047번 - 동전 0

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        int count = 0;
        for (int i = n - 1; i >= 0; i--) {
            if (a[i] <= k) {
                count += (k / a[i]);
                k = k % a[i];
                if (k == 0) break; 
            }
        }

        System.out.println(count);
    }
}

백준 1541번 - 잃어버린 괄호

import java.util.*;

class Main {
    public static void main(String[] args) {
        int answer = 0;
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] strs = str.split("-");

        for (int i = 0; i < strs.length; i++) {
            int num = sumNumber(strs[i]);
            if (i == 0) answer += num;
            else        answer -= num;
        }

        System.out.println(answer);
    }    

    public static int sumNumber(String str) {
        int sum = 0;
        String[] strs = str.split("[+]");

        for (int i = 0; i < strs.length; i++) {
            sum += Integer.parseInt(strs[i]);
        }

        return sum;
    }
}

해당 포스팅은 인프런에서 제공하는 김영한 님의 '스프링 핵심원리 고급편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

프록시 팩토리

동적 프록시 사용의 문제점

동적 프록시를 사용할 때 인터페이스가 있는 경우에는 JDK 동적 프록시를, 구체 클래스는 CGLIB를 적용해야 한다. 이를 자동화할 수 있는 방법이 필요하며, 이 때 JDK 동적 프록시가 제공하는 InvocationHandler와 CGLIB가 제공하는 MethodInterceptor를 각각 중복으로 개발하여 관리해야 하는지, 특정 조건에 부합할 때 프록시 로직을 적용하는 공통 기능 제공 등 고민해야 할 부분이 존재한다.

프록시 팩토리

스프링은 유사한 구체적인 기술들이 존재할 때 이를 통합해서 일관성 있게 접근하고 편리하게 사용할 수 있도록 추상화된 기술을 제공하며, 동적 프록시를 통합해서 관리하기 위해 프록시 팩토리(ProxyFactory)를 제공한다.

프록시 팩토리를 사용할 경우 인터페이스는 JDK 동적 프록시를, 구체 클래스만 존재할 경우 CGLIB를 사용한다. 또한 이 설정을 변경할 수도 있게 해준다.

Advice

또한 두 기술을 함께 사용할 때 부가 기능을 적용하기 위해 각 기술을 중복해서 개발하지 않도록 Advice라는 새로운 개념을 도입했다.

개발자는 InvocationHandler와 MethodInterceptor를 구분하지 않고 Advice 하나만을 만들면 프록시 팩토리가 기술에 맞게 해당 Advice를 호출하는 전용 InvocationHandler와 MethodInterceptor를 내부적으로 사용한다.

Advice 구현 및 프록시 팩토리 적용

Advice를 만드는 방법은 기본적으로 스프링 AOP 모듈에서 제공하는 org.aopalliance.intercept 패키지의 MethodInterceptor를 구현하면 된다.

public class TestAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("TestProxy Run");

        Object result = invocation.procced();    
        /* 
         * target 클래스 호출 및 결과 반환
         * target 클래스의 정보는 MethodInvocation 안에 모두 포함,
         * ProxyFactory를 생성하는 단계에 이미 target 정보를 파라미터로 전달
         */

        System.out.println("TestProxy Stop");
        return result;
    }

}

public class ProxyFactoryTest {

    public void interfaceProxy() {    // JDK 동적 프록시 적용
        TestInterface target = new TestInterface();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        // target 정보를 파라미터로 전달받는다.
        proxyFactory.addAdvice(new TestAdvice());

        TestInterface proxy = (TestInterface) proxyFactory.getProxy();

        proxy.execute();
    }

    public void concreteProxy() {    // CGLIB 적용
        TestClass target = new TestClass();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        // target 정보를 파라미터로 전달받는다.
        proxyFactory.addAdvice(new TestAdvice());

        TestClass proxy = (TestClass) proxyFactory.getProxy();

        proxy.execute();
    }

    public void interfaceProxyTargetClass() {    
    // Interface가 존재하지만 CGLIB 적용
        TestInterface target = new TestInterfaceImpl();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        // target 정보를 파라미터로 전달받는다.
        proxyFactory.setProxyTargetClass(true);    // 구현체에 적용
        proxyFactory.addAdvice(new TestAdvice());

        TestInterface proxy = (TestInterface) proxyFactory.getProxy();

        proxy.execute();
    }

}

Pointcut

스프링은 Pointcut이라는 개념을 도입해 특정 조건에 부합할 경우에만 프록시 부가 기능이 적용되도록 설정해줄 수 있게 해준다.

Pointcut, Advice, Advisor

프록시 팩토리는 역할과 책임을 명확하게 분리하기 위해 다음과 같은 단어들을 사용한다.

• Pointcut : 프록시 부가 기능을 적용할지 여부를 판단하는 필터링 로직. 주로 클래스와 메서드 이름으로 필터링 한다.
• Advice : 프록시가 호출하는 부가 기능. 프록시 로직
• Advisor : 하나의 포인트컷과 하나의 어드바이스를 포함한 개념

깊이 우선 탐색은 그래프 완전 탐색 기법 중 하나로, 그래프의 시작 노드에서 출발하여 탐색할 한 쪽 분기를 정하여 최대 깊이까지 탐색을 마친 후 다른 쪽 분기로 이동하여 다시 탐색을 수행하는 알고리즘이다.

특징으로는 재귀 함수로 구현되며, 스택 자료구조를 이용한다. 노드 개수를 V, 에지 개수를 E라고 할 경우 시간 복잡도는 O(V + E)이다.

깊이 우선탐색은 재귀 함수를 이용하므로 스택 오버플로우(stack overflow)에 유의해야 한다.

핵심 이론

1. DFS 시작 노드를 정한 후 사용할 자료구조 초기화

DFS를 위한 초기 작업은 인접 리스트로 그래프를 표현하고, 방문했던 노드를 체크하기 위한 방문 배열을 초기화한 후 시작 노드 스택에 한다.

2. 스택에서 노드를 꺼낸 후 꺼낸 노드의 인접 노드를 다시 스택에 삽입

스택에 들어있던 노드를 꺼낸 후 탐색 순서에 기입하고, 인접 리스트의 인접 노드를 스택에 삽입하며 방문 배열을 체크한다.

3. 스택 자료구조에 값이 없을 때 까지 반복

위의 과정을 스택 자료구조에 값이 없을 때까지 반복한다. 이 때 이미 다녀간 노드는 방문 배열을 바탕으로 재삽입하지 않는 것이 핵심이다.

DFS 구현

백준 11724번 - 연결 요소의 개수

import java.io.*;
import java.util.*;

class Main {
    static boolean[] VISITED;
    static ArrayList<Integer>[] A;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        VISITED = new boolean[n + 1];
        A = new ArrayList[n + 1];

        for (int i = 1; i < n + 1; i++) {
            A[i] = new ArrayList<>();
        }

        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int s = Integer.parseInt(st.nextToken());
            int e = Integer.parseInt(st.nextToken());
            A[s].add(e);
            A[e].add(s);
        }
        int count = 0;
        for (int i = 1; i < n + 1; i++) {
            if (!VISITED[i]) {
                count++;
                DFS(i);
            }
        }
        System.out.println(count);
    }    

    public static void DFS(int v) {
        if (VISITED[v]) {
            return;
        }
        VISITED[v] = true;
        for (int i : A[v]) {
            if (!VISITED[i]) {
                DFS(i);
            }
        }
    }
}

BFS(너비 우선 탐색)

그래프 완전 탐색 기법 중 하나로, 시작 노드에서 출발해 가까운 노드를 먼저 방문하면서 탐색하는 알고리즘이다. 노드 개수를 V, 에지 개수를 E라고 할 경우 시간 복잡도는 O(V + E)이다.

선입선출 방식으로 탐색하므로 큐를 이용해 구현하며, 탐색 시작 노드와 가까운 노드를 우선 탐색하므로 목표 노드에 도착하는 경로가 여러 개일 때 최단 경로를 보장한다.

핵심 이론

1. BFS 시작 노드를 정한 후 사용할 자료구조 초기화

인접 리스트로 그래프를 표현하고, 방문했던 노드를 체크하기 위한 방문 배열을 초기화한 후 시작 노드 큐에 한다.

2. 큐에서 노드를 꺼낸 후 꺼낸 노드의 인접 노드를 다시 큐에 삽입

큐에 들어있던 노드를 꺼낸 후 탐색 순서에 기입하고, 인접 리스트의 인접 노드를 큐에 삽입하며 방문 배열을 체크한다.

큐 자료구조에 값이 없을 때 까지 반복

위의 과정을 큐 자료구조에 값이 없을 때까지 반복한다. 이 때 이미 다녀간 노드는 방문 배열을 바탕으로 재삽입하지 않는 것이 핵심이다.

BFS 구현

백준 2178번 - 미로 탐색

import java.util.*;
import java.io.*;

class Main {
    static int[] DX = {0, 1, 0, -1};
    static int[] DY = {1, 0, -1, 0};

    static boolean[][] VISITED;
    static int[][] A;
    static int N, M;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());

        A = new int[N][M];
        VISITED = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            String line = st.nextToken();
            for (int j = 0; j < M; j++) {
                A[i][j] = Integer.parseInt(line.substring(j, j + 1));
            }
        }

        BFS(0, 0);
        System.out.println(A[N - 1][M - 1]);
    }

    private static void BFS(int i, int j) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[] {i, j});
        VISITED[i][j] = true;

        while (!queue.isEmpty()) {
            int now[] = queue.poll();

            for (int k = 0; k < 4; k++) {
                int x = now[0] + DX[k];
                int y = now[1] + DY[k];

                if (x >= 0 && y >= 0 && x < N && y < M) {
                    if (A[x][y] != 0 && !VISITED[x][y]) {
                        VISITED[x][y] = true;
                        A[x][y] = A[now[0]][now[1]] + 1;
                        queue.add(new int[] {x, y});
                    }
                } 
            }
        }
    }
}

이진 탐색

이진 탐색(binary search)은 데이터가 정렬되어 있는 상태에서 원하는 값을 찾아내는 알고리즘으로, 대상 데이터의 중앙값과 찾고자 하는 값을 비교해 데이터의 크기를 절반씩 줄이면서 대상을 찾는 알고리즘이다.

핵심 이론

1. 현재 데이터셋의 중앙값을 선택
2. 중앙값 > 타깃 데이터일 경우 중앙값 기준으로 왼쪽 데이터셋 선택
3. 중앙값 < 타깃 데이터일 경우 중앙값 기준으로 오른쪽 데이터셋 선택
4. 1 ~ 3을 반복하며 중앙값 == 타깃 데이터일 때 탐색 종료

이진 탐색 구현

백준 1920번 - 수 찾기

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] A = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = sc.nextInt();
        }
        Arrays.sort(A);

        int M = sc.nextInt();
        for (int i = 0; i < M; i++) {
            boolean find = false;
            int target = sc.nextInt();
            int start = 0;
            int end = A.length - 1;
            while (start <= end) {
                int mid = (start + end) / 2;
                int midValue = A[mid];
                if (midValue > target) {
                    end = mid - 1;
                } else if (midValue < target) {
                    start = mid + 1;
                } else {
                    find = true;
                    break;
                }
            }
            if (find) System.out.println(1);
            else      System.out.println(0);
        }
    }
}

버블 정렬은 loop를 돌며 데이터의 인접 요소끼리 비교하고, swap 연산을 수행하면 정렬하는 방식이다. 간단하게 구현할 수 있지만, 시간 복잡도가 O(n²)으로 다른 정렬 알고리즘보다 속도가 느린 편이다.

버블 정렬 과정

1. 비교 연산이 필요한 루프 범위 설정
2. 인접한 데이터 값 비교
3. swap 조건에 부합하면 swap 연산 수행
4. 루프 범위가 끝날 때까지 2~3번 반복
5. 정렬된 정렬 영역을 설정하여 다음 루프 실행시 이 영역 제외
6. 비교 대상이 존재하지 않을 때 까지 위의 과정 반복

만약 특정한 루프의 전체 영역에서 swap이 한 번도 발생하지 않았다면 그 영역 뒤에 있는 데이터가 모두 정렬되었다는 뜻이 되며, 프로세스를 종료해도 된다.

버블 정렬 구현

백준 2705번 - 수 정렬하기

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int num = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = num;
                }
            }
        }

        for (int i = 0; i < n; i++) {
            System.out.println(a[i]);
        }
    }
}

선택 정렬

선택 정렬은 대상 데이터에서 최대나 최소 데이터를 데이터가 나열된 순으로 찾아가며 선택하는 방법이다. 구현 방법이 복잡하고, 시간 복잡도도 O(n²)으로 비효율적이다.

선택 정렬 구현

백준 1427번 - 소트인사이드

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        int[] a = new int[str.length()];
        for (int i = 0; i < str.length(); i++) {
            a[i] = Integer.parseInt(str.substring(i, i+1));
        }

        for (int i = 0; i < a.length; i++) {
            int max = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[max] < a[j]) {
                    max = j;
                }
            }
            if (a[i] < a[max]) {
                int num = a[i];
                a[i] = a[max];  
                a[max] = num;
            }
        }

        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }
    }
}

삽입 정렬

이미 정렬된 데이터 범위에 정렬되지 않은 데이터를 적절한 위치에 삽입시켜 정렬하는 방식으로 O(n²)의 시간 복잡도로 느린 편이지만 구현이 쉽다. 선택 데이터를 현재 정렬된 데이터 범위 내 적절한 위치에 삽입하는 것이 핵심이다.

삽입 정렬 과정

1. 현재 index에 있는 데이터 값 선택
2. 선택한 데이터가 정렬된 데이터 범위에 삽입될 위치 탐색
3. 삽입 위치부터 index까지 shif연산 수행
4. 삽입 위치에 현재 선택한 데이터를 삽입한 후 index++
5. 선택할 데이터가 없을 때 까지 반복(전체 데이터의 크기만큼 index가 커질 때 까지) 적절한 삽입 위치를 탐색할 때 이진 탐색과 같은 탐색 알고리즘을 사용하면 시간 복잡도를 줄일 수 있다.

퀵 정렬

기준값을 선정해 해당 값보다 작은 데이터와 큰 데이터로 분류하는 것을 반복하여 정렬한다. 기준값(pivot) 선정 기준이 시간 복잡도에 많은 영향을 미치며, 평균 시간 복잡도는 O(nlogn)이며, 최악의 경우 O(n²)이 된다.

퀵 정렬 과정

1. 데이터를 분할하는 pivot 설정
2. pivot을 기준으로 다음 과정을 거쳐 데이터를 2개의 집합으로 분리
   • L이 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 L을 오른쪽으로 한칸 이동
   • R이 가리키는 데이터가 pivot이 가리키는 데이터보다 크면 R을 왼쪽으로 한칸 이동
   • L이 가리키는 데이터가 pivot이 가리키는 데이터보다 크고, R이 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 L, R이 가리키는 데이터를 swap하고, L은 오른쪽, R은 왼쪽으로 한칸씩 이동
   • L과 R이 만날 때 까지 위의 과정을 반복
   • L과 R이 만나면 만난 지점에서 가리키는 데이터와 pivot이 가리키는 데이터를 비교하여 pivot이 가리키는 데이터가 크면 만난 지점의 오른쪽에, 작으면 만난 지점의 왼쪽에 pivot이 가리키는 데이터를 삽입
3. 분리 집합에서 각각 다시 pivot을 선정
4. 분리 집합이 한개 이하가 될 때까지 위의 모든 과정을 반복

병합 정렬

분할 정복 방식을 사용해 데이터를 분할하고, 분할한 집합을 정렬하며 합치는 정렬방법이며, 시간 복잡도는 O(nlogn)이다.

두 그룹을 병합하는 과정

투 포인터 개념을 사용하여 두 그룹을 병합한다. 왼쪽 포인터(i)와 오른쪽 포인터(j)의 값을 비교하여 작은 값을 결과 배열에 추가하고 포인터를 오른쪽으로 이동시킨다.

병합 정렬 구현

public class MergeSort {
   public static void main(String[] args) {
    int[] arr = { 9, 7, 3, 1, 6, 2, 8, 4, 5 };
    mergeSort(arr, 0, arr.length - 1);
    for (int i : arr) {
      System.out.print(i + " ");
    }
  }


  public static void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
      int mid = (left + right) / 2;  // 중간 지점 계산
      mergeSort(arr, left, mid);     // 왼쪽 반 정렬
      mergeSort(arr, mid + 1, right);// 오른쪽 반 정렬
      merge(arr, left, mid, right);  // 정렬된 반들을 병합
    }
  }

  public static void merge(int[] arr, int left, int mid, int right) {
    int[] tempArr = new int[right - left + 1]; // 병합을 위한 임시 배열 생성
    int i = left, j = mid + 1, k = 0;

    while (i <= mid && j <= right) { // 병합
      if (arr[i] <= arr[j]) {
        tempArr[k++] = arr[i++];
      } else {
        tempArr[k++] = arr[j++];
      }
    }

    // 왼쪽 반 나머지 항목들 복사
    while (i <= mid) {
      tempArr[k++] = arr[i++];
    }

    // 오른쪽 반 나머지 항목들 복사
    while (j <= right) {
      tempArr[k++] = arr[j++];
    }

    // 임시 배열을 복사하여 정렬된 배열로 업데이트
    for (i = left, k = 0; i <= right; i++, k++) {
      arr[i] = tempArr[k];
    }
  }
}

기수 정렬

값을 비교하지 않고 비교할 자릿수를 정한 후 해당 자릿수만 비교하는 정렬 방식으로 시간 복잡도는 O(kn)이다. k는 데이터의 자릿수를 의미한다.

기수 정렬은 10개의 큐를 이용(0 ~ 9의 수를 담기 위해)하며, 각 큐는 값의 자릴수를 대표한다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '스프링 핵심원리 고급편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

리플렉션

자바의 리플렉션 기술은 클래스나 메서드의 메타정보를 동적으로 획득하고, 코드도 동적으로 호출할 수 있다.

리플렉션을 사용하는 방법은 다음과 같다.

• Class test = Class.forName("패키지경로.클래스명{$내부 클래스}") : 클래스 메타정보를 획득
• Method execute = test.getMethod("execute") : 해당 클래스의 execute() 메서드 메타정보를 획득
• execute.invoke(target) : 획득한 메서드 메타정보로 실제 인스턴스(target)의 메서드를 호출한다.

이렇듯 리플렉션을 사용하면 클래스나 메서드 정보를 동적으로 변경할 수 있으며, 이를 통해 비지니스 로직의 공통된 부분을 뽑아 공통 로직을 만들 수 있게 된다.

리플렉션 사용시 주의사항

리플렉션을 사용하면 어플리케이션을 동적으로 유연하게 만들 수 있다. 그러나 리플렉션은 런타임에 동작하기 때문에 컴파일 시점에 오류를 잡을 수 없다는 단점이 존재한다. 이는 굉장히 치명적인 오류로 발생할 수 있다.

따라서 리플렉션은 일반적으로 사용하지 않으며, 프레임워크나 매우 일반적인 공통 처리가 필요할 때 부분적으로 주의해서 사용해야 한다.

JDK 동적 프록시

프록시 패턴을 적용하기 위해서는 적용 대상의 수 만큼 많은 프록시 클래스를 만들어야 했다. 이는 적용 대상의 차이가 존재하기 때문에 발생하는 문제이며, 동적 프록시 기술을 통해 이를 해결할 수 있다.

동적 프록시 기술을 사용하면 개발자가 직접 프록시 객체를 만들지 않아도 런타임에 프록시 객체를 대신 만들어주며, 원하는 실행 로직을 지정해줄 수 있다.

public interface TestInterface { void execute(); }

public class TestImple implements TestInterface {
    @Override
    public void execute() { System.out.println("Test Execute"); }
}

JDK 동적 프록시는 인터페이스를 기반으로 프록시를 동적으로 만들어주기 때문에 인터페이스가 필수적이다. 위의 인터페이스와 구현체에 JDK 동적 프록시를 이용해 공통 로직을 적용하기 위해서는 InvocationHandler 인터페이스를 구현하면 된다.

public class TestInvocationHandler implemnts InvocationHandler {

    private final Object target;    // 동적 프록시가 호출할 대상

    public TestInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method,
                         Object[] args) throws Throwable {
                         // args : 메서드 호출시 넘겨줄 인수
        System.out.println("TestProxy Run");

        Object result = method.invoke(target, args);

        System.out.println("TestProxy End");
        return result;
    }
}

이렇게 구현된 프록시는 아래와 같이 사용할 수 있다.

void test() {
    TestInterface target = new TestImpl();
    TestInvocationHandler handler = new TestInvocationHandler(target);

    TestInterface proxy = (TestInterface) Proxy.newProxyInterface(TestInterface.class.getClassLoader(), new Class[]{TestInterface.class}, handler);

    proxy.execute();
}

위 메서드의 실행 결과는 다음과 같다.

TestProxy Run
Test Execute
TestProxy End

위 로직의 실행 순서는 다음과 같다.

• 클라이언트는 JDK 동적 프록시의 execute()를 실행한다.
• JDK 동적 프록시는 InvocationHandler의 invoke()를 호출하며, 그 구현체가 TestInvocationHandler이므로 TestInvocationHandler.invoke()가 호출된다.
• TestInvocationHandler가 내부 로직을 수행하고, method.invoke(target, args)를 호출하여 target의 실제 객치인 TestImpl를 호출한다.
• TestImpl의 execute()가 실행된다.
• TestImpl의 execute()가 종료되면 TestInvocationHandler로 응답이 돌아와 나머지 로직을 수행하고 그 결과를 반환한다.

JDK 동적 프록시의 효용과 한계

이렇게 살펴본 JDK 동적 프록시의 장점은 같은 부가 기능 로직을 한번만 개발해서 공통으로 사용할 수 있다는 것이다. 위의 코드에서 인터페이스 TestInterface와 구현체인 TestImpl의 위치에 어느 인터페이스와 그 구현체가 와도 프록시 부분은 재사용이 가능하다. 따라서 적용 대상만큼 프록시 객체를 만들지 않아도 된다. 결과적으로 부가 기능 로직도 하나의 클래스에 모아 *단일 책임 원칙(SRP)도 지킬 수 있게 되었다. *

그러나 JDK 동적 프록시는 인터페이스가 필수이기 때문에 구현체를 만들기 앞서 항상 인터페이스를 생성해주어야 한다는 단점이 존재한다. 이를 해결하기 위해서는 CGLIB라는 바이트코드를 조작하는 특별한 라이브러리를 사용해야 한다.

CGLIB

CGLIB : Code Generator Library

CGLIB는 바이트코드를 조작해서 동적으로 클래스를 생성하는 기술을 제공하는 라이브러리이다. 이를 사용하면 인터페이스가 없이 구체 클래스만 가지고 동적 프록시를 만들어낼 수 있다. CGLIB를 직접 사용하는 경우는 거의 없고, 스프링의 ProxyFactory가 이 기술을 편리하게 사용할 수 있게 해준다.

public class TestClass {

    public void execute() { 
        System.out.println("Test Execute"); 
    }

}

위의 콘크리트 클래스에 동적 프록시 로직을 적용하기 위해서는 MethodInterceptor를 사용하면 된다.

public class TestMethodInterceptor implements MethodInterceptor {

    private final Object target;

    public TestMethodInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercpet(Object obj, Method method, 
                            Object[] args, MethodProxy proxy
    ) throws Throwable {
        System.out.println("TestProxy Run");

        Object result = method.invoke(target, args);

        System.out.println("TestProxy End");
        return result;
    }

}

위의 예제를 살펴보면 알 수 있듯 기본적으로 JDK 동적 프록시와 그 사용에 있어 큰 차이가 존재하지 않는다. 그러나 이를 실행하는데 있어 약간의 차이가 있다.

void test {
    TestClass target = new TestClass();

    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(TestClass.class);
    enhancer.setCallback(new TestMethodInterceptor(target));

    TestClass proxy = (TestClass) enhancer.create();

    proxy.execute();
}

코드를 살펴보면 CGLIB는 Enhancer를 사용해 프록시를 생성하는 것을 알 수 있다. 이 때 프록시를 생성하고자 하는 구체 클래스(TestClass)를 상속 받아서 프록시를 생성한다.

CGLIB의 제약

CGLIB는 클래스 기반으로 상속을 사용하기 때문에 몇가지 제약이 존재한다.

• 부모 클래스의 생성자를 체크해야 하며, 자식 클래스를 동적으로 생성하기 때문에 기본 생성자가 필요하다.
• 클래스에 final 키워드가 붙으면 상속이 불가능하고 예외가 발생한다.
• 메서드에 final 키워드가 붙으면 해당 메서드를 오버라이딩할 수 없기 때문에 프록시 로직이 동작하지 않는다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '자바 ORM 표준 JPA 프로그래밍 - 기본편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

JPQL 조인

내부 조인과 외부 조인

JPQL의 조인은 SQL과 기능이 같지만, 문법에 약간의 차이가 있다. JPQL 조인의 가장 큰 특징은 다른 엔티티와 연관관계를 가지기 위해 사용하는 필드인 연관 필드를 사용해 조인한다는 것이다.

SELECT ... FROM Member m JOIN m.team t

외부 조인 또한 기능상 SQL의 외부 조인과 같다.

SELECT m FROM Member m LEFT JOIN m.team t

컬렉션 조인

일대다 관계나 다대다 관계처럼 컬렉션을 사용하는 곳에 조인하는 것을 컬렉션 조인이라 한다.

• 회원 -> 팀 : 다대일 조인, 단일 값 연관 필드(m.team) 사용
• 팀 -> 회원 : 일대다 조인, 컬렉션 값 연관 필드(m.members) 사용

세타 조인

전혀 관련 없는 엔티티도 세타 조인을 통해 조인할 수 있다. 세타 조인은 내부 조인만을 지원한다.

SELECT COUNT(m) FROM Member m, Team t WHERE m.username = t.name

ON

ON 절을 사용하면 조인 대상을 필터링하고 조인할 수 있다. 내부 조인의 ON절은 WHERE 절과 같은 결과를 반환하므로 보통 외부 조인에서만 사용한다.

SELECT m, t FROM Memeber m LEFT JOIN m.team t ON t.name = "A"

페치 조인

페치 조인은 JPQL에서 성능 최적화를 위해 제공하는 기능으로 연관된 엔티티나 컬렉션을 한 번에 같이 조회하는 기능이다. 페치 조인의 문법은 다음과 같다.

[ LEFT [OUTER] | INNER ] JOIN FETCH 조인 경로

엔티티 페치 조인

SELECT m FROM Member m JOIN FETCH m.team

위와 같은 JPQL 쿼리를 사용할 경우 연관된 엔티티나 컬렉션을 함께 조회할 수 있다. 일반적인 JPQL 조인과는 다르게 m.team 다음에 별칭이 존재하지 않으며, 페치 조인은 별칭을 사용할 수 없다.(하이버네이트는 허용)

페치 조인을 사용하면 지연 로딩으로 설정된 엔티티 객체를 조회할 때도 프록시가 아닌 실제 엔티티 객체를 조회할 수 있다. 그렇기에 준영속 상태가 되더라도 조회 된 범위 내에서 객체 그래프 탐색이 가능하다.

컬렉션 페치 조인

SELECT t FROM Team t JOIN FETCH t.members WHERE t.name = 'TeamA'

위의 쿼리문 실행 시 팀을 조회하며 연관된 회원 컬렉션도 함께 조회한다. 조회된 회원 컬렉션의 각 객체들은 같은 팀 객체를 참조하게된다.

페치 조인과 DISTINCT

JPQL의 DISTINCT는 SQL에 DISTINCT를 추가함과 동시에 어플리케이션에서 한 번 더 중복을 제거한다.

페치 조인과 일반 조인

JPQL은 결과를 반환할 때 SELECT절에 지정한 엔티티만을 조회할 뿐 연관관계까지 고려하지 않는다. 그렇기 때문에 연관관계 설정시 지연 로딩으로 설정하면 프록시나 아직 초기화되지 않은 컬렉션 래퍼를 반환한다. 반면 즉시 로딩으로 설정할 경우 해당 컬렉션을 즉시 로딩하기 위해 쿼리를 한 번 더 실행하게 된다. 하지만 페치 조인을 사용하면 연관된 엔티티를 함께 조회한다.

페치 조인의 특징과 한계

페치 조인 사용시 SQL을 최적화하여 호출 횟수를 줄일 수 있다. 페치 조인은 글로벌 로딩 전략보다 우선시 되기에 기본적으로 글로벌 로딩 전략을 지연 로딩으로 설정하고, 최적화가 필요한 조회시 페치 조인을 적용하는 것이 좋다.

그러나 페치 조인은 조인 대상에 별칭을 줄 수 없어 SELECT, WHERE, 서브 쿼리에서 페치 조인 대상을 사용할 수 없다. 또한 둘 이상의 컬렉션을 페치할 수 없다는 점과 페이징 API를 사용할 수 없다는 단점이 존재한다.

해당 포스팅은 인프런에서 제공하는 최태현 님의 '자바 개발자를 위한 코틀린 입문'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

조건문

if문

fun validationScore(score: Int) {
    if (score < 0) {
        throw IllegalArgumentException("${score}는 0보다 작을 수 없습니다.");
    }
}

위의 코드 예제를 통해 알 수 있는 코틀린과 자바의 차이는 함수를 선언하기 위해 fun키워드를 사용하며, Exception을 throw할 때 new 키워드를 생략한다는 것이다.

if문은 기본적으로 자바와 사용 방법이 동일하다. 그러나 자바에서 if-else는 Statement이지만 코틀린에서는 Expression이라는 차이가 있다.

Expression(문)과 Statement(표현식)

Expression은 '수식'이라는 뜻으로 하나 이상의 값으로 표현될 수 있는 코드를 뜻한다. 변수와 연산을 비롯해 함수 콜, 변수 이름과 같은 식별자, 배열등의 할당 연산자까지도 포함한 식을 의미한다.

Statement는 프로그래밍에서 실행가능한 최소의 독립적인 코드 조각을 말한다. 컴파일러가 이해하고 실행할 수 있는 모든 구문은 statement이며 한 개 이상의 expression과 프로그래밍 키워드를 포함한다.

int num = 30 + 40;    // Expression & Statement

boolean isPass = if (num > 50) { "Pass"; }
// if문을 하나의 값으로 취급하지 않기 때문에 에러 발생, !Expression & Statement

위의 예제와 같이 자바에서 if-else문은 statement이다. 그러나 코틀린에서는 expression이기 때문에 아래와 같이 사용할 수 있다.

val isPass: Boolean = if (score > 50) { "Pass" } else { "Fail" }

이처럼 조건문을 expression으로 사용할 수 있기 때문에 코틀린에는 삼항 연산자가 존재하지 않는다.

또한if (0 <= score && score <= 100)과 같은 범위에 대한 조건식을 if (score in 0..100)과 같이 in을 사용하여 간단하게 표기할 수 있다.

switch와 when

코틀린에서는 자바의 switch문이 when으로 대체되었다.

when(값) {
    조건부 -> 어떠한 구문
    조건부 -> 어떠한 구문
    else -> 어떠한 구문
}

조건부에는 어떠한 expression이라도 들어갈 수 있으며, 여러 개의 조건을 ,로 구분하여 동시에 검사할 수 있다. 값 부분이 없을 경우 early return 처럼 동작하며, when 역시 expression으로 사용 가능하다. Enum, Sealed Class와 함께 사용할 경우 시너지가 좋다.

반복문

for/for-each

기본적으로 for문과 for-each문 모두 자바와 거의 동일하게 동작하지만 문법에 약간의 차이가 있다.

for-each

자바와 동일하게 Iterable이 구현된 타입이라면 모두 for-each문을 사용할 수 있다. : 대신 in을 사용한다는 차이가 존재한다.

for (number in numbers) {
    println(number)
}

for

for (i in 1..3) {
    println(i)
}

위의 코드는 자바의 for (int i = 0; i <= 3; i++)와 동일하게 동작한다. i가 증감식이 감소되는 경우에는 for (i in 3 downTo 1)과 같이 표현할 수 있으며, 증가되는 수가 2 이상일 경우 for (i in 1..5 step 2)와 같이 표현할 수 있다. 여기서 사용되는 downTo와 step 모두 함수이며, 중위 호출 함수라 한다.

코틀린은 for문 사용 시 1..3과 같은 범위 연산자와 downTo, step과 같은 함수를 이용하여 등차수열을 만들어낸다. 1..3, 3 downTo 1을 통해 시작값과 끝값을 표현하고 step을 통해 공차를 표현해주는 것이다.

이 외의 반복문인 while, do while문은 자바와 완전히 동일하다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '자바 ORM 표준 JPA 프로그래밍 - 기본편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

JPA는 엔티티 객체를 중심으로 개발이 가능하게 도와준다. 검색 쿼리 또한 테이블이 아닌 엔티티 객체를 대상으로 검색을 하는데 현실적으로 모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능하다. 때문에 필요한 데이터만 DB에서 불러오기 위해서는 조건이 포함된 SQL이 필요하다.

JPQL

JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어를 제공한다. SQL 문법과 유사(SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN)하며, 데이터베이스 테이블을 대상으로 쿼리를 보내는 SQL과 달리 객체를 대상으로 쿼리를 보낸다. 또한 SQL을 추상화해서 사용하기 때문에 특정 데이터베이스의 SQL 문법에 의존적이지 않다.

JPQL 문법

SELECT m FROM Member m WHERE m.age > 20과 같이 엔티티와 속성은 대소문자를 구분하며, JPQL 키워드는 구분하지 않는다. 또한 객체를 대상으로 검색하기 때문에 테이블명이 아닌 엔티티 객체의 이름을 사용해야하며, 별칭(Alias, as는 생략 가능)을 반드시 명시해야 한다.

기본적으로 COUNT, SUM, AVG, MAX, MIN과 같은 집합 함수나 GROUP BY, HAVING과 같은 집합, ORDER BY와 같은 정렬 조건도 지원한다.(UNION은 지원하지 않는다.)

TypeQuery, Query

TypeQuery 객체는 반환 타입이 명확할 때 사용하며 TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m", Member.class)과 같이 제네릭으로 타입을 명시해줄 수 있다. 반면 반환 타입을 명확하게 지정할 수 없는 경우 Query 객체를 아래와 같이 사용할 수 있다.

Query query = em.createQuery("SELECT m.username, m.age FROM Member m")

List resultList = query.getResultList();
for (Object o : resultList) {
    Object[] result = (Object[]) o; // 결과가 둘 이상이면 배열 반환
    System.out.println("username = " + result[0]);
    System.out.println("age = " + result[1]);
}

결과 조회

다음 메서드들을 호출하면 실제 쿼리를 실행해서 데이터베이스를 조회한다.

• query.getResultList();
  • 결과를 컬렉션으로 반환
  • 결과가 없으면 빈 컬렉션을 반환한다.
• query.getSingleResult();
  • 결과가 정확히 하나일 때 사용한다.
  • 결과가 없으면 NoResultException 예외가 발생
  • 결과가 한개보다 많으면 NonUniqueResultException 예외가 발생한다. 따라서 사용에 주의해야 한다.

파라미터 파인딩

JDBC는 위치 기준 파라미터 파인딩만을 지원하지만(NamedParameterJdbcTemplate을 통해 지원한다.) JPQL은 이름 기준 파라미터 바인딩도 지원한다.

이름 기준 파라미터 바운딩

이름 기준 파라미터 바운딩은 기준 파라미터 앞에 :를 붙여서 사용한다.

List<Member> members = em.createQuery("SELECT m FROM Member m WHERE m.username = :username", Member.class)
                          .setParameter("username", "test")
                          .getResultList();

위치 기준 파라미터 바인딩

위치 기준으로 사용하려면 ?1과 같이 ? 뒤에 위치 값을 지정하고 파라미터 값을 넣어주면 된다. 위치 값은 1부터 시작된다.

프로젝션

SELECT 절에 조회할 대상을 지정하는 것을 프로젝션(projection)이라 한다. 프로젝션 대상은 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자 등 기본 데이터 타입)이 있다.

SELECT {프로젝션 대상} FROM ...

엔티티 프로젝션

SELECT m FROM Member m        // 회원
SELECT m.team FROM Member m    // 팀

위 예시에서 프로젝션은 모두 엔티티이다. 컬럼을 나열해서 조회해야 하는 SQL과 달리 객체 단위로 바로 조회가 가능하다. 이렇게 조회된 엔티티는 모두 영속성 컨텍스트에 의해서 관리된다.

임베디드 타입 프로젝션

임베디드 타입은 엔티티와 거의 비슷하게 사용된다. 그러나 조회의 시작점이 될 수 없다는 제약이 있기 때문에 엔티티를 통해 임베디드 타입을 조회해야 한다.

// Address = 임베디드 타입
SELECT a FROM Address a            // 조회 불가
SELECT m.address FROM Member m    // 엔티티를 통해 조회 가능

임베디드 타입은 엔티티 타입이 아닌 값 타입이기 때문에 직접 조회한 임베디드 타입은 영속성 컨텍스트의 관리 대상이 되지 않는다.

new 명령어

엔티티 객체나 임베디드 타입이 아닌 필드를 프로젝션할 경우 타입을 지정할 수 없어 TypeQuery를 사용할 수 없다. 이후 Object로 반환 받은 값을 DTO로 변환해서 사용하게 되는데, new 명령어를 통해 DTO 객체를 타입으로 지정하고 TypeQuery를 사용할 수 있다.

List<MemberDTO> memberList = em.createQuery(
        "SELECT new 패키지경로.MemberDTO(m.username, m.age) FROM Member m",
        MemberDTO.class
    )
    .getResultList();

new 명령어 사용시 패키지 명을 포함한 전체 클래스 명을 입력해야 하며, 순서와 타입이 일치하는 생성자가 필요하다.

페이징 API

JAP는 페이징을 setFirstResult(int startPosition);과 setMaxResults(int maxResult) 두 API로 추상화하였다. FirstResult의 시작은 0이다.

집합과 정렬

일반적으로 사용되는 COUNT, SUM, AVG, MAX, MIN과 같은 집합 함수를 모두 사용할 수 있다. 다음은 집합 함수 사용 시 참고사항을 정리한 것이다.

• NULL 값은 무시하기 때문에 통계에 잡히지 않는다. DISTINCT가 정의되어 있어도 무시된다.
• 값이 없을 때 사용하면 COUNT를 제외한 함수는 NULL을, COUNT는 0을 반환한다.
• DISTINCT를 집합 함수 안에 사용해서 중복된 값을 제거한 후 집합을 구할 수 있다.
  • SELECT COUNT(DISTINCT m.idx) FROM Member m
• DISTINCT를 COUNT에서 사용할 때 임베디드 타입은 지원하지 않는다.

GROUP BY와 HAVING, ORDER BY 모두 일반적인 SQL과 동일하게 사용할 수 있다.

시간 복잡도는 주어진 문제를 해결하기 위해 수행한 연산 횟수를 의미하며, 일반적으로 1억 번의 연산을 1초의 시간으로 간주하여 예측한다.

시간 복잡도 유형

int findNumber = (int)(Math.random() * 100);

for (int i = 0; i < 100; i++) {
    if (i == findNumber) {
        System.out.println(i);
        break;
    }
}

위 코드 예제를 통해 시간 복잡도를 살펴보면 다음과 같이 표기할 수 있다.

• 빅-오메가(Ω(n) = 1번) : 최선일 때(best case)의 연산 횟수
• 빅-세타(Θ(n) = 2/N번 = 50번) : 보통일 때(average case)의 연산 횟수
• 빅-오(O(n) = N번 = 100번) : 최악일 때(worst case)의 연산 횟수

항상 최악의 경우를 염두해야하기 때문에 빅-오 표기법을 사용해야 한다.

시간 복잡도 도출 기준

• 상수는 시간 복잡도 계산에서 제외한다.
• 가장 많이 중첩된 반복문의 수행 횟수가 시간 복잡도의 기준이 된다.

  int N = 100_000;
  int cnt = 0;
  

for (int i = 0; i < N; i++) { System.out.println("연산 횟수 : " + cnt++); }

```java
int N = 100_000;
int cnt = 0;

for (int i = 0; i < N; i++) {
    System.out.println("연산 횟수 : " + cnt++);
}

for (int i = 0; i < N; i++) {
    System.out.println("연산 횟수 : " + cnt++);
}

for (int i = 0; i < N; i++) {
    System.out.println("연산 횟수 : " + cnt++);
}

위의 두 예제의 연산 횟수는 N번과 3N번으로 3배의 차이가 난다. 그러나 상수는 일반적으로 시간 복잡도 계산에서 제외되므로 두 코드 모두 O(N)의 시간 복잡도를 갖는다.

int N = 100_000;
int cnt = 0;

for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
        System.out.println("연산 횟수 : " + cnt++);
    }
}

그러나 위의 코드에서는 중첩된 반복문을 기준으로 시간 복잡도가 도출되므로 N²이 된다.

그렇기에 효율적인 알고리즘을 짜기 위해서는 시간 복잡도를 고려하여 알맞은 알고리즘을 선택하고, 비효율 적인 로직을 찾아 효율적으로 최적화하는 작업이 필요하다.

데이터 베이스의 성능을 향상시키려면...

데이터베이스의 데이터는 결국 디스크에 저장된다. 즉 영속성이 있고 저렴하지만, 느리다는 성능에는 치명적인 단점이 있기에 데이터베이스 성능의 핵심은 디스크 I/O(접근)를 최소화 하는 것이라 할 수 있다.

디스크 접근을 줄이기 위해서는 메모리에 올라온 데이터로 최대한 요청을 처리해야한다. 즉 메모리 캐시 히트율을 높이는 것인데, 이는 읽기 뿐만 아니라 쓰기 시에도 동일하다.

그러나 메모리는 전원이 공급되지 않으면 휘발되는 데이터로, 전원 공급이 중단되거나 에러로 인해 데이터베이스 접속이 끊기게 된다면 데이터가 유실될 수 있다.

이러한 메모리의 데이터 유실을 막기위해 데이터베이스는 WAL(Write-Ahead-Logging)을 사용한다.

WAL의 기능

WAL을 사용하는 시스템이서 모든 수정은 적용전 먼저 로그에 기록된다. 트랜잭션 발생시 로그에 기입하여 기록을 남기고 적용을 지연시켜 랜덤I/O를 줄이고 순차적 I/O를 통해 정합성을 유지하며 일관성(Consistency)을 보장한다. 또한 서버가 다운되는 상황에서 기입된 로그를 통해 데이터의 유실을 막고, 중단된 지점 부터 다시 실행하여 원자성(Atomicity)을 보장할 수 있다.

Index

디스크 보다 메모리가 빠르다지만 모든 데이터를 메모리에 올려놓고 사용하는 것은 물리적으로 불가능에 가깝다. 그렇다면 어떻게 조회 속도를 향상시킬 수 있을까?

데이터베이스는 데이터와 데이터의 위치를 포함한 자료구조를 생성하여 빠르게 조회할 수 있도록 돕는다. 이것이 바로 인덱스(Index)이다.

Index의 자료구조

데이터를 담기 위한 자료구조는 Map, List, Tree등 여러 선택지가 있을 것이다. 그렇다면 인덱스는 어떠한 자료구조로 이루어져있을까?

Map

먼저 Map형태는 단건 검색의 시간 복잡도가 O(1)로 월등히 빠르다는 장점이 있다. 그러나 범위 탐색은 O(N)의 시간 복잡도를 가지며, 무엇보다 LIKE 'TEST%'와 같은 전방 일치 탐색이 불가능하다는 치명적인 단점이 있다.

List

List는 정렬되지 않은 리스트의 탐색이 O(N), 정렬된 리스트의 탐색은 O(logN)의 시간 복잡도를 가진다. 정렬된 탐색이 매우 빠르지만 위의 장점을 살리기 위해서는 데이터가 정렬되어야 한다는 전제 조건이 있다. 그렇기에 실제 데이터를 정렬하고 탐색하는 시간 복잡도는 O(N) ~ O(N * logN)이 되어버린다. 또한 삽입과 삭제 비용이 매우 높다는 단점이 있어 적합하지 않다.

Tree

Tree 구조는 검색 속도와 삽입, 삭제 모두 효율적이다. 그러나 트리 높이에 따라 시간 복잡도가 결정되며 빠른 탐색을 위해서는 트리의 높이를 최소화하고, 한쪽으로 노드가 치우치지 않도록 균형을 잡아주어야 한다.

그렇기에 삽입/삭제시 항상 균형을 이루며 하나의 노드가 여러 자식 노드를 가질 수 있고, 마지막 리프노드에만 데이터가 존재하여 연속적인 데이터 접근시 유리한 B+Tree가 인덱스의 자료구조로 적합하다.

Index 사용시 주의점

인덱스는 데이터를 정렬하여 하나의 테이블로 생성하는 것이다. 그렇기에 기본적으로 디스크의 메모리를 차지하며, 데이터의 삽입/삭제시 인덱스 테이블에도 값이 추가되어야 하는 추가적인 연산이 들어가게 된다. 즉, 조회 성능을 얻는 대신 쓰기 성능을 희생하는 trade-off가 있는 것이다. 그렇기에 꼭 인덱스로만 해결할 수 있는 문제인가를 고려해보아야 한다.

또한 하나의 쿼리에는 하나의 인덱스만 타며, 여러 인덱스를 동시에 탐색하지 않는다. 그렇기에 해당 쿼리에 맞지 않는 인덱스를 타게 되면 오히려 성능이 저하되는 역효과가 발생할 수 있다. 특히 WHERE, ORDER BY, GROUP BY를 혼합해서 사용할 때에는 인덱스를 잘 고려해야 한다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '스프링 핵심원리 고급편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

프록시

클라이언트와 서버의 관계에서 클라이언트는 서버를 직접 호출하고, 처리 결과를 직접 받는 직접 호출이 일반적이다. 그러나 클라이언트에서 서버에 직접 요청하지 않고 어떤 대리자(Proxy)를 통해서 간접적으로 할 수도 있다.

대리자를 통해 호출할 경우 대리자가 캐싱과 같은 접근 제어나 부가 기능을 수행할 수 있다. 또한 대리자를 통해 다른 대리자를 호출하는 것도 가능하다.

중요한 것은 클라이언트는 자신이 보낸 요청이 대리자에게 보낸 것인지, 서버에 보낸 것인지 몰라야 한다는 것이다. 즉 서버와 프록시는 같은 객체를 사용해야 하며, 서버 객체를 프록시 객체로 교체해도 클라이언트 코드를 변경하지 않고 동작이 가능해야 한다.

위의 그림은 프록시의 개념을 도표화 한 것이다. 이를 코드로 구현한다면 아래와 같다.

public class Client {

    pivate Subject subject;

    public Client(Subject subject) {
        this.subject = subject;
    }

    public void execute() {
        subject.doSomething();
    }

}

public interface Subject {
    void doSomething();
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        ...
    }
}

public class Proxy implements Subject {

    @Object
    public void doSomething() {
        somethingElse();
        ...
    }

    private void somethingElse() {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

클라이언트(Client)는 서버 인터페이스(Subject)에만 의존하며, 해당 인터페이스를 서버(RealSubject)와 프록시(Proxy)가 같이 사용한다. 런타임에 클라이언트 객체에 DI를 사용해서 서버 객체가 아닌 프록시 객체로 의존관계를 변경해도 클라이언트 코드를 전혀 변경하지 않을 수 있으며, 클라이언트는 인터페이스만을 의존하기 때문에 변경 사실 조차 알 수 없다.

프록시의 주요 기능

프록시를 통해 할 수 있는 일은 접근 제어와 부가 기능 추가로 구분할 수 있다. 이를 상세하게 보면 아래와 같다.

• 접근 제어
  • 권한에 따른 접근 차단
  • 캐싱
  • 지연 로딩
    • 부가 기능 추가
  • 기존 서버가 제공하는 기능에 추가적인 기능 수행
  • 요청 값, 응답 값 변형
  • 로깅

GOF 디자인 패턴에서는 이 둘을 의도에 따라 접근 제어가 목적이면 프록시 패턴, 새로운 기능 추가가 목적이면 데코레이터 패턴으로 구분한다.

구체 클래스 기반 프록시

Java의 다형성은 인터페이스를 구현하든 클래스를 상속하든 상위 타입만 맞으면 적용된다. 그렇기에 인터페이스가 아닌 구체 클래스를 사용해서도 프록시를 생성할 수 있다.

public class Client {

    pivate Subject subject;

    public Client(Subject subject) {
        this.subject = subject;
    }

    public void execute() {
        subject.doSomething();
    }

}

public class Subject {
    public void doSomething() {
        ...
    }
}

public class RealSubject extends Subject {
    @Override
    public void doSomething() {
        ...
    }
}

public class Proxy extends Subject {

    @Object
    public void doSomething() {
        somethingElse();
        ...
    }

    private void somethingElse() {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

구현이 아닌 상속이라는 것 말고는 기존 인터페이스 기반 프록시와 차이가 없는 것을 확인할 수 있다. 다만 Java의 기본 문법으로 인해 클래스를 생성할 때마다 항상 super()를 통해 부모 클래스의 생성자를 호출해야 한다는 점과 final 키워드가 붙은 클래스나 메서드는 상속과 오버라이딩이 불가능하다는 단점이 있다.

이렇듯 인터페이스 기반의 프록시는 상속이라는 제약에서 자유롭고, 역할과 구현을 명확하게 나눌 수 있어 보다 좋은 선택이 된다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '스프링 핵심원리 고급편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

핵심 기능과 부가 기능

핵심 기능은 해당 객체가 제공하는 고유의 기능을 말하며, 부가 기능은 핵심 기능을 보조하기 위해 제공되는 기능을 말한다. 필요에 따라 부가 기능이 늘어나게 되면서 객체 내에 핵심 기능 제공을 위한 코드보다 부가 기능을 위한 코드가 많아지는 경우가 생기게 된다. 또한 여러 객체에서 비슷한 부가 기능을 위한 중복되는 코드가 많아지면서 리소스를 낭비하고, 유지/보수가 어렵게 만든다.

그렇기에 핵심 기능과 부가 기능을, 변하는 것과 변하지 않는 것을 분리하는 것이 좋은 객체 지향 설계이지만, 막상 여러 기능이 혼재한 상황에서 단순하게 기능별로 메서드를 추출하는 것은 어려울 때가 많다.

이 때 변하는 부가 기능과 변하지 않는 핵심 기능을 분리하여 모듈화하여 이러한 문제를 해결 하기 위해 사용되는 디자인 패턴이 템플릿 메서드 패턴(Template Method Pattern)이다.

템플릿 메서드 패턴(Template Method Pattern)

템플릿 메서드 패턴은 이름 그대로 변하지 않는 부분을 템플릿이라는 틀에 몰아두고, 일부 변하는 부분을 별도로 호출해서 해결하는 방식을 이야기한다.

public abstract class AbstractClass {

    public void templateMethod() {
        // 변하지 않는 기능
       ...
       // 변하는 기능
        primitiveOperation1();
        primitiveOperation2();
    }

    protected abstract primitiveOperation1();

    protected abstract primitiveOperation2();

}

public class ConcreteClass extends AbstractClass {

    @Override
    protected void primitiveOperation1() {
        // 변하는 기능
    }

    @Override
    protected void primitiveOperation2() {
        // 변하는 기능
    }

}

위의 코드는 처음 그림을 코드로 작성한 예제이다. 변하지 않는 기능을 부모 클래스에 몰아 넣고 하나의 템플릿으로 만든다. 그리고 변하는 부분을 템플릿 안에서 호출하도록 처리한 뒤 자식 클래스에서 상속과 오버라이딩을 통해 구현한다.

즉 클라이언트에서 템플릿 메서드를 호출하면 템플릿을 포함한 부모 클래스가 그 구현체인 자식 클래스를 호출하여 오버라이딩 된 부가 기능 메서드를 호출하는 것이다.

템플릿 메서드 패턴의 단점과 해결

템플릿 메서드 패턴은 부가 기능을 위해 자식 객체를 계속 만들어야 한다는 단점이 존재한다. 그러나 아래 예제와 같이 익명 내부 클래스를 사용하여 이러한 단점을 해결할 수 있다.

AbstractClass template = new AbstractClass() {
    @Override
    protected void primitiveOperation1() {
        ...
    }

    @Override
    protected void primitiveOperation2() {
        ...
    }
}

template.templateMethod();

템플릿 메서드 패턴은 부모 클래스에서 알고리즘의 골격인 템플릿을 정의하고 변경되는 로직을 자식 클래스에서 정의하는 방식이다. 다형성을 통해 자식 클래스가 알고리즘 전체 구조를 변경하지 않은채 특정 부분만을 재정의함으로 단일 책임 원칙을 지킬 수 있게 해준다.

그러나 상속을 이용한다는 점에서 부모 클래스와 자식 클래스가 컴파일 시점에 강하게 결합되며 부모 클래스의 기능을 전혀 사용하지 않음에도 부모 클래스를 강하게 의존하게 된다. 그렇기에 부모 클래스의 기능 수정이 자식 클래스에도 영향을 끼칠 수 있다. 이러한 문제점들이 존재하기에 이를 개선한 디자인 패턴이 등장했으며, 바로 전략 패턴(Stragy Pattern)이다.

전략 패턴(Strategy Pattern)

템플릿 메서드 패턴의 단점들은 대부분 부모 클래스를 상속해서 사용한다는데서 온다. 이러한 단점을 극복하기 위해서는 변하는 부분을 상속이 아닌 다른 방법으로 해결해야 하는데, 전략 패턴은 이를 위임으로 해결한다.

전략 패턴은 변하지 않는 부분을 Context에 두고, 변하는 부분을 Stratgy라는 인터페이스를 만들고 이를 구현하도록 해서 문제를 해결한다.

위의 예제를 코드로 구현해보면 아래와 같다.

public interface Strategy {
    void execute();
}

public class StrategyA implements Strategy {
    @Override
    public void call() {
        //...
    }
}

public class StrategyB implements Strategy {
    @Override
    public void call() {
        //...
    }
}

public class SomeClass {    // Context

    private Strategy strategy;

    public SomeClass(strategy) {
        this.strategy = strategy;
    }

    public void execute() {
        //...
        strategy.
    }
}

전략 패턴의 핵심은 Context는 Strategy 인터페이스에만 의존한다는 점이다. Strategy의 구현체를 변경하거나 새로 만들지라도 Context에는 영향을 주지 않는다. 스프링에서 사용되는 의존관계 주입 방식이 바로 전략 패턴이다.

선조립 후 실행

전략 패턴은 Context 내부 필드에 Strategy를 두고 사용한다. 이 방식을 통해 Context와 Strategy를 실행 전에 원하는 모양으로 조립해두고, 실행 시점에 Context만 실행하면 된다.

스프링도 이처럼 어플리케이션 로딩 시점에 의존관계 주입을 통해 필요한 의존관계를 모두 맺어두고 실제 요청을 처리한다.

콜백 패턴(Callback Pattern)

전략 패턴의 단점은 Context와 Strategy를 조립한 이후에 전략을 변경하기가 번거롭다는 점이다. 특히 Context를 싱글톤으로 사용할 때 동시성 이슈 등 고려할 점이 많다.

이를 좀 더 유연하게 만들기 위해서는 Strategy를 실행 시점에 직접 파라미터로 전달해서 사용하면 된다. 그리고 이러한 방법을 콜백 패턴이라고 한다.

콜백

프로그래밍에서 콜백(callback) 또는 콜 애프터 함수(call-after-function)는 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 말한다. 콜백을 넘겨받는 코드는 이 콜백을 즉시/나중에 실행할 수 있다.

자바에서 콜백은 보통 하나의 메서드를 가진 인터페이스를 구현하고, 이를 익명 내부 클래스로 구현하여 사용했다. 자바8 이후로는 주로 람다를 사용한다.

템플릿 콜백 패턴

스프링에서 Strategy를 파라미터로 받는 전략 패턴을 템플릿 콜백 패턴이라고 한다. Context가 템플릿 역할을, Strategy 부분이 콜백으로 넘어온다. 스프링에서 이름에 ...Template가 붙어 있다면 보통 템플릿 콜백 패턴으로 만들어져 있다고 볼 수 있다.

해당 포스팅은 인프런에서 제공하는 최태현 님의 '자바 개발자를 위한 코틀린 입문'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

변수 선언

코틀린은 모든 변수에 수정 가능 여부를 명시해주어야 한다. val 키워드는 불변이나, 컬렉션에는 element를 추가할 수 있다.

var num1 = 10L    // var : 가변 
val num2 = 10L    // val : 불변

또한 타입을 명시적으로 선언하지 않아도 타입을 추론하며, 명시적으로 선언해줄 수도 있다.

var num1: Long = 10L
val num2: Long = 10L

모든 변수는 우선 불변인 val로 선언하고 필요할 경우에만 var로 변경하는 것이 좋다.

코틀린에서 변수는 기본적으로 null이 허용되지 않으며 nullable 변수를 생성하기 위해서는 타입?과 같이 명시적으로 선언해줘야 한다.

var num: Long?

또한 객체를 인스턴스화 할 때 new를 붙이지 않는다.

val obj = Object("New Object");

코틀린에서는 기본 자료형과 참조 자료형의 구분이 감춰져있다. 일반적으로는 자료형의 구별 없이 사용할 수 있으며, null이 허용된다면 참조형, 아니라면 기본형으로 선언된다. 즉 boxing/unboxing을 고려하지 않아도 되도록 코틀린이 처리 해준다.

null 안정성

코틀린은 null이 가능한 타입을 완전히 다르게 취급하며, 한 번 null check를 하면 컴파일러가 non-null임을 알 수 없다.(특히 Java의 코드를 사용하는 플랫폼 타입일 경우) 따라서 이를 위한 기능을 제공한다.

안전한 호출(safe call)

안전한 호출은 체인(chain)할 때 ?.를 사용하여 null이 아니면 해당 체인의 연산을 실행하고, null이면 실행하지 않는다. nullable 타입일 경우 안전한 호출을 통해서만 실행이 가능하다.

val str: String? = "ABC"
str.length // str이 nullable이기 때문에 실행 불가능
str?.length

Elvis 연산자

엘비스 연산자는 ?:를 사용하여 앞의 연산 결과가 null이면 뒤의 내용을 호출해준다.

str?.length ?: 0 // str.length의 값이 null일 경우 0 실행

엘비스 연산은 early return에도 사용할 수 있다.

fun calculate(number: Long?): Long {
    number ?: return 0
    ... null이 아닐 경우 로직
}

null 아님 단언

nullable 타입이지만 null이 될 수 없는 경우 !!를 사용할 수 있다.

fun startsWithA(str: String?): Boolean {
    return str!!.startsWith("A")
}

Type

코틀린은 선언된 기본값을 보고 타입을 추론하지만 타입간의 변환은 언제나 명시적으로 이루어져야 한다.

val num1 = 4
val num2: Long = num1 // Type mismatch
val num2: Long = num1.toLong()    // 명시적 형변환 필요

Java에서의 instanceof에 해당하는 키워드로 is 키워드가 있으며, 일반 타입은as를 통해 형변환이 가능하다.(기본 타입도 가능)

fun printAgeIfPerson(obj: Any) {
    if (obj is Person) {    
    // is == java: instance of
    // val person = obj as Person  
    // as = java: (Object) obj, 생략 가능
        println(obj.age)
    }
}

또한 nullable 변수에 대해 적절한 처리가 필요하다.

val num1: Int? = 3
val num2: Long = num1?.toLong() ?: 0L

fun printAgeIfPersonNullable(obj: Any?) {
    val person: Person? = obj as? Person    
    // as? : obj가 해당 타입이면 형변환, null이거나 해당 타입이 아니면 null을 반환
    println(person?.age)
}

Any

Java의 Object 처럼 모든 객체의 최상위 타입으로, 모든 기본 자료형의 최상위 타입 또한 Any이다. Any 자체로는 null을 포함할 수 없으며, Any?를 통해 포함시킬 수 있다. 기본적으로 equals, hashCode, toString이 존재한다.

Unit

Java의 void와 동일한 역할이지만, void와는 다르게 Unit 그 자체를 타입 인자로 사용 가능하다.

Nothing

함수가 정상적으로 끝나지 않았다는 사실을 표현하는 역할로, 무조건 예외를 반환하거나 무한 루프 함수 등에 사용된다.

fun fail(message: String): Nothin {
    throw IllegalArgumentException(message)
}

String interpolation

코틀린은 문자열의 동적인 가공을 위해 아래와 같이 String interpolation을 지원한다.

val person = Person("test", 100)
println("이름: ${person.name} / 나이: ${person.age}")

${변수}를 사용하면 해당 변수의 값이 포함되며 $변수를 사용할 경우 해당 변수명이 포함된다.

또한 """문자열""".trimIndent()을 통해 편리하게 여러 줄의 문자열을 가공할 수 있게 해준다.

String indexing

문자열에서 문자를 가져올 때 [index]를 통해 Java의 배열과 같이 가져올 수 있다.

연산자

단항 연산자 / 산술 연산자

단항/산술 연산자는 Java와 동일하다. ++, --로 단항 연산을 할 수 있으며 +, -, *, /, %로 산술 연산을, +=, -=, *=, /=, %/로 산술 대입 연산이 가능하다.

비교 연산자

비교 연산자 또한 Java와 동일하게 >, <, >=, <=, == 으로 할 수 있다. 단, Java와 다르게 객체를 비교할 때 비교 연산자를 사용하면 자동으로 compareTo를 호출해준다.

두 객체의 값이 같은지 비교하는 동등성 비교에 equals, 주소가 같은 완전히 동일한 객체인지 비교하는 동일성 비교에 ==를 사용하는 Java와는 다르게 동등성에 ==를 사용하여 간접적으로 equals를 호출하며, 동일성 비교는 ===을 사용한다.

논리 연산자

&&, ||, !을 통해 논리 연산이 가능하며, Java와 같이 Lazy 연산을 수행한다.

이 외에 코틀린에만 존재하는 연산자로는 컬렉션의 범위에 포함되어있는지의 여부를 리턴하는 in/!in, a에서 b까지의 범위 객체를 생성하는 a..b, a[i], a[i] = b로 a에서 특정 index i를 통해 값을 처리할 수 있는 연산자가 존재한다.

연산자 오버로딩

코틀린에서는 아래와 같이 객체마다 연산자를 직접 정의할 수 있다.

data class Money(
    val amount: Long
) {

    operator fun plus(other: Money): Money {
        return Money(this.amount + other.amount)
    }

}
...
val money1 = Money(1_000L)
val money2 = Money(2_000L)
print(money1 + money2) // Money(3_000L)

해당 포스팅은 인프런에서 제공하는 김영한 님의 '자바 ORM 표준 JPA 프로그래밍 - 기본편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

JPA의 데이터 타입은 크게 엔티티 타입과 값 타입으로 나눌 수 있다. 엔티티 타입은 @Entity로 매핑되는 테이블 객체이고, 값 타입은 단순히 값으로 사용되는 자바 기본 타입이나 객체를 말한다.

엔티티 타입은 식별자가 있어 추적이 가능하지만, 값 타입은 속성만 존재하므로 추적이 불가능하다. 값 타입은 다음과 같이 분류할 수 있다.

• 기본값 타입(basic value type)

  • Java 기본 타입(int, double...)
  • 래퍼 클래스(Integer...)
  • String

• 임베디드 타입(embedded type, 복합 값 타입)

• 컬렉션 타입(collection value type)

  기본값 타입

  @Entity
  public class Example {
  
    @Id @GeneratedValue
    private Long id;
  
    // 기본 값 타입
    private String name;
    private int number;
  

}

위 예제의 String, int가 값 타입이며, Example 엔티티는 id라는 식별자 값과 생명주기가 있지만, name, number와 같은 값 타입은 식별자가 없으며, 생명주기 또한 엔티티에 의존한다. 또한 **값 타입은 java의 기본 타입(primitive type)과 같이 공유되면 안된다**.
## 임베디드 타입(복합 값 타입)
JPA에서는 새로운 값 타입을 직접 정의해서 사용할 수 있으며, 이를 임베디드 타입(embedded type)이라고 한다.

```java
@Entity
public class Member {

    @Id @GeneratedValue
    private Long id;

    private String name;

    // 주소
    private String city;
    private String street;
    private String zipcode;

}

위의 Member 엔티티가 주소 값을 가지고 있는 것 처럼 엔티티 객체가 상세 데이터를 그대로 가지고 있는 것은 객체지향적이지 않으며, 응집력만 떨어뜨린다. 이를 아래와 같이 임베디드 타입으로 분리시킬 수 있다.

@Entity
public class Member {

    @Id @GeneratedValue
    private Long id;

    private String name;

    @Embedded
    private Address address;

}

@Embeddable
public class Address {

    @Column(name = "city")
    private String city;
    private String street;
    private String zipcode;

}

새로 정의한 값 타입은 재사용이 가능하며, 응집도도 아주 높다. 또한 값 타입 객체 내에 해당 값 타입만 사용하는 의미 있는 메서드들도 만들 수 있다. 임베디드 타입을 사용하기 위한 어노테이션을 다음과 같으며, 둘 중 하나는 생략이 가능하다.

• @Embeddable : 값 타입을 정의하는 곳에 표시
• @Embedded : 값 타입을 사용하는 곳에 표시

임베디드 타입은 기본 생성자가 필수이다.

임베디드 타입과 테이블 매핑

임베디드 타입은 엔티티의 값일 뿐이기에 값이 속한 엔티티의 테이블에 매핑되며, 사용하기 전과 후의 테이블의 형태는 같다. 임베디드 타입을 통해 객체와 테이블을 아주 세밀하게 매핑하는 것이 가능해지기에 보다 객체지향 모델을 설계하기에 편리해진다.

임베디드 타입이 null일 경우 매핑한 컬럼 값은 모두 null이 된다.

임베디드 타입과 연관관계

임베디드 타입은 아래 예제와 같이 값 타입을 포함하거나 엔티티를 참조할 수 있다.

@Entity
public class Member {

    ...
    @Embedded
    private Address address;

}

@Embeddable
public class Address {

    private String city;
    private String street;
    @Embedded
    private Zipcode zipcode;

}

@Embeddable
public class Zipcode {
    private Zip zip;
    private String plusFour;
}

@Entity
public class Zip {
    @Id
    private String code;
}

@AttributeOverride : 속성 재정의

임베디드 타입에 정의한 매핑 정보를 @AttributeOverride로 재정의할 수 있다.

@Entity
public class Member {

    ...
    @Embedded
    private Address homeAddress;

    @Embedded
    @AttributeOverrides({
        AttributeOverride(name = "city", columne = @Column(name = "COMPANY_CITY"),
        AttributeOverride(name = "street", columne = @Column(name = "COMPANY_STREET"),
        AttributeOverride(name = "zipcode", columne = @Column(name = "COMPANY_ZIPCODE"))
    })
    private Address companyAddress;

}

값 타입과 불변 객체

값 타입은 객체를 조금이라도 단순화하기 위해 만든 개념이다. 그렇기에 언제나 단순하고 안전하게 다룰 수 있어야 한다.

값 타입 공유 참조

임베디드 타입 같은 값 타입을 여러 엔티티에서 그대로 참조해서 사용할 경우 값 타입의 값 변경시 해당 인스턴스를 참조하는 모든 엔티티의 값이 변경되는 사이드 이펙트가 발생할 수 있다. 그렇기에 하나의 값 타입을 여러 엔티티에서 사용할 경우 참조가 아닌 복사를 통해 사용해야 한다.

값 타입 복사

자바는 기본 타입에 값을 대입하면 항상 값을 복사해서 전달한다. 그렇기에 원본과 복사본은 완전히 독립된 값을 가지며, 부작용도 없다.

그러나 객체 타입은 항상 참조값을 전달하며, 원본과 복사본이 같은 인스턴스를 공유한다. 그렇기에 원복 값 변경시 복사본의 값 또한 변경된다. 이를 막기 위해 객체를 대입할 때마다 항상 인스턴스를 복사해서 대입하면 되지만, 자바에서 복사하지 않고 원본의 참조 값을 직접 넘기는 것을 막을 방법이 없다는 근본적인 문제가 있다. 이러한 근본적인 문제를 해결하기 위해서는 setter와 같은 수정자 메서드를 모두 제거해야 한다.

불변 객체

값 타입은 부작용 걱정 없이 사용해야 한다. 그렇기에 될 수 있으면 불변 객체(immutable Object)로 설계해야 한다. 불변 객체도 결국 객체기 때문에 인스턴스의 참조 값 공유를 피할 수 없지만 해당 값을 수정할 수 없기 때문에 부작용이 발생하지는 않는다.

값 타입의 비교

자바가 제공하는 객체 비교는 인스턴스의 참조 값을 비교하는 동일성(Identity) 비교(==)와 인스턴스의 값을 비교하는 동등성(Equivalence) 비교(equals()) 두 가지가 있다.

값 타입은 서로 다른 인스턴스일지라도 그 안에 값이 같으면 같은 것으로 봐야 한다. 따라서 값 타입의 equals() 메서드를 재정의하고, 동등성을 비교해야 한다. 또한 자바에서 equals() 메서드를 재정의하면 hashCode()도 재정의해야 해시를 사용하는 컬렉션(HashSet, HashMap)들이 정상 동작한다.

값 타입 컬렉션

값 타입을 하나 이상 저장하기 위해서는 컬렉션에 보관하고 @ElementCollection, @CollectionTable 어노테이션을 사용한다.

@Entity
public class Member {

    ...
    @ElementCollection
    @CollectionTable(name = "ADDRESS", 
        joinColumns = @JoinColumn(name = "MEMBER_ID"))
    private List<Address> addressHistory = new ArrayList<Address>();

}

관계형 데이터베이스의 테이블은 컬럼 안에 컬렉션을 포함할 수 없기 때문에 위와 같은 값 타입 컬렉션을 가진 객체를 테이블로 매핑하려면 별도의 테이블을 추가하고 @CollectionTable을 사용해야 한다.

값으로 사용되는 컬럼이 하나일 경우 @Column을 사용해서 컬럼명을 지정할 수 있으며, @AttributeOverride를 사용해서 매핑정보를 재정의할 수도 있다.

값 타입 컬렉션 사용

값 타입 컬렉션은 영속성 전이와 고아 객체 제거 기능을 필수로 가지며, 조회시 페치 전략을 선택할 수 있다. 기본 전략은 LAZY이다.

값 타입은 불변해야 하기 때문에 엔티티의 값 타입 수정은 다음과 같다.

1. 임베디드 값 타입 : 엔티티에 새로운 임베디드 인스턴스 생성 후 엔티티만 UPDATE한다.
2. 기본값 타입 컬렉션 : 수정하고자 하는 기본값 타입을 제거하고 새 값을 추가한다.
3. 임베디드 값 타입 컬렉션 : 수정하고자 하는 임베디드 값 타입을 제거하고 새 값을 추가한다. eqauls()와 hashCode()를 꼭 구현해야 한다.

값 타입 컬렉션의 제약사항

값 타입은 식별자라는 개념이 없는 단순한 값들의 모음이기 때문에 값을 변경해버리면 데이터베이스에서 저장된 원본 데이터를 찾기 어렵다.

특정 엔티티에 소속된 값 타입은 소속된 엔티티를 데이터베이스에서 찾고 변경하면 되지만, 값 타입 컬렉션은 별도의 테이블에 보관되기 때문에 값이 변경되면 원본 데이터를 찾기 어렵다는 문제가 있다. 그렇기에 JPA 구현체들은 값 타입 컬렉션에 변경 사항이 발생하면 값 타입 컬렉션이 매핑된 테이블의 모든 연관 데이터를 삭제하고 현재 객체에 있는 값들을 다시 저장하며, 이 때 해당 컬렉션 길이만큼 INSERT된다. 그렇기에 값 타입 컬렉션이 매핑된 테이블에 데이터가 많다면 일대다 관계를 고려해야 한다.

또한 값 타입 컬렉션을 매핑하는 모든 컬럼을 묶어서 기본 키를 구성해야 하기 때문에 컬럼에 null을 입력할 수 없고, 중복된 값을 저장할 수 없다는 제약이 있다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '자바 ORM 표준 JPA 프로그래밍 - 기본편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

영속성 전이

JPA에서 엔티티를 저장할 때 연관된 모든 엔티티가 영속 상태여야 한다. 이 때 영속성 전이(transitive persistence) 기능을 사용하며,CASCADE 옵션을 사용하면 부모 엔티티를 영속 상태로 만들 때 자식 엔티티를 함께 영속 상태로 만들 수 있다.

영속성 전이는 연관관계 매핑과는 아무 관련이 없으며, 엔티티를 영속화할 때 연관된 엔티티를 함께 영속화하는 기능만을 제공한다.

저장

@Entity
public class Parent {

    @Id    @GeneratedValue
    private Long id;

    @OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
    private List<Child> children = new ArrayList<Child>();

}

@Entity
public class Child {

    @Id    @GeneratedValue
    privaet Long id;

    @ManyToOne
    private Parent parent;

}

public void save(EntityManager em) {

    Child child1 = new Child();
    Child child2 = new Child();

    Parent parent = new Parent();
    child1.setParent(parent);
    child2.setParent(parent);
    parent.getChildren().add(child1);
    parent.getChildren().add(child2);

      em.persist(parent);
}

위의 예제를 통해 알 수 있듯이 CascadeType.PERSIST로 설정한 자식 엔티티는 부모 엔티티가 영속화할 때 함께 영속화되어 저장된다.

삭제

CascadeType.REMOVE 속성을 사용할 경우 엔티티를 삭제할 때도 영속성 전이를 사용할 수 있다. 삭제 순서는 외래 키 제약조건을 고려해서 자식을 먼저 삭제하고 부모를 삭제한다.

CASCADE

CascadeType 속성에는 다음과 같은 옵션이 있다.

• ALL : 모두 적용
• PERSIST : 영속, flush 호출시 전이 발생
• MERGE : 병합
• REMOVE : 삭제, flush 호출시 전이 발생
• REFRESH : REFRESH
• DETACH : DETACH

고아 객체

JPA의 고아 객체(ORPHAN) 제거는 부모 엔티티의 컬렉션에서 자식 엔티티의 참조만 제거하면 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 자동으로 삭제해주는 기능이며, 영속성 컨텍스트를 플러시할 때 적용된다. 이를 활성화하기 위해서는 자식 엔티티를 참조하는 컬렉션에 orphanRemoval = true를 설정해주면 된다.

고아 객체 제거는 참조가 제거된 엔티티는 다른 곳에서 참조하지 않는 고아 객체로 보고 삭제하는 기능이기 때문에 참조하는 곳이 하나일 때만 사용해야 한다. 이런 이유로 orphanRemoval은 @OneToOne, @OneToOne에서만 사용할 수 있다.

영속성 전이 + 고아 객체 생명주기

CascadeType.ALL과 orphanRemoval = true를 동시에 사용할 경우 부모 엔티티를 통해서 자식 엔티티의 등록/삭제 등 생명주기를 관리할 수 있다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '스프링 핵심원리 고급편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

동시성 문제

여러 쓰레드가 동시에 같은 인스턴스의 필드 값을 변경하면서 발생하는 문제를 동시성 문제라고 하며 쓰레드가 많아질수록, 즉 트래픽이 늘어날수록 자주 발생하게 된다. 지역 변수와 같은 쓰레드 별 메모리 영역이 할당되는 값은 해당되지 않으며 스프링 빈, static 객체와 같이 싱글톤 객체의 필드를 변경하며 사용할 때 발생한다. 이를 해결하기 위해 사용하는 것이 쓰레드 로컬(ThreadLocal)이다.

동시성 문제에 대한 java에서의 처리 방법이 궁금해져서 OpenAi의 ChatGPT에게 물어보았더니 아래와 같은 답변을 얻었다.

Java에서 동시성 문제를 해결하는 방법에는 다음과 같은 것들이 있습니다.

1. Synchronized 키워드 : Java에서 synchronized 키워드를 사용하여 메소드 또는 블록을 잠글 수 있습니다.

2. Lock 객체 : Java에서 Lock 객체를 사용하여 동시적으로 접근하려는 자원에 대한 접근을 제어할 수 있습니다.

3. Atomic 클래스 : Java에서 Atomic 클래스를 사용하여 동시성 문제가 발생하는 경우 자동적으로 락을 걸어주고 해제하여 동시성 문제를 해결할 수 있습니다.

4. Executor Framework : Java에서 Executor Framework를 사용하여 다중 스레드 환경에서 동시성 문제를 해결할 수 있습니다.

이 외에도 Java 5에서 추가된 Concurrent Package 등의 라이브러리를 사용하여 동시성 문제를 해결할 수 있습니다.

쓰레드 로컬(ThreadLocal)

쓰레드 로컬은 쓰레드 별로 생성되는 별도의 내부 저장소를 지칭한며, 다음과 같은 기능을 제공한다.

• 값 저장 : ThreadLocal.set()
• 값 조회 : ThreadLocal.get()
• 값 제거 : ThreadLocal.remove()

예제 코드

@Slf4j
public class ThreadLocalService {

    private ThreadLocal<String> nameStore = new ThreadLocal<>();

     public String logic(String name) {
         log.info("저장 name={} -> nameStore={}", name, nameStore.get());
         nameStore.set(name);

        sleep(1000);

        log.info("조회 nameStore={}",nameStore.get());

         return nameStore.get();
    }

     private void sleep(int millis) {
         try {
             Thread.sleep(millis);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}

@Slf4j
public class ThreadLocalServiceTest {

     private ThreadLocalService service = new ThreadLocalService();

    @Test
     void threadLocal() {
         log.info("main start");

         Runnable userA = () -> {
             service.logic("userA");
         };

         Runnable userB = () -> {
             service.logic("userB");
         };

         Thread threadA = new Thread(userA);
         threadA.setName("thread-A");

         Thread threadB = new Thread(userB);
         threadB.setName("thread-B");

         threadA.start();
         sleep(100);

         threadB.start();
         sleep(2000);

         log.info("main exit");
     }

    private void sleep(int millis) {
         try {
             Thread.sleep(millis);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
}

실행 결과

[Test worker] main start
[Thread-A] 저장 name=userA -> nameStore=null
[Thread-B] 저장 name=userB -> nameStore=null
[Thread-A] 조회 nameStore=userA
[Thread-B] 조회 nameStore=userB
[Test worker] main exit

쓰레드 로컬 사용시 주의점

쓰레드 로컬을 모두 사용 후 ThreadLocal.remove()를 통해 쓰레드 로컬에 저장된 값을 제거해주어야 한다. 쓰레드의 생성 비용은 비싸기 때문에 WAS는 사용이 끝난 쓰레드를 제거하지 않고, 보통 쓰레드 풀을 통해 재사용한다. 그렇기에 사용 후 제거하지 않으면 심각한 문제가 발생할 수 있다.

해당 포스팅은 인프런에서 제공하는 김영한 님의 '자바 ORM 표준 JPA 프로그래밍 - 기본편'을 수강한 후 정리한 글입니다. 유료 강의를 정리한 내용이기에 제공되는 예제나 몇몇 내용들은 제외하였고, 정리한 내용을 바탕으로 글 작성자인 저의 언어로 다시 작성한 글이기에 서술이 부족하거나 잘못된 내용이 있을 수 있습니다. 그렇기에 해당 글은 개념에 대한 참고 정도만 해주시고, 강의를 통해 학습하시기를 추천합니다.

지연로딩

엔티티가 조회될 때 연관관계에 있는 엔티티들을 사용하지 않음에도 함께 조회해 두는 것은 효율적이지 않다. 그렇기에 JPA는 엔티티가 실제 사용될 때까지 데이터베이스 조회를 지연하는 방법을 제공하며, 이를 지연 로딩이라고 한다.

JPA의 구현체인 하이버네이트는 지연 로딩을 지원하기 위해 프록시를 사용하는 방법과 바이트코드를 수정하는 두 가지 방법을 제공하며, 복잡한 설정이 필요한 바이트코드 조작에 비해 프록시는 별도의 설정 없이 사용할 수 있다.

프록시

프록시의 특징

프록시는 실제 클래스를 상속 받아 만들어지며, 실제 클래스와 겉 모양이 같다. 그렇기에 사용자의 입장에서 해당 객체가 원본 객체인지, 프록시 객체인지 구분하지 않고 사용할 수 있다.

프록시 객체는 실제 객체에 대한 참조(target)를 보관하며, 프록시 객체의 메서드가 호출되면 참조를 통해 실제 객체의 메서드를 호출한다. 이 때 실제 객체가 생성되어있지 않다면 해당 객체에 대한 생성을 요청하며, 이를 초기화 한다.

JPA의 관점에서 본다면 아래와 같다.

1. 프록시 객체 호출
2. 실제 엔티티의 참조를 통한 호출
   • 실제 엔티티가 존재하지 않을 경우 영속성 컨텍스트에 생성 요청(초기화) 후 멤버 변수에 담음
   • 실제 엔티티 호출
3. 호출에 대한 결과 반환

프록시의 특징을 정리하면 다음과 같다.

• 프록시 객체는 처음 사용할 때 한 번만 초기화된다.
• 초기화 된 프록시는 실제 엔티티로 변환되는 것이 아닌 실제 객체에 대한 접근만 가능해진다.
• 프록시 객체는 원본 엔티티를 상속받았기에 타입 체크 시 주의해야 한다.
• 영속성 컨텍스트에 이미 실제 엔티티가 있다면 em.getReference() 호출시 프록시가 아닌 실제 엔티티를 반환한다.
• 초기화는 영속성 컨텍스트를 통해서만 가능하며, 준영속 상태의 프록시를 초기화할 경우 예외가 발생한다.

프록시와 식별자

엔티티를 프록시로 조회할 때 식별자(PK) 값을 파라미터로 전달 받아 프록시 객체 내부에 보관한다. 그렇기에 식별자 값만 호출된다면 프록시를 초기화 하지 않지만, 엔티티 접근 방식을 프로퍼티(@Access(AccessType.PROPERTY))가 아닌 필드(@Access(AccessType.FIELD))로 설정한 경우에는 초기화한다.

프록시를 사용하면 연관관계를 설정할 때 식별자 값만 사용하므로 데이터베이스 접근 횟수를 줄일 수 있다. 이러한 연관관계 설정시에는 엔티티 접근 방식을 필드로 설정해도 프록시를 초기화하지 않는다.

프록시 확인

JPA가 제공하는 PersistenceUnitUtil.isLoaded(Object entity) 메서드를 사용하면 프록시 인스턴스의 초기화 여부를 확인할 수 있다. 초기화되었거나 프록시 인스턴스가 아닐 경우 true를 반환한다. 또한 하이버네이트의 initialize() 메서드를 통해 강제로 프록시를 초기화할 수도 있다.

즉시 로딩과 지연 로딩

JPA는 연관된 엔티티의 조회 시점을 선택할 수 있도록 엔티티를 조회할 때 연관된 엔티티도 함께 조회하는 즉시 로딩과 지연 로딩 두 가지 방법을 제공한다.

즉시 로딩(EAGER LOADING)

즉시 로딩을 사용하기 위해서는 @ManyToOne(fetch = FetchType.EAGER)와 같이 연관관계 매핑의 fetch 속성을 FetchType.EAGER로 지정하면 된다.

JPA 구현체는 즉시 로딩을 최적화하기 위해 가능하면 조인 쿼리를 사용한다. 외래 키가 null을 허용할 경우를 대비해 JPA는 외부 조인(OUTER JOIN)을 기본적으로 사용한다. 따라서 null을 허용하지 않는 외래 키를 사용해 조회할 때 최적화를 위해 내부 조인(INNER JOIN)을 사용하기 위해서는 @JoinColumn(..., nullable = false)를 통해 명시해주어야 한다.

지연 로딩(LAZY LOADING)

지연 로딩을 사용하기 위해서는 @ManyToOne(fetch = FetchType.LAZY)와 같이 연관관계 매핑의 fetch 속성을 FetchType.LAZY로 지정하면 된다.

지연 로딩을 사용할 경우 사용하지 않는 연관관계 객체에 프록시 객체를 넣어두고 사용하기 전까지 초기화를 미뤄둔다.

지연 로딩 활용

프록시와 컬렉션 래퍼

하이버네이트는 엔티티를 영속 상태로 만들 때 엔티티 내부에 컬렉션이 있으면 이를 추적하고 관리할 목적으로 원본 컬렉션을 하이버네이트 내장 컬렉션을 변경하며, 이를 컬렉션 래퍼라 한다.

엔티티를 지연 로딩할 경우 프록시 객체를 사용하고, 컬렉션을 지연 로딩할 때는 컬렉션 래퍼가 지연 로딩을 처리한다.

JPA 기본 페치 전략

JPA의 기본 페치(fetch) 전략은 연관된 엔티티가 하나일 경우 즉시 로딩을, 컬렉션일 경우 지연 로딩을 사용한다. 그러나 개발 단계에선 모든 연관관계를 지연 로딩으로 설정하고, 조회 빈도가 높은 곳에서만 즉시 로딩을 사용하도록 최적화하는 것이 좋다.

컬렉션을 하나 이상 즉시 로딩하는 것은 권장되지 않는다. 과도한 SQL 실행으로 어플리케이션의 성능을 저하시키는 1+N 문제가 발생할 수 있기 때문이다. 또한 컬렉션 즉시 로딩은 항상 외부 조인을 사용하기 때문에 이를 인지하고 사용해야 한다.