풀이

올바른 오리의 울음 소리는 울음 소리를 한 번 또는 그 이상 연속해서 내는 것이다. 예를 들어, "quack", "quackquackquackquack", "quackquack"는 올바른 오리의 울음 소리이다.

오리의 수를 세기 위해 HashMap을 사용하여 map(오리 번호, 해당 오리의 현재 문자열 사이즈) 을 저장한다. 그 다음 문자를 입력받을 때마다, map 엔트리를 탐색해 알맞은 오리를 찾아 그 오리의 value값에 1을 더한다. 예를 들면, 'a'(idx=2) 를 만나면 값이 2('qu')인 map 엔트리의 값을 3으로 바꾼다.

주의

• 문자열의 문자를 체크하다가 오리의 울음소리가 될 수 없는 소리(문자)를 만날 경우를 처리하기 위해 boolean형 변수 flag, fail을 추가한다. ex) 예제 입력 6 quackqauckquack
• map의 엔트리를 탐색하다가 값이 5가 아닌 오리가 있을 경우, 올바른 오리의 울음소리가 아니므로, 이 경우도 -1을 출력해야 한다.

코드

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


public class Main {

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

        String str = br.readLine();
        String duck = "quack";
        HashMap<Integer, Integer> map = new HashMap<>();
        int num = 0; // 오리 번호

        boolean fail = false; // 오리의 울음소리가 될 수 없는 소리(문자)가 있을 때 true

        int cnt = 0;

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

            if (str.charAt(i) == 'q') { // 문자가 'q'인 경우 따로 처리

                boolean flag = false;
                for (int key: map.keySet()) {
                    if (map.get(key) == 5) {
                        map.put(key, 1);
                        flag = true;
                        break;
                    }
                }
                if (!flag) // 새로운 오리 추가
                    map.put(num++, 1);
            }

            else {

                int idx = duck.indexOf(String.valueOf(str.charAt(i))); // duck 문자열의 인덱스 위치

                boolean flag = false;  // 오리의 울음소리가 될 수 없는 소리(문자)가 있을 때 true

                for (int key: map.keySet()) {

                    if (map.get(key) == idx) {
                        map.put(key, map.get(key)+1);
                        flag = true;
                        break;
                    }
                }

                if (!flag) {
                    // 올바른 오리의 울음소리가 아니므로 반복문 종료
                    fail = true;
                    break;
                }

            }
        }

        if (fail) {
            // 올바른 오리의 울음소리가 아니므로 -1 출력
            System.out.println(-1);
        }
        else {
            for (int key : map.keySet()) {

                if (map.get(key) == 5) {
                    // 값이 5라면 올바른 오리가 있다
                    cnt++;
                }
                else {
                    // 올바른 오리의 울음소리가 아닌 경우
                    cnt = 0;
                    break;
                }
            }

            System.out.println(cnt == 0 ? -1 : cnt);
        }

    }

}

풀이

규칙을 찾기 위해 위 그림과 같이 N=3, N=5인 경우 한 방향으로 이동할 때 이동하는 칸 수를 셌다. ex) 1 -> 2 : 1 2 -> 3 : 1 3 -> 5 : 2

N = 3 : 1 1 2 2 2

N = 5 : 1 1 2 2 3 3 4 4 4

1 2번, 2 2번,..., (N-1) 3번이다. 위 규칙을 활용하여 문제를 풀었다.

코드

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


public class Main {

    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int k = Integer.parseInt(br.readLine());
        int[][] arr = new int[n][n];

        int i = n/2, j = n/2; //배열 인덱스
        int dir = 0; //방향 인덱스
        int num = 1; // 배열에 저장할 숫자

        int cnt = 0; // 현재 line 으로 총 2번 이동했는지 카운트

        int line = 1; // 이동해야 하는 칸 수
        int move = 0; // 현재 이동한 칸 수

        int xIdx = 0, yIdx = 0; //정답 인덱스

        while(num <= n*n) {
            move = 0;

            while (move < line) {
                arr[i][j] = num;
                if (num == k) {
                    xIdx = i;
                    yIdx = j;
                }
                num++;
                i += dx[dir];
                j += dy[dir];
                move++;
            }
            cnt++;

            dir = (dir+1) % 4; // 방향 변환

            // 이동하는 칸 수가 N-1일 경우 총 3번을 이동해야 하기 때문에 따로 처리
            if (line == n-1) {
                if (cnt == 3) {
                    break;
                }
            }

            // 현재 line으로 2번 이동했으면 이동하는 칸 수 증가
            else if (cnt >= 2) {
                line++;
                cnt = 0;
            }

        }
        arr[0][0] = num;
        xIdx++;
        yIdx++;

        StringBuilder sb = new StringBuilder();
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++)
                sb.append(arr[i][j] + " ");
            sb.append("\n");
        }
        sb.append(xIdx + " " + yIdx);

        System.out.println(sb);

    }
}

• 방향 배열을 정의하여 행 인덱스 i에는 dx[dir]을 더하고 열 인덱스 j에는 dy[dir]을 더한다.

주의

• 로직 순서: 배열에 숫자를 저장 -> 이동하기 때문에 마지막 숫자(n*n)를 배열에 따로 저장하는 코드가 있어야 한다. arr[0][0] = num;
• xIdx, yIdx는 0부터 시작하므로 각각 1을 더해야 한다. xIdx++; yIdx++;
• 위치를 찾고자 하는 자연수가 nn일 수 있으므로 xIdx, yIdx 모두 *0으로 초기화**한다.

다른 풀이 2

위 방법과 같이 안쪽에서 바깥쪽으로 배열을 채워나가며, 이동하는 칸의 횟수가 1 > 1 > 2 > 2 > 3 > 3> 4 > ... > n 씩 이동하는 것을 활용하여 구현한다.

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


public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int m = Integer.parseInt(br.readLine());
        int[][] arr = new int[n][n];

        int i = n/2, j = n/2; //배열 인덱스
        int num = 1; // 배열에 저장할 숫자

        int line = 1; // 이동해야 하는 칸 수

        int xIdx = 0, yIdx = 0; //정답 인덱스

        while(true) {

            for (int k = 0; k < line; k++) {
                if (num == m) {
                    xIdx = i;
                    yIdx = j;
                }
                arr[i--][j] = num++;
            }

            // 배열을 다 채웠으면 이 때 num = n*n + 1
            if (num > n*n)
                break;

            for (int k = 0; k < line; k++) {
                if (num == m) {
                    xIdx = i;
                    yIdx = j;
                }
                arr[i][j++] = num++;
            }
            line++;

            for (int k = 0; k < line; k++) {
                if (num == m) {
                    xIdx = i;
                    yIdx = j;
                }
                arr[i++][j] = num++;
            }
            for (int k = 0; k < line; k++) {
                if (num == m) {
                    xIdx = i;
                    yIdx = j;
                }
                arr[i][j--] = num++;
            }
            line++;

        }

        xIdx++;
        yIdx++;

        StringBuilder sb = new StringBuilder();
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++)
                sb.append(arr[i][j] + " ");
            sb.append("\n");
        }
        sb.append(xIdx + " " + yIdx);

        System.out.println(sb);

    }
}

• 이동 방향은 모든 경우에 대해 항상 같으므로 방향 배열이 필요 없다.
• 두 번의 반복문을 수행하면 이동하는 칸의 횟수가 늘어나므로 두번째, 네번째 반복문 다음에 line++
• arr[0][0]까지 배열을 다 채웠으면 이 때 num = n*n + 1이 되므로 반복문을 종료해야 한다.

  마지막 반복문 (N = 5)
  num = 21 -> 22 -> 23 -> 24 -> 25 -> 

  참고: https://loosie.tistory.com/538

다른 풀이 3

위 방법들과 다르게 바깥쪽에서 안쪽으로 배열을 채워나간다.

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


public class Main {

    static int[] dx = {1, 0, -1, 0};
    static int[] dy = {0, 1, 0, -1};

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int m = Integer.parseInt(br.readLine());
        int[][] arr = new int[n][n];

        int i = 0, j = 0; // 배열 인덱스
        int num = n * n; // 배열에 저장할 숫자
        int dir = 0; // 방향 인덱스

        int xIdx = 0, yIdx = 0; //정답 인덱스

        while(num > 0) {

            if (num == m) {
                xIdx = i+1;
                yIdx = j+1;
            }
            arr[i][j] = num--;

            i += dx[dir];
            j += dy[dir];

            if (i < 0 || j < 0 || i >= n || j >= n || arr[i][j] != 0 ) {
                // 이전 위치로 복구
                i -= dx[dir];
                j -= dy[dir];

                dir = (dir + 1) % 4; // 뱡향 변환

                // 바뀐 방향으로 이동
                i += dx[dir];
                j += dy[dir];
            }
        }

        StringBuilder sb = new StringBuilder();
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++)
                sb.append(arr[i][j] + " ");
            sb.append("\n");
        }
        sb.append(xIdx + " " + yIdx);

        System.out.println(sb);

    }
}

• i < 0 || j < 0 || i >= n || j >= n || arr[i][j] != 0 이동한 위치가 배열의 인덱스 밖이거나, 이미 배열에 값이 채워져있다면 이전 위치로 복구한 다음 새로운 방향으로 이동한다.

참고: https://bbangson.tistory.com/110

• 바깥쪽에서 안쪽으로 배열을 채워나가는 3번째 방법이 제일 코드가 깔끔하고 가독성이 높다.

풀이

준현이와 성민이가 주식을 매매하는 방법은 다르다. 이를 함수로 구현하고, 배열에 주식 가격을 저장한다. 단, 마지막 날의 주식 가격은 따로 저장한다. 즉, arr 배열에는 13일까지의 주식 가격만 저장한다. 주식 가격의 상승/하락 여부는 boolean형 변수로 나타낸다.

코드

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

public class Main {

    public static int funcOne(int n, int[] arr, int last) {
        int cnt = 0;
        for (int price : arr) {
            if (n >= price) {
                cnt += n / price;
                n %= price;
            }
        }
        return n + cnt * last;
    }

    public static int funcTwo(int n, int[] arr, int last) {
        boolean upOne = false, upTwo = false, downOne = false, downTwo = false;
        int cnt = 0;

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[i-1]) {
                downOne = downTwo = false;
                if (!upOne)
                    upOne = true;
                else if (!upTwo)
                    upTwo = true;
                else {
                    n += arr[i] * cnt;
                    cnt = 0;
                }
            }
            else if (arr[i] < arr[i-1]) {
                upOne = upTwo = false;
                if (!downOne)
                    downOne = true;
                else if (!downTwo)
                    downTwo = true;
                else {
                    cnt += n / arr[i];
                    n %= arr[i];
                }
            }
        }

        return n + cnt * last;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[13];

        StringTokenizer st = new StringTokenizer(br.readLine());

        for (int i = 0; i < 13; i++)
            arr[i] = Integer.parseInt(st.nextToken());
        int last = Integer.parseInt(st.nextToken());

        int first = funcOne(n, arr, last);
        int second = funcTwo(n, arr, last);

        if (first == second)
            System.out.println("SAMESAME");
        else
            System.out.println(first > second ? "BNP" : "TIMING");

    }
}

다른 풀이

boolean형 변수를 사용하지 않고, 주식이 상승/하락할 때마다 upCnt/downCnt에 1을 더한다.

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

