• https://www.acmicpc.net/problem/1926

🌻 문제 간단한 설명

• DFS, BFS 를 통해서 그림의 개수를 구하고, 그림의 최댓값을 찾는 문제다.

⚡️ 풀이

🌝 전체 코드

DFS

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
    static int Y;
    static int X;
    static int count;
    static int[] dy = {1, 0, -1, 0};
    static int[] dx = {0, 1, 0, -1};
    static String[][] map;
    static boolean[][] isVisited;

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

        Y = Integer.parseInt(st.nextToken());
        X = Integer.parseInt(st.nextToken());

        map = new String[Y][X];
        isVisited = new boolean[Y][X];

        for (int i = 0; i < Y; i++) {
            map[i] = br.readLine().split(" ");
        }

        List<Integer> answer = new ArrayList<>();
        for (int i = 0; i < Y; i++) {
            for (int j = 0; j < X; j++) {
                count = 0;
                if (!isVisited[i][j] && map[i][j].equals("1")) {
                    dfs(i, j);
                    answer.add(count);
                }
            }
        }

        Collections.sort(answer);
        System.out.println(answer.size());
        System.out.println(answer.size() == 0 ? 0 : answer.get(answer.size() - 1));
    }

    private static void dfs(int y, int x) {
        isVisited[y][x] = true;
        count++;
        for (int i = 0; i < 4; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];
            if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
                continue;
            }
            if (!isVisited[ny][nx] && map[ny][nx].equals("1")) {
                dfs(ny, nx);
            }
        }
    }
}

BFS

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static int Y;
    static int X;
    static int count;
    static int[] dy = {1, 0, -1, 0};
    static int[] dx = {0, 1, 0, -1};
    static String[][] map;
    static boolean[][] isVisited;

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

        Y = Integer.parseInt(st.nextToken());
        X = Integer.parseInt(st.nextToken());

        map = new String[Y][X];
        isVisited = new boolean[Y][X];

        for (int i = 0; i < Y; i++) {
            map[i] = br.readLine().split(" ");
        }

        List<Integer> answer = new ArrayList<>();
        for (int i = 0; i < Y; i++) {
            for (int j = 0; j < X; j++) {
                count = 0;
                if (!isVisited[i][j] && map[i][j].equals("1")) {
                    bfs(i, j);
                    answer.add(count);
                }
            }
        }

        Collections.sort(answer);
        System.out.println(answer.size());
        System.out.println(answer.size() == 0 ? 0 : answer.get(answer.size() - 1));
    }

    private static void bfs(int y, int x) {
        Queue<Point> queue = new LinkedList<>();
        queue.add(new Point(y, x));
        isVisited[y][x] = true;
        while (!queue.isEmpty()) {
            Point point = queue.poll();
            count++;
            for (int i = 0; i < 4; i++) {
                int ny = point.y + dy[i];
                int nx = point.x + dx[i];
                if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
                    continue;
                }
                if (!isVisited[ny][nx] && map[ny][nx].equals("1")) {
                    queue.add(new Point(ny, nx));
                    isVisited[ny][nx] = true;
                }
            }
        }
    }

    static class Point {
        int y;
        int x;

        public Point(int y, int x) {
            this.y = y;
            this.x = x;
        }
    }
}

🌛 코드별 설명

• 값 입력받기, 배열 생성 부분은 생략

탐색시작

// 그림의 갯수를 넣을 리스트 생성
List<Integer> answer = new ArrayList<>();
for (int i = 0; i < Y; i++) {
    for (int j = 0; j < X; j++) {
        // 그림의 넓이를 초기화 작업
        count = 0;
        if (!isVisited[i][j] && map[i][j].equals("1")) {
            bfs(i, j);
            // 탐색이 끝나면 count = 연결된 그림의 넓이이므로 답에 추가
            answer.add(count);
        }
    }
}

// BFS
private static void bfs(int y, int x) {
    Queue<Point> queue = new LinkedList<>();
    // 시작 지점 삽입
    queue.add(new Point(y, x));
    // 방문 체크
    isVisited[y][x] = true;
    while (!queue.isEmpty()) {
        Point point = queue.poll();
        // 그림의 넓이++;
        count++;
        for (int i = 0; i < 4; i++) {
            // 현위치에서 상하좌우 좌표
            int ny = point.y + dy[i];
            int nx = point.x + dx[i];
            // map, isVisited의 값을 넘지않는지 체크
            if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
                continue;
            }
            // 방문하지 않았고, 그림이 연결되어있으면 탐색영역 추가
            if (!isVisited[ny][nx] && map[ny][nx].equals("1")) {
                // 이동가능하면 탐색영역 추가
                queue.add(new Point(ny, nx));
                // BFS는 while문에서 돌기때문에 따로 방문체크
                // 반면 DFS는 초기에 한번만 방문체크 하면됨(재귀)
                isVisited[ny][nx] = true;
            }
        }
    }
}

static class Point {
    int y;
    int x;

    public Point(int y, int x) {
        this.y = y;
        this.x = x;
    }
}

// DFS 위 BFS에 설명했으므로 생략
private static void dfs(int y, int x) {
    isVisited[y][x] = true;
    count++;
    for (int i = 0; i < 4; i++) {
        int ny = y + dy[i];
        int nx = x + dx[i];
        if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
            continue;
        }
        if (!isVisited[ny][nx] && map[ny][nx].equals("1")) {
            dfs(ny, nx);
        }
    }
}

정답 출력

// 오름차순 정렬 정답 도출
Collections.sort(answer);
System.out.println(answer.size());
System.out.println(answer.size() == 0 ? 0 : answer.get(answer.size() - 1));

// 내림차순 정렬 정답 도출
// answer.sort(Collections.reverseOrder()); 도 가능
Collections.sort(answer, Collections.reverseOrder());
System.out.println(answer.size());
System.out.println(answer.size() == 0 ? 0 : answer.get(0));

🌞 끝으로

DFS, BFS는 정해진 틀이 있으므로 그것을 잘 활용하는게 중요한것 같다. 대부분 저 틀을 활용해서 문제를 풀어왔지만, 조금더 어려운 문제는 3차원 배열을 활용하거나 정답을 다른방식으로 도출하는게 문제일것이다.

• https://www.acmicpc.net/problem/17615

🌻 문제 간단한 설명

• 그리디 알고리즘을 통해 해결할 수 있다.

• 색깔별로 양쪽으로 나눌경우 이동거리의 최소값을 구하는 문제이다.
  • RBBBRBRRR : 저걸 오른쪽으로 옮긴다.
  • RBBBBRRRR(이동횟수 1) : 저걸 오른쪽으로 옮긴다.
  • BBBBRRRRR(이동횟수 2) 끝
    • 다른방법도있음
  • RBBBRBRRRR(이동횟수 1) : 4번자리로 이동
  • BBBRRBRRRR(이동횟수 2) : 3번자리로 이동 끝

⚡️ 풀이

🌝 전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

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());
        char[] balls = br.readLine().toCharArray();

        int redBall = 0;
        int blueBall = 0;

        for (char ball : balls) {
            if (ball == 'R') {
                redBall++;
            } else {
                blueBall++;
            }
        }

        int searchFrontRed = redBall - searchFront(balls, 'R');
        int searchFrontBlue = blueBall - searchFront(balls, 'B');
        int searchBackRed = redBall - searchBack(balls, 'R');
        int searchBackBlue = blueBall - searchBack(balls, 'B');

        System.out.println(Math.min(searchFrontRed, Math.min(searchFrontBlue, Math.min(searchBackRed, searchBackBlue))));
    }

    private static int searchFront(char[] balls, char color) {
        int count = 0;
        for (char ball : balls) {
            if (ball == color) {
                count++;
            } else {
                break;
            }
        }

        return count;
    }

    private static int searchBack(char[] balls, char color) {
        int count = 0;
        for (int i = balls.length - 1; i >= 0; i--) {
            if (balls[i] == color) {
                count++;
            } else {
                break;
            }
        }

        return count;
    }
}

