✔️ 출처

게임 맵 최단거리 level 2

📖 문제

dfs/bfs 문제이다. bfs로 풀면 좋을것 같아서 bfs로 방향을 잡았다. 방문한 좌표에 대해 check를 해주고, 갈 수 있는 곳을 check해주는 것이 핵심이다.

처음에 visited를 q에서 뽑고나서 true로 해주어서 무한 루프에 빠졌었는데 중복 좌표값이 Queue 에 추가되서 그런거였다. 1 2 3 4 그래프가 이렇게 있고 Queue에 2,3 순으로 들어가 있다고 하자.

2가 나와서 4를 추가한다. 3이 나와서 4를 추가한다. << 이런 중복 좌표값이 생긴다. 이를 해결하기 위해서 while문 밖에서 시작지점에 true를 미리 넣어주고 가능한 좌표일때 방문 표시를 즉시 해줌으로써 해결하였다.

🔅 문제 풀이

import java.util.*;

class Solution {
    static int[] dxarr = {0, 0, 1, -1};
    static int[] dyarr = {1, -1, 0, 0};

    public int solution(int[][] maps) {
        boolean[][] visited = new boolean[maps.length][maps[0].length];
        int answer = bfs(visited, maps);
        return answer;
    }

    public int bfs(boolean[][] visited, int[][] map) {
        Queue<int[]> q = new LinkedList<>();
        visited[0][0] = true;
        q.add(new int[]{0,0});

        while(!q.isEmpty()) {
            int[] coord = q.poll();

            for(int i = 0; i < 4; i++) {
                int dx = coord[1] + dxarr[i]; // 열
                int dy = coord[0] + dyarr[i]; // 행

                if (dx >= 0 && dx < map[0].length && dy >= 0 && dy < map.length) {
                    if(!visited[dy][dx] && map[dy][dx] >= 1) {
                        map[dy][dx]+= map[coord[0]][coord[1]]; // 이전 거리를 더한다.
                        q.add(new int[]{dy, dx});
                        visited[dy][dx] = true;
                    }
                } 
            }
        }

        int endPoint = map[map.length - 1][map[0].length - 1];
        return  endPoint == 1 ? -1 : endPoint;
    }
}

❗ 오답노트 / 필요한 지식

1. 깊이/너비 탐색문제 오랜만에 시도해보니 좀 어려웠다. 다시 개념을 정리하고 많이 풀어보자.

✔️ 출처

행렬의 곱셈 level 2

📖 문제

arr1 x arr2 = arr3 axn * nxb = axb인 행렬이 생긴다.

🔅 문제 풀이

class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {
        int[][] answer = new int[arr1.length][arr2[0].length];

        for (int i = 0; i < arr1.length; i++) {
            for(int j = 0; j < arr2[0].length; j++) {
                for (int k = 0; k < arr2.length; k++) {
                    answer[i][j] += arr1[i][k] * arr2[k][j];
                }
            }
        }
        return answer;
    }
}

arr1 = [[1,2],[7,8]] arr2 =[[3,5],[4,6]] answer[i][j] = C arr1[i][k] = [1,2] arr2[k][j] = [3][4] i는 answer와 arr1의 행을 가리킨다. j는 arr2의 열을 가리킨다. [1,2] 가 1열 [3][4], 2열 [4][6]을 곱연산하게 끔한다. k는 arr1의 열, arr2의 행을 가리킨다.

제일 좋은 방법은 직접 손으로 행렬을 그려보는 것이다.

처음 시도

class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {
        int[][] answer = new int[arr1.length][arr2.length];

        for (int i = 0; i < arr1.length; i++) {
            for(int j = 0; j < arr2.length; j++) {
                for (int k = 0; k < arr2.length; k++) {
                    answer[i][j] += arr1[i][k] * arr2[k][j];
                }
            }
        }
        return answer;
    }
}

문제 예시에서 행과 열이 같은 경우만 주어져서 이렇게 생각한 것 같다... 당연히 실패했다.

❗ 오답노트 / 필요한 지식

1. 수학 문제는 항상 개념을 확실하게 이해할 필요가 있다. 그렇지 않으면 시간낭비일 뿐이다.

✔️ 출처

n^2 배열 자르기 level 2

📖 문제

nxn크기의 2차원 배열을 i행 i열에 i 값을 넣는다. 123 223 333 이런식으로 그다음 각 행을 모두 이어붙이고 left~right까지만 배열로 반환

🔅 문제 풀이

class Solution {
    public int[] solution(int n, long left, long right) {
        int[] answer = new int[(int)(right-left+1)];

        for (int i = 0; i < answer.length; i++) {
            answer[i] = (int)(Math.max((left + i) / n, (left + i) % n) + 1);
        }

        return answer;
    }
}

1차시도때 2차원 배열 만들고 값을 하나씩 넣은다음 그 중에서 left~right 배열을 반환하려 했으나 보면 알겠지만 n의 값이 최대 10^7이고 right - left 는 10^5 미만이다. 2차원 배열을 만들 경우 n *n 인 10^14크기의 배열을 만들어야하므로 메모리 초과가 뜬다.

무작정 풀게 아니라 우리에게는 아주 좋은 나누기 연산과 나머지 연산이 있다. 굳이 한 배열로 이어붙이는 로직을 짤 필요가 없다는 의미이다.

left ~right까지 반복하게 끔 반복문을 만든 후 left / n 과 left % n 중 가장 큰 값이 처음 i행 i열에 i 값을 넣은 그 값이다. 물론 +1을 해주어야한다. 나는 0행, 0열부터 시작하게끔 설정하였으므로..

입출력 예 1번을 예시로 풀어보면 left=2이고 max(2/3, 2%3) 이면 0, 2이므로 arr[0][2] 의 값이라는 뜻이다. 여기서 우리는 처음 열,행이 0부터 시작이므로 최대값 2에 +1을 해준 3이 left=2에 해당하는 값이다.

처음 시도

class Solution {
    public int[] solution(int n, long left, long right) {
        // 메모리 초과
        int[][] arr = new int[n][n];
        int[] answer = new int[(int)(right-left+1)];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                arr[j][i] = arr[i][j] = i + 1;   
            } 
        }

        for (int index = 0; index <= right - left; index++) {
            answer[index] = arr[(int)(left + index) / n][(int)(left + index) % n];
        }

        return answer;
    }
}

2차원 배열을 만들기만 해도 메모리초과가 떠서 2차원배열로 푸는 문제가 아니라는 것을 깨달았다.

❗ 오답노트 / 필요한 지식

1. 무작정 풀어보고 생각을 다듬는 것이 좋아보인다.

✔️ 출처

H-Index level 2

📖 문제

문제를 잘 못 이해해서 삽질했다. n편 중 h 번 이상 인용된 논문이 h편 이상이고, 나머지 논문은 개수에 상관없이 h 번 이하 인용되었다면 h의 최댓값이 H-Index이다.

🔅 문제 풀이

import java.util.Arrays;

class Solution {
    public int solution(int[] citations) {
        Arrays.sort(citations);
        int max = 0;

        // i = 논문 인용 횟수
        for (int i = 0; i < citations[citations.length - 1]; i++) {
            int count = 0;
            // 인용횟수 h 이상인 논문 카운트
            for (int j = 0; j < citations.length; j++) {
                if ( i <= citations[j]) count++;   
            }
            // 인용횟수 h이상인 논문이 h편 이상인지 판별
            if (i <= count) max = i;
            else break;

        }

        // n편중 h번 이상이 h 개 이상, 나머지는 h번 이하 인 h의 최댓값

        return max;
    }
}

흠.. 느리다.

프로그래머스 좋아요 1등 풀이

import java.util.*;

class Solution {
    public int solution(int[] citations) {
        Arrays.sort(citations);

        int max = 0;
        for(int i = citations.length-1; i > -1; i--){
            int min = (int)Math.min(citations[i], citations.length - i);
            if(max < min) max = min;
        }

        return max;
    }
}

이해 해보기

예제 [1,1,1,7,8,10] 이고 정답은 3이다.

결국에는 citations 길이 안에서 결정이 난다. 왜냐하면 h 개 이상의 논문이 있어야하기때문이다.

쉽게 보자면 10 이상 인용된 논문의 개수 : 1 8 이상 인용된 논문의 개수 : 2 7 이상 인용된 논문의 개수 : 3 ...

citations의 요소가 인용된 횟수이며, 그 횟수 이상이 논문의 개수여야한다. 인용횟수와 논문 개수중 더 작은 것을 찾아내고 그 중에서 최댓값을 선정한다.