public class Main {

    public static int funcOne(int n, int[] arr, int last) {
        int cnt = 0;
        for (int price : arr) {
            if (n >= price) {
                cnt += n / price;
                n %= price;
            }
        }
        return n + cnt * last;
    }

    public static int funcTwo(int n, int[] arr, int last) {
        int cnt = 0, upCnt = 0, downCnt = 0;

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[i-1]) {
                downCnt = 0;
                if (upCnt < 2)
                    upCnt++;
                else {
                    n += arr[i] * cnt;
                    cnt = 0;
                }
            }
            else if (arr[i] < arr[i-1]) {
                upCnt = 0;
                if (downCnt < 2)
                    downCnt++;
                else {
                    cnt += n / arr[i];
                    n %= arr[i];
                }
            }
        }

        return n + cnt * last;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[13];

        StringTokenizer st = new StringTokenizer(br.readLine());

        for (int i = 0; i < 13; i++)
            arr[i] = Integer.parseInt(st.nextToken());
        int last = Integer.parseInt(st.nextToken());

        int first = funcOne(n, arr, last);
        int second = funcTwo(n, arr, last);

        if (first == second)
            System.out.println("SAMESAME");
        else
            System.out.println(first > second ? "BNP" : "TIMING");

    }
}

첫번째 방법과 두번째 방법의 메모리와 실행시간의 차이가 크지 않다.

풀이

처음에는 문제 그대로 N개의 숫자를 M으로 나누었을 때, 나머지가 모두 같게 되는 M을 모두 찾으려 했다.

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

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];

        StringBuilder sb = new StringBuilder();
        ArrayList<Integer> list = new ArrayList<>();
        int min, i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);
        min = arr[0];

        for (i = 2; i < arr[1]; i++) {
            int div = arr[0] % i;
            boolean flag = true;
            for (int idx = 1; idx < n; idx++) {
                if (arr[idx] % i != div) {
                    flag = false;
                    break;
                }
            }
            if (flag) list.add(i);
        }


        for (int num : list)
            sb.append(num + " ");
        System.out.println(sb);
    }
}

• Arrays.sort(arr); : arr 정렬 arr[0]이 arr의 가장 작은 값이 된다. i가 arr[0]보다 커지면 나머지는 arr[0]이 되기 때문에 i를 arr[1] 전까지만 for문을 돌린다. => for (i = 2; i < arr[1]; i++)

하지만 숫자가 10억까지 입력할 수 있기 때문에 시간 초과가 났다. 그래서 두 수의 차이를 이용하여 실행시간을 줄인다.

a = b * i + d
e = u * i + d

e - a = (u-b) * i

두 수의 차이를 gap 배열에 저장하고 그 차이가 i로 나누어 떨어지면 된다.

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

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        int[] gap = new int[n-1];

        StringBuilder sb = new StringBuilder();
        ArrayList<Integer> list = new ArrayList<>();
        int i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);
        for (i = 1; i < n; i++) {
            // gap에 두 수의 차이를 저장
            gap[i-1] = arr[i] - arr[i-1];
        }

        for (i = 2; i < arr[1]; i++) {

            boolean flag = true;
            for (int idx = 0; idx < n-1; idx++) {
                if (gap[idx] % i != 0) {
                    flag = false;
                    break;
                }
            }

            if (flag) list.add(i);
        }

        for (int num : list)
            sb.append(num + " ");
        System.out.println(sb);
    }
}

하지만 76%에서 시간 초과가 뜬다.

생각해보니 gap[idx] % i != 0이면 i는 답이 될 수 없다. => 즉 gap[idx] 보다 i가 크면 그 이후의 숫자부터는 답이 될 수 없으므로 gap에서 가장 작은 값까지만 for문을 도리면 된다. 그래서 gap을 정렬한 다음 for (i = 2; i <= gap[0]; i++) 로 for문 을 돌렸다. 그 결과 통과할 수 있었다.

코드

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

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        int[] gap = new int[n-1];

        StringBuilder sb = new StringBuilder();
        ArrayList<Integer> list = new ArrayList<>();
        int i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);

        // gap에 두 수의 차이를 저장
        for (i = 1; i < n; i++) {
            gap[i-1] = arr[i] - arr[i-1];
        }
        Arrays.sort(gap);
        int min = gap[0];

        for (i = 2; i <= min; i++) {

            boolean flag = true;
            for (int idx = 0; idx < n-1; idx++) {
                if (gap[idx] % i != 0) {
                    flag = false;
                    break;
                }
            }

            if (flag) list.add(i);
        }

        for (int num : list)
            sb.append(num + " ");
        System.out.println(sb);
    }
}

다른 풀이 - 2

두 수의 차이를 gap 배열에 저장하고 그 차이가 i로 나누어 떨어지면 된다. => 두 수의 차이의 최대공약수를 구한 다음 계속해서 최대공약수를 업데이트하여 최종적으로 모든 수(두 수의 차이)의 최대공약수를 구한다. 그리고 그 수의 2 이상의 약수를 출력한다. gap 배열을 사용할 필요 없으며 최대공약수를 구하는 gcd 함수를 사용한다.

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

public class Main {

    public static int gcd(int a, int b) {
        int r;
        while (b > 0) {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];

        StringBuilder sb = new StringBuilder();
        int i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);
        int val = arr[1] - arr[0];

        for (i = 2; i < n; i++) {
            val = gcd(val, arr[i] - arr[i-1]);
        }

        for (i = 2; i <= val; i++) {
            if (val % i == 0)
                sb.append(i + " ");
        }
        System.out.println(sb);
    }
}

다른 풀이 - 3

최대공약수의 약수를 굳이 끝까지 탐색할 필요가 없다. 굳이 약수를 찾는데 val까지 찾을 필요 없이 val의 절반까지만 탐색해도 된다.

물론 이 때 주의해야 할 것은 마지막에 최대공약수 자신도 출력해주어야 한다.

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

public class Main {

    public static int gcd(int a, int b) {
        int r;
        while (b > 0) {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];

        StringBuilder sb = new StringBuilder();
        int i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);
        int val = arr[1] - arr[0];

        for (i = 2; i < n; i++) {
            val = gcd(val, arr[i] - arr[i-1]);
        }

        for (i = 2; i <= val/2; i++) {
            if (val % i == 0)
                sb.append(i + " ");
        }
        sb.append(val);
        System.out.println(sb);
    }
}

다른 풀이 - 4

탐색 범위를 (val / 2) 가 아닌 제곱근, 즉 √val 까지만 탐색하여 i와 val/i를 ArrayList에 넣고 리스트를 정렬한 다음 출력한다. 물론 이 때 주의해야 할 것은 마지막에 최대공약수 자신도 list에 넣어주어야 한다.

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

public class Main {

    public static int gcd(int a, int b) {
        int r;
        while (b > 0) {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];

        StringBuilder sb = new StringBuilder();
        int i;

        for (i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        Arrays.sort(arr);
        int val = arr[1] - arr[0];

        for (i = 2; i < n; i++) {
            val = gcd(val, arr[i] - arr[i-1]);
        }

        ArrayList<Integer> list = new ArrayList<>();
        for (i = 2; i <= Math.sqrt(val); i++) {
            if (Math.sqrt(val) == i) {
                list.add(i);
            }
            else if (val % i == 0) {
                list.add(i);
                list.add(val/i);
            }
        }
        list.add(val);

        Collections.sort(list);

        for (int num : list)
            sb.append(num + " ");
        System.out.println(sb);
    }
}

4번째 방법이 메모리와 실행시간이 가장 작다. 최대공약수의 약수를 탐색하는 탐색 범위를 줄일 때 가장 실행시간이 크게 감소한 것을 볼 수 있다.

참고: https://st-lab.tistory.com/155

풀이

출발점과 속한 원의 개수와 도착점이 속한 원의 개수를 더한다. 단, 두 점이 같은 원에 속할 경우 그 원은 제외한다.

코드

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

public class Main {

    public static double distancePow(int x1, int y1, int x2, int y2) {
        return (Math.pow(x1-x2, 2) + Math.pow(y1-y2, 2));
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());

        StringBuilder sb = new StringBuilder();

        while(t-- > 0) {
            int cnt = 0;
            StringTokenizer st = new StringTokenizer(br.readLine());

            int x1 = Integer.parseInt(st.nextToken());
            int y1 = Integer.parseInt(st.nextToken());
            int x2 = Integer.parseInt(st.nextToken());
            int y2 = Integer.parseInt(st.nextToken());

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

            for (int i = 0; i < n; i++) {
                st = new StringTokenizer(br.readLine());
                int x = Integer.parseInt(st.nextToken());
                int y = Integer.parseInt(st.nextToken());
                int r = Integer.parseInt(st.nextToken());

                double d1 = distancePow(x,y,x1,y1);
                double d2 = distancePow(x,y,x2,y2);
                r = r*r;

                if (d1 < r && d2 > r) //출발점만 현재 원에 속하는 경우
                    cnt++;
                else if (d1 > r && d2 < r) //도착점만 현재 원에 속하는 경우
                    cnt++;

            }

            sb.append(cnt+"\n");
        }

        System.out.println(sb);
    }
}

풀이

가장 긴 가로, 세로 길이를 구하고 곱하여 직사각형의 넓이를 구하고 그 넓이에서 빈 직사각형의 넓이를 빼야 한다. 빈 직사각형의 가로와 세로를 구하는 방법은 다음과 같다.

가장 긴 가로 옆에 위치한 두 세로의 길이 차이가 빈 사각형의 세로가 된다.
같은 원리로 가장 긴 세로 양 옆에 위치한 두 가로의 차이가 빈 사각형의 가로가 된다.

코드

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

public class Main {

    static class Line {
        int dir, num;
        public Line(int dir, int num) {
            this.dir = dir;
            this.num = num;
        }

        @Override
        public boolean equals(Object o) {
            Line ob = (Line) o;
            if (this.dir == ob.dir && this.num == ob.num)
                return true;
            else return false;
        }
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int k = Integer.parseInt(br.readLine());

        ArrayList<Line> list = new ArrayList<>();

        int maxWidth = 0, maxHeight = 0;
        Line wLine=null, hLine=null;

        for (int i = 0; i < 6; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int dir = Integer.parseInt(st.nextToken());
            int num = Integer.parseInt(st.nextToken());

            list.add(new Line(dir, num));

            if (dir == 1 || dir == 2) {
                //가로 중 가장 긴 선분
                if (maxWidth < num) {
                    maxWidth = Math.max(maxWidth, num);
                    wLine = new Line(dir, num);
                }
            }
            else {
                //세로 중 가장 긴 선분
                if (maxHeight < num) {
                    maxHeight = Math.max(maxHeight, num);
                    hLine = new Line(dir, num);
                }
            }
        }

        //가로 중 가장 긴 선분 옆에 위치한 세로의 길이 차를 구함
        int wIdx = list.indexOf(wLine);
        int h = Math.abs(list.get((wIdx+5)%6).num - list.get((wIdx+1)%6).num);

        //세로 중 가장 긴 선분 옆에 위치한 가로의 길이 차를 구함
        int hIdx = list.indexOf(hLine);
        int w = Math.abs(list.get((hIdx+5)%6).num - list.get((hIdx+1)%6).num);

