radderveloper

#33 기능개발

RadderNepa — Fri, 5 Apr 2024 01:49:44 +0900

import java.util.Queue;
import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        Queue<Double> queue = new LinkedList<>();
        for(int i = 0; i < progresses.length; i++) {
            int tmp = (100 - progresses[i]) / speeds[i];
            if(((100 - progresses[i]) % speeds[i]) == 0) {
                queue.add((double) tmp);    
            } else {
                queue.add(tmp + 0.1);    
            } 
        }
        
        List<Integer> list = new ArrayList<>();
        
        int deploy = 0;
        while(!queue.isEmpty()) {
            double front = queue.poll();
            deploy++; // 처음 무조건 하나는 배포
            
            while(queue.size() > 0 && front >= queue.peek()) {
                queue.poll();
                deploy++;
            }
            
            list.add(deploy);
            deploy = 0;
        }

        int[] answer = new int[list.size()];
        for(int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i);
        }
        return answer;
    }
}
// 100 - 90 = 10 / 10 = 1
// 100 - 90 = 10 / 9  = 1.111111111111111...

// 100 - 93 = 7  / 1  = 7;
// 100 - 30 = 70 / 30 = 2.3333...
// 100 - 55 = 45 / 5  = 9;

// 100 - 95 = 5
// 100 - 90 = 10
// 100 - 99 = 1
// 100 - 99 = 1
// 100 - 80 = 20
// 100 - 99 = 1

#32 카펫(완전탐색)

RadderNepa — Wed, 13 Mar 2024 01:20:26 +0900

[문제]

출처 : https://school.programmers.co.kr

[해답]

class Solution {
    public int[] solution(int brown, int yellow) {
        int[] answer = new int[2];

        // 제곱근 판별
        double squareRoot = Math.sqrt(yellow); // 제곱근
        double flootRoot = Math.floor(squareRoot); // 소수점 제거
        
        if(squareRoot == flootRoot) { // 노란색 격자 모음이 정사각형 모양
            answer[0] = ((int) flootRoot) + 2;
            answer[1] = answer[0];
        } else { // 노란색 격자 모음이 직사각형 모양
            for(int i = 1; i <= yellow; i++) {  // i    = 직사각형의 가로 칸 개수
                int sero = yellow / i;          // sero = 직사각형의 세로 칸 개수
                
                // 직사각형 가로 변의 길이를 가로 칸 개수로 나누었을 때 나머지가 없다.(그래야 정사각형 모양이 된다.)
                // &&
                // 카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.(문제 조건)
                if(yellow % i == 0 && i >= sero) {
                    int brown_garo = (i + 2) * 2;
                    int brown_sero = sero * 2;
                    if((brown_garo + brown_sero) == brown) {
                        answer[0] = (i + 2);
                        answer[1] = sero + 2;
                        break;
                    }
                }
            }
        }
        return answer; // 카펫의 [가로, 세로] 크기를 순서대로 배열에 담아 return                                            
    }
}
// 중앙에는 노란색으로 칠해져 있고 '테두리 1줄'은 갈색으로 칠해져 있는 격자 모양 카펫
// 카펫의 노란색과 갈색으로 색칠된 격자의 개수는 기억 but 전체 카펫의 '크기'는 기억하지 못했습니다.
// 카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.
// (가로 길이 = 세로 길이) or (가로 길이 > 세로 길이)

[문제 해결 흐름]
0. yellow 타일의 모양을 먼저 구하고, 이를 기반으로 brown 타일의 모양을 구하자

1. CASE를 나눴다.(brown 타일의 갯수를 세는 방법이 다를 것 같다고 예상되어 case를 나눴다.)
CASE1) 중앙에 모이는 노란색 격자가 정사각형인 경우
CASE2) 중앙에 모이는 노란색 격자가 정사각형이 아닌 경우(=직사각형)
CASE3) 정사각형도, 직사각형도 아닌 경우 → "설마 이런 모양으로 문제를 내겠어" 라는 생각으로 머리속에서 case 분류만 했지 별도의 로직을 세우지는 않았다.(문제에서 "이런 모양도 있을 수 있다 or 이런 모양은 없다" 처럼 조금 더 자세하게 설명해주면 좋았을 것 같다.)

2. CASE1, CASE2에서 정사각형 or 직사각형 여부를 판단하기 위해 아래의 코드를 이용했다.
double squareRoot = Math.sqrt(yellow); // 제곱근
double flootRoot = Math.floor(squareRoot); // 소수점 제거
if(squareRoot == flootRoot) {......}

2-1. 노란색 격자가 정사각형인 경우
=> 그것을 둘러싸는 brown 타일의 가로, 세로 길이는 모두 (노란색 정사각형 한 변의 길이 + 2)
=> brown 타일의 가로, 세로 길이 = 카펫의 [가로, 세로] 크기

3. 노란색 격자가 정사각형이 아닌 경우(=직사각형)
=> 우선 노란색 타일이 어떠한 모양으로 있는지를 알아내는 것이 관건이었다.
=> 여기서는 문제의 전제 조건인 [카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.]를 이용했다.