🌛 코드별 설명

앞에서 부터 탐색

• 만약 왼쪽으로 R을 몰아버릴 경우 (RBBBRBRRR -> RRRRRBBBB)
  • 전체 R볼의 개수(5) - 왼쪽에서 연속된 R볼의 갯수(1)이다.
  • RBBBRBRRR -> RRBBBBRRR (Count 1)
  • RRBBBBRRR -> RRRBBBBRR (Count 2)
  • RRRBBBBRR -> RRRRBBBBR (Count 3)
  • RRRRBBBBR -> RRRRRBBBB (Count 4)

int searchFrontRed = redBall - searchFront(balls, 'R');

private static int searchFront(char[] balls, char color) {
    int count = 0;
    for (char ball : balls) {
        if (ball == color) {
            count++;
        } else {
            break;
        }
    }

    return count;
}

뒤에서 부터 탐색

• 만약 오른쪽으로 R을 몰아버릴 경우(RBBBRBRRR -> BBBBRRRRR)
  • 전체 R볼의 개수(5) - 오른쪽에서 연속된 R볼의 갯수(3)이다.
  • RBBBRBRRR -> RBBBBRRRR (Count 1)
  • RBBBBRRRR -> BBBBRRRRR (Count 2)

int searchBackRed = redBall - searchBack(balls, 'R');

private static int searchBack(char[] balls, char color) {
    int count = 0;
    for (int i = balls.length - 1; i >= 0; i--) {
        if (balls[i] == color) {
            count++;
        } else {
            break;
        }
    }

    return count;
}

🌞 끝으로

그리디 알고리즘 문제를 풀어봤다. 그리디 알고리즘은 주어진 상황에서 최적해를 구하는 알고리즘이지 전체적으로 봤을때 최적해를 보장하지 않는 알고리즘이다. 그래서 앞에 R, 앞에 B, 뒤에 R, 뒤에 B 이렇게 주어진 조건에 한에서 최적해를 구하고 그 중에서 Math.min을 통해서 최적해를 찾았다.

• https://www.acmicpc.net/problem/1446

🌻 문제 간단한 설명

• DP를 활용해서 최소 이동거리를 구하는 문제이다.

• if(지름길이 있고 && 그냥 이동하는 거리 < 지름길을 이용하는 거리) 일경우 지름길을 선택한다.
  • 예) 0 -> 50 (그냥 이동거리 50)
  • 지름길 (0 50 10) 이용시 이동거리 10
  • 50 < 10 이므로 dp[50] 의 값은 10 이다.

⚡️ 풀이

🌝 전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

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

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

        int[] dp = new int[M + 1];
        int[][] shortcuts = new int[N][3];

        for (int i = 0; i < N; i++) {
            shortcuts[i] = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        }

        Arrays.sort(shortcuts, (o1, o2) -> o1[0] - o2[0]);

        for (int i = 1; i <= M; i++) {
            dp[i] = dp[i - 1] + 1;
            for (int[] shortcut : shortcuts) {
                if (i == shortcut[1]) {
                    dp[i] = Math.min(dp[i], dp[shortcut[0]] + shortcut[2]);
                }
            }
        }

        System.out.println(dp[M]);
    }
}

🌛 코드별 설명

• 입력받고 배열 생성하는 부분은 생략한다.

정렬

• 지름길의 시작지점을 기준으로 정렬해준다.

• 정렬에는 다양한 방법이 있다.

// 참고로 이건 오름차순
Arrays.sort(shortcuts, (o1, o2) -> o1[0] - o2[0]);

or

Arrays.sort(shortcuts, Comparator.comparingInt(o -> o[0]));

// 이건 내림차순
Arrays.sort(shortcuts, (o1, o2) -> o2[0] - o1[0]);

DP 값 입력 & 정답 출력

for (int i = 1; i <= M; i++) {
    // dp[1] = 1 거리 기본값 저장
    dp[i] = dp[i - 1] + 1;
    // 지름길 하나씩 순회하면서 탐색 (최대길이 12)
    for (int[] shortcut : shortcuts) {
        // i = 현재거리 / shortcut[1] = 지름길 도착위치
        if (i == shortcut[1]) {
            // Math.min의 비교값 설명
            // dp[i] -> 지름길을 타지 않았을 경우의 거리
            // dp[shortcut[0](지름길 시작지점)] -> 지름길 시작지점의 최소이동거리
            // shrtcut[2] -> 지름길을 이동했을 경우 소요 이동거리
            dp[i] = Math.min(dp[i], dp[shortcut[0]] + shortcut[2]);
        }
    }
}

System.out.println(dp[M]);

🌞 끝으로

DP의 문제의 핵심은 점화식을 찾는것이다. 어떻게 문제의 규칙성을 파악하고 어떻게 문제를 해결해야할지 생각할 시간이 많이 필요한 문제이다. 화이팅

• https://www.acmicpc.net/problem/14940

🌻 문제 간단한 설명

• BFS 알고리즘을 사용하는 문제이다.

• 메모리 제한이 있기 때문에 무턱대고 System.out.println을 사용해선 안된다.
• DFS, BFS는 거의 틀이 잡혀있기 때문에 문제를 많이 풀면 이해하기 쉬울 것이다.

⚡️ 풀이

🌝 전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    static int Y;
    static int X;
    static int[] dy = {1, 0, -1, 0};
    static int[] dx = {0, 1, 0, -1};
    static int[][] map;
    static boolean[][] isVisited;

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

        map = new int[Y][X];
        isVisited = new boolean[Y][X];
        for (int i = 0; i < Y; i++) {
            map[i] = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        }

        boolean flag = false;
        int startY = 0, startX = 0;
        for (int i = 0; i < Y; i++) {
            if (!flag) {
                for (int j = 0; j < X; j++) {
                    if (map[i][j] == 2) {
                        map[i][j] = 0;
                        flag = true;
                        startY = i;
                        startX = j;
                        break;
                    }
                }
            }
        }

        bfs(startY, startX);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < Y; i++) {
            for (int j = 0; j < X; j++) {
                if (!isVisited[i][j] && map[i][j] == 1) {
                    sb.append(-1).append(" ");
                } else {
                    sb.append(map[i][j]).append(" ");
                }
            }
            sb.append("\n");
        }

        System.out.println(sb);
    }

    private static void bfs(int startY, int startX) {
        Queue<Point> queue = new LinkedList<>();
        queue.add(new Point(startY, startX));
        isVisited[startY][startX] = true;
        while (!queue.isEmpty()) {
            Point point = queue.poll();
            int y = point.y;
            int x = point.x;
            for (int i = 0; i < 4; i++) {
                int ny = y + dy[i];
                int nx = x + dx[i];
                if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
                    continue;
                }
                if (!isVisited[ny][nx] && map[ny][nx] == 1) {
                    queue.add(new Point(ny, nx));
                    isVisited[ny][nx] = true;
                    map[ny][nx] = map[y][x] + 1;
                }
            }
        }
    }

    static class Point {
        int y;
        int x;

        public Point(int y, int x) {
            this.y = y;
            this.x = x;
        }
    }
}

🌛 코드별 설명

시작 지점 설정 & 값 초기화

• 시작지점이 따로 정해져있지 않고 숫자 2가 있는곳에서 출발 한다.

• 또한 새로운 int[][]을 만들지 않고 덮어씌울 예정이라 값을 0으로 초기화 했다.
• 물론 새로운 answer[][]을 만들어서 해도된다.(해보니 통과함)
  • 난 이게 편한듯