❗ 오답노트 / 필요한 지식

1. 저런 발상을 하는 연습이 필요한 것 같다...
2. 내가 짠게 뭔가 이해가 더 잘되는 것 같다. 풀이는 내가하던대로 하되 나중에 더 최적화해야겠다 싶을 때 분석해서 코드를 리팩토링하는게 맞는 것 같다.

✔️ 출처

영어 끝말잇기 level 2

📖 문제

핵심 말 그대로 끝말잇기이며 앞 뒤 문자가 이어지는 지 확인 중복 단어 불가

🔅 문제 풀이

import java.util.*;

class Solution {

    // 1번 부터 순서대로 한사람씩 단어
    // 마지막 다음 1번부터 다시시작
    // 마지막 문자로 시작하는 단어
    // 중복 단어 불가
    // 한 글자 불가

    public int[] solution(int n, String[] words) {
        Map<String, Boolean> map = new HashMap<>();
        char lastWord = words[0].charAt(0);

        for (int i = 0; i < words.length; i++) {          
            if(map.getOrDefault(words[i], false)) 
                return new int[]{(i % n) + 1 , (int)Math.ceil((float)(i + 1) / n)};

            else if (lastWord != words[i].charAt(0)) 
                return new int[]{(i % n) + 1 , (int)Math.ceil((float)(i + 1) / n)};

            map.put(words[i], true);
            lastWord = words[i].charAt(words[i].length() - 1);
        }

        return new int[]{0,0};
    }
}

다른사람풀이를 보며

왜 Math.round Ceil을 쓸생각을 했을까 없어도 충분히 되는데...

import java.util.*;

class Solution {

    // 1번 부터 순서대로 한사람씩 단어
    // 마지막 다음 1번부터 다시시작
    // 마지막 문자로 시작하는 단어
    // 중복 단어 불가
    // 한 글자 불가

    public int[] solution(int n, String[] words) {
        Map<String, Boolean> map = new HashMap<>();
        char lastWord = words[0].charAt(0);

        for (int i = 0; i < words.length; i++) {          
            if(map.getOrDefault(words[i], false)) 
                return new int[]{(i % n) + 1, (i  / n) + 1};

            else if (lastWord != words[i].charAt(0)) 
                return new int[]{(i % n) + 1 , (i / n) + 1};

            map.put(words[i], true);
            lastWord = words[i].charAt(words[i].length() - 1);
        }

        return new int[]{0,0};
    }
}

❗ 오답노트 / 필요한 지식

1. 처음에 Math.round를 사용했는데 생각해보니 반올림이 아닌 올림을 해줘야하는 것이였다. ceil()메서드를 기억하자.
2. 올림, 반올림같은 메서드는 실수형을 매개변수에 넣어야한다. 사용시 캐스팅해주자.
3. 중복체크에 적합한 Set이 있다..
4. 굳이 반올림, 올림 안해도 충분한데 이걸 생각못했다. 잘 기억해두고 써먹자.

✔️ 출처

카펫 level 2

📖 문제

핵심 가로 길이 >= 세로길이 가로 세로 길이를 구하되 갈색과 노란색의 개수가 맞아야함

🔅 문제 풀이

좀 이상하게 풀었는데 우선 가로 세로를 찾기위해 약수를 구한다. 약수가 가로 세로가 된다. 약수를 check 메서드에 넘긴다.

check 메서드는 가로가 위아래로 2개 있으므로 가로 길이 x 2를 해준 다음 전체 갈색개수에서 빼준다. 이를 2로 나누면 사각형에서 양 옆의 개수가 된다. 위 예시와 같이 4 / 2 = 2 세로 옆구리가 2다.

이 값이 매개변수로 넘어온 약수로 찾은 가로세로중 세로 길이 - 2 한 값보다 작거나 같으면 정상적으로 사각형이 성립된다.

만약 옆구리가 2 고 약수로 찾은 세로가 1이면 갈색이 1 남는다.. 이러면 아닌 것이다.

class Solution {
    public int[] solution(int brown, int yellow) {

        // 너비는 brown + yellow 와 같다. 
        // 가로 길이 >= 세로
        int area = brown + yellow;

        for (int i = 3; i < 5001; i++) {
                                    // 이과정은 세로를 구하는 과정 (가로 x 세로 = 넓이)
            if (area % i == 0 && (area / i) <= i ) {   
                                // i :가로, area/i :세로
                if (check(new int[] {i, area/i}, brown, yellow)) 
                    return new int[] {i, area/i};     
            }
        }
        return null;
    }

    public boolean check(int[] arr, int br, int ye) {
        int temp = (br - (arr[0] * 2)) / 2;
        if (temp <= arr[1] - 2)
            return true;

        return false;
    }
}

다른 사람 풀이를 보며

(가로 - 2 ) x (세로 - 2)= 노란색 넓이 이걸 생각해내지 못했다...ㅠㅠ

약수를 찾아서 가로 세로를 구하고 (가로 -2) x (세로 -2) == 노란색 넓이 로 조건문을 걸어서 참이면 그것이 가로세로 정답이다.

❗ 오답노트 / 필요한 지식

1. 나름 생각해서 원칙을 찾아본다고 한게 저 풀이인데 많이 아쉽다. 하지만 풀었으니 다행이다.

✔️ 출처

JadenCase 문자열 만들기 level 2

📖 문제

핵심 공백문자가 연속해서 나올 수 있다. 첫 문자는 대문자 그외에는 소문자

🔅 문제 풀이

처음 시도

import java.util.*;

class Solution {
    public String solution(String s) {
        s += "#";

        String[] str = s.split(" ");
        char temp;
        String answer = "";

            for (int i = 0; i < str.length; i++) {

                if (str[i].isBlank()) {
                    answer += " ";
                    continue;
                }

                temp = str[i].charAt(0);
                if (97 <= temp && temp <= 122) {
                    answer += ((char)(temp-32) + str[i].substring(1).toLowerCase());
                } else {
                    answer += str[i] ;
                }

                if (i < str.length) {
                    answer += " ";
                }
            }

        return answer.substring(0, answer.length() - 2);
    }
}

매우 부끄럽게도 왜 안되지 이해를 못했는데 직접 테스트 케이스를 만들다가 알게되었다... if문에서 temp가 소문자일 때는 대문자로 바꾸고 뒤에 것을 tolowerCase로 갖다 붙이는데 정작 temp가 대문자이고 그 뒤에 문자열도 대문자일 때를 생각하지 못했다...

2차 시도 / 정답

class Solution {
    public String solution(String s) {
        s += "#";

        String[] str = s.split(" ");
        char temp;
        String answer = "";

            for (int i = 0; i < str.length; i++) {  
                // 기존 s 에서 공백 2개일때 answer에 공백 추가 
                // split(" ")을 하게되면 입력이 "  a" 이렇게 연속 공백이면 " ", "a" 이런식으로 저장되기때문에 따로 공백을 추가해주었다.  
                if (str[i].isBlank()) {
                    answer += " ";
                    continue;
                }

                temp = str[i].charAt(0);
                if (97 <= temp && temp <= 122) {
                    answer += ((char)(temp-32) + str[i].substring(1).toLowerCase());
                } else {
                    answer += str[i].charAt(0) + str[i].substring(1).toLowerCase();    
                }

                if (i < str.length) {
                    answer += " ";
                }
            }

        return answer.substring(0, answer.length() - 2);
    }
}

맞추긴 했는데 느리다. ㅠㅠ 문자열을 다루는 문제에 약하다. 문자열 문제를 좀 집중적으로 풀어볼 필요가 있다.

❗ 오답노트 / 필요한 지식

1. 고민중인 것은 일단 무작정 풀기 or 최고의 효율을 생각해보고 풀기이다.
2. 물론 무작정 풀기가 시간면에서 나을 수도 있으나 시험이 아니니 이럴때 효율적으로 풀다보면 무작정 풀때 효율적으로 풀던 방식이 습관적으로 작용하지 않을까 싶다. 그러니 최대한 효율성도 챙기자.

✔️ 출처

프로그래머스 PCCP 기출문제 2번 / 석유 시추

📖 문제

핵심 그래프 bfs or dfs을 사용하여 각 석유 덩어리에 개수를 따로 저장하고 번호를 매긴다. 각 열이 어떤 번호를 가졌는지 저장한다음 반복문으로 각 열을 돌아서 가진 번호에 대한 석유 덩어리 개수들을 뽑아서 최대값을 찾는다.

🔅 문제 풀이