for(int i = 1; i <= yellow; i++) {  // i    = 직사각형의 가로 칸 개수
    int sero = yellow / i;          // sero = 직사각형의 세로 칸 개수

    // 직사각형 가로 변의 길이를 가로 칸 개수로 나누었을 때 나머지가 없다.(그래야 정사각형 모양이 된다.)
    // &&
    // 카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.(문제 조건)
    if(yellow % i == 0 && i >= sero) {
    
 => (i >= sero) : 해당 조건을 이용해 우선 노란색 타일의 모양을 구했다.
 
 4.
 - (겹치는 부분 제외) brwon 타일의 가로 길이 = 노란색 타일의 가로 길이 + 2
 - (겹치는 부분 제외) brwon 타일의 세로 길이 = 노란색 타일의 세로 길이
 - 위와 같기에 [{(노란색 타일의 가로 길이 + 2) * 2} + (노란색 타일의 세로 길이) * 2] = 인자로 주어진 brwon 타일 개수
int brown_garo = (i + 2) * 2;
int brown_sero = sero * 2;
if((brown_garo + brown_sero) == brown) {
    answer[0] = (i + 2);
    answer[1] = sero + 2;
    break;
}

#31 모의고사(완전탐색)

RadderNepa — Tue, 12 Mar 2024 00:29:40 +0900

* 이런, 완전탐색을 이진탐색(Binary Search)으로 착각한 상태에서 이번 문제를 풀어버렸다.(정확히는 해답을 보기전까지 그렇게 생각하고 있었다.)

* 도대체 언제부터... 이진탐색을 사용중이라고 착각한 거지?

[문제]

- 완전탐색의 설명 자체가 아래와 같이 간단명료하게 나와있다.

출처 : https://school.programmers.co.kr

[해답]

- 3명의 수포자가 각각 답을 몇 개 맞추었는지를 밝혀내는 것은 어렵지 않았다.

[내가 문제를 풀지 못 한 원인]
1) return 하는 answer 값을 어떻게 만들어야할지 도저히 감이 잡히지가 않았던 것이다.
2) 1번의 연장선으로서 문제를 똑바로 안 읽었다.
- 문제는 분명히 "가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return" 라고 말했다.
- 이것을 제대로 이해를 못해 "전체 수포자를 문제를 많이 맞힌 순서대로 담아서 return" 이라고 이해했다.
- 사실 윗 말을 이해했어도 그걸 구현했을지는 의문이지만 어쨌든 문제를 똑바로 안 읽고 냅다 코드부터 친 것이 화근이었다. 그야말로 기본기 부족에서 비롯된 문제였다.

// 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.
// 1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, (이후 반복됨) 1, 2, 3, 4, 5, ...
// 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, (이후 반복됨) 2, 1, 2, 3, 2, 4, 2, 5, ...
// 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, (이후 반복됨) 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(int[] answers) {       
        int[] first = {1, 2, 3, 4, 5};
        int[] two   = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] three = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        
        int firstLeng = 0; int twoLeng = 0; int threeLeng = 0;      
        int firstCnt = 0; int twoCnt = 0; int threeCnt = 0;
        
        for(int i = 0; i < answers.length; i++) {
            int tmp = answers[i];
            
            if(tmp == first[firstLeng]) firstCnt++;
            if(tmp == two[twoLeng]) twoCnt++;
            if(tmp == three[threeLeng]) threeCnt++;
            
            firstLeng++; twoLeng++; threeLeng++;

            if(firstLeng == first.length) firstLeng = 0;
            if(twoLeng == two.length) twoLeng = 0;
            if(threeLeng == three.length) threeLeng = 0;
        }
        
        List<Integer> list = new ArrayList<>();
        int max = Math.max(firstCnt, Math.max(twoCnt, threeCnt)); // 3개 중 가장 큰 수 찾기
        // 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬
        if(max == firstCnt) list.add(1); 
        if(max == twoCnt) list.add(2);
        if(max == threeCnt) list.add(3);
        
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

- 코드가 지저분하다고 느껴질 뿐 아래까지 구현하는 것은 어렵지 않았다.

int[] first = {1, 2, 3, 4, 5};
int[] two   = {2, 1, 2, 3, 2, 4, 2, 5};
int[] three = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

int firstLeng = 0; int twoLeng = 0; int threeLeng = 0;      
int firstCnt = 0; int twoCnt = 0; int threeCnt = 0;

for(int i = 0; i < answers.length; i++) {
    int tmp = answers[i];

    if(tmp == first[firstLeng]) firstCnt++;
    if(tmp == two[twoLeng]) twoCnt++;
    if(tmp == three[threeLeng]) threeCnt++;

    firstLeng++; twoLeng++; threeLeng++;

    if(firstLeng == first.length) firstLeng = 0;
    if(twoLeng == two.length) twoLeng = 0;
    if(threeLeng == three.length) threeLeng = 0;
}

- 아래 부분을 구현하지 못 했다.