boolean flag = false;
int startY = 0, startX = 0;
for (int i = 0; i < Y; i++) {
        if (!flag) {
            for (int j = 0; j < X; j++) {
                if (map[i][j] == 2) {
                    map[i][j] = 0;
                    flag = true;
                    startY = i;
                    startX = j;
                    break;
                }
            }
      }
}

bfs(startY, startX);

정답 출력

• 여기서 메모리 초과를 해서 시간이 오래 걸렸다.

• 원래 갈 수 있는 땅인 부분 중에서 도달할 수 없는 위치는 -1을 출력한다.
• 그래서 두 코드의 메모리의 차이를 알고 싶어서 찾아봤는데 메모리 차이가 거의 없다고 한다. 하지만 실제 문제를 의도하고 출제를 하였다면 문제는 틀렸다. 최대한 메모리를 적게 사용하는 방법을 택해야겠다.

Before (메모리 초과)

for (int i = 0; i < Y; i++) {
    for (int j = 0; j < X; j++) {
        if (!isVisited[i][j] && map[i][j] == 1) {
            map[i][j] = -1;
        }
    }
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < Y; i++) {
    sb.append(Arrays.stream(map[i])
                    .mapToObj(String::valueOf)
                    .reduce((x, y) -> x + " " + y)
                    .orElse(""))
                    .append("\n");
}

System.out.println(sb);

After (성공)

StringBuilder sb = new StringBuilder();
for (int i = 0; i < Y; i++) {
    for (int j = 0; j < X; j++) {
        if (!isVisited[i][j] && map[i][j] == 1) {
            sb.append(-1).append(" ");
        } else {
            sb.append(map[i][j]).append(" ");
        }
    }
    sb.append("\n");
}

System.out.println(sb);

BFS

• 전형적인 BFS 코드이다.

• 2(시작지점) 지점을 0으로 초기화를 해줬기 때문에 마지막에 이전의 칸의 값을 + 1 해줬다.

private static void bfs(int startY, int startX) {
    Queue<Point> queue = new LinkedList<>();
    queue.add(new Point(startY, startX));
    isVisited[startY][startX] = true;
    while (!queue.isEmpty()) {
        Point point = queue.poll();
        int y = point.y;
        int x = point.x;
        for (int i = 0; i < 4; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];
            if (ny < 0 || nx < 0 || ny >= Y || nx >= X) {
                continue;
            }
            if (!isVisited[ny][nx] && map[ny][nx] == 1) {
                queue.add(new Point(ny, nx));
                isVisited[ny][nx] = true;
                map[ny][nx] = map[y][x] + 1;
            }
        }
    }
}

🌞 끝으로

시간복잡도, 공간복잡도, 메모리를 계산하면서 풀려고 해야겠다. 아직까지 그 부분이 조금 부족한듯하다. (솔직히 잘 모름) 만약 구글링이 안 됐으면 거의 하루종일 못 풀었을 듯하다.

프로세스(process)

• 프로그램이 메모리에 올라가 인스턴스화 된것 (독립적으로 실행되는 개체)

• 프로세스 간의 자원 공유는 좀 더 복잡한 절차를 거쳐 이루어짐
• 프로세스는 최소 1개의 스레드(thread)를 존재

프로세스의 메모리 구조

스택

• 프로세스의 실행 시 함수 호출과 지역 변수를 저장하고 관리하는 메모리 영역
• 메모리가 늘거나 줄어들수 있음

  힙

• 프로그램 실행 중 동적 할당을 위해 사용되는 메모리 영역

  데이터 영역

• 프로세스의 전역 변수와 정적 변수를 저장하는 공간

  코드 영역

• 프로그램의 코드

PCB

• 운영체제에서 프로세스에 대한 메타데이터를 저장한 데이터

• 일반 사용자가 접근하지 못하도록 커널 스택의 가장 앞부분에서 관리

• 프로세스 관리와 스케줄링을 용이하게 하고, 프로세스 간 전환(context switch)을 원활하게 수행

• 프로세스 식별자(Process ID) : 프로세스를 고유하게 식별하는 번호

• 프로세스 상태(Process State) : 프로세스의 현재 상태를 나타내는 정보

• 프로그램 카운터(Program Counter, PC) : 프로세스에서 실행해야 할 다음 명령어의 주소에 대한 포인터

• 레지스터 상태(Register State) : 프로세스가 실행되는 동안 사용되는 레지스터들의 상태를 저장(이 정보는 프로세스 간 전환 시 필요)

• 메모리 관리 정보(Memory Management) : 프로세스의 메모리 할당을 관리하기 위한 정보

• 프로세스 우선순위(Process Priority) : 프로세스 대기열에서 스케줄링 알고리즘에 따라 실행 순서를 정하기 위해 사용되는 우선순위 값

• 입출력 상태 및 정보(Input/Output Status, Information): 프로세스에 할당된 I/O 디바이스 목록

• 계정 정보(Accounting Information) : 프로세스 실행에 사용된 CPU사용량, 실행한 유저의 정보

컨텍스트 스위칭(context switching)

• 운영 체제에서 실행 중인 프로세스(혹은 스레드)를 중단하고 다른 프로세스(혹은 스레드)로 전환하는 과정

• 여러 프로세스들이 동시에 실행되는 것처럼 느껴지게 하며, 프로세서의 사용을 효율적으로 관리(아주 빠른 속도로 실행)

실행 순서

1. 현재 실행 중인 프로세스(Process P1)의 상태를 PCB에 저장
2. 다음 실행할 프로세스(Process P2)를 결정
3. 프로세스의(Process P2) PCB에서 프로세서 상태와 관련된 정보를 가져와 프로세서에 로드

스레드(thread)

• 프로세스 내에서 독립적으로 실행되는 작업의 흐름

• 프로세스 내의 코드와 자원을 공유(스레드 간에 데이터 공유와 통신이 상대적으로 간단)
• 자신만의 스택 공간을 가지며, 프로세스의 다른 스레드와 힙 공간, 전역 변수, 프로세스 코드 등을 공유
• CPU에서 실행되는 단위(unit of execution)

멀티스레딩 & 멀티프로세싱

멀티스레딩

• 프로세스 내 작업을 여러 개의 스레드, 멀티스레드로 처리하는 기법

• 스레드끼리 메모리, 파일, 그리고 네트워크 리소스와 같은 프로세스 내부의 코드와 데이터를 공유
• 한 스레드가 중단 되어도 다른 스레드는 실행 상태일 수 있기 때문에 중단되지 않는 빠른 처리 가능(동시성)
• 한 스레드에 문제가 생기면 다른 스레드에 영향을 끼쳐 프로세스에 영향을 줄수도 있음

멀티프로세싱

• 여러 개의 프로세서(CPU)가 동시에 작업을 수행하는 컴퓨팅 방식

• 여러 프로세스들 또는 스레드들을 병렬로 처리(프로세스 중 문제가 발생되더라도 다른프로세스를 이용 -> 신뢰성 높음)

대칭 다중처리(SMP, Symmetric multiprocessing)

• 두 개 이상의 프로세서가 메모리와 기타 시스템 리소스를 공유하는 방식

• 모든 CPU가 동등한 상태로 동작하며, 운영 체제에서 각 프로세서에 작업을 균등하게 분산하는 스케줄링 방식
• 부하 분산을 효과적으로 수행(한 프로세서가 필요할 때 다른 프로세서의 작업을 쉽게 전달가능)

비대칭 다중처리(ASMP, Asymmetric multiprocessing)

• 각 프로세서가 전용 역할을 수행하고 특정 작업이나 리소스에 대한 권한이 할당된 구조

• 특정 프로세서가 시스템 관리 업무(Master)를 전담하고, 나머지 프로세서들이 사용자 작업(Slave)을 전담
• 특정 프로세서가 오버헤드를 처리하므로, 다른 프로세서들이 더 효과적으로 동작

📎 참고자료