        System.out.println((maxWidth*maxHeight - w*h) * k);
    }
}

• static class Line을 선언하여 방향과 길이를 저장한다.
• public boolean equals(Object o)를 Override한다.
  • indexOf() 메서드는 equals() 메소드를 사용하여 객체를 찾기 때문이다.

다른 풀이

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

public class Main {

    static class Line {
        int dir, num;
        public Line(int dir, int num) {
            this.dir = dir;
            this.num = num;
        }
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int k = Integer.parseInt(br.readLine());

        ArrayList<Line> list = new ArrayList<>();

        int maxWidth = 0, maxHeight = 0, maxWidthIdx = 0, maxHeightIdx=0;

        for (int i = 0; i < 6; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int dir = Integer.parseInt(st.nextToken());
            int num = Integer.parseInt(st.nextToken());

            list.add(new Line(dir, num));

            if (dir == 1 || dir == 2) {
                //가로 중 가장 긴 선분
                if (maxWidth < num) {
                    maxWidth = Math.max(maxWidth, num);
                    maxWidthIdx = i;
                }
            }
            else {
                //세로 중 가장 긴 선분
                if (maxHeight < num) {
                    maxHeight = Math.max(maxHeight, num);
                    maxHeightIdx = i;
                }
            }
        }

        //가로 중 가장 긴 선분 옆에 위치한 세로의 길이 차를 구함
        int h = Math.abs(list.get((maxWidthIdx+5)%6).num - list.get((maxWidthIdx+1)%6).num);

        //세로 중 가장 긴 선분 옆에 위치한 가로의 길이 차를 구함
        int w = Math.abs(list.get((maxHeightIdx+5)%6).num - list.get((maxHeightIdx+1)%6).num);

        System.out.println((maxWidth*maxHeight - w*h)*k);
    }
}

• equals() 메서드를 Override 할 필요 없이 인덱스도 따로 저장해 놓는다,

게시판 컨트롤러 수정

BoardController

    @GetMapping
    public String postList(Model model,
                           @RequestParam(required = false, defaultValue = "0") Integer page,
                           @RequestParam(required = false, defaultValue = "5") Integer size) {
        model.addAttribute("resultMap", boardService.findAll(page, size));
        return "board/postList";
    }

    @GetMapping("/{postId}")
    public String postView(@PathVariable Long postId, Model model) {
        log.info("postView");

        Board post = boardService.findOne(postId).orElseThrow();
        model.addAttribute("post", post);

        return "board/post";
    }

• postList() : 게시글 조회 메서드
  • 게시글 조회 메서드에 페이징 처리를 위한 파라미터를 받도록 한다.
  • defaultValue를 지정하여 게시글 조회 화면에서 기본적으로 첫페이지가 나타나고, 게시글 5개가 나타나도록 한다.

게시판 서비스 수정

BoardService

    /**
     * 게시글 전체 조회
     */
    public HashMap<String, Object> findAll(Integer page, Integer size) {
        HashMap<String, Object> listMap = new HashMap<>();
        Page<Board> list = boardRepository.findAll(PageRequest.of(page, size));

        listMap.put("list", list);
        listMap.put("paging", list.getPageable());
        listMap.put("totalCnt", list.getTotalElements());
        listMap.put("totalPage", list.getTotalPages());
        return listMap;
    }

Spring Data JPA에서는 페이지 처리를 위한 PageRequest 객체를 지원하므로 간단하게 페이징 처리를 할 수 있다.

• findAll() : 게시글 전체 조회 메서드
  • HashMap<String, Object>를 반환

게시글 조회 뷰 템플릿 수정

postList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

    <div id="wrapper">
        <div class="container">
            <div class="col-md-12">
                <div class="py-5 text-center">
                    <h2>게시판</h2>
                </div>
                <button class="btn btn-dark"
                        th:onclick="|location.href='@{/}'|" type="button">
                    홈 화면
                </button>

                <button class="btn btn-primary"
                        th:onclick="|location.href='@{/board/register}'|" type="button">
                    게시글 작성
                </button>

                <hr class="my-4">

                <table class="table">
                    <thead>
                    <tr>
                        <th width="10%">게시글번호</th>
                        <th width="">제목</th>
                        <th width="20%">작성자</th>
                        <th width="20%">작성일</th>
                    </tr>
                    </thead>
                    <tbody>
                    <tr th:each="list,index: ${resultMap.list}" th:with="paging=${resultMap.paging}">
                        <td>
                            <span th:text="${(resultMap.totalCnt - index.index) - (paging.pageNumber * paging.pageSize)}"></span>
                        </td>
                        </td>
                        <td>
                            <a th:href="@{/board/{postId}(postId=${list.id})}"
                            th:text="${list.title}">제목</a>
                        </td>
                        <td th:text="${list.user.loginId}">작성자</td>
                        <td th:text="${list.registerDate}">작성일</td>
                    </tr>
                    </tbody>
                </table>

                <div class="row">
                    <div class="col">
                        <ul class="pagination">
                            <li class="page-item" th:if="${resultMap.totalPage} > 0" th:each="index : ${#numbers.sequence(1, resultMap.totalPage)}"
                                th:with="paging=${resultMap.paging}">
                                <a class="page-link"
                                   th:href="@{/board/(page=${index-1},size=${paging.pageSize})}">
                                    <span th:text="${index}"></span>
                                </a>
                            </li>
                        </ul>
                    </div>
                </div>

                <hr class="my-4">

            </div>
        </div>
    </div>

</body>

• th:each="list,index: ${resultMap.list}" th:with="paging=${resultMap.paging}"
• th:text="${(resultMap.totalCnt - index.index) - (paging.pageNumber * paging.pageSize)}" : 게시글 번호 지정
• th:href="@{/board/{postId}(postId=${list.id})}" : 게시글 제목을 클릭하면 해당 게시글 상세 조회 화면으로 이동한다.
• th:if="${resultMap.totalPage} > 0" : page 개수가 1개 이상이라면, 태그를 출력한다.
• th:href="@{/board/(page=${index-1},size=${paging.pageSize})}" : 쿼리 파라미터로 현재 페이지 번호와 페이지 크기를 전달한다.

• th:each : 반복하려는 html 엘리먼트에 사용하여 콜렉션(Collection)을 반복 th:each="콜렉션 변수명, status 변수명:${리스트}"

• th:with : 변수형태의 값을 재정의 th:with="변수명=${...}" 참고: https://kitty-geno.tistory.com/124

게시글 상세 조회 뷰 템플릿 수정

• 게시글 번호가 안 나타나도록 게시글 번호 <div>태그 삭제

게시글 조회 화면

• http://localhost:8080/board
• http://localhost:8080/board/?page=0&size=5
• http://localhost:8080/board/?page=1&size=5

문제점

게시글 조회 화면을 보면 가장 최근에 작성한 게시글이 1번이 되어 마지막 페이지에 나타난다. 내가 원하는 요구사항은 가장 최근에 작성한 게시글이 마지막 번호가 되어 가장 첫 페이지에 나타나도록 하는 것이다.

해결

구글링을 통해서 해결 방법을 찾았다.

• BoardController에서 Pageable 객체를 생성하고 정렬 순서, 사이즈 등의 정보를 넣은 다음, boardService.findAll(pageable)를 호출해 파라미터로 넘긴다.
• BoardService에서 PageRequest 객체 대신 Pageable 객체를 사용한다.
• 참고 : Spring Boot JPA 게시판 페이징 처리 구현

BoardController 수정

@GetMapping
    public String postList(Model model,
                           @PageableDefault(sort = "id", direction = Sort.Direction.DESC, size = 5) Pageable pageable) {
        model.addAttribute("resultMap", boardService.findAll(pageable));
        return "board/postList";
    }

@PageableDefault 어노테이션을 사용해 간단하게 구현한다.

• id를 기준으로 내림차순으로 정렬한다.

@PageableDefault

• size : 한 페이지에 담을 모델의 수를 정할 수 있다. 기본 값은 10이다.
• sort : 정렬의 기준이 되는 속성을 정한다.
• direction : 오름차순과 내림차순 중 기준을 선택할 수 있다.
• Pageable pageable : PageableDefault 값을 갖고 있는 변수를 선언한다.

BoardService 수정

    /**
     * 게시글 전체 조회
     */
    public HashMap<String, Object> findAll(Pageable page) {
        HashMap<String, Object> listMap = new HashMap<>();
        Page<Board> list = boardRepository.findAll(page);

        listMap.put("list", list);
        listMap.put("paging", list.getPageable());
        listMap.put("totalCnt", list.getTotalElements());
        listMap.put("totalPage", list.getTotalPages());
        return listMap;
    }

• Spring Data JPA에서 페이징 처리와 정렬은 findAll() 메소드로 한다.
• findAll() 메소드 파라미터로 pageable을 넣어준다.

PageRequest를 사용해도 page를 정렬 할 수 있다. ex) boardRepository.findAll(PageRequest.of(page, 5, Sort.by(Sort.Direction.DESC, "id")));

postList.html 수정

            <div class="row">
                    <div class="col">
                        <ul class="pagination">
                            <li class="page-item" th:if="${resultMap.totalPage} > 0" th:each="index : ${#numbers.sequence(1, resultMap.totalPage)}"
                                th:with="paging=${resultMap.paging}">
                                <a class="page-link"
                                   th:href="@{/board/(page=${index-1})}">
                                    <span th:text="${index}"></span>
                                </a>
                            </li>
                        </ul>
                    </div>
                </div>

• 불필요한 size 파라미터 삭제

결과 화면

http://localhost:8080/board http://localhost:8080/board/?page=0 http://localhost:8080/board/?page=1

풀이

두 원의 중심의 거리(d)와 반지름 사이의 관계를 고려해 두 원의 접점을 찾는 문제다.

코드

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

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();

        while (t-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int x1 = Integer.parseInt(st.nextToken());
            int y1 = Integer.parseInt(st.nextToken());
            int r1 = Integer.parseInt(st.nextToken());
            int x2 = Integer.parseInt(st.nextToken());
            int y2 = Integer.parseInt(st.nextToken());
            int r2 = Integer.parseInt(st.nextToken());

            double d = Math.sqrt(Math.pow(x2- x1, 2) + Math.pow(y2-y1, 2));

            if (d == 0 && r1==r2)
                sb.append("-1\n");
            else if (d > r1 + r2 || d < Math.abs(r1- r2))
                sb.append("0\n");
            else if (d == r1+r2 || d == Math.abs(r1-r2))
                sb.append("1\n");
            else
                sb.append("2\n");
        }

        System.out.println(sb);

    }
}

• d == 0 && r1==r2 : 두 원이 같으면 접점의 개수는 무한대이므로 -1
• d > r1 + r2 || d < Math.abs(r1- r2) : 두 원의 접점이 없다.
• d == r1+r2 || d == Math.abs(r1-r2) : 두 원의 접점이 1개
• 그 이외의 경우는 두 원의 접점이 2개다.

풀이

정수론 및 조합론의 이전 문제인 팩토리얼 0의 개수의 풀이를 응용하면 된다. 팩토리얼 0의 개수를 구할 때는 5의 개수만 구하면 됐지만, 이번 문제는 2의 개수도 따로 구해주어야 한다.

코드

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

public class Main {