List<Integer> list = new ArrayList<>();
int max = Math.max(firstCnt, Math.max(twoCnt, threeCnt)); // 3개 중 가장 큰 수 찾기
// 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬
if(max == firstCnt) list.add(1); 
if(max == twoCnt) list.add(2);
if(max == threeCnt) list.add(3);

return list.stream().mapToInt(Integer::intValue).toArray();

#30 폰켓몬

RadderNepa — Thu, 7 Mar 2024 00:39:12 +0900

[문제]

출처 : https://school.programmers.co.kr

[해답]

import java.util.*;

class Solution {
    public int solution(int[] nums) {
        // 1.
        // 반복문을 돌면서 폰켓몬 번호대로 map에 넣는다. ==> map.put(폰켓몬 번호, 폰켓몬 번호);
        // 풀이의 키포인트는 key의 개수이기에 value는 중요하지 않다.
        
        // 2.
        // 반복문이 끝난 후 keySet 메소드를 이용해 key의 개수를 알아낸다.(key의 개수 = 폰켓몬의 종류 개수)
        
        // 3.
        // 가져갈 수 있는 폰켓몬 마릿수 = nums.length / 2
        
        // 3.
        // 경우의 수는 총 3가지
        // 1. 폰켓몬의 종류 개수 > 가져갈 수 있는 폰켓몬 마릿수 ==> 가져갈 수 있는 폰켓몬 마릿수
        // 2. 폰켓몬의 종류 개수 < 가져갈 수 있는 폰켓몬 마릿수 ==> 폰켓몬의 종류 개수
        // 3. 폰켓몬의 종류 개수 = 가져갈 수 있는 폰켓몬 마릿수 ==> 둘 중 아무거나 해도 상관 없음
        
        Map<Integer, Integer> map = new HashMap<>();
        for(int num : nums) {
            map.put(num, num);
        }
        
        int answer = 0;                     // return 값
        int monster = map.keySet().size();  // 폰켓몬의 종류 개수
        int take = nums.length / 2;         // 가져갈 수 있는 폰켓몬 마릿수
        
        // if(monster > take) {
        //     answer = take;
        // } else if(monster <= take) {
        //     answer = monster;
        // }
        // return answer;
        
        // 결국은 최소값을 찾는거라 아래처럼 간단하게 return 해도 됨
        return Math.min(monster, take);
    }
}

#29 올바른 괄호

RadderNepa — Mon, 4 Mar 2024 23:28:23 +0900

[문제]

- 아직 안 풀었는데 나만의 우스꽝스러운 생각을 기억에서 지우기 싫어 먼저 글을 저질러버렸다.

출처 : https://school.programmers.co.kr

- 문제 조건 자체가 Stack 혹은 Queue를 이용해 풀라고 했다.

- 근데 오늘 길을 걷다 청개구리를 닮은 돌멩이를 봐서 그런지 이상하게 그렇게 풀기가 싫었다.

- 그래서 아래와 같이 변화구를 던져봤다. 개굴

class Solution {
    boolean solution(String s) {
        boolean answer = true;
        
        // 1. 처음이 ')' or 끝이 '(' 로 끝나면 false 처리
        // 이 경우 배열로 자르고 Stack을 이용하고 자시고 할 필요 없음(리소스 줄이자)
        if(s.charAt(0) == ')' || s.charAt(s.length() - 1) == '(') {
            return false;
        }
        
        // 2. "()()" 같이 이쁜(?) 모양일 경우에도 간단하게 replace 사용
        String afterReplace = s.replace("()", "");
        if(afterReplace.length() == 0) {
            return true;
        }
        
        String[] tmp = afterReplace.split("");
        int left = 0; int right = 0;
        for(String str : tmp) {
            if("(".equals(str)) {
                left += 1;
            } else if(")".equals(str)) {
                right += 1;
            }
        }
        
        if(left == right) {
            return true;
        } else {
            return false;
        }
    }
}

- 근데 역시나 문제는 풀리지 않았다. 근데 또 놀라운건, 대부분의 문제를 통과했다는 것이다.

정확성 테스트에 한 번 더 놀라 자빠졌다.

[24.03.06]

- 무친,;; 아래와 같이 하니까 결국 풀림

class Solution {
    boolean solution(String s) {
        boolean answer = true;
        
        // 1. 처음이 ')' or 끝이 '(' 로 끝나면 false 처리
        // 이 경우 배열로 자르고 Stack을 이용하고 그럴 필요가 없다.(리소스 줄이자)
        if(s.charAt(0) == ')' || s.charAt(s.length() - 1) == '(') {
            return false;
        }
        
        // 2. "()()" 같이 정갈한(?) 모양일 경우에도 간단하게 replace 사용
        String afterReplace = s.replace("()", "");
        if(afterReplace.length() == 0) {
            return true;
        } else {
            // ()))))((((() 같은 경우를 가정하고 한 번더 1번 방법을 사용
            if(afterReplace.charAt(0) == ')' || afterReplace.charAt(afterReplace.length() - 1) == '(') {
                return false;
            }   
        }
        
        String[] tmp = afterReplace.split("");
        int left = 0; int right = 0;
        for(String str : tmp) {
            if("(".equals(str)) {
                left += 1;
            } else if(")".equals(str)) {
                right += 1;
            }
        }
        
        if(left == right) {
            return true;
        } else {
            return false;
        }
    }
}