• 프로세스, 스레드, 멀티태스킹, 멀티스레딩, 멀티프로세싱, 멀티프로그래밍, 이 모든 것을 한 방에 깔끔하게 설명합니다!! 콘텐츠 퀄리티 만족하실 겁니다!
• [CS전공지식면접] 프로세스와 스레드의 차이는?
• Process와 Thread의 차이
• [10분 테코톡] 🌷 코다의 Process vs Thread

네트워크 프로토콜

네트워크 통신을 하기 위해서 통신에 참여하는 주체들이 따라야 하는 형식, 절차, 규약

OSI 7 Layer

• 네트워크 프로토콜 기능을 계층구조로 모델링

• 범용적인 네트워크 구조
• 각 레이어의 프로토콜은 하위 레이어의 프로토콜이 제공하는 기능을 사용하여 동작

🤔 왜 사용하는가 ?

• 모듈화: 각 계층은 독립적이며 서로 다른 기능을 수행하므로, 하나의 계층의 기능을 개선하거나 변경해도 다른 계층에 영향을 주지 않는다.
• 네트워크 통신의 이해와 표준화: OSI 7 계층의 구조를 통해 네트워크 전문가들이 통신의 원리와 함께 각 계층의 역할과 책임을 더 잘 이해할 수 있으며, 기기 간의 호환성이 폭넓게 보장된다.
• 간편한 문제 해결: 계층화된 구조로 인해 문제 발생 시 해당 부분을 명확하게 파악하고 손쉽게 원인을 찾아 수정할 수 있다.

응용 계층 (Application Layer)

• 사용자 인터페이스와 네트워크를 연결하는 역할을 담당

• 다양한 프로토콜과 응용 프로그램을 지원
  • HTTP : 웹 사이트를 이용하는 데 사용되는 프로토콜
  • DNS : 도메인 이름과 IP 주소를 매핑해주는 서버
  • SMTP : 메일 전송을 위한 인터넷 표준 통신 프로토콜
  • FTP : 장치간의 파일을 전송하는 데 사용되는 표준 통신 프로토콜
  • SSH : 암호화 네트워크 프로토콜

표현 계층 (Presentation Layer)

• 애플리케이션 간의 통신에서 메시지 포맷 관리

• 암/복호화 및 압축/해제와 같은 서비스를 제공

세션 계층 (Session Layer)

• 사용자 간의 상호작용 및 서버간의 연결 세션을 관리하고, 연결 유지와 세션 종료를 처리

전송 계층 (Transport Layer)

• 애플리케이션 간의 통신 담당

• 데이터 전송의 오류 및 흐름을 관리

• TCP(전송 제어 프로토콜) : 패킷 사이의 순서를 보장하고 연결지향 프로토콜을 사용해 연결, 신뢰성을 구축해서 수신 여부를 확인 (가상회선 패킷 교환 방식)

• UDP(사용자 데이터그램 프로토콜) : 순서를 보장하지 않고 수신 여부를 확인하지 않으며 단순히 데이터만 주는 프로토콜 (데이터그램 패킷 교환 방식)

네트워크 계층 (Network Layer)

• 다른 네트워크와의 원활한 데이터 전송을 위해 IP 주소 등의 라우팅 및 경로 설정을 담당(데이터 전송)

• 네트워크 간의 최적의 경로 설정

데이터 링크 계층 (Data Link Layer)

• 인접한 노드 간의 통신 담당

• MAC 주소기반 통신
  • IP 주소 -> MAC 주소 (ARP 프로토콜)
  • MAC 주소 -> IP 주소 (RARP 프로토콜)

물리 계층 (Physical Layer)

• 비트 단위의 데이터를 전송하는 데 사용되는 하드웨어와 기초적인 연결 방식을 정의

📎 참고자료

• [네트워크] 가상회선 패킷 교환 vs 데이터그램 패킷 교환
• 면접을 위한 CS 전공지식 노트 - 주홍철
• [Q&A] 네트워크 | OSI 7계층 - 홍달쌤
• [입문용] 프로토콜과 OSI 7 layer 설명! 네트워크의 기능들이 어떻게 구조화 돼서 동작하는지를 설명합니다! 👍 - 쉬운코드

😌 졸업

5개월 동안 멋쟁이 사자처럼 백엔드 스쿨 3기 학습과정을 어제 마쳤다. 아직 까지는 실감이 나질 않는다. 이제 진짜 시작이라는 느낌이 강하게 든다. 짧다면 짧고 길다면 긴 시간이 지나 좋은 사람들도 많이 사귀었다. 많이 배우고 많이 성장할 수 있는 기간이었다. 이제 취업이라니...

😁 앞으로 계획

🐻 알고리즘 공부

알고리즘 공부를 꾸준히 해야겠다. 꾸준하게 공부를 해야 할 부분인 것 같다. 나의 최종 목표인 대기업을 가기 위해서는 알고리즘은 필수이기 때문에 길게 꾸준히 공부를 할 생각이다. 우선 하루에 2문제 정도 꾸준히 풀려고 노력할 것!!

🐼 CS공부

비전공자이기 때문에 CS 공부가 부족한건 현실이다. 이 부분을 인정하고 전공자처럼 비슷한 수준이 되기 위해서는 꾸준한 학습이 필요하다. 유튜브 & 강의 & 도서를 통해서 꾸준한 학습을 할 예정이다.

🐹 1차, 2차 프로젝트 리펙토링

프로젝트를 함으로써 많이 부족한 부분이 많았다. 강사님들의 피드백도 많이 받았고 지금에서야 다시 보면 수정이 필요한 부분이 더럿 보인다. 또한 이력서를 지원할 때 포트폴리오도 중요하기 때문에 팀원들과 프로젝트를 리펙토링 할 계획이다. 또한 스프링부트, JPA를 더 학습을 병행할 계획이다.

🐱 취업준비

우선 지금 제일 중요한 부분이 취업이다. 교육기간이 끝나고 강사님의 교육수료 후 10 계명에서 많은 것을 느꼈다. 혼자서 공부하는 것도 좋지만 실무에서 배우는 게 제일 좋다고 하셨다. 강사님이 말한 것처럼 취업을 위해서 나는 아직 더 공부해야 한다라는 생각이 강했는데 우선 취업을 준비하면서 부딪혀 볼 생각이다.

• 하루에 30~1시간 정도 채용공고 확인하기
  • 나는 음악을 좋아해서 음악관련 회사에 가고 싶다.
  • SI 보다는 스타트업에 가고싶다.
• 이력서, 자소서 다듬기
  • 첫 이력서, 자소서다 보니 많이 부족하다. 그래서 계속 보완을 해야겠다.

🥲 끝으로..

멋쟁이사자처럼의 품을 떠나 이제 홀로서기를 해야 할 시간이다. 짧았던 5개월 동안 스스로 많이 발전하게 된 시간이었다. 이제 취업을 해야해서 걱정이 되지만...무엇보다 좋은 사람들을 만나게 돼서 너무 좋았다. 같이 알고리즘을 공부했던 스터디원, 1차 프로젝트 팀원, 2차 프로젝트 팀원 그 외 궁금한 점을 서로 공유했던 훈련생들 그리고 5개월 동안 좋은 교육을 준비를 해주신 강사님, 특별강사님, 멘토님 마지막으로 운영에 힘써주신 매니저님들 전부 만나서 너무 좋았다. 혼자였으면 힘들었겠지만 같이 함께해서 좋은 결과로 끝을 맺을 수 있었다. 다들 각자의 위치해서 열심히 해서 모두 행복했으면 좋겠다. 끝으로 내가 제일 좋아하는 Juice Wrld의 명언으로 마무리..

"The goal in life is not to live forever but to create something that will - Jucie Wrld"

자~ 취업 드가자

Jira가 뭘까 ?