row = 깊이 col = 1 2 3 4 .. 등 시추할 위치 열

import java.util.*;

class Solution {
    private static int[][] graph;
    private static int[] upDown = {0, 0, 1, -1};
    private static int[] leftRight = {1, -1, 0, 0};

    public int solution(int[][] land) {
        graph = land;
        int number = 2;
        int maxAmount = 0;
        int tempAmount = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        Set<Integer> numberSet = new HashSet<>();
        int[] depth = new int[land[0].length];

        for (int col = 0; col < land[0].length; col++) {
            for (int row = 0; row < land.length; row++) {

                // 석유 덩어리 넘버링 및 개수 map에 저장
                if (graph[row][col] == 1) {
                    // 석유 덩이리인 number에 대한 값을 가짐
                    map.put(number, bfs(row,col,number,tempAmount));
                    number++;

                }
                // set에 한 열에 대한 덩어리 넘버링을 저장
                if (graph[row][col] > 1) {
                    numberSet.add(graph[row][col]);
                }

            }
            // 저장해뒀던 넘버링을 꺼내서 각 열에 저장
            for (Integer i : numberSet) {
                depth[col] += map.getOrDefault(i, 0);
            }

            numberSet.clear();
        }

        // int max = 0;
        // for (int ia : depth) {
        //     max = Math.max(max, ia);
        // }

        // return max;

        return Arrays.stream(depth)
                .max()
                .getAsInt();
    }

    public  int bfs(int row, int col, int number, int temp) {

        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{row, col});
        graph[row][col] = number;

        while (!q.isEmpty()) {
            int[] poll = q.poll();
            temp++;

            for (int i = 0; i < 4; i++) {
                int tempCol = poll[0] + upDown[i];
                int tempRow = poll[1] + leftRight[i];

                if (tempCol>= 0 && tempRow >= 0 && tempCol < graph.length && tempRow < graph[0].length) {
                    if(graph[tempCol][tempRow] == 1) {
                        q.add(new int[]{tempCol, tempRow});
                        graph[tempCol][tempRow] = number;
                    }

                }
            }
        }
        return temp;
    }
}

스트림 연습한다고 return에 깨알 스트림을 사용했다ㅎㅎㅎㅎㅎ

❗ 오답노트 / 필요한 지식

처음에 할 때는 정확성만 통과하고 효율성에서 다 시간초과로 떴는데 이유는

1. 넘버링 하지 않았기에 같은 석유 덩어리 라인에 대한 중복 조회가 계속 이루어졌다.
2. 덩어리 값을 반복문 안에서 더하고 Math.max계속 호출하였다.

이 두가지 인 것 같다.

넘버링 하고 그런 것은 처음 문제 볼때 생각하긴 했었는데 일단 그냥 해보자 해서 정확성 매우빠르게 나오고 통과하길래 잘된줄 알았더니 효율성에서 시간초과가 떴다.

효율성 테스트에서는 항상 최소한의 반복문, 참조, 접근으로 코드를 짜주자..

✔️ 출처

프로그래머스 PCCP 기출문제 10번 / 데이터 분석

📖 문제

핵심 val_ext 보다 ext가 더 작은 데이터를 뽑고, 거기서 sort_by에 해당하는 값을 기준으로 오름차순

🔅 문제 풀이

import java.util.*;

class Solution {
    public  int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {
        int[][] answer;
        int filterIndex = indexTranslator(ext);
        List<int[]> filterList = new ArrayList<>();

        for (int[] datum : data) {
            if (datum[filterIndex] < val_ext)
                filterList.add(datum);
        }


        filterList.sort((o1, o2) -> {
            if (o1[indexTranslator(sort_by)] - o2[indexTranslator(sort_by)] < 0) return -1;
            else {
                return 1;
            }
        });

        answer = new int[filterList.size()][4];

        for (int i = 0; i < filterList.size(); i++) {
            answer[i] = filterList.get(i);
        }

        return  answer;
    }

    private  int indexTranslator(String value) {
        switch (value) {
            case  "code" : return 0;
            case "date" : return 1;
            case  "maximum" : return 2;
            default: return 3;
        }
    }
}

사실 스트림, 람다식 사용할려고 했는데 2차원 배열을 처리할 때 스트림 최종연산에서 아무리해도 안되서 포기하고 저렇게 한것이였다. 다른 사람들 풀이를 보니 스트림으로만 푸신분들이 있어서 보고 배워야겠다.

스트림, 람다식으로만 해서 다시 풀이

import java.util.*;

class Solution {
    public  int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {
        int filterIndex = indexTranslator(ext);
        return Arrays.stream(data).filter(x -> x[filterIndex] < val_ext).sorted((o1, o2) -> o1[indexTranslator(sort_by)] - o2[indexTranslator(sort_by)]).toArray(int[][]::new);
    }
    private  int indexTranslator(String value) {
        switch (value) {
            case  "code" : return 0;
            case "date" : return 1;
            case  "maximum" : return 2;
            default: return 3;
        }
    }
}

근데 역시 스트림은 느린것 같다.

❗ 오답노트 / 필요한 지식

1. ToArray(int[][]::new)를 배웠다.
2. x-> x[] 처럼 x가 배열이지만 이렇게 사용할 수 있다. 파라미터이니까

✔️ 출처

프로그래머스 PCCP 기출문제 1번 / 붕대감기

📖 문제

🔅 문제 풀이

class Solution {
    public static int solution(int[] bandage, int health, int[][] attacks) {
        int time = 0;
        int timeIndex = 0;
        int healthTime = 0;
        int maxHp = health;

        //공격 시간 
        int attackTime = attacks[timeIndex][0];

        while(health > 0) {
            time++;

            if (timeIndex == attacks.length ) {
                return health;
            }
            // 공격
            if (time == attackTime) {
                health -= attacks[timeIndex++][1];
                if (timeIndex != attacks.length) {
                    attackTime = attacks[timeIndex][0];
                }
                healthTime = 0;

                // 회복
            } else {
                if (maxHp > health + bandage[1]) {
                    health += bandage[1];
                    healthTime++;
                } else {
                    health = maxHp;
                }

                if (healthTime == bandage[0]) {
                    healthTime = 0;

                    // 추가 회복량 
                    if (maxHp >= health + bandage[2]) {
                        health += bandage[2];
                    } else {
                        health = maxHp;
                    }
                }
            }

        }
        return -1;

    }
}

문제를 제대로 이해하지 못해서 좀 애먹었다. 핵심은 회복량이 최대 체력을 넘길양이면 최대체력까지만 회복하고 더이상 회복하지 않는다는 것이다..

❗ 오답노트 / 필요한 지식

1. Math 클래스를 잘 이용해보자.
2. 문제를 수학적으로 한 번 생각해 볼 필요가 있다.

@Import도 확인하고 Config도 확인했는데 자꾸 저렇게 떠서 JpaRepository 상속받은 SpringDataJpaItemRepository 에 가보니 노란줄이 있었다.

알고보니 itemName을 넘겨주지 않아서 생긴 문제였다. 이런게 안맞으면 스프링 에서 프록시를 생성하지 못하나 보다. 그래서 스프링 빈에 없었던 것이었고.. 놓친 부분이 있나 항상 잘 확인하자 .

✔️ 출처

숨바꼭질 1697번 - 백준

📖 문제

🔅 문제 풀이

수빈이의 위치 x 동생의 위치 k

수빈이는 -1, +1, *2 로 이동할 수 있고 이는 1초를 사용한다.

graph를 조건에 만족하는 최대 크기로 만들어서 각 위치에 따른 초를 적을 것이다. 처음 수빈이가 있는 장소는 1로 초기화한다.

너비우선탐색으로 하되 문제에서 주어진 위치에 대한 조건식을 걸어주고 (0 <= x, k <= 100000) 이동하려는 곳에 이전에 이동한 흔적이 있는지 확인하여 걸린시간이 덮어씌어지는 것을 방지한다.

x-1, x+1, x*2 3번의 위치이동을 하고 graph 인덱스의 값에 현재 위치의 걸린시간 +1 초를 더해 이동한 흔적을 남긴다. 그리고 이동한 위치를 queue에 넣는다. 방문하지 않은 곳은 걸린시간이 0이다. 왜냐하면 graph를 만들 때 수빈이의 위치말곤 따로 값을 초기화해주지 않았기 때문이다. 루프를 돌면서 queue에서 꺼낸 위치가 동생 위치일 때, 수빈이가 동생에게 도달했다는 것이고, 그 위치에는 분명 이동한 흔적이 있을 것이다. 그것이 가장 빨리 도달한 시간이다.