[해답] - 정상적으로 문제 해결 시 업로드 예정

[24.03.06] 정상적으로 풀어봄

- 아래의 글의 정리 부분을 먼저 참고하자

2023.02.02 - [CS/자료구조 및 알고리즘] - #6 Stack(스택) - 개념(FILO : First In Last Out)

#6 Stack(스택) - 개념(FILO : First In Last Out)

● Stack이란? - Stack은 단순한 규칙을 가지고 있는 리스트이다. 여기서 규칙은 FILO(First In Last Out)이다. - FILO(First In Last Out) : 먼저 들어간 데이터가 나중에 나오는 규칙 ex) 10명의 사람이 모두 1층에

radderveloper.tistory.com

import java.util.*;

class Solution {
    boolean solution(String s) {
        boolean answer = true;
        
        // 1. 처음이 ')' or 끝이 '(' 로 끝나면 false 처리
        if(s.charAt(0) == ')' || s.charAt(s.length() - 1) == '(') {
            return false;
        }
        
        // 2. "()()" 같이 정갈한(?) 모양일 경우에도 간단하게 replace 사용
        String s_replace = s.replace("()", "");
        if(s_replace.length() == 0) {
            return true;
        }
        
        // 3. 다시 한 번 1번 방법 사용
        if(s_replace.charAt(0) == ')' || s_replace.charAt(s_replace.length() - 1) == '(') {
            return false;
        }

        // 4. Stack 사용
        // 1단계, "(" 만나면 stack에 넣는다. ==> push()
        // 2단계, ")" 만나면 stack에서 가장 최근에 들어온 "("를 꺼내서 지운다. ==> pop()
        // 3단계, 반복문을 다 돌고난 후 stack이 비어있으면 true 아니면 false 반환
        String[] arr = s_replace.split("");
        Stack<String> stack = new Stack<>();
        for(String str : arr) {
            if(")".equals(str) && stack.empty()) {
                return false;
            } else if("(".equals(str)) {
                stack.push(str);    
            } else {
                stack.pop(); // Stack 맨 위 요소 제거
            }
        }       
        
        if(stack.empty()) {
            return true;
        }
        return false;
    }
}

- 위의 코드에서 1~3번 방법은 4번의 stack 방법까지 오기 전에 미리 필터링할 만한 것은 다 걸러줘서 불필요하게 들어가는 리소스를 줄이기 위해 그대로 가져왔다.

- 그리고 무엇보다 1~3번 방법을 주석 처리하고 Stack 방법만 이용하면 아래 같은 사태가 발생한다.

풀이 로직은 맞는데 시간이 많이 들어가서 틀림 처리 되는 것 같다.

#28 같은 숫자는 싫어 with Stack

RadderNepa — Mon, 26 Feb 2024 00:28:16 +0900

[문제]

출처 : https://school.programmers.co.kr

[해답]

- 문제 조건 자체가 Stack 혹은 Queue를 이용해 풀라고 했기에 Stack을 이용해 풀었다.

import java.util.*;
import java.util.stream.*;

public class Solution {
    public int[] solution(int []arr) {
        Stack<Integer> stack = new Stack<>();
        
        // 제네릭에는 원시형 타입이 들어가지 않기에 Integer List로 변환
        List<Integer> arrInteger = Arrays.stream(arr).boxed().collect(Collectors.toList());
        
        for(Integer num : arrInteger) {
            if(stack.empty() || (stack.peek() != num)) { // stack이 비어 있을 때도 체크해줘야 함
                stack.push(num);
            }
        }
        
        // Stream을 이용해 Stack을 int Array로 변환
        int[] answer = stack.stream().mapToInt(Integer::intValue).toArray();

        return answer;
    }
}

- 통과는 했는데 아마 Stream을 2번 사용해서 효율은 그닥 좋지 않은 것 같다.

- 이렇게 더 간략(?)하게 풀 수도 있었다.(일주일 지났는데 우연히 생각나서 다시 한 번 풀어봄)

- 위 풀이와 비교했을 때 arrInteger List를 굳이 만들 필요가 없었다.

import java.util.*;
import java.util.stream.*;

public class Solution {
    public int[] solution(int []arr) {        
        Stack<Integer> stack = new Stack<>();

        for(int num : arr) {
            if(stack.empty() || !(stack.peek().intValue() == num)) { // Integer 주소 말고 숫자값 그 자체를 비교
                stack.push(Integer.valueOf(num));
            }
        }
        
        int[] answer = stack.stream().mapToInt(Integer::intValue).toArray();
        return answer;
    }
}

cf)

- 아래와 같은 식으로 반복문만을 이용해서 풀수도 있긴 한데... 문제 전제가 그것이 아니었기에 일부러 사용하지 않았다.

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        ArrayList<Integer> tempList = new ArrayList<Integer>();
        int preNum = 10;
        for(int num : arr) {
            if(preNum != num) {
                tempList.add(num);
            }
            preNum = num;
        }       
        int[] answer = new int[tempList.size()];
        for(int i=0; i<answer.length; i++) {
            answer[i] = tempList.get(i).intValue();
        }
        return answer;
    }
}