    public static int division(int n, int div) {
        int cnt = 0;

        while (n >= div) {
            cnt += n / div;
            n /= div;
        }
        return cnt;
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int c = a - b;

        int two = 0, five = 0;

        two += division(a, 2);
        five += division(a, 5);

        two -= (division(b, 2) + division(c, 2));
        five -= (division(b, 5) + division(c, 5));

        System.out.println(Math.min(two, five));

    }
}

• nCr = n! / r!(n-r)!
• 위의 공식을 사용하여 nCr을 소인수분해 했을 때 2의 개수와 5의 개수를 따로 구한다.
• 그 다음 두 수 중 최솟값을 출력한다.

참고: 백준 1676 팩토리얼 0의 개수 알고리즘 설명 글

풀이

처음 풀이에는 map과 조합을 사용한다. map에는 map(타입, 해당 타입의 옷 개수)를 저장한다. 2가지 이상의 옷을 고를 경우, 모든 조합의 경우를 구하여 각 조합에 속한 수들을 모두 곱한 값을 cnt에 더한다. 하지만 아래 코드로 풀이한 결과 50%에서 시간 초과가 떴다.

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

public class Main {

    static int cnt;

    public static void combination(int size, int L, int start, ArrayList<Integer> list, int[] comb) {
        if (size == L) {
            int tmp = 1;
            for (int num : comb)
                tmp *= num;
            cnt += tmp;
        }
        else {
            for (int i = start; i < list.size(); i++) {
                comb[L] = list.get(i);
                combination(size, L+1, i+1, list, comb);
            }
        }
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());

        StringBuilder sb = new StringBuilder();

        while (t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            cnt = 0;
            HashMap<String, Integer> map = new HashMap<>();
            ArrayList<Integer> list = new ArrayList<>();

            for (int i = 0; i < n; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                String name = st.nextToken();
                String type = st.nextToken();
                map.put(type, map.getOrDefault(type, 0) + 1);
            }

            //map에 저장된 옷 개수를 list에 저장
            //옷을 1가지만 입는 경우의 수를 cnt에 더함
            for (String type : map.keySet()) {
                int num = map.get(type);
                list.add(num);
                cnt += num;
            }

            int m = list.size();
            //옷을 2~m가지 입는 경우의 수를 cnt에 더하는 재귀함수
            for (int i = 2; i <= m; i++) {
                int[] comb = new int[i];
                combination(i, 0, 0, list, comb);
            }

            sb.append(cnt+ "\n");
        }

        System.out.println(sb);
    }
}

질문 검색을 통해 답을 찾았다. map을 사용하여 map(타입, 해당 타입의 옷 개수)를 저장하고, 해당 타입의 옷 개수에 1을 더해서 입지 않은 경우까지 고려하고, 각 타입의 옷 개수를 모두 곱해주고 아무것도 입지 않은 경우를 빼주면 된다.

코드

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

public class Main {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());

        StringBuilder sb = new StringBuilder();

        while (t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            HashMap<String, Integer> map = new HashMap<>();

            for (int i = 0; i < n; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                String name = st.nextToken();
                String type = st.nextToken();
                map.put(type, map.getOrDefault(type, 0) + 1);
            }

            int cnt = 1;
            for (String type : map.keySet()) {
                int num = map.get(type);
                cnt *= (num+1);
            }
            cnt--;

            sb.append(cnt+ "\n");
        }

        System.out.println(sb);
    }
}

참고: https://st-lab.tistory.com/164

풀이

• 처음에는 아래의 식을 사용하여 재귀함수를 이용하여 풀었다. nCr = n-1Cr + n-1Cr-1
• 하지만 입력 범위가 1000까지 가기 때문에 메모이제이션을 사용하여 조합 수를 배열에 저장하여 풀었다.
• 하지만 다음 코드를 제출하면 틀렸습니다 가 뜬다.

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

public class Main {

static int[][] cal = new int[1001][1001];

public static int comb(int a, int b) {
    if (cal[a][b] != 0)
        return cal[a][b];

    if (b == 0 || a == b) {
        return cal[a][b] = 1;
    }

    return cal[a][b] = comb(a-1, b) + comb(a-1, b-1);
}

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

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    int a = Integer.parseInt(st.nextToken());
    int b = Integer.parseInt(st.nextToken());

    System.out.println(comb(a, b) % 10007);
}

}

- 위의 코드가 틀린 이유는 입력 범위가 `1 ≤ N ≤ 1000` 이므로 너무 숫자가 커져 **overflow**가 발생하여 잘못된 값을 발생시키기 때문이다.
- 이를 해결하기 위해 모듈러 연산의 성질을 이용한다.
![](https://velog.velcdn.com/images/serendipity-dev/post/75ea496f-48ea-4203-98bc-2797a5070a7d/image.png)


### 코드

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

public class Main {

static int[][] cal = new int[1001][1001];

public static int comb(int a, int b) {
    if (cal[a][b] != 0)
        return cal[a][b];

    if (b == 0 || a == b) {
        return cal[a][b] = 1;
    }

    return cal[a][b] = (comb(a-1, b)%10007 + comb(a-1, b-1)%10007)%10007;
}

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

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    int a = Integer.parseInt(st.nextToken());
    int b = Integer.parseInt(st.nextToken());

    System.out.println(comb(a, b));
}

}