• 프로젝트 관리를 위한 강력한 이슈 추적 도구로, 팀의 업무를 조직화하고 추적하며 원활한 협업업무를 제공한다.

Jira의 핵심 기능과 개념

프로젝트(Project)

• JIRA에서 프로젝트 단위로 이슈를 관리하는 공간
• 각 프로젝트마다 독립된 설정값을 따르며 이슈키의 ID도 다른 형태로 생성

이슈(Issue)

• 보드 내 생성된 작업들을 이슈라고 한다.
• 크게 Epic, Story, Task, Bug, Sub-Task를 기본적으로 사용
• 팀이 작업의 상태와 진행 상황을 파악할 수 있도록 도와준다.

이슈 키

• Jira로 추적하는 모든 작업에 대한 고유 식별자
• GitHub 와 연동하여 Commit , Branch , PR 등등 활용가능

1. 프로젝트 키
2. 일련 번호

에픽(Epic)

• 스프린트를 거쳐 완료되는 정도의 작업량을 가진 업무
• Stroy들을 묶은 상위 개념의 기능을 의미
• 기능에 대한 정의만하지 상세한 기술은 Stroy를 통해 설명

스토리(Story)

• 최소 단위의 요구사항을 말한다.
• 하나의 Epic에 여러개의 Stroy 가능

태스크(Task)

• 하나의 스토리를 완성하기 위한 구체적인 작업들
  • 디자인
  • 기술검토
  • 개발
  • 문서화

• Story 를 눌러 하위 이슈 추가 버튼 클릭

백로그

• 일반적으로 팀이 프로젝트에서 수행할 작업 (해야 할일들의 목록)

1. 백로그 : 백로그의 현재 문제 목록입니다(여기에 몇 가지 문제가 표시되어 어떻게 표시되는지 알 수 있습니다).
2. 이슈 상세 보기 : 현재 선택된 이슈의 상세 보기입니다.

이슈 만들기

로드맵 탭에서 만들기 에픽 클릭

• ex) HAPPY-44 게시판 관련 기능 구현 작업 예시

에픽 생성후 하위 스토리 생성

• 해당 스토리 자세히 보기 / 수정도 가능

백로그 탭에서 스토리 추가 확인 가능

백로그 탭에서 이슈 생성가능 하지만 따로 에픽,스토리 설정해줘야함

스프린트

• 백로그에서 작업을 완료하는 고정된 기간

스프린트 만들기

백로그 탭으로 이동후 스프린트 만들기 클릭

해당 스프린트에 대한 내용 기입

해당 스프린트에 수행할 백로그 이동(Drag)후 스프린트 시작

• 해당 스프린트는 2주차 기능구현으로 예시를 듦

보드 탭에서 해당 스프린트 별 내용 확인 가능

로드맵 탭에서도 해당 스프린트 내용 확인 가능

Jira와 GitHub 연동 작업

작업할 이슈를 선택

• ex) 이슈코드 HAPPY-43 작업

해당 이슈에 대한 Branch 생성

• Repository / Branch from / Branch name 설정

• 해당 이슈코드로 Branch 가 생성된 것을 볼 수 있다.

해당 Branch 에서 작업 (커밋 메시지에 이슈코드 삽입 X)

• Git Convention 을 지키며 메시지 작성
• ex) 작업 예시 md파일 수정

IDE 에서 원격으로 생성된 브런치 가져오기

• 해당 내용은 위에서 사용하는 이슈코드 HAPPY-43 이 아닌 다른 걸로 진행됩니다
• 제가 실수로 HAPPY-43을 이미 머지를 해버려서...

원격 Branch명 확인

IDE 터미널에서 git fetch 입력해서 원격 브런치 가져오기

git fetch --prune

가져온 브런치 확인 git branch -r

브런치 변경 git checkout HAPPY-119

Branch PR생성

해당 PR 제목은 이슈코드를 제외 한 기능 이름 사용

Jira에서 Branch , PR 확인 가능

해당 Branch 작업 종료후 Merge

Jira에서 Merge 확인

Jira에서 WorkFlow 수정

• 우선 Lombok에서 제공하는 어노테이션 3개를 떠올릴 수 있다.

  @NoArgsConstructor

• 매개변수가 없는 기본 생성자를 자동으로 생성
• JPA에서는 프록시를 생성을 위해서 기본 생성자를 반드시 하나를 생성해야한다.

  @NoArgsConstructor
  public class Example {
    private String field;
  }
  

↓

public class Example { private String field;

public Example() {
}

}

## @AllArgsConstructor
- 모든 필드를 매개변수로 받는 생성자를 자동으로 생성
- 매우 편리하게 생성자를 만들어주지만, 별 생각없이 작성한 코드가 치명적인 버그를 만들어낼 수도 있다.
```java
@AllArgsConstructor
public class Example {
    private String field;
}

↓

public class Example {
    private String field;

    public Example(String field) {
        this.field = field;
    }
}

@RequiredArgsConstructor

• 필드 중 초기값이 할당되지 않은 final 필드, 그리고 @NonNull 어노테이션으로 표시된 필드를 매개변수로 받는 생성자를 자동으로 생성

  @RequiredArgsConstructor
  public class Example {
    private final String field1;
    @NonNull
    private String field2;
  }
  

↓

public class Example { private final String field1; private String field2;

public Example(String field1, String field2) {
    if (field2 == null) {
      throw new NullPointerException("field2 is marked non-null but is null");
    }
    this.field1 = field1;
    this.field2 = field2;
}

}

## 결론
- 물론 편하게 위 생성자를 사용해서 생성자를 만드는것도 좋지만, **_사소한 객체 생성부터 고민해보는 것이 클린 코드, 유지 보수를 고려한 좋은 코드를 만들 수 있는 습관이 된다고_** 한다.
- 최대한 `@RequiredArgsConstructor`, `@AllArgsConstructor`사용을 지양하며 `@NoArgsConstructor`에 생성자의 접근레벨을 `PROTECTED`로 해준뒤 생성자를 생성할경우 `@Builder`를 붙여주는 방향으로 해야겠다.
```java
// refactor 전 코드 
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ReviewImage {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long Id;
    @ManyToOne
    private Review review;
    @NotNull
    private String imageUrl;
}

// refactor 후 코드
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class CommentImage {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long Id;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "comment_id")
    private Comment comment;
    @NotNull
    private String imageUrl;

    @Builder
    public CommentImage(Comment comment, String imageUrl) {
        this.comment = comment;
        this.imageUrl = imageUrl;
    }
}

• 엔티티를 생성해줬음에도 DB에서는 아무런 정보를 찾을수 없었다.

문제 해결

• application.yml에서 따로 설정을 해주어야 한다.

  jpa: JPA(Java Persistence API)에 대한 설정을 지정하는 섹션 hibernate: Hibernate ORM(Object-Relational Mapping)에 대한 설정을 지정하는 섹션입니다. Hibernate는 JPA의 구현체 중 하나로 많이 사용됩니다. ddl-auto: 데이터베이스 스키마의 생성 및 변경 방법을 설정 create: 애플리케이션 시작 시 매번 데이터베이스 스키마를 새로 생성

회고

이것 또한 엄청 초보적인 실수를 저지르고 말았다. 다음에는 똑같은 실수를 하지 않겠습니다.

문제

• 위 사진과 같이 @CreatedDate, @LastModifiedDate를 어노테이션을 사용을 했음에도 DB에는 null값이 저장이 되었다.

문제 해결

• @CreatedDate, @LastModifiedDate 어노테이션이 활성화 되기 위해서는 @EnableJpaAuditing 을 붙여 주어야 한다.
• @EnableJpaAuditing : Spring Data JPA에서 제공하는 기능으로, JPA 엔티티에 대한 감사(Auditing) 기능을 활성화하는 데 사용됩니다. 감사 기능을 활성화하면 엔티티의 생성일(created date) 및 수정일(modified date)을 자동으로 추적할 수 있습니다.