import java.io.*;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static int answer;

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] graph = new int[100001];

        int x = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());


        graph[x] = 1;

        bfs(x, graph, k);
        bw.write(answer+"\n");
        bw.flush();
        bw.close();

    }

    private static void bfs(int x, int[] graph, int k) {
        Queue<Integer> q = new LinkedList<>();
        q.add(x);

        while (!q.isEmpty()) {
            int current = q.poll();
            int count = graph[current];

            if (current == k) {
                answer = count - 1;
                return;
            }

            if (current - 1 >= 0 && graph[current - 1] == 0) {
                graph[current - 1] = count + 1;
                q.add(current - 1);
            }
            if (current + 1 < graph.length && graph[current + 1] == 0) {
                graph[current + 1] = count + 1;
                q.add(current + 1);
            }
            if (current * 2 < graph.length && graph[current * 2] == 0) {
                graph[current * 2] = count + 1;
                q.add(current * 2);
            }
        }

    }
}

이런 문제 잘 못풀어서 힘들었다.

❗ 오답노트 / 필요한 지식

bfs, dfs 에 대한 특징에 대해 아직은 학습이 부족한 것 같다. 더 공부해야한다.

🌿 시작하기 앞서

스프링 부트 2.6.5 버전을 기준으로 작성됨 H2 데이터베이스 Version 2.2.224 (2023-09-17) 강의에서 제공하는 기본 소스코드에서 DB 관련 기술만 학습

application.properties 는 src/main 과 src/test는 다른 구역이므로 테스트에서도 동일한 환경을 사용한다면 src/test의 application.properties도 설정해주자.

spring.profiles.active=test
spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.username=sa

logging.level.org.springframework.jdbc=debug

dataSource가 이 정보를 토대서 생성됨

🌱 테스트

✔️ 로컬 DB 테스트

@SpringBootTest 애노테이션은 @SpringBootApplication을 찾아서 설정으로 사용한다.

H2 데이터베이스로 테스트를 실패할 경우 2가지를 확인하자

1. H2 데이터베이스 실행 여부
2. H2 데이터베이스의 데이터 초기화 여부

로컬에서 사용하는 애플리케이션 서버와 테스트에서 같은 데이터베이스를 사용해서 문제가 발생한다.

가장 간단한 방법 테스트 전용 데이터베이스를 별도로 운영

• jdbc:h2:tcp://localhost/~/test local에서 접근하는 서버 전용 데이터베이스
• jdbc:h2:tcp://localhost/~/testcase test 케이스에서 사용하는 전용 데이터베이스

생성방법은 서버 재실행 -> url에 testcase등으로 바꾸고 연결 하면 testcase.mv.db가 생성된다. 이제 jdbc:h2:tcp://localhost/~/testcase 이 url로 접속

src/test appliation.properties도 변경

spring.profiles.active=test
spring.datasource.url=jdbc:h2:tcp://localhost/~/testcase
spring.datasource.username=sa

테스트의 중요한 원칙

• 테스트는 다른 테스트와 격리해야 한다.
• 테스트는 반복해서 실행할 수 있어야 한다.

테스트가 끝날때마다 delete sql을 사용하는 것은 테스트 도중 예외 발생시 애플리케이션이 종료되버리면 delete sql을 실행할 수 없기 때문에 좋지 않다.

✔️ 데이터 롤백

트랜잭션을 사용하면 해결된다.

1. 트랜잭션 시작
2. 테스트 A 실행
3. 트랜잭션 롤백

4. 트랜잭션 시작
5. 테스트 B 실행
6. 트랜잭션 롤백

.
.
.

테스트는 각각의 테스트 실행 전 후로 동작하는 @BeforeEach , @AfterEach 라는 편리한 기능을 제공

//트랜잭션 관련 코드
@Autowired
PlatformTransactionManager transactionManager; //스프링 부트 자동 빈 등록 
TransactionStatus status;

@BeforeEach
void beforeEach() {
    //트랜잭션 시작
    status = transactionManager.getTransaction(new DefaultTransactionDefinition());
}

@AfterEach
void afterEach() {
    //MemoryItemRepository 의 경우 제한적으로 사용
    if (itemRepository instanceof MemoryItemRepository) {
        ((MemoryItemRepository) itemRepository).clearStore();
    }

    //트랜잭션 롤백
     transactionManager.rollback(status);
 }

✔️ @Transactional

사실 더 좋은 방법이 있는데 @Transactional 애노테이션 하나만 붙이면 된다. 이러면 각 테스트 전 후로 트랜잭션 시작, 롤백을 자동으로 해준다. 해당 기능은 test에서만 적용된다.

메서드나 클래스에 @Transactional 이 있으면 트랜잭션을 시작한다. 테스트 메서드가 끝나면 트랜잭션을 강제로 롤백한다.

참고 트랜잭션을 테스트에서 시작하기 때문에 서비스, 리포지토리에 있는 @Transactional 도 테스트에서 시작한 트랜잭션에 참여한다. 라고 하는데 트랜잭션 전파라는 것을 배워야 하나보다. 같은 트랜잭션 범위에 들어간다 라고 알아두자

강제 커밋 @Commit

@Commit 애노테이션을 클래스 또는 메서드에 붙이면 테스트 종료 후 롤백 대신 커밋이 호출된다. @Rollback(value = false) 도 마찬가지이다.

✔️ 임베디드 모드 DB

테스트 케이스 실행을 위해 별도의 데이터베이스 설치, 설정, 운영은 번잡한 작업이다.

H2 데이터베이스는 자바로 개발되었고, JVM 안에서 메모리 모드로 동작하는 특별한 기능을 제공한다. 즉, JVM 메모리에 H2 데이터베이스를 포함해서 함께 실행이 가능하다. 이를 임베디드 모드 라 한다. (DB를 애플리케이션에 내장)

애플리케이션이 종료되면 임베디드 모드로 동작하는 H2 데이터베이스도 함께 종료, 데이터도 모두 삭제

// h2 임베디드 메모리 DB 사용
@Bean
@Profile("test")
public DataSource dataSource() {
    log.info("메모리 데이터베이스 초기화");
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("org.h2.Driver");
    dataSource.setUrl("jdbc:h2:mem:db;DB_CLOSE_DELAY=-1"); // 임베디드 메모리 모드
    dataSource.setUsername("sa");
    dataSource.setPassword("");
    return dataSource;
}

• @Profile("test")
  • 프로필이 test인 경우에만 데이터소스를 스프링 빈으로 등록
  • 테스트 케이스에서만 이 데이터소스를 스프링 빈으로 등록해서 사용하겠다는 뜻
• dataSource()
  • jdbc:h2:mem:db : 중요! 데이터소스를 만들때 이렇게만 적으면 임베디드 모드(메모리 모 드)로 동작하는 H2 데이터베이스를 사용 가능
  • DB_CLOSE_DELAY=-1 : 임베디드 모드에서는 데이터베이스 커넥션 연결이 모두 끊어지면 데이터베이스도 종료되는 것을 방지하는 설정

✔️ 스프링 부트와 임베디드 모드

스프링 부트는 임베디드 데이터베이스에 대한 설정도 기본으로 제공한다. 데이터베이스에 대한 별다른 설정이 없으면 임베디드 데이터베이스를 사용

데이터베이스에 접근하는 DataSource 설정 정보도 주석처리

application.properties의 datasource 설정 정보도 주석처리

이로써 스프링부트가 임베디드 데이터베이스를 제공한다.

 conn0: url=jdbc:h2:mem:0e4053f9-xxxx-xxxx-xxxx-xxxxxxxxxxx user=SA] 

테스트를 실행하면 이런 식으로 임베디드 모드가 연결된 것을 확인 할 수 있다.

✔️ 스프링 부트 - 기본 SQL 스크립트를 사용한 데이터베이스 초기화 기능

메모리 DB는 애플리케이션 종료될 때 함께 사라지기에 실행 시점에 데이터베이스 테이블도 새로 만들어 줘야한다.

스프링 부트는 SQL 스크립트를 실행해서 애플리케이션 로딩 시점에 데이터베이스를 초기화하는 기능 제공

src/test/resource/schema.sql 해당 위치에 schema.sql 파일을 생성

drop table if exists item CASCADE;
create table item
(
    id bigint generated by default as identity,
    item_name varchar(10),
    price integer,
    quantity integer,
    primary key (id)
);

sql문을 입력해놓으면 된다.

🔖 학습내용 출처

스프링 DB 2편 - 데이터 접근 활용 기술