```

참고: https://st-lab.tistory.com/162

요구사항을 보면 로그인 한 사용자만 게시글 작성, 상세 조회, 수정, 삭제가 가능하다. 여러 컨트롤러에서 로그인 여부를 체크하는 로직을 하나하나 작성하면 되겠지만, 등록, 수정, 삭제, 조회 등등 컨트롤러의 여러 로직에 공통으로 로그인 여부를 확인해야 한다. 더 큰 문제는 향후 로그인과 관련된 로직이 변경될 때 이다. 작성한 모든 로직을 다 수정해야 할 수 있다. 이렇게 애플리케이션 여러 로직에서 공통으로 관심이 있는 있는 것을 공통 관심사(cross-cutting concern)라고 한다. 여기서는 등록, 수정, 삭제, 조회 등등 여러 로직에서 공통으로 인증에 대해서 관심을 가지고 있다. 이러한 공통 관심사는 스프링의 AOP로도 해결할 수 있지만, 웹과 관련된 공통 관심사는 서블릿 필터 또는 스프링 인터셉터를 사용하는 것이 좋다. 웹과 관련된 공통 관심사를 처리할 때는 HTTP의 헤더나 URL의 정보들이 필요한데, 서블릿 필터나 스프링 인터셉터는 HttpServletRequest를 제공한다.

스프링 인터셉터

서블릿 필터가 서블릿이 제공하는 기술이라면, 스프링 인터셉터는 스프링 MVC가 제공하는 기술이다. 둘다 웹과 관련된 공통 관심 사항을 처리하지만, 적용되는 순서와 범위, 그리고 사용 방법이 다르다. 스프링 인터셉터가 훨씬 더 많은 기능을 제공한다. 인터셉터는 스프링 MVC 구조에 특화된 필터 기능을 제공한다고 이해하면 된다. 스프링 MVC를 사용하고, 특별히 필터를 꼭 사용해야 하는 상황이 아니라면 인터셉터를 사용하는 것이 더 편리하다.

스프링 인터셉터 - 로그인 인증 체크

스프링 인터셉터를 사용하여 로그인 인증 체크 기능을 개발한다. LoginCheckInterceptor

package hello.board.interceptor;

import hello.board.controller.SessionConst;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();
        log.info("인증 체크 인터셉터 실행 {}", requestURI);

        HttpSession session = request.getSession(false);

        if (session == null || session.getAttribute(SessionConst.LOGIN_USER) == null) {
            log.info("미인증 사용자 요청");

            //로그인으로 redirect
            response.sendRedirect("/login?redirectURL=" + requestURI);
            return false;
        }

        return true;
    }
}

• 스프링의 인터셉터를 사용하려면 HandlerInterceptor 인터페이스를 구현하면 된다.
• 인증이라는 것은 컨트롤러 호출 전에만 호출되면 되기 때문에 preHandle만 구현하면 된다.
• response.sendRedirect("/login?redirectURL=" + requestURI);
  • 미인증 사용자는 로그인 화면으로 리다이렉트 한다. 그런데 로그인 이후에 다시 홈으로 이동해버리면, 원하는 경로를 다시 찾아가야 하는 불편함이 있다. 예를 들어서 게시글 상세 조회 면을 보려고 들어갔다가 로그인 화면으로 이동하면, 로그인 이후에 다시 게시글 상세 조회 화면으로 들어가는 것이 좋다. 이런 부분이 개발자 입장에서는 좀 귀찮을 수 있어도 사용자 입장으로 보면 편리한 기능이다. 이러한 기능을 위해 현재 요청한 경로인 requestURI 를 /login 에 쿼리 파라미터로 함께 전달한다. 물론 /login 컨트롤러에서 로그인 성공시 해당 경로로 이동하는 기능은 추가로 개발해야 한다.
  • Status Code: 302
  • 응답 헤더 Location: http://localhost:8080/login?redirectURL=/board/1
• return false : 인터셉터나 컨트롤러가 더는 호출되지 않는다. 앞서 redirect 를 사용했기 때문에 redirect 가 응답으로 적용되고 요청이 끝난다.

Ctrl + o → 인터페이스에서 오버라이드할 메서드 선택

웹 설정 정보 추가 - 인터셉터 등록

WebConfig

package hello.board;

import hello.board.interceptor.LoginCheckInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginCheckInterceptor())
                .order(1)
                .addPathPatterns("/**")
                .excludePathPatterns("/", "/signup", "/login", "/logout", "/board",
                        "/*.ico", "/css/**", "/error");
    }
}

WebMvcConfigurer 가 제공하는 addInterceptors() 를 사용해서 인터셉터를 등록할 수 있다.

• registry.addInterceptor(new LoginCheckInterceptor()) : 인터셉터를 등록한다.
• order(1) : 인터셉터의 호출 순서를 지정한다. 낮을 수록 먼저 호출된다.
• addPathPatterns() : 인터셉터를 적용할 URL 패턴을 지정한다.
• excludePathPatterns() : 인터셉터에서 제외할 패턴을 지정한다.

인터셉터를 적용하거나 하지 않을 부분은 addPathPatterns와 excludePathPatterns에 작성하면 된다.

• 기본적으로 모든 경로에 해당 인터셉터를 적용하되 ( /** ), 홈( /), 회원가입( /signup ), 로그인( /login ), 로그아웃 (/logout ), 게시글 조회( /board ), 리소스 조회( /css/** ), 오류( /error )와 같은 부분은 로그인 체크 인터셉터를 적용하지 않는다.

스프링의 URL 경로 스프링이 제공하는 URL 경로는 서블릿 기술이 제공하는 URL 경로와 완전히 다르다. 더욱 자세하고, 세밀하게 설정할 수 있다. 자세한 내용은 다음을 참고하자. PathPattern 공식 문서

? 한 문자 일치
* 경로(/) 안에서 0개 이상의 문자 일치
** 경로 끝까지 0개 이상의 경로(/) 일치
{spring} 경로(/)와 일치하고 spring이라는 변수로 캡처
{spring:[a-z]+} matches the regexp [a-z]+ as a path variable named "spring"
{spring:[a-z]+} regexp [a-z]+ 와 일치하고, "spring" 경로 변수로 캡처
{*spring} 경로가 끝날 때 까지 0개 이상의 경로(/)와 일치하고 spring이라는 변수로 캡처

링크: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/util/pattern/PathPattern.html

로그인 컨트롤러 수정

LoginController

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute("loginForm") UserLoginForm loginForm, BindingResult bindingResult,
                        HttpServletRequest request,
                        @RequestParam(defaultValue = "/") String redirectURL) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "login/loginForm";
        }

        User loginUser = loginService.login(loginForm.getLoginId(), loginForm.getPassword());

        if (loginUser == null) {
            log.info("login Fail");
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
            return "login/loginForm";
        }

        //로그인 성공
        //세션이 있으면 세션 반환, 없으면 신규 세션을 생성
        HttpSession session = request.getSession();

        //세션에 로그인 회원 정보 보관
        session.setAttribute(SessionConst.LOGIN_USER, loginUser);

        return "redirect:" + redirectURL;
    }

• 로그인에 성공하면 처음 요청한 URL로 이동
• 로그인 체크 인터셉터에서, 미인증 사용자는 요청 경로를 포함해서 /login 에 redirectURL 요청 파라미터를 추가해서 요청했다. 이 값을 사용해서 로그인 성공시 해당 경로로 redirect 한다.
• 로그인 리다이렉트 결과 URL : http://localhost:8080/login?redirectURL=/board/1

마무리

여기까지 SpringBoot, Gradle, JPA, MySQL, Thymeleaf를 이용하여 간단한 로그인 기능과 게시판 CRUD 기능을 구현하였다. 첫 프로젝트라 디테일한 부분도 부족하고, 강의에서 배운 내용을 활용하고 CRUD 기능을 구현하는데 초점을 맞췄기 때문에 복잡한 기능은 구현하지 않았다. 이 프로젝트에서 추가적으로 기능을 더 구현할 수도 있고, 다른 프로젝트(팀 프로젝트나 클론 코딩)를 시작할 예정이다.

프로젝트 깃헙 링크

풀이

DFS를 사용하여 팀을 만들 수 있는 모든 경우를 탐색한 다음 최솟값을 구한다. 이 때 조합을 사용하여 모든 조합의 경우의 수를 탐색하고, 구분은 boolean[] check 배열을 사용한다.

코드

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

public class Main {

    static int n, answer = Integer.MAX_VALUE;
    static int[][] s;
    static boolean[] check;

    public static void comb(int L, int start) {
        if (L == n/2) {
            int st = 0, link = 0;

            for (int i = 0; i < n; i++){
                for (int j = 0; j < n; j++) {
                    if (check[i] && check[j])
                        st += s[i][j];
                    else if (!check[i] && !check[j])
                        link += s[i][j];
                }
            }

            answer = Math.min(answer, Math.abs(st-link));
            return;
        }

        for (int i = start; i < n; i++) {
            check[i] = true;
            comb(L+1, i+1);
            check[i] = false;
        }

    }


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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        s = new int[n][n];
        check = new boolean[n];

        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < n; j++)
                s[i][j] = Integer.parseInt(st.nextToken());
        }

        comb(0, 0);
        System.out.println(answer);
    }
}

• 조합을 만드는 재귀함수를 사용한다.
• L == n/2이면 팀이 만들어졌으므로 이중 for문을 사용해 각 팀의 능력치 합을 구한다.
• 두 팀의 능력치 차이의 최솟값을 answer에 저장한다.

다른 풀이

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

public class Main {

    static int n, answer = Integer.MAX_VALUE;
    static int[][] s;
    static boolean[] check;

    public static void comb(int L, int start) {
        if (L == n/2) {
            int st = 0, link = 0;

            for (int i = 0; i < n-1; i++){
                for (int j = i+1; j < n; j++) {
                    if (check[i] && check[j]) {
                        st += s[i][j];
                        st += s[j][i];
                    }
                    else if (!check[i] && !check[j]) {
                        link += s[i][j];
                        link += s[j][i];
                    }
                }
            }

            answer = Math.min(answer, Math.abs(st-link));

            if (answer == 0) {
                System.out.println(0);
                System.exit(0);
            }

            return;
        }

        for (int i = start; i < n; i++) {
            check[i] = true;
            comb(L+1, i+1);
            check[i] = false;
        }

    }


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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        s = new int[n][n];
        check = new boolean[n];

        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < n; j++)
                s[i][j] = Integer.parseInt(st.nextToken());
        }

        comb(0, 0);
        System.out.println(answer);
    }
}

• s[i][j], s[j][i]를 한 번에 더하기 위해서는 대각선을 기준으로 위쪽 구역만 탐색하면 된다.
• answer 값이 0이면 답이 될 수 있는 가장 최솟값이므로 System.exit(0)을 호출해 프로그램을 종료한다.

참고: https://st-lab.tistory.com/122?category=862595

첫번째 방법이 더 근소하게 메모리와 시간을 적게 쓴다.

풀이

DFS를 사용하여 모든 경우의 수를 탐색해 최솟값과 최댓값을 구한다.

코드

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

public class Main {

    static int n, min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
    static int[] arr;
    static int[] operator = new int[4];

    public static void operation(int idx, int value) {
        if (idx == n) {
            min = Math.min(min, value);
            max = Math.max(max, value);
            return;
        }

        int num = arr[idx];
        for (int i = 0; i < 4; i++) {
            if (operator[i] != 0) {
                operator[i]--;
                switch(i) {
                    case 0: operation(idx+1, value+num); break;
                    case 1: operation(idx+1, value-num); break;
                    case 2: operation(idx+1, value*num); break;
                    case 3: operation(idx+1, value/num); break;
                }
                operator[i]++;
            }
        }

    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        arr = new int[n];

        StringTokenizer st = new StringTokenizer(br.readLine());

        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < 4; i++) {
            operator[i] = Integer.parseInt(st.nextToken());
        }

        operation(1, arr[0]);

        System.out.print(max + "\n" + min);
    }
}

• operator 배열에 각 연산자의 개수를 저장한다.
• 재귀함수 내 for문에서 연산자 개수가 0 이상인 경우(operator[i] != 0) 해당 연산자 개수를 1 감소하고 재귀호출을 한다.
• 모든 피연산자를 다 쓴 경우(idx == n) 값을 비교하여 min, max 값을 업데이트한다.

게시판 컨트롤러 수정 및 추가

BoardController

package hello.board.controller.board;

import hello.board.controller.SessionConst;
import hello.board.entity.Board;
import hello.board.entity.User;
import hello.board.service.BoardService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import javax.validation.Valid;

@Controller
@Slf4j
@RequiredArgsConstructor
@RequestMapping("/board")
public class BoardController {

    private final BoardService boardService;

    @GetMapping
    public String postList(Model model) {
        model.addAttribute("list", boardService.findAll());
        return "board/postList";
    }

    @GetMapping("/{postId}")
    public String postView(@PathVariable Long postId, Model model) {
        log.info("postView");

        Board post = boardService.findOne(postId).orElseThrow();
        model.addAttribute("post", post);

        return "board/post";
    }

    @GetMapping("/register")
    public String registerForm(@ModelAttribute PostForm postForm) {
        return "board/registerForm";
    }

    @PostMapping("/register")
    public String register(@Valid @ModelAttribute PostForm postForm, BindingResult bindingResult, @SessionAttribute(name = SessionConst.LOGIN_USER, required = false) User loginUser, RedirectAttributes redirectAttributes) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "board/registerForm";
        }

        Long registerId = boardService.register(postForm.getTitle(), postForm.getContent(), loginUser.getId());
        redirectAttributes.addAttribute("postId", registerId);

        return "redirect:/board/{postId}";
    }

    @GetMapping("/{postId}/edit")
    public String editForm(@PathVariable Long postId, Model model) {

        Board post = boardService.findOne(postId).orElseThrow();

        PostForm postForm = new PostForm();
        postForm.setTitle(post.getTitle());
        postForm.setContent(post.getContent());

        model.addAttribute("postForm", postForm);
        model.addAttribute("postId", postId);

        return "board/editForm";
    }

    @PostMapping("/{postId}/edit")
    public String edit(@PathVariable Long postId, @Valid @ModelAttribute PostForm postForm, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "board/editForm";
        }

        boardService.updateBoard(postId, postForm.getTitle(), postForm.getContent());

        return "redirect:/board/{postId}";
    }

    @PostMapping("/{postId}/delete")
    public String delete(@PathVariable Long postId) {
        boardService.deleteById(postId);
        return "redirect:/board";
    }
}

• register() 게시글 등록 메서드 수정
  • RedirectAttributes를 사용하여 새로 만들어진 게시글의 상세 조회 화면으로 redirect하도록 한다.
• editForm() : 게시글 수정 폼
  • @PathVariable로 URL에서 게시글 id(postId)를 가져온다.
  • boardService.findOne(postId).orElseThrow()로 해당 게시글을 가져온다.
  • 새로운 PostForm 객체를 생성 후, 제목과 내용을 설정하고, model에 postForm, postId를 넣고 뷰 화면으로 넘긴다.
• edit() : 게시글 수정
  • Bean Validation 기술을 사용하여 postForm 객체를 검증한다. 에러가 있으면 board/editForm 뷰 화면을 다시 보여준다.
  • 검증에 통과하면 boardService.updateBoard()를 호출하여 게시글을 수정하고, 게시글 상세 조회 화면으로 redirect한다.
• delete() : 게시글 삭제
  • @PathVariable로 URL에서 게시글 id(postId)를 가져온다.
  • boardService.deleteById(postId);로 해당 게시글을 삭제한다.
  • 게시글 조회 화면으로 redirect 한다.

RedirectAttributes RedirectAttributes를 사용하면 URL 인코딩도 해주고, pathVarible, 쿼리 파라미터까지 처리해준다.

• 예시) redirectAttributes.addAttribute("postId", registerId); redirectAttributes.addAttribute("status", true);
• redirect:/board/{postId}
  • pathVariable 바인딩: {postId}
• 나머지는 쿼리 파라미터로 처리: ?status=true => 자동으로 pathVariable 바인딩을하며, 바인딩이 안되는 것은 쿼리 파라미터로 넘어간다.

수정용 폼 뷰 템플릿

board/editForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
    <style>
    .container{
        max-width: 700px;
    }
    .field-error {
    border-color: #dc3545;
    color: #dc3545;
    }
    </style>
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>게시글 수정</h2>
    </div>
    <form th:action th:object="${postForm}" method="post">
        <div>
            <label for="title">제목</label>
            <input type="text" id="title" th:field="*{title}" class="form-control"
                   th:errorclass="field-error">
            <div class="field-error" th:errors="*{title}" />
        </div>
        <div class="mb-3">
            <label for="content">내용</label>
            <textarea class="form-control" rows="5"
                      id="content" name="content"
                      th:value="*{content}" th:text="*{content}"></textarea>
        </div>
        <hr class="my-4">

        <button class="btn btn-primary" type="submit">
            수정 완료
        </button>

        <button class="btn btn-secondary"
                th:onclick="|location.href='@{/board/{postId}(postId=${postId})}'|"
                type="button">취소
        </button>

    </form>

</div>
</body>

수정 화면

DB에도 반영된 것을 확인할 수 있다.

삭제 후 조회

DB에도 반영된 것을 확인할 수 있다.

게시글 상세 조회 뷰 템플릿 변경

board/post.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
    <style>
    .container{
        max-width: 700px;
    }
    .field-error {
    border-color: #dc3545;
    color: #dc3545;
    }
    </style>
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>게시글</h2>
    </div>

    <button class="btn btn-dark pull-right"
            onclick="location.href='board/postList.html'"
            th:onclick="|location.href='@{/board}'|"
            type="button">목록으로
    </button>

    <div>
        <label for="postId">게시판번호</label>
        <input type="text" id="postId" name="postId" class="form-control"
               value="1" th:value="${post.id}" readonly>
    </div>

    <div>
        <label for="postTitle">제목</label>
        <input type="text" id="postTitle" name="postTitle" class="form-control"
               value="제목" th:value="${post.title}" readonly>
    </div>
    <div>
        <label for="postContent">내용</label>
        <textarea class="form-control" rows="5"
                  id="postContent" name="postContent"
                  th:value="${post.content}" th:text="${post.content}" readonly></textarea>
    </div>
    <div>
        <label for="writer">작성자</label>
        <input type="text" id="writer" name="writer" class="form-control"
               value="작성자" th:value="${post.user.loginId}" readonly>
    </div>
    <div>
        <label for="registerDate">작성일</label>
        <input type="text" id="registerDate" name="registerDate" class="form-control"
               value="작성자" th:value="${post.registerDate}" readonly>
    </div>
    <hr class="my-4">

    <form th:action="@{/board/{postId}/delete(postId=${post.id})}" method="post">

        <button class="btn btn-primary"
                th:onclick="|location.href='@{/board/{postId}/edit(postId=${post.id})}'|"
                type="button">수정</button>

        <button class="btn btn-danger" type="submit">삭제</button>
    </form>

</div> <!-- /container -->

</body>

• 게시글을 삭제 기능을 구현하기 위해 form 태그를 새로 생성
• <form th:action="@{/board/{postId}/delete(postId=${post.id})}" method="post">
• <button class="btn btn-danger" type="submit">삭제</button>

풀이

처음에는 2차원 배열과 이중 for문을 통해 배열을 탐색해서 arr[i][j] == 0이면 1~9까지의 숫자를 넣고 check한 다음, 통과하면 재귀함수sudoku(i,j+1)를 호출해서 계속 탐색해서 마지막까지 오면 배열을 출력하도록 했다. 하지만 재귀함수를 호출하여 이중 for문을 쓰면 원하는 위치에서 탐색을 시작해도 배열의 탐색이 이루어지지 않는다. 매개변수 없이 재귀함수(sudoku())를 정해도 이전 재귀함수로 돌아가는 시점(return)도 정하기 매우 어렵다.

그래서 0인 위치를 ArrayList에 넣고, 그 위치에 1~9까지의 숫자를 넣고 check한 다음, 통과하면 재귀함수 sudoku(idx + 1)을 호출한다. 여기서 idx는 ArrayList의 인덱스다.

코드

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static int[][] arr = new int[9][9];
    static ArrayList<int[]> points;

    static public boolean check(int row, int col) {
        int n = arr[row][col];
        arr[row][col] = -1; //체크할 때 현재 위치는 제외하기 위해 -1로 값을 변경한다

        //같은 열이나 같은 행에서 같은 숫자가 있는지 체크
        for (int idx = 0; idx < 9; idx++) {
            if (arr[row][idx] == n || arr[idx][col] == n) {
                return false;
            }
        }

        //3x3 정사각형 안에 같은 숫자가 있는지 체크
        int tmpRow = (row / 3) * 3;
        int tmpCol = (col / 3) * 3;

        for (int i = tmpRow; i < tmpRow+3; i++) {
            for (int j = tmpCol; j < tmpCol+3; j++) {
                if (arr[i][j] == n) {
                    return false;
                }
            }
        }

        arr[row][col] = n;
        return true;
    }

    static public void sudoku(int idx) {

        if (idx == points.size()) {

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++)
                    sb.append(arr[i][j] + " ");
                sb.append("\n");
            }
            System.out.println(sb);

            System.exit(0);
        }

        int[] tmp = points.get(idx);

        for (int k = 1; k <= 9; k++) {

            arr[tmp[0]][tmp[1]] = k;

            if (check(tmp[0], tmp[1])) {
                sudoku(idx + 1);
            }

            arr[tmp[0]][tmp[1]] = 0;

        }

    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        points = new ArrayList<>();

        for (int i = 0; i < 9; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                int n = Integer.parseInt(st.nextToken());
                arr[i][j] = n;
                if (n == 0)
                    points.add(new int[]{i, j});
            }
        }

        sudoku(0);

    }
}

• System.exit(0) : 프로그램을 바로 종료한다.
• arr[tmp[0]][tmp[1]] = k; : for문 안에서 1~9까지 숫자를 집어넣는다.
• 중요: arr[tmp[0]][tmp[1]] = 0; : 다시 0을 집어넣어야 한다. 그렇지 않으면, 이전 함수로 돌아갈 때 9가 남겨져 있는 채로 return 될 수 있다.

수정한 버전

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static int[][] arr = new int[9][9];
    static ArrayList<int[]> points;

    static public boolean check(int row, int col, int value) {

        //같은 열이나 같은 행에서 같은 숫자가 있는지 체크
        for (int idx = 0; idx < 9; idx++) {
            if (arr[row][idx] == value || arr[idx][col] == value) {
                return false;
            }
        }

        //3x3 정사각형 안에 같은 숫자가 있는지 체크
        int tmpRow = (row / 3) * 3;
        int tmpCol = (col / 3) * 3;

        for (int i = tmpRow; i < tmpRow+3; i++) {
            for (int j = tmpCol; j < tmpCol+3; j++) {
                if (arr[i][j] == value) {
                    return false;
                }
            }
        }

        return true;
    }

    static public void sudoku(int idx) {

        if (idx == points.size()) {

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++)
                    sb.append(arr[i][j] + " ");
                sb.append("\n");
            }
            System.out.println(sb);

            System.exit(0);
        }

        int[] tmp = points.get(idx);

        for (int k = 1; k <= 9; k++) {

            if (check(tmp[0], tmp[1], k)) {
                arr[tmp[0]][tmp[1]] = k;
                sudoku(idx + 1);
            }
            arr[tmp[0]][tmp[1]] = 0;
        }

    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        points = new ArrayList<>();

        for (int i = 0; i < 9; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                int n = Integer.parseInt(st.nextToken());
                arr[i][j] = n;
                if (n == 0)
                    points.add(new int[]{i, j});
            }
        }

        sudoku(0);

    }
}

• check(row, col, value)
• check 메서드를 통과한 후, arr[tmp[0]][tmp[1]] = k;
• 이렇게 하면 check 메서드에서 arr[row][col] = -1;을 하지 않아도 된다.

다른 풀이

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static int[][] arr = new int[9][9];

    static public boolean check(int row, int col, int value) {

        //같은 열이나 같은 행에서 같은 숫자가 있는지 체크
        for (int idx = 0; idx < 9; idx++) {
            if (arr[row][idx] == value || arr[idx][col] == value) {
                return false;
            }
        }

        //3x3 정사각형 안에 같은 숫자가 있는지 체크
        int tmpRow = (row / 3) * 3;
        int tmpCol = (col / 3) * 3;

        for (int i = tmpRow; i < tmpRow+3; i++) {
            for (int j = tmpCol; j < tmpCol+3; j++) {
                if (arr[i][j] == value) {
                    return false;
                }
            }
        }

        return true;
    }

    static public void sudoku(int row, int col) {

        if (col == 9) {
            sudoku(row + 1, 0);
            return;
        }

        if (row == 9) {

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++)
                    sb.append(arr[i][j] + " ");
                sb.append("\n");
            }
            System.out.println(sb);

            System.exit(0);
        }

        if (arr[row][col] == 0) {
            for (int k = 1; k <= 9; k++) {
                if (check(row, col, k)) {
                    arr[row][col] = k;
                    sudoku(row, col + 1);
                }
            }
            arr[row][col] = 0;
            return;
        }

        sudoku(row, col+1);

    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        for (int i = 0; i < 9; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        sudoku(0, 0);
    }
}

• 재귀함수: sudoku(row, col) 위치를 매개변수로 전달
• sudoku(0, 0)부터 시작해서 sudoku(row, col+1)을 재귀호출한다.
• col == 9이면 sudoku(row+1, 0)
  • return을 꼭 해야 한다. 아니면 런타임 에러(ArrayIndexOutOfBounds)가 난다.

참고: https://st-lab.tistory.com/119

게시글 등록 및 조회 기능 개발

Board 엔티티 수정

registerDate 타입을 LocalDateTime으로 하면 게시글 조회 화면에서 년-월-일T시:분:초 라고 나타나기 때문에 DateTimeFormatter를 사용해서 registerDate를 String 타입으로 저장한다.

package hello.board.entity;

import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Board {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "board_id")
    private Long id;

    private String title;
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;

    private String registerDate;

    @Builder
    public Board(String title, String content, User user, LocalDateTime registerDate) {
        this.title = title;
        this.content = content;
        this.user = user;
        this.registerDate = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(registerDate);
    }

    //==생성 메서드==//
    public static Board createBoard(String title, String content, User user) {
        return Board.builder()
                .title(title).content(content).user(user)
                .registerDate(LocalDateTime.now())
                .build();
    }

    //==비즈니스 메서드==//
    public void update(String title, String content) {
        this.title = title;
        this.content = content;
    }
}

• 생성자 메서드에 LocalDateTime을 보내면, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(registerDate);를 통해 포맷한 문자열을 registerDate에 저장한다.

ddl도 수정한다.

create table board (
       board_id bigint not null auto_increment,
        title varchar(255),
        content text,
        user_id bigint,
        register_date varchar(20),
        primary key (board_id),
        constraint fk_user_board
        foreign key (user_id)
        references users (user_id) on update cascade
    ) engine=InnoDB default charset=utf8mb4;

• register_date varchar(20)

게시글 등록용 폼 객체

PostForm

package hello.board.controller.board;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Getter @Setter
public class PostForm {

    @NotBlank(message = "제목을 입력해주세요.")
    private String title;

    private String content;
}

게시판 컨트롤러

BoardController

package hello.board.controller.board;

import hello.board.controller.SessionConst;
import hello.board.entity.Board;
import hello.board.entity.User;
import hello.board.service.BoardService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@Controller
@Slf4j
@RequiredArgsConstructor
@RequestMapping("/board")
public class BoardController {

    private final BoardService boardService;

    @GetMapping
    public String postList(Model model) {
        model.addAttribute("list", boardService.findAll());
        return "board/postList";
    }

    @GetMapping("/{postId}")
    public String postView(@PathVariable Long postId, Model model) {
        log.info("postView");

        Board post = boardService.findOne(postId).orElseThrow();
        model.addAttribute("post", post);

        return "board/post";
    }

    @GetMapping("/register")
    public String registerForm(@ModelAttribute PostForm postForm) {
        return "board/registerForm";
    }

    @PostMapping("/register")
    public String register(@Valid @ModelAttribute PostForm postForm, BindingResult bindingResult, @SessionAttribute(name = SessionConst.LOGIN_USER, required = false) User loginUser) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "board/registerForm";
        }

        boardService.register(postForm.getTitle(), postForm.getContent(), loginUser.getId());

        return "redirect:/board";
    }
}

• postList(): 게시글 전체 조회
  • boardService.findAll()의 반환 값인 List<Board>를 model에 담아서 뷰 템플릿으로 전달한다.
• postView(): 게시글 상세 조회
  • URL로 받은 postId로 게시글을 찾아 model에 담아서 뷰 템플릿에 전달한다.
• registerForm(): 게시글 등록 폼 화면
• register(): 게시글 등록
  • @Valid 어노테이션으로 PostForm 객체를 검증한다.
  • 검증에 실패하면, 에러 메시지와 함께 게시글 등록 폼 화면을 다시 보여준다.
  • @SessionAttribute로 현재 로그인한 회원(loginUser)의 정보를 얻어 id 값을 찾고, boardService.register()를 호출한다.

문제점

게시글의 내용(content)은 아무것도 입력하지 않아도 된다. 하지만, 내용에 아무것도 입력하지 않으면 BoardController의 register() 메서드의 boardService.register(postForm.getTitle(), postForm.getContent(), loginUser.getId()); 에서 NPE가 발생한다.

해결

PostForm에 @NotNull 어노테이션을 추가한다.

package hello.board.controller.board;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Getter @Setter
public class PostForm {

    @NotBlank(message = "제목을 입력해주세요.")
    private String title;

    @NotNull
    private String content;
}

게시글 조회 뷰 템플릿

board/postList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

    <div id="wrapper">
        <div class="container">
            <div class="col-md-12">
                <div class="py-5 text-center">
                    <h2>게시판</h2>
                </div>
                <button class="btn btn-dark"
                        th:onclick="|location.href='@{/}'|" type="button">
                    홈 화면
                </button>

                <button class="btn btn-primary"
                        th:onclick="|location.href='@{/board/register}'|" type="button">
                    게시글 작성
                </button>

                <hr class="my-4">

                <table class="table">
                    <thead>
                    <tr>
                        <th width="10%">게시글번호</th>
                        <th width="">제목</th>
                        <th width="20%">작성자</th>
                        <th width="20%">작성일</th>
                    </tr>
                    </thead>
                    <tbody>
                    <tr th:each="post : ${list}">
                        <td>
                            <a th:href="@{/board/{postId}(postId=${post.id})}"
                            th:text="${post.id}">게시글 번호</a>
                        </td>
                        <td>
                            <a th:href="@{/board/{postId}(postId=${post.id})}"
                            th:text="${post.title}">제목</a>
                        </td>
                        <td th:text="${post.user.loginId}">작성자</td>
                        <td th:text="${post.registerDate}">작성일</td>
                    </tr>
                    </tbody>
                </table>
                <hr class="my-4">

            </div>
        </div>
    </div>

</body>

게시글 등록 폼 뷰 템플릿

board/registerForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
    <style>
    .field-error {
    border-color: #dc3545;
    color: #dc3545;
    }
    </style>
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>게시글 등록</h2>
    </div>
    <form th:action th:object="${postForm}" method="post">
        <div>
            <label for="title">제목</label>
            <input type="text" id="title" th:field="*{title}" class="form-control"
                   th:errorclass="field-error">
            <div class="field-error" th:errors="*{title}" />
        </div>
        <div class="mb-3">
            <label for="content">내용</label>
            <textarea class="form-control" rows="5"
                      id="content" name="content" th:value="*{content}"></textarea>
        </div>
        <hr class="my-4">

        <button class="btn btn-primary btn-lg" type="submit">
            작성
        </button>
        <button class="btn btn-secondary btn-lg"
                th:onclick="|location.href='@{/board}'|"
                type="button">
            취소
        </button>

    </form>

</div>
</body>

• 내용(content)을 적는 칸에는 input 태그 대신 textarea 태그를 사용하여, 여러 줄의 텍스트를 입력할 수 있는 입력 칸을 만든다.

게시글 상세 조회 뷰 템플릿

board/post.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
    <style>
    .container{
        max-width: 700px;
    }
    .field-error {
    border-color: #dc3545;
    color: #dc3545;
    }
    </style>
</head>
<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>게시글</h2>
    </div>

    <button class="btn btn-dark pull-right"
            onclick="location.href='board/postList.html'"
            th:onclick="|location.href='@{/board}'|"
            type="button">목록으로
    </button>

    <div>
        <label for="postId">게시판번호</label>
        <input type="text" id="postId" name="postId" class="form-control"
               value="1" th:value="${post.id}" readonly>
    </div>

    <div>
        <label for="postTitle">제목</label>
        <input type="text" id="postTitle" name="postTitle" class="form-control"
               value="제목" th:value="${post.title}" readonly>
    </div>
    <div>
        <label for="postContent">내용</label>
        <textarea class="form-control" rows="5"
                  id="postContent" name="postContent"
                  th:value="${post.content}" th:text="${post.content}" readonly></textarea>
    </div>
    <div>
        <label for="writer">작성자</label>
        <input type="text" id="writer" name="writer" class="form-control"
               value="작성자" th:value="${post.user.loginId}" readonly>
    </div>
    <div>
        <label for="registerDate">작성일</label>
        <input type="text" id="registerDate" name="registerDate" class="form-control"
               value="작성자" th:value="${post.registerDate}" readonly>
    </div>
    <hr class="my-4">

    <button class="btn btn-primary"
            th:onclick="|location.href='@{/board/{postId}/edit(postId=${post.id})}'|"
            type="button">수정</button>

    <button class="btn btn-danger"
            th:onclick="|location.href='@{/board/{postId}/delete(postId=${post.id})}'|"
            type="button">삭제</button>


</div> <!-- /container -->

</body>

• 내용(content)을 적는 칸에는 input 태그 대신 textarea 태그를 사용하여, 여러 줄의 텍스트를 입력할 수 있는 입력 칸을 만든다.
  • 주의할 점: textarea 태그는 th:text를 사용해야지 넘겨받은 변수내용을 표기할 수 있다. th:value만 사용한다면 값이 표기되지 않는다.
• input 태그와 textarea 태그의 속성으로 readonly를 사용하여 수정이 불가능하도록 한다.

게시글 등록 화면

게시글 조회 화면

게시글 상세 조회 화면

풀이

백트래킹의 대표적인 문제다. 맨 첫번째 줄부터 하나씩 퀸을 놓은 다음, 그 다음 줄에 퀸을 놓는데 만약 퀸을 놓을 수 없는 자리면 그 칸은 더이상 탐색을 하지 않고 그 줄의 다음 칸에 퀸을 놓는다.

코드

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static int n, m;
    static int[][] queen;
    static int answer = 0;

    static public boolean check(int row, int col) {
        for (int i = 1; i < row; i++) { //같은 열에 퀸이 있는 경우
            if (queen[i][col] == 1) {
                return false;
            }
        }
        for (int i = row-1, j = col-1; i > 0 && j > 0; i--, j--) { //현재 놓은 위치에 대각선에 퀸이 있는 경우
            if (queen[i][j] == 1) {
                return false;
            }
        }
        for (int i = row-1, j = col + 1; i > 0 && j <= n; i--, j++) { //현재 놓은 위치에 대각선에 퀸이 있는 경우
            if (queen[i][j] == 1)
                return false;
        }
        return true;
    }

    static public void nQueen(int row) {
        if (row > n) {
            answer++;
            return;
        }

        for (int i = 1; i <= n; i++) {
            queen[row][i] = 1;
            if (check(row, i)) {
                nQueen(row + 1);
            }
            queen[row][i] = 0;
        }
    }

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        n = Integer.parseInt(br.readLine());

        queen = new int[n+1][n+1];

        nQueen(1);

        System.out.println(answer);
    }
}

• check 함수를 통해 현재 칸에 퀸을 놓을 수 있는지 체크한다. 만약 놓을 수 있으면 nQueen(row + 1)을 호출하여 다음 줄에 퀸을 놓는다.
• row > n이라면, 모든 줄에 퀸을 놓은 것이므로, answer++한다.

다른 풀이

• 2차원 배열이 아닌 1차원 배열을 사용한다. 각 원소의 index를 '열'이라 생각하고, 원소 값을 '행'이라 생각하는 것이다.
• depth는 각 줄을 의미하고, 0부터 시작한다.
• depth == N이면 count++한다.
• check 함수로 퀸이 같은 줄에 놓여있는지, 대각선 위치에 있는지 확인한다.
  • arr[col] == arr[i]
  • Math.abs(col - i) == Math.abs(arr[col] - arr[i])

    import java.util.*;
    

public class Main {

static int N;
static int[] arr;
static int count = 0;

public static void main(String[] args) {
    // TODO Auto-generated method stub

    Scanner sc = new Scanner(System.in);

    N = sc.nextInt();
    arr = new int[N];

    N_queen(0);

    System.out.println(count);
}

static void N_queen(int depth) {

    if(depth == N) {
        count++;
        return;
    }


    for(int i = 0; i < N; i ++) {
        arr[depth] = i;

        if(check(depth) == true) {
            N_queen(depth + 1);
        }
    }
}

static boolean check(int col) {

    for(int i = 0; i < col; i ++) {

        if(arr[col] == arr[i]) {
            return false;

        }else if(Math.abs(col - i) == Math.abs(arr[col] - arr[i])) {
            return false;
        }
    }

    return true;
}

}

``` 참고: https://st-lab.tistory.com/118 https://velog.io/@ilil1/%EB%B0%B1%EC%A4%80-9663%EB%B2%88-java