#1 인터넷 네트워크 - 인터넷 통신 & IP

RadderNepa — Fri, 23 Feb 2024 00:04:29 +0900

● 인터넷 통신

- 클라이언트는 한국에 있고 서버는 미국에 있다고 해보자
- 이때 (클라이언트 컴퓨터 - 서버 컴퓨터)를 이어주는 것이 인터넷이다.
- Web, HTTP 모두 인터넷 네트워크 망에 기반해서 동작한다.

- (한국 → 미국)으로 텍스트 메세지를 보낸다고 했을 때 인터넷 망을 통해서 데이터를 보내야 한다.

- 이때 송신되는 데이터는 수 많은 중간 노드(서버)들을 거쳐서 안전하게 전달돼야 한다.

ex) 해저 케이블을 거치고, 인공위성을 거치는 등

인프런 - 모든 개발자를 위한 HTTP 웹 기본 지식(김영한)

그렇다면 과연 어떤 규칙으로 어떻게 넘어가는 것일까?

● IP(Internet Protocol)

- 이것을 알기 위해 가장 먼저 알아야 하는 지식이 바로 IP(Internet Protocol) 이다.

[IP의 역할]
1. 지정한 IP 주소(IP Address)에 데이터 전달
2. 패킷(Packet)이라는 통신 단위로 데이터 전달

[IP의 한계]
1. 비연결성
- 패킷을 받을 대상이 없거나 서비스 or 통신 불능 상태여도 패킷 전송

2. 비신뢰성
- 중간에 패킷이 사라지면?
- 복수의 패킷을 보냈을 때 그것들이 순서대로 안오면?(패킷이 순서대로 안 오면?)

3. 프로그램 구분
- 같은 IP를 사용하는 서버에서 통신하는 애플리케이션이 둘 이상이라면?

#30 반납 기능

RadderNepa — Mon, 9 Oct 2023 18:31:14 +0900

[요구 사항]
- 사용자가 책을 반납할 수 있다.

[API 스펙]
- HTTP Method : PUT
- HTTP Path : /book/return
- HTTP Body(JSON) : {
"userName" : String,
"bookName" : String
}
- 결과 반환 X, HTTP Code 200이면 OK

- 대출(/book/loan)과 반납(/book/return)을 위한 HTTP Body(DTO)가 완전히 동일하다.

- 이때 반납을 위한 DTO를 새로 만드는게 좋을까? or 재활용하는게 좋을까?

cf) 대출을 위한 DTO(BookLoanRequest)는 이전 글에서 이미 만들어져 있는 상태

인프런 - 자바와 스프링 부트로 생애 최초 서버 만들기, 누구나 쉽게 개발부터 배포까지!(최태현)

- 이 경우 강사는 (개인적으로) 새로 만드는 것을 선호한다.

- why? 나중에 대출과 반납 중 한 기능에 변화가 생겼을 때 유연하게 대처할 수 있기 때문이다.

1. 반납을 위한 Table은 따로 만들 필요 없다.(user_loan_history table 그대로 사용)

2. BookRetuenRequest(DTO)

package com.group.libraryapp.dto.book.request;

public class BookRetuenRequest {
    private String bookName;
    private String userName;

    public String getBookName() {
        return bookName;
    }

    public String getUserName() {
        return userName;
    }
}

3. Controller, Service

Controller

@RestController
public class BookController {

    private final BookService bookService;

    @PutMapping("/book/return")
    public void returnBook(@RequestBody BookRetuenRequest request) {
        bookService.returnBook(request);
    }
}

Service

@Service
public class BookService {
    private final BookRepository bookRepository;
    private final UserLoanHistoryRepository userLoanHistoryRepository;
    private final UserRepository userRepository;

    // 생성자를 만들어 Spring bean을 주입받는다.
    public BookService(BookRepository bookRepository,
                       UserLoanHistoryRepository userLoanHistoryRepository,
                       UserRepository userRepository
    ) {
        this.bookRepository = bookRepository;
        this.userLoanHistoryRepository = userLoanHistoryRepository;
        this.userRepository = userRepository;
    }

    @Transactional
    public void returnBook(BookRetuenRequest request) {
        // 1. User table에서 User 정보를 가져온다.
        User user = userRepository.findByName(request.getUserName())
                .orElseThrow(IllegalArgumentException::new);

        // 2. 유저의 ID와 책 이름을 이용해 대출 기록을 가져온다.
        UserLoanHistory userLoanHistory = userLoanHistoryRepository
                .findByUserIdAndBookName(user.getId(), request.getBookName())
                .orElseThrow(IllegalArgumentException::new);
        
        // 3. 반납 처리
        userLoanHistory.doReturn();

        // 4. user_loan_history 테이블의 IS_RETURN 컬럼 업데이트
        // 영속성 컨텍스트의 '변경 감지' 기능으로 인해 별도의 코드나 쿼리를 작성할 필요가 없다.(그래서 아래 코드 주석 처리)
        // by @Transactional Annotation
        // userLoanHistoryRepository.save(userLoanHistory);
    }
}