🌿 시작하기 앞서

스프링 부트 2.6.5 버전을 기준으로 작성됨 H2 데이터베이스 Version 2.2.224 (2023-09-17)

SQL을 직접 사용하는 경우 좋은 DB접근 기술이다.

🌱 JdbcTemplate 기본 사용

장점

• 설정의 편리함
  • JdbcTemplate은 spring-jdbc 라이브러리에 포함 (스프링 기본 사용 라이브러리)
  • 별도의 복잡한 설정 없이 바로 실행 가능

• 반복 문제 해결
  • 템플릿 콜백 패턴
  • 개발자는 SQL 작성, 전달 파라미터 정의, 응답 값 매핑 까지만 하면 된다.
  • 대부분의 반복 작업 대신 처리
    • 커넥션 획득
    • statement 를 준비 및 실행
    • 결과를 반복하도록 루프 실행
    • 커넥션 종료, statement, resultset 종료
    • 트랜잭션 다루기 위한 커넥션 동기화
    • 예외 발생시 스프링 예외 변환기 실행

단점

• 동적 SQL 해결이 어려움

JdbcTemplate를 dependencies에 추가

build.gradle

//JdbcTemplate 추가
implementation 'org.springframework.boot:spring-boot-starter-jdbc'

✔️ JdbcTemplate 적용

기본

private final JdbcTemplate template;

public JdbcTemplateItemRepository(DataSource dataSource) {
    this.template = new JdbcTemplate(dataSource);
}

JdbcTemplate는 dataSource가 필요 dataSource를 의존 관계 주입을 받고 생성자 내부에서 JdbcTemplate 생성 (관례상 많이 사용)

save

KeyHolder keyHolder = new GeneratedKeyHolder();
template.update(connection -> {
//자동 증가 키
PreparedStatement ps = connection.prepareStatement(sql, new String[] {"id"}); 
    //ps.setXxx로 파라미터 바인딩
    return ps;
    }, keyHolder);

long key = keyHolder.getKey().longValue();

PK 생성에 identity (auto increment) 방식을 사용했기에 id 값을 비워두고 저장 하지만 이러면 insert 가 완료되어야 생성된 PK id값을 확인 가능 -> KeyHolder 와 connection.prepareStatement(sql, new String[] {"id"}) 를 사용해서 id를 지정해주면 insert 쿼리 실행 이후에 DB에서 생성된 id 값 조회 가능

prepareStatement 메서드 살펴보기

// 여러 개가 있지만 여기서 사용된 메서드 
PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException;

1. sql 문
2. 자동 생성되는 키들의 컬럼 이름

findById()

@Override
public Optional<Item> findById(Long id) {
    String sql = "select id, item_name, price, quantity from item where id = ?";
    try {
        Item item = template.queryForObject(sql, itemRowMapper(), id);
         return Optional.of(item);
     } catch (EmptyResultDataAccessException e) {
         return Optional.empty();
     }
 }

queryForObject()

• 결과 로우가 하나일 때 사용
• RowMapper는 데이터베이스의 반환 결과인 ResultSet을 객체로 변환
• 결과가 없으면 EmptyResultDataAccessException 예외 발생
• 결과가 둘 이상이면 IncorrectResultSizeDataAccessException 예외 발생

ItemRepository.findById() 인터페이스는 결과가 없을 때 Optional을 반환해야한다. 따라서 결과가 없으면 예외를 잡아서 Optional.empty를 대신 반환

findAll()

@Override
public List<Item> findAll(ItemSearchCond cond) {
    String itemName = cond.getItemName();
    Integer maxPrice = cond.getMaxPrice();
    String sql = "select id, item_name, price, quantity from item";
    // 동적 쿼리
    if (StringUtils.hasText(itemName) || maxPrice != null) {
        sql += " where";
    }
    boolean andFlag = false;
    List<Object> param = new ArrayList<>();
    if (StringUtils.hasText(itemName)) {
        sql += " item_name like concat('%', ?, '%')";
        param.add(itemName);
        andFlag = true;
    }
    if (maxPrice != null) {
        if (andFlag) {
            sql += " and";
        }
        sql += " price <= ?";
        param.add(maxPrice);
    }
    log.info("sql={}", sql);
    return template.query(sql, itemRowMapper(), param.toArray());
}

데이터를 리스트로 조회, 검색 조건에 따른 데이터 조회 template.query()

• 결과가 하나 이상일 때 사용
• RowMapper는 데이터베이스의 반환 결과인 ResultSet을 객체로 변환
• 결과가 없으면 빈 컬렉션을 반환
• 동적 쿼리에 대한 부분을 직접 짜줘야함

RowMapper()

JdbcTemplate가 루프를 돌려주고, 개발자는 RowMapper를 구현해서 그 내부 코드만 채운다.

while(resultSet 이 끝날 때 까지) {
    rowMapper(rs, rowNum);
}

✔️ 동적 쿼리 문제

findAll에서 사용자가 검색하는 값에 따라 SQL이 동적으로 달라져야한다. select id, item_name, price, quantity from item

select id, item_name, price, quantity from item where item_name like concat('%', ?, '%')

...

검색 조건의 개수는 1개의 검색조건이 있다 없다 하여 2가지 경우의 수이고 2개면 2x2 3개면 2x2x2 즉 검색 조건의 수가 n이라 했을 때 SQL문의 경우의 수는 2^n 이 된다.

또한 2가지 이상의 조건이면 and 를 넣어줘야하고 골치아프다.

MyBatis의 가장 큰 장점은 SQL을 직접 사용할 때 동적 쿼리를 쉽게 작성할 수 있다

✔️ 구성과 실행

JdbcTemplateV1Config

@Configuration
@RequiredArgsConstructor
public class JdbcTemplateV1Config {

    private final DataSource dataSource;

    @Bean
    public ItemService itemService() {
        return new ItemServiceV1(itemRepository());
    }

    @Bean
    public ItemRepository itemRepository() {
        return new JdbcTemplateItemRepositoryV1(dataSource);
    }
}

ItemServiceApplication

@Slf4j
//@Import(MemoryConfig.class)
@Import(JdbcTemplateV1Config.class)
@SpringBootApplication(scanBasePackages = "hello.itemservice.web")
public class ItemServiceApplication {

데이터 베이스 접근 설정

// application.properties              // src/main
spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.username=sa

스프링 부트가 해당 설정을 사용해서 커넥션 풀과 DataSource, 트랜잭션 매니저를 스프링 빈으로 자동 등록한다.

JdbcTemplate가 실행하는 SQL 로그 확인 방법

 // application.properties
#jdbcTemplate sql log
logging.level.org.springframework.jdbc=debug

📌 이름 지정 파라미터

✔️ 기존 순서대로 바인딩

String sql = "update item set item_name=?, price=?, quantity=? where id=?";
        template.update(sql,
                updateParam.getItemName(),
                updateParam.getPrice(),
                updateParam.getQuantity(),
                itemId);

SQL 코드의 순서 변경시

String sql = "update item set item_name=?, price=?, quantity=? where id=?";
        template.update(sql,
                updateParam.getItemName(),
                updateParam.getQuantity(),
                updateParam.getPrice(),
                itemId);

가격이 수량이 되고 수량이 가격이되어버리는 큰 사고 발생

개발을 할 때는 코드를 몇줄 줄이는 편리함도 중요하지만, 모호함을 제거해서 코드를 명확하게 만드는 것이 유지보수 관점에서 매우 중요

✔️ 이름 지정 바인딩

이러한 문제들을 해결하기위해 이름을 지정해서 파라미터를 바인딩 하는 기능을 제공 NamedParameterJdbcTemplate를 사용

private final NamedParameterJdbcTemplate template;

public JdbcTemplateItemRepositoryV2(DataSource dataSource) {
    this.template = new NamedParameterJdbcTemplate(dataSource);
}

NamedParameterJdbcTemplate도 DataSource가 필요

save

@Override
public Item save(Item item) {
    String sql = "insert into item(item_name, price, quantity) " +
            "values (:itemName, :price, :quantity)";

    BeanPropertySqlParameterSource param = new BeanPropertySqlParameterSource(item);

    KeyHolder keyHolder = new GeneratedKeyHolder();
    template.update(sql, param, keyHolder);

    long key = keyHolder.getKey().longValue();
    item.setId(key);

    return item;
}

SQL 에서 ? -> :파라미터이름으로 받는다.

insert into item(item_name, price, quantity) values (:itemName, :price, :quantity)

✔️ 이름 지정 파라미터 전달

이름 지정 파라미터를 전달하려면 Map 처럼 Key, value 데이터 구조를 만들어서 전달해야 한다. key : :파라미터이름으로 지정한, 파라미터의 이름 value : 해당 파라미터의 값

이름 지정 바인딩에서 자주 사용하는 파라미터 종류는 크게 3가지

• Map
• SqlParameterSource
  • MapSqlParameterSource
  • BeanPropertySqlParameterSource

1. Map

단순히 Map 사용

Map<String, Object> param = Map.of("id", id);
Item item = template.queryForObject(sql, param, itemRowMapper());

2. MapSqlParameterSource

Map과 유사한데 SQL 타입을 지정할 수 있는 등 SQL에 좀 더 특화된 기능 제공 SqlParameterSource 인터페이스의 구현체 메서드 체인을 통해 편리한 사용법도 제공

SqlParameterSource param = new MapSqlParameterSource()
    .addValue("itemName", updateParam.getItemName())
    .addValue("price", updateParam.getPrice())
    // 파라미터 계속 추가
    .addValue("id", itemId); // id를 넣는 부분이 별도로 필요
template.update(sql, param);

3. BeanPropertySqlParameterSource

SqlParameterSource 인터페이스의 구현체 자바빈 프로퍼티 규약을 통해서 자동으로 파라미터 객체를 생성 getXxx() -> xxx, getItemName() -> itemName

ex) getItemName()