회고

이렇게 간단한 문제로 시간을 잡아 먹혔다는 것을 조금 반성을 해야겠다. 다음부터는 똑같은 실수는 일어나지 않을것같다. 충격 그 자체

• 구글 API를 활용해서 소셜로그인 기능을 구현을 했다.

    @Column(unique = true)
    private String username;
    private String password;
    private String name;
    @Column(unique = true)
    private String nickName;
    @Column(unique = true)
    private String email;
    @Builder.Default
    private String role = "user";
    private String providerTypeCode;

  //MemberService
  Member member = Member
                .builder()
                .providerTypeCode(providerTypeCode)
                .username(username)
                .password(password)
                .name(name)
                .nickName(nickName)
                .email(email)
                .build();

• 에러내용

  • 에러내용 There was an unexpected error (type=Internal Server Error, status=500). could not execute statement; SQL [n/a]; constraint [member.UK_mbmcqelty0fbrvxp1q58dn57t] org.springframework.dao.DataIntegrityViolationException: could not execute statement; SQL [n/a]; constraint [member.UK_mbmcqelty0fbrvxp1q58dn57t]

• 이런 에러가 발생했다.

• GPT에게 문의 한 답변

  해당 에러는 내부 서버 오류(Internal Server Error)로, 데이터 무결성(Data Integrity) 제약조건 위반으로 인해 SQL 문장을 실행할 수 없음을 나타냅니다. 보다 구체적으로는 "member.UK_mbmcqelty0fbrvxp1q58dn57t" 제약조건이 위반되었음을 알려줍니다. 이 에러는 주로 데이터베이스 시스템에서 발생하는데, 일반적으로 테이블에 대해 고유한(unique) 제약조건이 설정되어 있는 경우, 그 제약조건을 위반하는 데이터를 삽입하려고 할 때 발생할 수 있습니다.

• 그래서 혹시 뭐가 문제인지 하나씩 빼고 실행을 해보니 nickName, email에서 문제가 발생했다. 아마 원인이 @Column(unique = true) 를 설정해줘서 join()에 "" 값을 넣어서 저장해서 원인이 발생한듯 했다.

문제 해결 방법

1. 우선 첫번째 방법으로는 nickName, email에 @Column(unique = true) 값을 제거 해주면 정상 작동하였다.

• 하지만 이번 프로젝트에서는 nickName, email 값이 유니크해야 하므로 이방법은 패스 하게 되었다.

2. 두번째 방법으로는 join()메소드에 ""값을 넣어주는 것이 아닌 null을 넣어주는 방법으로 해결하였다.

문제에 대한 궁금증

• 이러한 에러가 발생한 이유가 뭘까 ?

  • email, nickName의 값을 unique로 설정해주었지만 소셜로그인을 하게 되면 전부다 ""로 저장되기 때문에 같은 값을 저장해서 원인이 발생했다.

• 이렇게 해결하는게 최선의 방법일까 ?

  • 추후 업데이트 예정

네이버 클라우드 플랫폼에서 포트 열어주기

젠킨스 설치하기

• 열어 주었던 8081포트에 설치

  docker run \\
  --name jenkins_1 \\
  -p 8081:8080 \\
  -e TZ=Asia/Seoul \\
  -v /docker_projects/jenkins_1/var/jenkins_home:/var/jenkins_home \\
  -v /var/run/docker.sock:/var/run/docker.sock \\
  -v /docker_projects/jenkins_1/data:/data \\
  -u root \\
  -d \\
  --restart unless-stopped \\
  jenkins/jenkins:lts

• --name jenkins_1 : 컨테이너의 이름을 "jenkins_1"로 지정
• -p 8081:8080 : 호스트의 8081 포트와 컨테이너의 8080 포트를 매핑
• -e TZ=Asia/Seoul : 컨테이너 내부에서 사용할 타임존을 "Asia/Seoul"로 설정
• -v docker_projects/jenkins_1/var/jenkins_home:/var/jenkins_home : 호스트의 /docker_projects/jenkins_1/var/jenkins_home 경로와 컨테이너의 /var/jenkins_home 경로를 볼륨 매핑 / Jenkins 설정과 데이터를 영구적으로 보관
• -v /var/run/docker.sock:/var/run/docker.sock : 호스트의 Docker 소켓 파일(/var/run/docker.sock)을 컨테이너 내부의 동일한 경로에 바인드 (Docker 명령을 컨테이너에서 실행가능)
• -v /docker_projects/jenkins_1/data:/data : 호스트의 /docker_projects/jenkins_1/data 경로와 컨테이너의 /data 경로를 볼륨 매핑 / Jenkins 작업 데이터를 영구적으로 보관
• -u root: 컨테이너 내부에서 root 사용자로 실행
• -d: 컨테이너를 백그라운드에서 실행 (데몬)
• --restart unless-stopped : 컨테이너가 비정상적으로 종료되었을 때 자동으로 재시작
• jenkins/jenkins:lts : 사용할 Docker 이미지를 jenkins/jenkins:lts로 지정

  젠킨스 로그인

초기 비밀번호 확인

docker exec jenkins_1 cat /var/jenkins_home/secrets/initialAdminPassword

JDK Update

# jenkins_1 컨테이너 내부로 들어가서 작업을 수행
docker exec -it jenkins_1 bash

# 패키지 관리자인 apt를 사용하여 패키지 목록을 최신 상태로 업데이트
apt-get update

# 컨테이너 내부에서 openjdk-17-jdk 패키지를 설치
apt-get install openjdk-17-jdk -y

젠킨스 컨테이너 내에 Docker 설치

# jenkins_1 bash 접속
docker exec -it jenkins_1 bash

apt-get update -y
apt-get install -y ca-certificates curl gnupg lsb-release
mkdir -p /etc/apt/keyrings
rm /etc/apt/keyrings/docker.gpg
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update
apt-get install -y docker-ce docker-ce-cli docker-compose-plugin

• apt-get update -y : 패키지 업데이트
• apt-get install -y ca-certificates curl gnupg lsb-release : Docker 설치를 위해 종속성 패키지 설치
• mkdir -p /etc/apt/keyrings : /etc/apt/keyrings 경로에 디렉토리를 생성 (APT 패키지 매니저의 키링(keyring) 파일을 저장하기 위한 공간)
• rm /etc/apt/keyrings/docker.gpg : /etc/apt/keyrings/docker.gpg 파일을 삭제 (Docker의 공식 GPG 키를 저장하기 위한 용도)
• curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg : Docker의 공식 GPG 키를 다운로드하여 /etc/apt/keyrings/docker.gpg 파일로 저장(GPG 키는 APT가 Docker의 패키지를 신뢰할 수 있는지 확인하는 데 사용)
• echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null : Docker의 APT 저장소 정보를 /etc/apt/sources.list.d/docker.list 파일에 저장 (Docker 관련 패키지를 설치)
• apt-get update : 패키지 업데이트
• apt-get install -y docker-ce docker-ce-cli docker-compose-plugin : Docker와 Docker Engine 및 Docker Compose의 구성 요소 설치

젠킨스에서 Pipeline 생성

Credentials을 이용해 secret.yml 자동 업로드

• Credentials : 보안 관련 정보를 저장하고 관리하기 위한 기능
• 원격 Git 저장소에서 코드를 가져올 때 인증 정보를 사용하거나, 도커 레지스트리에 이미지를 푸시할 때 인증 정보를 사용

파이프 라인 작성

빌드 성공

Github Webhooks 설정

젠킨스 트리거 설정

자동배포 성공

Git push 트리거 생성

젠킨스 자동 빌드 실행

☠️ 배포 작업중 막혔던 내용

🤯 openjdk-17-jdk