- UserLoanHistory에 doReturn method 추가

package com.group.libraryapp.domain.user.loanhistory;

import javax.persistence.*;

@Entity
public class UserLoanHistory {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id = null;

    @Column(nullable = false, name = "user_id")
    private long userId;

    @Column(nullable = false, name = "book_name")
    private String bookName;

    @Column(nullable = false, name = "is_return")
    // is_return 컬럼은 자료형이 tinyint이기 때문에 DB에 0(false) 혹은 1(true)이 들어가도 된다.
    // == boolean으로 처리해도 tinyint에 잘 매핑된다.
    private boolean isReturn;

    protected UserLoanHistory() {}

    public UserLoanHistory(long userId, String bookName, boolean isReturn) {
        this.userId = userId;
        this.bookName = bookName;
        this.isReturn = isReturn;
    }

    public boolean getIsReturn() {
        return isReturn;
    }

    // 반납 처리
    public void doReturn() {
        this.isReturn = true;
    }
}

cf) userLoanHistoryRepository.save(userLoanHistory)를 주석 처리한 이유

2023.09.28 - [Spring] - #27 영속성 컨텍스트

#27 영속성 컨텍스트

- Service 계층의 주요 역할 중 하나가 트랜잭션을 관리하는 것이다. @Transactional - Spring에서 트랜잭션을 적용하는 방법 - 메소드에 @Transactional Annotation이 붙으면 메소드가 시작될 때 트랜잭션을 시

radderveloper.tistory.com

● 테스트

- user_loan_history table 현재 상황(0 = 대출 중 / 1 = 반납 완료) / user table 현재 상황

user_loan_history table / user table

[현재 대출 상황]
손승완 - 주먹을 단련하는 법
배주현 - 하체를 단련하는 법

반납 완료

#29 대출 기능 API

RadderNepa — Sat, 7 Oct 2023 19:31:02 +0900

[요구사항]
- 사용자가 책을 빌릴 수 있다.
- 다른 사람이 빌린 책은 또 다른 사람이 빌릴 수 없다.

[API 스펙]
- HTTP Method : POST
- HTTP Path : /book/loan
- HTTP Body(JSON) : {
"userName" : String,
"bookName" : String
}
- 결과 반환 X, HTTP Code 200이면 OK

1. Book Table

- 사용자의 대출 기록을 저장하는 새로운 테이블이 필요하다.

CREATE TABLE USER_LOAN_HISTORY (
  ID        BIGINT AUTO_INCREMENT, // 대출 기록 id
  USER_ID   BIGINT,                // 책을 빌린 유저 id
  BOOK_NAME VARCHAR(255),          // 빌린 책 이름
  IS_RETURN TINYINT(1),            // 현재 대출(0) or 반납(1) 여부
  PRIMARY KEY(ID)
);

cf) user table의 id 값을 다시 1부터 시작하기 위해 AUTO_INCREMENT 값을 초기화했다.

https://amaze9001.tistory.com/28

[mySQL] AUTO_INCREMENT 값 초기화

오늘은 mySQL AUTO_INCREMENT 값을 초기화 하는 방법을 소개하려고 합니다.아래는 [heidiSQL] 화면인데요,선택할 수 있는 기본값의 종류입니다. 그 중, 맨 아래에 있는 아이가 오늘 소개할 AUTO_INCREMENT 에

amaze9001.tistory.com

ID 값 새로 1 부터 시작 됨

2. UserLoanHistory 객체 & UserLoanHistoryRepository

UserLoanHistory

package com.group.libraryapp.domain.user.loanhistory;

import javax.persistence.*;

@Entity
public class UserLoanHistory {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id = null;

    @Column(nullable = false, name = "user_id")
    private long userId;

    @Column(nullable = false, name = "book_name")
    private String bookName;

    @Column(nullable = false, name = "is_return")
    // is_return 컬럼은 자료형이 tinyint이기 때문에 DB에 0(false) 혹은 1(true)이 들어가도 된다.
    // == boolean으로 처리해도 tinyint에 잘 매핑된다.
    private boolean isReturn;

    protected UserLoanHistory() {}

    public UserLoanHistory(long userId, String bookName, boolean isReturn) {
        this.userId = userId;
        this.bookName = bookName;
        this.isReturn = isReturn;
    }
}

UserLoanHistoryRepository

package com.group.libraryapp.domain.user.loanhistory;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserLoanHistoryRepository extends JpaRepository<UserLoanHistory, Long> {

}

cf) 현재 package 구조

3. DTO, Controller, Service

DTO

- DTO는 HTTP Body 스펙을 보고 그에 맞게 생성하면 된다.

package com.group.libraryapp.dto.book.request;

public class BookLoanRequest {
    private String bookName;
    private String userName;

    public String getBookName() {
        return bookName;
    }

    public String getUserName() {
        return userName;
    }
}