• key=itemNamem value=상품명 값

SqlParameterSource param = new BeanPropertySqlParameterSource(item);
KeyHolder keyHolder = new GeneratedKeyHolder();
template.update(sql, param, keyHolder);

매우 간편하다.

여기서 주의할 점은 :id 바인딩을 해주어야하는 상황에서 파라미터에서 넘어온 Dto에 id값이 없다면 사용할 수 없다. 이때는 MapSqlParameterSource를 사용하자

BeanPropertyRowMapper

기존 itemRowMapper 를 사용할 때는 람다식을 사용해서 하나하나 값을 세팅해주었다.

// 기존
private RowMapper<Item> itemRowMapper() {
    return ((rs, rowNum) -> {
        Item item = new Item();
        item.setId(rs.getLong("id"));
        // setter로 item 값 설정 ...
        return item;
    });
}

이번에는 BeanPropertyRowMapper를 사용해서 간편해졌다.

// new
private RowMapper<Item> itemRowMapper() {
    return BeanPropertyRowMapper.newInstance(Item.class); // camel 변환 지원
}

BeanPropertyRowMapper는 ResultSet의 결과를 받아서 자바빈 규약에 맞추어 데이터를 반환

ex) DB 조회 결과가 select id, itemName이라고 한다면 다음과 같은 코드를 작성해준다. (실제로는 리플렉션 같은 기능을 사용)

Item item = new Item();
item.setId(rs.getLong("id");
item.setItemName(rs.getString("itemName");

데이터베이스에서 조회한 결과 이름을 기반으로 setId(), setPrice() 처럼 자바빈 프로퍼티 규약에 맞춘 메서드를 호출

별칭

컬럼 명에 _ 이 중간에 포함되어 있거나 아예 다른 컬럼명이면 어떻게 해야할까?

이때는 as 를 사용하여 별칭을 붙여준다. select item_name as itemName select member_name as username

이러한 방법으로 자주 사용한다.

관례의 불일치

자바 객체는 카멜 표기법 관계형 데이터베이스는 스네이크 케이스 표기법(언더스코어 사용)

BeanPropertyRowMapper는 언더스코어 표기법을 카멜로 자동 변환해준다. select item_name으로 조회 -> setItemName()에 문제 없이 값이 들어간다.

참고 리플렉션이란? 구체적인 클래스 타입을 알지 못해도 그 클래스의 메소드, 타입, 변수들에 접근할 수 있도록 해주는 자바 API

✔️ SimpleJdbcInsert

private final NamedParameterJdbcTemplate template;
private final SimpleJdbcInsert jdbcInsert;

public JdbcTemplateItemRepositoryV3(DataSource dataSource) {
    this.template = new NamedParameterJdbcTemplate(dataSource);
    this.jdbcInsert = new SimpleJdbcInsert(dataSource)
            .withTableName("item")
            .usingGeneratedKeyColumns("id");
    //      .usingColumns("item_name", "price", "quantity"); 생략 가능 심플 jdbc가 item table의 메타 데이터를 읽음

    }

SimpleJdbcInsert 도 dataSource를 받는다.

• withTableName : 데이터를 저장할 테이블 명 지정
• usingGeneratedKeyColumns : key를 생성하는 PK 컬럼 명을 지정
• usingColumns : INSERT SQL에 사용할 컬럼을 지정, 특정 값만 저장하고 싶을 때 사용, 모든 컬럼 저장시 생략가능

SimpleJdbcInsert는 생성 시점에 데이터베이스 테이블의 메타 데이터를 조회 어떤 컬럼이 있는지 확인하기에 usingColumns을 생략 가능

save()

jdbcInsert.executeAndReturnKey(param)을 사용해서 INSERT SQL을 실행하고, 생성된 키 값도 매우 편리하게 조회 가능

public Item save(Item item) {
    SqlParameterSource param = new BeanParameterSource(item);
    Number key = jdbcInsert.executeAndReturnKey(param);
    item.setId(key.longValue());
    return item;
}

나머지 코드 부분은 기존과 같다.

@Override
public Item save(Item item) {
    BeanPropertySqlParameterSource param = new BeanPropertySqlParameterSource(item);
    Number key = jdbcInsert.executeAndReturnKey(param);
    item.setId(key.longValue());
    return item;
}

🔅 JdbcTemplate 기능 정리

✔️ 주요 기능

• JdbcTemplate
  • 순서 기반 파라미터 바인딩 지원
• NamedParameterJdbcTemplate
  • 이름 기반 파라미터 바인딩을 지원 (권장)
• SimpleJdbcInsert
  • INSERT SQL을 편리하게 사용 가능
• SimpleJdbcCall
  • 스토어드 프로시저를 편리하게 호출 가능
  • 스토어드 프로시저 공식문서

✔️ 사용법 정리

스프링 JdbcTemplate 사용 방법 공식 메뉴얼

🔖 학습내용 출처

스프링 DB 2편 - 데이터 접근 활용 기술

Reflection이란 / @yeon

강의 따라 작성하는데 빨간줄이 뜨고 확인해보니 Could not autowire. No beans of 'DataSource' type found. 이라고 뜬다.

여기서 Import를 Jdbcconfig로 바꾸니

해결되었다.

알고보니 컴포넌트 스캔 범위를 줄여서 해당 config 클래스가 컨테이너에 빈으로 등록되지 않아서 그런거였다....

그러니 @Import 애노테이션을 사용해서 JdbcTemplateV1Config를 Import하여 스프링 빈 컨테이너에 추가해준다. 이로써 DataSource에 의존관계 주입이 가능해져 에러가 사라진다.

Optional은 NullPointException 발생 방지를 위해 사용 Java8

Optional<T>는 null 이 올 수 있는 값을 감싸는 Wrapper 클래스

✔️ null 체크

기존에는 if문을 사용해서 null 체크

List<String> list = store.get("itemName");
if ( list == null) {
    log.info("없는 상품");
    // 처리 
}

public final class Optional<T> {
    /**
     *  빈 optional을 공통객체로서 가지고 있다. 
     */
    private static final Optional<?> EMPTY = new Optional<>(null);

    /**
     * null이 아닐 경우 값이 담기고, null 일 경우null 이 담긴다. 
     */
    private final T value;

    // 생성자 
    private Optional(T value) {
        this.value = value;
    }
}    

✔️ 메서드

empty()

public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked") // 컴파일 경고를 사용하지 않도록 설정
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

공통 객체로 갖고 있는 빈 optional을 반환한다.

of(T value)

public static <T> Optional<T> of(T value) {
    return new Optional<>(Objects.requireNonNull(value));
}

null 체크 value 가 null이면 requireNonNull()에서 NPE을 던진다.

ofNullable(T value)

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? (Optional<T>) EMPTY : new Optional<>(value);
}

null일 가능성이 있는 value를 파라미터로 넘긴다. null : Optional EMPTY를 반환 , (빈 공통 객체) non-null : new Optional<>(value) 반환

isPresent()

public boolean isPresent() {
    return value != null;
}

ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
    if (value != null) {
        action.accept(value);
    } else {
        emptyAction.run();
    }
}