로그인 폼 전송용 객체

• 로그인 ID와 비밀번호를 전송하기 위한 폼 전송용 객체를 따로 생성한다.
• controller 패키지 내 login 패키지를 생성하여 login 패키지 안에서 생성한다.

UserLoginForm

package hello.board.controller.login;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotBlank;

@Getter @Setter
public class UserLoginForm {

    @NotBlank
    private String loginId;

    @NotBlank
    private String password;
}

로그인 서비스

LoginService

package hello.board.service;

import hello.board.entity.User;
import hello.board.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
@RequiredArgsConstructor
public class LoginService {

    private final UserRepository userRepository;

    /**
     * 로그인
     * @return null 로그인 실패
     */
    public User login(String loginId, String password) {
        return userRepository.findByLoginId(loginId)
                .filter(u -> u.getPassword().equals(password))
                .orElse(null);
    }
}

• 핵심 비즈니스 로직 : 로그인이 되는지 판단하는 로직 로그인의 핵심 비즈니스 로직은 회원을 조회한 다음에 파라미터로 넘어온 password와 비교해서 같으면 회원을 반환하고, 만약 password가 다르면 null을 반환한다.

Optional<User> findUser = userRepository.findByLoginId(loginId);
User user = findUser.get();
if (user.getPassword().equals(password)) {
        return user;
}
else return null;