Controller(loanBook method 추가)

package com.group.libraryapp.controller.book;

import com.group.libraryapp.dto.book.request.BookCreateRequest;
import com.group.libraryapp.dto.book.request.BookLoanRequest;
import com.group.libraryapp.service.book.BookService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BookController {

    private final BookService bookService;

    // 생성자를 만들어 Spring bean을 주입받는다.
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @PostMapping("/book")
    public void saveBook(@RequestBody BookCreateRequest request) {
        bookService.saveBook(request);
    }

    @PostMapping("/book/loan")
    // HTTP body를 파싱하기 위해 @RequestBody가 필요하다.
    public void loanBook(@RequestBody BookLoanRequest request) {
        bookService.loanBook(request);
    }
}

Service(loanBook method 추가)

[By 앞에 들어갈 수 있는 구절]
- find : 1건을 가져온다. 반환 타입은 객체가 될 수도 있고 Optional<타입>이 될 수도 있다.
- findAll : 쿼리의 결과물이 N개인 경우 사용, List<타입> 반환
- exists : 쿼리 결과가 존재하는지 확인, 반환 타입은 boolean(존재 O = true / 존재 X = false)
- count : SQL의 결과 개수를 센다. 반환 타입은 long ex) long countByAge(Integer age);

package com.group.libraryapp.service.book;

import com.group.libraryapp.domain.book.Book;
import com.group.libraryapp.domain.book.BookRepository;
import com.group.libraryapp.domain.user.User;
import com.group.libraryapp.domain.user.UserRepository;
import com.group.libraryapp.domain.user.loanhistory.UserLoanHistory;
import com.group.libraryapp.domain.user.loanhistory.UserLoanHistoryRepository;
import com.group.libraryapp.dto.book.request.BookCreateRequest;
import com.group.libraryapp.dto.book.request.BookLoanRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    private final BookRepository bookRepository;
    private final UserLoanHistoryRepository userLoanHistoryRepository;
    private final UserRepository userRepository;

    // 생성자를 만들어 Spring bean을 주입받는다.
    public BookService(BookRepository bookRepository,
                       UserLoanHistoryRepository userLoanHistoryRepository,
                       UserRepository userRepository
    ) {
        this.bookRepository = bookRepository;
        this.userLoanHistoryRepository = userLoanHistoryRepository;
        this.userRepository = userRepository;
    }

    @Transactional
    public void saveBook(BookCreateRequest request) {
        bookRepository.save(new Book(request.getName()));
    }

    @Transactional
    public void loanBook(BookLoanRequest request) {
        // 1. Book table에서 책 정보를 가져온다.
        Book book = bookRepository.findByName(request.getBookName())
                .orElseThrow(IllegalArgumentException::new);

        // 2. 빌리려는 책이 현재 대출중인지 확인
        if(userLoanHistoryRepository.existsByBookNameAndIsReturn(book.getName(), false)) {
            // 대출 O
            throw new IllegalArgumentException("이미 대출중인 책 입니다.");
        } else {
            // 대출 X
            // 3. 사용자 정보를 가져온다.
            User user = userRepository.findByName(request.getUserName())
                    .orElseThrow(IllegalArgumentException::new);

            // 4. 사용자 정보 & 책 정보를 이용해 userLoanHistory 저장
            userLoanHistoryRepository.save(new UserLoanHistory(user.getId(), book.getName(), false));
        }
    }
}

package com.group.libraryapp.domain.user;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;
import java.util.Optional;

// JpaRepository를 상속하는 것만으로도 UserRepository는 Spring bean으로 등록된다.
public interface UserRepository extends JpaRepository<User, Long> {
    // name을 기준으로 조회
    // 데이터가 있으면 User 객체 반환, 없으면 null 반환
    Optional<User> findByName(String name);
    // 함수 이름이 중요하다.
    // 반드시 findByName 이라고 적어줘야한다. 함수 이름에 맞춰서 알아서 SQL이 생성돼 날라간다.
    // 'find'라고 작성하면 1개의 데이터만 가져온다.
    // 'By' 뒤에 붙는 필드 이름으로 SELECT 쿼리의 WHERE 문이 작성된다.
    // 결론 : findByName = SELECT * FROM USER WHERE NAME = ?;

    // Optional<User> findByName(String name);

    boolean existsByName(String name);

    long countByAge(Integer age);

    List<User> findAllByNameAndAge(String name, int age);

    List<User> findAllByAgeBetween(int startAge, int endAge);
}

package com.group.libraryapp.domain.book;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface BookRepository extends JpaRepository<Book, Long> {
    Optional<Book> findByName(String name);
}

package com.group.libraryapp.domain.user.loanhistory;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserLoanHistoryRepository extends JpaRepository<UserLoanHistory, Long> {
    // SELECT * FROM USER_LOAN_HISTORY WHERE BOOK_NAME = ? AND IS_RETURN = ?
    boolean existsByBookNameAndIsReturn(String bookName, boolean isReturn);
}

2023.09.26 - [Spring] - #26 JPA를 이용해 SQL 날리기 with Spring Data JPA2