처음 파라미터는 Optional 객체에 값이 null이 아닐때 실행되는 Consumer 를 받고, 두 번째 파라미터는 Optional 객체의 값이 null일 때 실행되는 Runnable을 받는다.

둘다 함수형 인터페이스이기에 람다식이 가능하다.

orElse(T other)

public T orElse(T other) {
    return value != null ? value : other;
}

Optional이 null 이 아니면 value 반환 null 이라면 파라미터로 들어온 other을 그대로 반환

orElseGet(Supplier<? extends T> supplier)

public T orElseGet(Supplier<? extends T> supplier) {
    return value != null ? value : supplier.get();
}

Supplier 라는 함수형 인터페이스가 있기에 람다식을 사용할 수 있다. 값이 Optonal 에 있으면 value를 반환, 없으면 Supplier 에서 생성된 결과 반환

orElseThrow()

public T orElseThrow() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

OPtional에 값이 있으면 반환 없으면 NoSuchElementException을 던진다.

Optional은 반환형으로만 사용하자

반환타입으로 값이 있는지 여부를 확인하기 위해 탄생했다.

그외

map, filter 등 많이 있다 필요할 때 찾아서 사용하자

✔️ 다른 분이 정리하신 것

[ 올바른 Optional 사용법 가이드 ]

• Optional 변수에 Null을 할당하지 말아라
• 값이 없을 때 Optional.orElseX()로 기본 값을 반환하라
• 단순히 값을 얻으려는 목적으로만 Optional을 사용하지 마라
• 생성자, 수정자, 메소드 파라미터 등으로 Optional을 넘기지 마라
• Collection의 경우 Optional이 아닌 빈 Collection을 사용하라
• 반환 타입으로만 사용하라

출처: https://mangkyu.tistory.com/203 [MangKyu's Diary:티스토리]

🌿 시작하기 앞서

스프링 부트 2.6.5 버전을 기준으로 작성됨 H2 데이터베이스 Version 2.2.224 (2023-09-17)

🌱 데이터 접근 기술

데이터 접근 기술

• Jdbc Template
• Mybatis
• JPA, Hibernate
• 스프링 데이터 JPA
• Querydsl

SQLMapper

• JdbcTemplate
• MyBatis

ORM 관련 기술

• JPA, Hibernate
• 스프링 데이터 JPA
• Querydsl

SQLMapper 주요기능

• 개발자가 SQL만 작성 -> 결과를 객체로 편리하게 매핑해준다.
• JDBC를 직접 사용할 때 발생하는 여러 중복을 제거, 기타 개발자에게 여러 편리한 기능을 제공

ORM 주요 기능

• JPA는 기본적인 SQL은 JPA가 대신 작성 및 처리
• 개발자가 저장하고 싶은 객체를 마치 자바 컬렉션에 저장하고 조회하듯이 사용하면 ORM 기술이 데이터베이스에 해당 객체를 저장 및 조회 해준다.
• JPA는 자바 진영의 ORM 표준 , Hibernate(하이버네이트)는 JPA에서 가장 많이 사용하는 구현체
  • JPA 인터페이스 사용 , Hibernate 구현체로 사용
• 스프링 데이터 JPA, Querydsl은 JPA를 더 편리하게 사용 가능하게 도와주는 프로젝트 (거의 필수)

데이터 접근 기술 진행 방식

• 데이터 접근 기술에 대한 기본 이해와 전체 큰 그림을 그린다.
• 각 기술들의 핵심 기능 위주로 학습
• 각 기술들을 점진적으로 도입하는 과정을 통해서 각 기술의 특징과 장단점을 자연스럽게 이해

⚙️ 프로젝트 구조 및 설정

Repository 는 향후 다양한 데이터 접근 기술 구현체로 손쉽게 변경하기 위해 인터페이스 도입

public interface ItemRepository {
    Item save(Item item);
    void update(Long itemId, ItemUpdateDto updateParam);
    Optional<Item> findById(Long id);
    List<Item> findAll(ItemSearchCond cond);
}

검색, 수정

검색과 수정은 Dto 클래스를 각각 만들어서 처리 ItemSearchCond ItemUpdateDto

// Dto 사용
 @Override
 public void update(Long itemId, ItemUpdateDto updateParam) {
     Item findItem = findById(itemId).orElseThrow();
    findItem.setItemName(updateParam.getItemName());
     //...
 }

DTO (Data Transfer Object)

• 데이터 전송 객체
• DTO는 기능은 없고 데이터를 전달만 하는 용도로 사용되는 객체
• 객체 이름에 DTO를 꼭 붙일 필요는 없지만 붙여두면 용도를 알 수 있다는 장점이 있다.

확인용 초기 데이터 추가

@EventListener(ApplicationReadyEvent.class)
public void initData() {
    itemRepository.save(new Item("itemA", 10000, 10));
    // 추가할 데이터넣기 
}

• 애플리케이션을 실행할 때 초기 데이터를 저장
• @EventListener(ApplicationReadyEvent.class: 스프링 컨테이너가 완전히 초기화를 다 끝내고, 실행 준비가 되었을 때 발생하는 이벤트
  • 스프링이 이 시점에 해당 애노테이션이 붙은 initData() 메서드를 호출해준다.
  • @PostConstruct를 사용할 경우 AOP 같은 부분이 아직 다 처리되지 않은 시점에 호출될 수 있기에 간혹 문제 발생가능성이 있다. ex) @Transactional 과 관련된 AOP가 적용되지 않은 상태로 호출
  • @EventListener(ApplicationReadyEvent.class) 는 AOP를 포함한 스프링 컨테이너가 완전히 초기화 된 이후에 호출되기 때문에 이런 문제가 발생하지 않는다.

여러 설정

@Import(MemoryConfig.class)
@SpringBootApplication(scanBasePackages = "hello.itemservice.web")
public class ItemServiceApplication {

    public static void main(String[] args) {
    SpringApplication.run(ItemServiceApplication.class, args);
    }

    @Bean
    @Profile("local")
    public TestDataInit testDataInit(ItemRepository itemRepository) {
        return new TestDataInit(itemRepository);
    }
}

• @Import : 설정파일로 MemoryConfig 클래스를 사용
• @scanBasePackages : 컴포넌트 스캔 경로를 hello.itemservice.web 하위로 지정
• @Profile : 특정 프로필의 경우에만 해당 스프링 빈을 등록
  • 여기서는 local이라는 이름의 프로필이 사용되는 경우에만 testDataInit 이라는 스프링 빈을 등록

프로필

스프링은 로딩 시점에 application.properties의 spring.profiles.active 속성을 읽어서 프로필을 사용

이 프로필은 로컬 (내 PC), 운영환경, 테스트 실행 등 다양한 환경에 따라 다른 설정을 할 때 사용하는 정보 프로필을 사용함으로써 현재 환경에 따른 설정을 할 수 있다!

main 프로필

/src/main/resource 하위의 application.properties

spring.properties.active=local

• 이 위치의 application.properties 는 /src/main 하위의 자바 객체를 실행할 때 (주로 main() ) 동작하는 스프링 설정
  

test 프로필

/src/test/resources 하위의 application.properties

spring.profiles.active=test

• 이 위치의 application.properties는 /src/test 하위의 자바 객체를 실행할 때 동작하는 스프링 설정
• 주로 테스트 케이스를 실행할 때 동작
• 이 경우 local로 설정한 datainit는 빈에 등록되지 않는다.

✔️ 권장하는 식별자 선택 전략

데이터 베이스 기본 키는 다음 3가지 조건을 모두 만족해야 한다.

1. null 값은 허용 x
2. 유일해야 함
3. 변해선 안 됨

테이블의 기본 키를 선택하는 전략 2가지

• 자연 키 (natural key)

  • 비지니스에 의미가 있는 키
  • ex) 주민등록번호, 이메일, 전화번호

• 대리 키 (surrogate key)

  • 비지니스와 관련 없는 임의로 만들어진 키, 대체 키로도 불린다.
  • ex) 오라클 시퀀스, auto_increment, identity, 키생성 테이블 사용
  
  

자연키 보다는 대리 키를 권장

이메일, 전화번호 등은 언제든 바뀔 수 있고 주민등록번호는 3가지 조건이 다 만족해보이는 것처럼 보이지만 현실과 비지니스 규칙은 생각보다 쉽게 변하며 주민등록 조차도 여러가지 이유로 변경될 수 있다.

비지니스 환경은 언젠가 변한다.

🔖 학습내용 출처

스프링 DB 2편 - 데이터 접근 활용 기술