• JDK를 Doker에서는 설치를 해줘서 왜 안되지 하면서 계속 JDK 삭제하고 다시 설치하고, 또 환경변수 설정이 잘못됐나 확인하며 시간을 많이 보냈다.

😏 해결 방법

• 젠킨스에서 JDK를 사용하기 위해서는 설정을 해줘야 한다.

  1. 젠킨스 관리 페이지에 로그인합니다.
  2. 좌측 메뉴에서 "시스템 설정"을 선택합니다.
  3. JDK 섹션으로 스크롤하거나 "JDK installations..." 링크를 클릭합니다.
  4. "Add JDK" 버튼을 클릭하여 새로운 JDK 설정을 추가합니다.
  5. JDK 설정 페이지에서 다음 정보를 입력합니다:
  6. "Name": JDK의 이름을 지정합니다. (예: JDK 11)
  7. "JAVA_HOME": JDK의 설치 경로를 입력합니다.
  8. 저장을 클릭하여 JDK 설정을 저장합니다

🤯 Docker Rm Fail

• 처음 빌드 할경우 Docker Rm은 정상 작동한다. 하지만 이후 Build Docker Images 에서 실패를 할경우 다시 재빌드를 하게 되면 이전에 Docker Rm에서 이미 이미지와 컨테이너가 삭제 되었기 때문에 삭제할게 없어서 에러가 발생한다.

😏 해결방안

• 수동으로 도커이미지와 도커컨테이너를 만들어주고 빌드를 돌린다.
• 파이프라인에서 도커이미지, 도커컨테이너가 있으면 삭제하고 없으면 넘어간다 라는 파이프라인 코드를 작성해 준다. (추후 도전예정)

🤯 Build Docker image

• 도커 이미지 빌드에서 오류가 났다. 분명 리눅스 환경에서는 명령어가 잘 수행하지만 빌드에서는 실패를 했다. 원인을 찾다보니 Dockerfile을 찾을수 없다고 한다. 하지만 분명 리눅스 환경에서 도커파일을 설치했는데 의문이 들었다. 그래서 도커파일을 못찾는 줄 알고 경로를 설정하거나 절대경로를 설정해도 원인을 찾을수 없었다.

😏 해결방안

• 깃 레포지터리에 Dockerfile을 따로 만들어 주어야 한다. 리눅스환경에 도커파일이 있으면 될줄 알았지만 아니였다. 파이프라인은 도커 -> 젠킨스 컨테이너 -> 젠킨스내부의 도커 에서 실행되기 떄문이다.

🤯 Githook

• Payload URL 정보가 잘못됐다고 한다. 원인을 몰라서 http -> https도 바꿔보고 포트를 8080으로 바꿔보고 해봐도 되지않았다.

😏 해결방안

• 수정예정

HTTP(Hypertext Transfer Protocol)

• 인터넷에서 웹 페이지를 전송하는 데 사용되며, 데이터 전송 시에 보안 기능이 없다.
• HTTP는 암호화되지 않기 때문에 누구나 데이터를 볼 수 있다.
• 개인 정보를 전송하는 경우 보안에 취약

HTTPS(Hypertext Transfer Protocol Secure)

• HTTPS는 SSL(Secure Sockets Layer) 또는 TLS(Transport Layer Security) 프로토콜을 사용하여 데이터를 암호화하고 보호
• 제 3자가 볼 수 없다. 개인 정보를 전송하는데 안전함
• 기관으로부터 검증된 사이트만 주소에 https 사용이 허가해줌
  • 접속하는 사이트가 믿을만한 사이트인지 알려준다.

🔑 대칭키(Symmetric Key)

• 하나의 비밀 키(secret key)를 사용하여 암호화와 복호화를 수행하는 암호화 방식
• 빠르고 간단한 구현이 가능하기 때문에 대용량 데이터를 암호화하는 데 유용

🔑 비대칭키(Asymmetric Key)

• 공개 키(public key)와 비밀 키(secret key) 두 개의 키를 사용하여 암호화와 복호화를 수행하는 암호화 방식
• 대칭키보다 더 안전하며, 공개 키는 유출시 문제가 없다.
• 인터넷에서 정보를 안전하게 교환하는 데 널리 사용

📎 참고영상

• HTTPS가 뭐고 왜 쓰나요? (Feat. 대칭키 vs. 비대칭키)

• 프로그램 동작시 발생하는 모든일을 기록하는 행위
• 기록 자체를 로그(log)라고 함
• 출력형식을 지정할 수 있음
• 로깅 시스템은 메시지 레벨에 따라 출력될 메시지를 필터링하고 지정가능
• 콘솔뿐아니라 파일, 네트워크에도 로그를 별도에 위치에 남길 수 있음
• 디버깅을 사용하기 어려운 환경에서의 최선의 선택

💡 로그레벨

• 로그에 남겨지는 메시지의 중요도를 나타내는 수준

  개발자가 의도한 에러

  • TRACE : 가장 상세한 로그 레벨, 개발환경에서 버그를 해결하기 위해 사용
  • DEBUG : 개발 단계에서 프로그램의 실행 과정을 추적하기 위해 사용, 일반적으로 코드 흐름과 변수의 값을 추적
  • INFO : 명확한 의도가 있는 에러, 요구사항에 따라 시스템 동작을 보여줄때 사용
  • WARN : 에러가 될 수 있는 잠재적 가능성이 있는 경우 (ex : 데이터베이스 연결이 실패하거나, 파일을 찾을 수 없는 경우)

  ---

  개발자가 의도하지 않은 에러

  • ERROR : 로그는 반드시 처리, 의도하지 않은 에러가 발생하는 경우 (프로그램 종료 X)
  • FATAL : 애플리케이션이 실행 중지될 수 있는 치명적인 오류

🔎 디버깅

• 예외사항을 가장 잘 파악할 수 있음 (변수의 값이나, 메모리 주소등을 breakPoint 를 활용해 확인가능)
• 소프트웨어 버그(Bug)를 찾아내고 수정하는 과정
• 스택 트레이스(Stack Trace)나 콘솔 출력 등의 디버깅 정보를 활용하여 버그를 추적하고 해결

System.out.println()

• 간단한 디버깅용으로 사용되는 콘솔 출력 메소드
• 프로그램에서 로그 메시지를 수집하거나 분석하는 데 사용 X

🔎 SLF4J(Simple Logging Facade for Java)

• 로깅 프레임워크
• 자바 어플리케이션에서 로깅에 대한 추상화 계층을 제공하는 인터페이스를 제공 (단독으로 사용 X)

SLF4J 모듈

• Bridge : 다른 로깅 API로부터 SLF4J API로 연결해주는 도구, Binding과 같은 프레임워크를 사용 X
• API : 로깅에 대한 추상 레이어(인터페이스) 제공, 하나의 API모듈에 하나의 Binding을 둬야한다.
• Binding : API를 로깅구현체와 연결하는 도구

📎 참고 자료

• [10분 테코톡] ☂️ 검프의 Logging(로깅) #1
• [10분 테코톡] ☂️ 검프의 Logging(로깅) #2
• [10분 테코톡] 🥂무늬의 로깅

int[] -> List

List<Integer> intList = Arrays.stream(arr)
                              .boxed() // int -> Integer
                              .collect(Collectors.toList());

오름차순 정렬

int[] sortedArr = Arrays.stream(arr)
                        .sorted()
                        .toArray();

절대값 기준으로 정렬

int[] sortedArr = Arrays.stream(arr)
                        .boxed() // int -> integer
                        .sorted(Comparator.comparingInt(Math::abs))
                        .mapToInt(Integer::intValue)
                        .toArray();

List<>

List -> Array

List<Integer> list = new ArrayList<>();
int[] array = list.stream().mapToInt(Integer::intValue).toArray();

HashMap<K,V>

value 값으로 정렬하기

Map<Integer, Float> map = new HashMap<>();