⇒ 스트림 사용

return userRepository.findByLoginId(loginId)
                .filter(u -> u.getPassword().equals(password))
                .orElse(null);

로그인 컨트롤러

• login 패키지 안에서 생성한다.

loginController

package hello.board.controller.login;

import hello.board.entity.User;
import hello.board.service.LoginService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import javax.validation.Valid;

@Controller
@Slf4j
@RequiredArgsConstructor
public class LoginController {

    private final LoginService loginService;

    @GetMapping("/login")
    public String loginForm(@ModelAttribute("loginForm") UserLoginForm loginForm) {
        return "login/loginForm";
    }

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute("loginForm") UserLoginForm loginForm, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "login/loginForm";
        }

        User loginUser = loginService.login(loginForm.getLoginId(), loginForm.getPassword());

        if (loginUser == null) {
            log.info("login Fail");
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다");
            return "login/loginForm";
        }

        //로그인 성공 TODO

        return "redirect:/";
    }
}

• 로그인 컨트롤러는 로그인 서비스를 호출해서 로그인에 성공하면 홈 화면으로 이동하고, 로그인에 실패하면 bindingResult.reject() 를 사용해서 글로벌 오류( ObjectError)를 생성한다. 그리고 정보를 다시 입력하도록 로그인 폼을 뷰 템플릿으로 사용한다.
• 글로벌 오류는 직접 작성하는 것이 낫다. (DB 조회 과정을 거치는 경우도 있기 때문)