람다식은 메서드로 전달할 수 있는 익명 함수를 단순화한 코드 블록 () -> {} () : 파라미터 -> : 화살표 {} : 실행문

• 람다식은 함수 자체를 전달 인자로 보내거나 변수에 저장하는 것이 가능

• 람다식에서 타입이 예측가능하다면 생략 가능

• 특정 람다식을 사용하여 변수에 담는데 그 변수의 타입은 함수형 인터페이스 타입이다.

함수형 인터페이스 : 하나의 추상 메서드를 갖는 인터페이스 함수 디스크립터 : 함수형 인터페이스의 추상 메서드 시그니처 메소드 시그니쳐 : 메소드의 이름 + 메소드의 파라미터 + 파라미터의 수

더 있지만 자세한 건 강의 참조

기본형 특화의 경우 wrapper 클래스와 primitive 타입의 오토 언박싱을 문제없이 처리해주기 위해 특화된 것이다.

✔️ 함수형 인터페이스를 알아야 하는 이유

람다 표현식은 함수 자체를 전달 인자 or 변수 저장하는게 가능하다 하였는데

그렇다면 전달 인자나 변수의 타입이 정의되어야하기 때문이다. 그렇기에 함수형 인터페이스를 변수의 타입이나 전달 인자에 명시해주면 된다.

람다식이 가능한 Stream의 filter 매개변수를 확인해 보니 진짜로 함수형 인터페이스를 매개변수로 받고 있다.

〰️ Stream

컬렉션이나 배열 등 데이터를 처리하는 기술 중간 연산을 통해 가공된 스트림은 마지막으로 최종 연산을 통해 요소를 소모하여 결과를 출력 한 번 생성한 스트림은 사용 후 재사용 불가, 전체 데이터에 대한 처리가 이루어지면 종료 -> 다시 스트림을 생성해야 함

Collection의 Stream은 이미 데이터가 모여있는 형태의 스트림 객체 생성

Collection의 stream() 메서드는 default로 정의하고 있다. List, Set, Queue, (Map.value() -> map.value().stream()) 에서 사용가능

Array의 stream 은 Arrays.stream(arr[])로 사용

Stream 사용방법

1. Stream.builder

Stream.Builder<String> builder = Stream.builder();
builder.accept("123");
builder.accept("456");

List<Integer> collect = builder.build().map(Integer::parseInt).toList();
for (Integer i : collect) {
    System.out.println("i = " + i);
}

Stream 객체의 생성방식은 자체적으로 데이터 생성, 처리 가능 (많이 사용하지는 않는다.)

*2. 람다식 사용 *

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);


int[] array = list.stream().filter(x -> x < 3).mapToInt(x -> x).toArray();

for (int i : array) {
    System.out.println("i = " + i);
}

스트림 연산 처리

1. 스트림 객체 생성
2. 중간 연산
3. 최종 연산

중간 연산

중간 연산은 결과물이 Stream 이기에 반드시 최종 연산으로 결과를 반환해야한다.

최종 연산

중간 연산을 통해 가공된 스트림을 최종 연산을 통해 각 요소를 소모하여 결과를 출력

더 많이 있으니 찾아보자

Stream() 에서 sum을 사용하려면 숫자 연산 관련 자료형에 mapToInt등으로 스트림을 숫자 관련 자료형으로 Mapping 해주고 사용

mapToInt -> toArray() 가능, List 나 Collection 으로 사용 불가능 왜냐하면 int 형으로 mapping 되었기에 wrapper 클래스 타입을 받는 Collection을 사용할 수 없기 때문이다.

🟰 병렬 스트림

말 그대로 병렬로 처리한다. 2개의 스레드로 처리해서 속도가 높아지지만 중복 제거의 경우 문제가 생길 수 있음 -> eqauls() 사용

// List
list.parallelStream()

// Array
Arrays.stream(arr[]).parallel()

정렬

sorted()를 이용한 정렬 : 반드시 대상 객체들이 Comparable 인터페이스를 구현한 클래스 즉, 비교가 가능한 객체여야 한다.

혹은 sorted(Comparator.comparing(E))를 사용해서 정리

✔️ Mapping

스트림이 관리하는 데이터를 다른 형태의 데이터로 변환

map, mpaToInt(), mapToDouble() 등

🔖 학습 참조

유튜브 나무소리

멤버 전체조회 코드를 짜고 테스트했는데 IncorrectResultSetColumnCountException 예외가 터졌다 예외에서 코드 따라가보니

public List<Member> findAll() {
    String sql = "select  * from member";
    List<Member> members = template.queryForList(sql, Member.class);
    return members;
}

여기서 문제가 발생했다. queryForList 메서드를 추적해서 가져왔다

@Override
public <T> List<T> queryForList(String sql, Class<T> elementType) throws DataAccessException {
    return query(sql, getSingleColumnRowMapper(elementType));
}

즉 getSingleColumnRowMapper 한가지의 컬럼만 받아올 수 있다는 것이다. 내가 작성한 것은 모든 컬럼을 가져오는 것이었고 Member 테이블의 컬럼은 id, money 즉 2가지라서 actual 2가 뜬 것 같다.

결론

queryForList 를 사용하지 말고 query메서드로 RowMapper 람다식을 사용해서 조회하자

public List<Member> findAll() {
    String sql = "select  * from member";
    List<Member> members = template.query(sql, (rs, rowNum) -> {
        Member member = new Member();
        member.setMemberId(rs.getString("member_id"));
        member.setMoney(rs.getInt("money"));
        return member;
    });
    return members;
}

queryForObject(String sql, RowMapper<T> , @Nullable Object... args)

queryForObject 메서드는 여러가지가 있는데 그중 스프링 DB에서 썼던 것을 살펴보자

@Override
@Nullable
public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws DataAccessException 

sql : sql 문 RowMapper<T> : ResultSet 데이터를 매핑하는데 사용 arg : sql 파라미터

rs = pstmt.executeQuery() DB에서 조회한 값은 ResultSet 타입으로 반환된다. 이때 객체로 반환받고 싶다면 RowMapper를 사용하면 된다.

단일 데이터 조회시 사용한다.

RowMapper

@FunctionalInterface
public interface RowMapper<T> {

    @Nullable
    T mapRow(ResultSet rs, int rowNum) throws SQLException;

}

인터페이스를 구현해서 사용한다면 mapRow 메서드를 override 해서 사용

@Override
public Member mapRow(ResultSet rs, int rowNum) throws SQLException {
    Member member = new Member();
    member.setMemberId(rs.getString("member_id"));
    member.setMoney(rs.getInt("money"));
    return member;
}

람다식으로 적용

public Member findById(String memberId) {
    String sql = "select  * from member where member_id = ?";
    return template.queryForObject(sql, memberRowMapper(), memberId);
}


private RowMapper<Member> memberRowMapper() {
    return (rs, rowNum) -> {
        Member member = new Member();
        member.setMemberId(rs.getString("member_id"));
        member.setMoney(rs.getInt("money"));
        return member;
    };
}

구현해서 사용할려면 ResultSet이 필요하다. 그러면 커넥터, PreparedStatement 등이 필요하고 직접 코드로 짜줘야하기에 JdbcTemplate로 간단하게 할 수 있는 람다식이 더 편한 것 같다.

멤버 전체 조회

public List<Member> findAll() {
    String sql = "select  * from member";

    List<Member> members = template.query(sql, (rs, rowNum) -> {
        Member member = new Member();
        member.setMemberId(rs.getString("member_id"));
        member.setMoney(rs.getInt("money"));
        return member;
    });
     return members;
}

test

package hello.jdbc.repository;

import hello.jdbc.domain.Member;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

@Slf4j
@SpringBootTest
public class MemberRepositoryfindAllTest {


    private final MemberRepositoryV5 repository;

    @Autowired
    public MemberRepositoryfindAllTest(MemberRepositoryV5 repository) {
        this.repository = repository;
    }


    @TestConfiguration
    static class TestConfig {

        private final DataSource dataSource;

        public TestConfig(DataSource dataSource) {
            this.dataSource = dataSource;
        }

        @Bean
        MemberRepositoryV5 memberRepository() {
            return new MemberRepositoryV5(dataSource);
        }


    }

    @Test
    void findAllMember() {
        repository.save(new Member("하나요", 11111));
        repository.save(new Member("둘이요", 22222));

        log.info("list={}", repository.findAll());

        repository.delete("하나요");
        repository.delete("둘이요");
    }
}

결과

🔖 참고내용 출처

스프링 DB 1편 - 데이터 접근 핵심 원리