map.entrySet().stream()
//오름차순        .sorted(Map.Entry.comparingByValue())
//내림차순        .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                .mapToInt(Map.Entry::getKey)
                .toArray();

값 넣기 (값이 있으면 + 1, 없으면 0)

HashMap<Integer, Integer> hashMap = new HashMap<>();
for (int arr : array) {
    hashMap.put(arr, hashMap.getOrDefault(arr, 0) + 1);
}

Value 값으로 Key값 구하기

for (Map.Entry<Integer, Integer> hash : hashMap.entrySet()) {
    if (hash.getValue() == maxValue) {
        answer.add(hash.getKey());
    }
}

Set<>

정규식

0~9 값인지

String.matches("^[0-9]+$");

String.matches("\\d+");

📕 CORS

• 다른 출처간(웹사이트, API주소)의 리소스(주고 받는 데이터)를 추가 HTTP 헤더를 사용해 다른 출처의 리소스에 접근할 수 있는 권한을 부여하도록 브라우저에 알려주는 체제

  작동방식

1. 요청에 Origin이라는 header(받는 쪽의 IP주소, 사용할 프로토콜...)를 추가 (scheme(요청할자원의 접근방법 http,ftp...), 도메인, 포트) 해서 API로 보낸다.
2. API서버는 답장 header에 지정된 ACAO 정보를 실어서 보낸다.
3. 브라우저가 origin에서 보낸 출처값이 서버의 답장 헤더에 담긴 ACAO에 똑같이 있으면 리소스를 공유해준다.

출처(origin)이란 ?

📗 CORS의 종류

Simple Request

• 브라우저에서 본 요청을 바로 보내며 서버에서는 추가적인 처리 없이 요청을 처리할 수 있습니다.

Preflight Request

• 본 요청을 보내기 전에 서버가 본 요청을 수락할 수 있는지 확인하기 위한 과정, 요청에 의해서 서버 정보가 바뀔 수 있기 때문에.
• HTTP 메서드 중 OPTIONS 메서드를 사용하며, 브라우저는 이에 대한 응답으로 서버가 허용하는 메서드, 헤더, 출처 등에 대한 정보를 받아옵니다.

  SOP(Same Origin Policy)

• SOP는 같은 출처에 속하는 리소스끼리는 자유롭게 상호작용할 수 있도록 허용하고, 다른 출처의 리소스에는 접근할 수 없도록 제한
• XSS(Cross-Site Scripting) 공격과 CSRF(Cross-Site Request Forgery) 공격을 방지하는 데 중요한 역할

ACAO(Access-Control-Allow-Origin)

• CORS(Cross-Origin Resource Sharing)에서 서버에서 브라우저로 응답을 보낼 때 허용되는 출처(origin)를 설정하는 HTTP 헤더
• 서버에서 브라우저로 보내는 응답에 포함되며, 브라우저는 이를 통해 자신이 요청한 리소스가 허용된 출처에서 온 것인지 확인

📎 참고영상

• 웹개발 짜증유발자! CORS가 뭔가요?
• [10분 테코톡] 🌳 나봄의 CORS

• Java Servlet, JavaServer Pages(JSP), Java Expression Language(EL)과 같은 Java 기술을 사용하여 동적인 웹 페이지를 생성하고,웹 어플리케이션을 실행
• 가볍고 빠르며, 모듈화된 아키텍처를 통해 필요한 기능만 선택하여 사용할 수 있습니다.
• 톰캣은 다양한 운영체제와 플랫폼에서 실행할 수 있다.

🤔 톰캣을 왜 사용할까 ?

• JSP 컴파일러 : 톰캣은 JSP 컴파일러인 Jasper를 내장하고 있어, JSP 페이지를 빠르고 효율적으로 실행할 수 있습니다.
• 서블릿 컨테이너 : 톰캣은 서블릿 컨테이너를 포함하고 있어, 웹 어플리케이션에서 서블릿을 실행하고 관리할 수 있습니다. 이를 통해, 동적인 웹 어플리케이션 개발이 용이해집니다.

서블릿

• 자바 언어로 작성된 서버 사이드 웹 어플리케이션의 구성 요소 중 하나로, HTTP 요청에 대한 동적인 처리를 담당
• 서블릿은 HTTP 요청에 대한 처리를 위한 doGet(), doPost(), doPut() 등의 메소드를 제공하며, 필요한 경우에는 init()과 destroy() 등의 메소드를 오버라이딩하여 서블릿의 생명 주기를 관리할 수 있습니다.

서블릿 컨테이너

• 클라이언트로부터 요청을 받아, 해당 요청을 처리하는 서블릿을 호출하고, 서블릿의 실행 결과를 클라이언트에게 반환합니다.
  • 서블릿의 생명 주기를 관리하고, HTTP 요청 및 응답 처리, 멀티 스레드 처리, 세션 관리, 보안 등 다양한 기능을 제공
• 서블릿 컨테이너로는 Apache Tomcat, Jetty, JBoss 등이 있습니다.

Coyote

• Tomcat의 HTTP 커넥터(클라이언트와 서버 간에 HTTP 요청과 응답을 주고받는 역할) 구현체

Catalina

• Tomcat의 서블릿 컨테이너 구현체
• 웹 어플리케이션의 시작과 종료, HTTP 요청 및 응답 처리, 세션 관리, JSP 컴파일 등을 수행

Jasper

• Tomcat의 JSP(JavaServer Pages / HTML과 Java 코드를 혼합하여 동적인 웹 페이지를 생성하는 기술) 컴파일러
• JSP 파일을 컴파일하여 서블릿 클래스로 변환하고, 그 결과를 서블릿 컨테이너(예: Tomcat의 Catalina)에 전달

📎 참고영상

• Great-Stone - 톰캣 유튜브

IPv4

• 현재 인터넷에서 가장 널리 사용되는 IP 버전 중 하나
• 0~255사이의 숫자 4개로 이루어져 있다.
• IPv4 주소의 수가 한정되어 있어서, 인터넷의 빠른 성장으로 인해 주소 고갈 문제가 발생 / 이를 해결하기위해 IPv6가 개발

IPv6

• IPv4의 주소 고갈 문제를 해결하고 더 많은 주소를 사용할 수 있도록 개발되었다.
• 128비트 이진수로 구성되어 있으며, 보통 8개의 16진수 블록으로 표시

포트포워딩(port forwarding)

• 인터넷을 통해 연결된 장치에서 어떤 포트로 들어오는 데이터 패킷을 다른 장치로 전달하는 네트워크 설정 방법
• 수신 데이터가 NAT 방화벽을 우회하도록 하여 인터넷 연결 속도를 개선
• 내부 네트워크에 있는 특정 포트를 외부로 포워딩 (외부에서 내부 네트워크의 서비스에 접속가능)

DMZ

• 내부 네트워크와 외부 네트워크 사이에 위치한 별도의 지역
• 서버나 장비는 내부 네트워크와는 별도로 관리되며, 외부에서 접속 가능한 IP 주소를 사용

DDNS

• 동적 IP 주소를 가진 장치들을 쉽게 인터넷에 연결하기 위해 사용되는 기술
• 인터넷에 연결된 기기들이 쉽게 액세스되도록 하기 위한 서비스로, 인터넷에 연결된 기기들의 IP 주소를 고정 IP 주소로 변환하여 사용자가 쉽게 기기에 접속할 수 있도록 해준다.

📎 참고영상

• IP주소를 알아봅시다! (Feat. 공인/사설/고정/유동IP, 포트포워딩, DMZ, DDNS)

이미 8080포트를 사용하고 있어서 사용을 못한다고 한다. 8080포트를 사용하는 PID 번호를 찾아준다.

lsof -i :8080

저렇게 PID 번호가 나온다. 그럼 터미널을 열어서 8080를 사용하는 프로세스를 죽여준다.

kill -9 PID번호