로그인 폼 뷰 템플릿

templates/login/loginForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
    <style>
    .container {
    max-width: 560px;
    }
    .field-error {
    border-color: #dc3545;
    color: #dc3545;
    }
</style>
</head>

<body>
<div class="container">
    <div class="py-5 text-center">
        <h2>로그인</h2>
    </div>
    <form action="item.html" th:action th:object="${loginForm}" method="post">

        <div th:if="${#fields.hasGlobalErrors()}">
            <p class="field-error" th:each="err : ${#fields.globalErrors()}"
               th:text="${err}">전체 오류 메시지</p>
        </div>

        <div>
            <label for="loginId">ID</label>
            <input type="text" id="loginId" th:field="*{loginId}" class="form-control"
                   th:errorclass="field-error">
            <div class="field-error" th:errors="*{loginId}" />
        </div>
        <div>
            <label for="password">비밀번호</label>
            <input type="password" id="password" th:field="*{password}"
                   class="form-control"
                   th:errorclass="field-error">
            <div class="field-error" th:errors="*{password}" />
        </div>

        <hr class="my-4">
        <div class="row">
            <div class="col">
                <button class="w-100 btn btn-primary btn-lg" type="submit">
                    로그인</button>
            </div>
            <div class="col">
                <button class="w-100 btn btn-secondary btn-lg"
                        th:onclick="|location.href='@{/}'|"
                        type="button">취소</button>
            </div>
        </div>
    </form>
</div> <!-- /container -->
</body>
</html>

로그인 화면

로그인 상태 유지

• 쿠키와 세션(HttpSession)을 사용하여 로그인 상태를 유지하고, 로그인이 되면 홈 화면에 사용자의 로그인 ID가 보이도록 한다.

  서블릿 HTTP 세션

• 서블릿은 세션을 위해 HttpSession 이라는 기능을 제공하는데, 세션을 생성, 조회, 삭제하는 기능을 제공한다. 추가로 세션을 일정시간 사용하지 않으면 해당 세션을 삭제하는 기능을 제공한다.
• 서블릿을 통해 HttpSession 을 생성하면 다음과 같은 쿠키를 생성한다. 쿠키 이름이 JSESSIONID이고, 값은 추정 불가능한 랜덤 값이다.

Cookie: JSESSIONID=5B78E23B513F50164D6FDD8C97B0AD05

Cookie, Session, Token 의 차이점 세션 / 쿠키 방식과 토큰의 가장 큰 차이점은 세션 / 쿠키는 세션 저장소에 유저 정보를 넣는 반면, JWT 는 토큰 안에 유저의 정보들이 넣어진다는 점 입니다. 클라이언트 입장에서는 HTTP 헤더에 세션 ID 나 토큰을 실어서 보내준다는 점에선 동일하지만, 서버 측에서는 인증을 위해 암호화를 한다 vs 별도의 저장소를 이용한다 의 차이가 발생합니다.

SessionConst

package hello.board.controller;

public abstract class SessionConst {
    public static final String LOGIN_USER = "loginUser";
}

• HttpSession 에 데이터를 보관하고 조회할 때, 같은 이름이 중복되어 사용되므로, 상수를 하나 정의했다.
• 생성하는 객체가 아니라 static final로 글자만 참조할 것이기 때문에, 추상 클래스나 인터페이스로 생성한다.

로그인 컨트롤러

package hello.board.controller.login;

import hello.board.controller.SessionConst;
import hello.board.entity.User;
import hello.board.service.LoginService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.validation.Valid;

@Controller
@Slf4j
@RequiredArgsConstructor
public class LoginController {

    private final LoginService loginService;

    @GetMapping("/login")
    public String loginForm(@ModelAttribute("loginForm") UserLoginForm loginForm) {
        return "login/loginForm";
    }

    @PostMapping("/login")
    public String login(@Valid @ModelAttribute("loginForm") UserLoginForm loginForm, BindingResult bindingResult, HttpServletRequest request) {

        if (bindingResult.hasErrors()) {
            log.info("errors = {}", bindingResult);
            return "login/loginForm";
        }

        User loginUser = loginService.login(loginForm.getLoginId(), loginForm.getPassword());

        if (loginUser == null) {
            log.info("login Fail");
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다");
            return "login/loginForm";
        }

        //로그인 성공
        //세션이 있으면 세션 반환, 없으면 신규 세션을 생성
        HttpSession session = request.getSession();

        //세션에 로그인 회원 정보 보관
        session.setAttribute(SessionConst.LOGIN_USER, loginUser);

        return "redirect:/";
    }

    @PostMapping("/logout")
    public String logout(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session != null) {
            session.invalidate();
        }
        return "redirect:/";
    }
}

세션 생성과 조회 세션을 생성하려면 request.getSession(true) 를 사용하면 된다. public HttpSession getSession(boolean create);

• request.getSession(true) : default
  • 세션이 있으면 기존 세션을 반환한다.
  • 세션이 없으면 새로운 세션을 생성해서 반환한다.
• request.getSession(false)
  • 세션이 있으면 기존 세션을 반환한다.
  • 세션이 없으면 새로운 세션을 생성하지 않는다. null 을 반환한다.

세션에 로그인 회원 정보 보관 session.setAttribute(SessionConst.LOGIN_USER, loginUser);

로그아웃 session.invalidate() : 세션을 제거한다.

HttpSession 동작원리

• request.getSession()을 하면 request 정보에서 얻어온 UUID값으로 이뤄진 쿠키의 value 값을 보고 Session들을 모아둔 Session저장소에서 동일한 sessionId(=UUID) 값이 있는지 찾는다.
• Session저장소에서 sessionId는 key값으로 쓰인다.
• 동일한 sessionId가 있으면 해당 Session을 가져오고, sessionId가 없으면 Session을 새로 만들어 반환한다.
• session.setAttribute(SessionConst.LOGIN_USER, loginUser)를 하면 request.getSession으로 가져온 특정 Session 내에 key(=SESSIONCONST.LOGIN_USER)와 value(=loginUser)를 저장시켜 나중에, sessionId를 통해 특정 Session을 가져올 때 가져온 Session 내에서 key(loginUser)를 가지고 loginUser 값을 가져올 수 있다. 참고 : 인프런 커뮤니티 질문 글

세션 생성 후, 응답에 쿠키로 jsessionid가 담겨져 클라이언트에게 전달된다. jsessionid가 발급되고 응답에 쿠키로 넣는 것은 tomcat이 처리한다. ⇒ 세션 생성 시, 세션 ID 생성 및 쿠키 생성을 tomcat이 다 처리한다.

홈 컨트롤러 수정

HomeController - homeLogin()

package hello.board.controller;

import hello.board.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.SessionAttribute;

@Controller
@Slf4j
public class HomeController {

//    @GetMapping("/")
//    public String home() {
//        log.info("home controller");
//        return "home";
//    }

    @GetMapping("/")
    public String loginHome(@SessionAttribute(name = SessionConst.LOGIN_USER, required = false) User loginUser, Model model) {

        if (loginUser == null) {
            return "home";
        }

        model.addAttribute("user", loginUser);
        return "loginHome";
    }
}

• @SessionAttribute를 사용하여 세션을 찾고, 세션에 들어있는 데이터를 찾는 과정을 편리하게 처리한다.

홈 화면 - 로그인 사용자 전용

templates/loginHome.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <link th:href="@{/css/bootstrap.min.css}"
          href="../css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container" style="max-width: 600px">
    <div class="py-5 text-center">
        <h2>홈 화면</h2>
    </div>

    <h4 class="mb-3" th:text="|로그인: ${user.loginId}|">로그인 사용자 이름</h4>

    <hr class="my-4">

    <div class="row">
        <div class="col">
            <button class="w-100 btn btn-info btn-lg" type="button"
                    th:onclick="|location.href='@{/board}'|">
                게시판
            </button>
        </div>
        <div class="col">
            <form th:action="@{/logout}" method="post">
                <button class="w-100 btn btn-dark btn-lg" type="submint">
                    로그아웃
                </button>
            </form>
        </div>
    </div>
    <hr class="my-4">

</div> <!-- /container -->
</body>
</html>

문제점

로그인을 처음 시도하면 홈 화면이 뜨지 않고 Welcom Page가 뜬다. 로그를 찍어본 결과, login을 하면 홈 화면으로 리다이렉트 되어야 하는데 리다이렉트 되지 않는다. 하지만 다른 창에서 다시 localhost로 접속하면 로그인 화면이 제대로 뜬다.

해결

로그인을 처음 시도하면 URL이 다음과 같이 jsessionid 를 포함하고 있는 것을 확인할 수 있다. http://localhost:8080/;jsessionid=6B84F014CBDF6C3D24DE6E532C83B291 이것은 웹 브라우저가 쿠키를 지원하지 않을 때 쿠키 대신 URL을 통해서 세션을 유지하는 방법이다. URL에 jsessionid가 같이 전달되어 컨트롤러에서 해당되는 URL을 찾지 못하고 Welcome Page가 뜨는 것이다. URL 전달 방식을 끄고 항상 쿠키를 통해서만 세션을 유지하고 싶으면 다음 옵션을 넣어주면 된다. 이렇게 하면 URL에 jsessionid가 노출되지 않는다. application.properties server.servlet.session.tracking-modes=cookie

TrackingModes

로그인을 처음 시도하면 URL이 다음과 같이 jsessionid 를 포함하고 있는 것을 확인할 수 있다. http://localhost:8080/;jsessionid=F59911518B921DF62D09F0DF8F83F872 이것은 웹 브라우저가 쿠키를 지원하지 않을 때 쿠키 대신 URL을 통해서 세션을 유지하는 방법이다. 이 방법을 사용하려면 URL에 이 값을 계속 포함해서 전달해야 한다. 타임리프 같은 템플릿은 엔진을 통해서 링크를 걸면 jsessionid를 URL에 자동으로 포함해준다. 서버 입장에서 웹 브라우저가 쿠키를 지원하는지 하지 않는지 최초에는 판단하지 못하므로, 쿠키 값도 전달하고, URL에 jsessionid도 함께 전달한다.

정상적으로 로그인 화면이 뜨는 것을 확인할 수 있다.

로그인 성공 화면