#26 JPA를 이용해 SQL 날리기 with Spring Data JPA2

1. 삭제 1. name을 기준으로 User가 있는지 확인 2. User가 있다면 DELETE 쿼리를 날린다. // JpaRepository를 상속하는 것만으로도 UserRepository는 Spring bean으로 등록된다. public interface UserRepository extends JpaReposi

radderveloper.tistory.com

● 테스트

현재 user table과 book table

user table / book table

1. 정상 대출

2. 이미 빌린 책을 다른 사람이 빌리려고 할 때(못 빌림)

3. 없는 책을 빌리려고 할 때

4. 배주현 정상 대출

#28 책 생성 API - INSERT

RadderNepa — Mon, 2 Oct 2023 22:45:11 +0900

- 다음 글 부터는 먼저 코드를 작성한 다음에 강의를 들어보자

● 도서관에 책을 등록하는 기능

[API 스펙]
- HTTP Method : POST
- HTTP Path : /book
- HTTP Body(JSON) : {"name" : String // 책 이름} → name은 필수
- 결과 반환 X, HTTP Code 200이면 OK

- 이러한 구조로 만들어야 한다.

인프런 - 자바와 스프링 부트로 생애 최초 서버 만들기, 누구나 쉽게 개발부터 배포까지!(최태현)

1. Book Table

CREATE TABLE BOOK (
   ID     BIGINT       AUTO_INCREMENT,
   NAME   VARCHAR(255) NOT NULL,
   PRIMARY KEY(ID)
);

- VARCHAR(255)라고 설정한 이유

1. JPA를 사용할 때 @Column Annotation의 length 속성의 기본값이 255이다. → @Column Annotation에서 length 속성을 생략할려고 (255)로 설정한 것이다.

2. 문자열 필드의 경우 최적화를 해야 하는 CASE가 아니라면 조금 여유롭게 설정하는 것이 좋다.

2. Book 객체

package com.group.libraryapp.domain.book;

import javax.persistence.*;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id = null;

    @Column(nullable = false, name = "name")
    private String name;

    // JPA Entity는 기본 생성자가 하나 필요하다.
    protected Book() {}

    public Book(String name) {
        // name은 필수값이다.
        if(name == null || name.isBlank()) throw new IllegalArgumentException(String.format("잘못된 name(%s)이 들어왔습니다.", name));
        this.name = name;
    }
}

3. BookRepository

package com.group.libraryapp.domain.book;

import org.springframework.data.jpa.repository.JpaRepository;

public interface BookRepository extends JpaRepository<Book, Long> {

}

cf)

- 강의를 듣다보니 BookRepository와 UserRepository를 왜 하필 domain package 아래에 생성하는지 궁금했다. 그냥 Repository package 아래에 생성하면 통일성이 있는데 강사는 왜 그런 것일까?

- 아니나 다를까 이미 다른 사람이 이에 대해서 물어봤다.

- 강사의 답변을 보니 이건 그냥 강사 개인이 이번 Spring 강의에서 만드는 프로젝트는 이러한 구조가 더 적합한 것 같아서 그렇게 구성한 것이라고 한다.

- 패키지를 구성하는 방법에는 정답이 없고 상황에 따라 매번 달라진다.

4. DTO

- DTO는 HTTP Body 스펙을 보고 그에 맞게 생성하면 된다.

HTTP Body(JSON) : {"name" : String // 책 이름} → name은 필수

package com.group.libraryapp.dto.book.request;

public class BookCreateRequest {
    private String name;

    public String getName() {
        return this.name;
    }
}

BookCreateRequest class 위치

5. Controller & Service

[Controller]

package com.group.libraryapp.controller.book;

import com.group.libraryapp.dto.book.request.BookCreateRequest;
import com.group.libraryapp.service.book.BookService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BookController {

    private final BookService bookService;

    // 생성자를 만들어 Spring bean을 주입받는다.
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @PostMapping("/book")
    public void saveBook(@RequestBody BookCreateRequest request) {
        bookService.saveBook(request);
    }
}

[Service]

package com.group.libraryapp.service.book;

import com.group.libraryapp.domain.book.Book;
import com.group.libraryapp.domain.user.BookRepository;
import com.group.libraryapp.dto.book.request.BookCreateRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BookService {
    private final BookRepository bookRepository;

    // 생성자를 만들어 Spring bean을 주입받는다.
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @Transactional
    public void saveBook(BookCreateRequest request) {
        bookRepository.save(new Book(request.getName()));
    }
}

cf)

2023.08.04 - [Spring] - #7 DTO와 VO(Entity는 링크한 글을 보자)

#7 DTO와 VO(Entity는 링크한 글을 보자)

DTO : 데이터 전달용 객체 / VO : 값 표현용 객체 DTO VO 용도 레이어 간 데이터 전달 값 그 자체 표현 동등 결정 속성값이 모두 같아도 동일한 객체 X 속성값이 모두 같으면 동일 객체 가변 / 불변 sette

radderveloper.tistory.com

● 테스트

인텔리제이 콘솔에는 이렇게 찍혔다.