Computer Science Knowledge Storage

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
SWEA 1218 괄호 짝짓기입니다.

포인트

닫힌 괄호 ), ], }, >는 항상 그에 대응하는 열린 괄호 (, [, {, <보다 뒤에 나와야 합니다.
따라서 문자열을 순회하면서 닫힌 괄호를 만날 때마다 최근에 열린 괄호와 짝이 맞는지 확인해주는 방식으로 유효성을 판단할 수 있습니다.

이를 위해 가장 적절한 자료구조는 LIFO(Last-In-First-Out) 구조인 스택(Stack) 입니다.

• 열린 괄호는 스택에 저장하고,
• 닫힌 괄호를 만났을 때 스택의 top과 매칭되는 열린 괄호인지 확인합니다.
• 괄호가 올바르게 짝지어지지 않았거나, 스택이 비어있는 경우 → 올바르지 않은 문자열로 판단합니다.
• (), {}, [], <>의 네 종류 괄호 짝을 모두 고려합니다.

소스코드

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

public class Q1218 {
    private static int tc = 10, len;
    private static Set<Character> openSet = new HashSet<>();
    private static Map<Character, Character> closeMap = new HashMap<>();

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

        for (int t = 1; t <= tc; t++) {
            sb.append("#").append(t).append(" ");
            len = Integer.parseInt(br.readLine());
            Stack<Character> validation = new Stack<>();
            String line = br.readLine();
            boolean check = true;
            for (int i = 0; i < len; i++) {
                char cur = line.charAt(i);
                if (openSet.contains(cur)) {
                    validation.add(cur);
                } else {
                    char open = closeMap.get(cur);
                    if (open == validation.peek()) {
                        validation.pop();
                    } else {
                        check = false;
                        break;
                    }
                }
            }
            if (!validation.isEmpty()) {
                check = false;
            }
            sb.append(check ? 1 : 0).append("\n");
        }
        System.out.println(sb);
    }

    private static void init() {
        openSet.add('(');
        openSet.add('{');
        openSet.add('[');
        openSet.add('<');

        closeMap.put(')', '(');
        closeMap.put('}', '{');
        closeMap.put(']', '[');
        closeMap.put('>', '<');
    }
}

코드 설명

• 전역변수
  • openSet: 여는 괄호 집합
  • closeMap: 닫는 괄호 -> 여는 괄호 대응 매핑
• init() 함수
  
  • 열린 괄호들을 Set에 넣고, 닫힌 괄호의 대응 관계를 Map에 저장합니다.
  • 코드의 유연성과 가독성을 높이기 위해 사용된 초기 설정입니다.

main() 함수

Stack<Character> validation = new Stack<>();
boolean check = true;

• 스택을 이용한 검사
  • validation 스택을 사용해 열린 괄호를 저장합니다.
  • check 변수는 문자열의 유효성을 판별하는 플래그입니다.

for (int i = 0; i < len; i++) {
    char cur = line.charAt(i);
    if (openSet.contains(cur)) {
        validation.add(cur);
    } else {
        char open = closeMap.get(cur);
        if (open == validation.peek()) {
            validation.pop();
        } else {
            check = false;
            break;
        }
    }
}

• 문자 순회 및 처리
  • 열린 괄호 → 스택에 push
  • 닫힌 괄호 → 스택 top과 비교 후 pop 또는 실패 처리
  • 만약 스택이 비어있거나 짝이 맞지 않으면 실패로 처리
• 반복이 끝났는데도 스택이 비어있지 않으면, 열린 괄호가 닫히지 않은 경우 -> 실패

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
SWEA 1226 미로1입니다.

포인트

• 먼저 시작점과 목표 지점을 설정합니다.
• 시작점으로부터 상하좌우 방향으로 이동 가능한지를 순회하면서 탐색을 진행합니다.
• 이동 중에는 벽은 갈 수 없도록 범위 체크를 합니다.
• 또한 이미 방문한 구간은 다시 탐색하지 않도록 처리하여 중복을 방지합니다.

위 조건을 기반으로, 너비 우선 탐색(BFS)를 사용해 전체 경우를 탐색합니다.

소스코드

package SWExpert.Implementation;

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

public class Q1226 {
    static class Pair {
        int x, y;

        public Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    private static int tc = 10, ROW = 16, COL = 16;
    private static int[][] miro;
    private static boolean[][] visited;
    private static Pair start, end;
    private static int[] dx = {-1, 0, 1, 0};
    private static int[] dy = {0, 1, 0, -1};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        for (int t = 1; t <= tc; t++) {
            br.readLine();
            init();
            for (int i = 0; i < ROW; i++) {
                String line = br.readLine();
                for (int j = 0; j < COL; j++) {
                    miro[i][j] = line.charAt(j) - '0';
                    if (miro[i][j] == 2) {
                        start = new Pair(i, j);
                    } else if (miro[i][j] == 3) {
                        end = new Pair(i, j);
                    }
                }
            }

            adventure();

            sb.append("#").append(t).append(" ").append(visited[end.x][end.y] ? 1 : 0).append("\n");
        }
        System.out.println(sb);
    }

    private static void adventure() {
        Queue<Pair> q = new LinkedList<>();
        q.add(start);
        visited[start.x][start.y] = true;

        while (!q.isEmpty()) {
            Pair cur = q.poll();

            for (int idx = 0; idx < 4; idx++) {
                int nx = cur.x + dx[idx];
                int ny = cur.y + dy[idx];
                if (canGo(nx, ny)) {
                    visited[nx][ny] = true;
                    q.add(new Pair(nx, ny));
                }
            }
        }
    }

    private static boolean canGo(int x, int y) {
        if (!inRange(x, y)) {
            return false;
        }

        if (visited[x][y] || miro[x][y] == 1) {
            return false;
        }

        return true;
    }

    private static boolean inRange(int x, int y) {
        return 0 <= x && x < ROW && 0 <= y && y < COL;
    }

    private static void init() {
        miro = new int[ROW][COL];
        visited = new boolean[ROW][COL];
    }
}

코드 설명

• Pair 클래스
  BFS 탐색을 위해 (x, y) 위치를 저장하는 단순한 좌표 클래스
• main() 함수
  • 한 테스트 케이스마다 미로를 입력받고, 2는 시작점, 3은 도착점으로 저장합니다.
  • adventure() 함수를 통해 BFS로 탐색을 수행합니다.
  • 최종적으로 도착 지점을 방문했는지 여부에 따라 1 또는 0을 출력합니다.

• adventure() 함수
  BFS 탐색
  
  • BFS 큐를 통해 너비 우선 탐색을 수행합니다.
  • 다음 위치 (nx, ny)가 갈 수 있는 위치이면 큐에 추가하고 방문 처리합니다

• init()
  테스트케이스에 따른 초기화 함수(miro 배열, visited 배열)
• inRange(int x, int y)
  x, y가 격자 내에 있는지 판단하는 함수
  • ROW와 COL을 기준으로 좌표가 16×16 격자 안에 있는지 확인합니다.
• canGo(int x, int y)
  다음 칸을 갈 수 있는지 판단
  • 격자 범위를 벗어나지 않았고
  • 아직 방문하지 않았으며
  • 벽(1)이 아니라면 true 반환

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁
SWEA 2819 격자판의 숫자 이어붙이기입니다.

포인트

제가 생각한 포인트는 다음과 같습니다.

1. 4X4의 격자
   1. 시작점이 16개
2. 완전탐색 가능성
   1. 총 7개의 길이.
   2. 16 * 4^6 = 2^16의 작업
   3. Java기준 4초 내 가능 => 완전탐색 가능
3. DFS(재귀)를 통한 탐색
   1. 각 칸을 시작점으로 재귀적으로 탐색하여 경로를 구성.
   2. 각 숫자는 중복을 허용하지 않는 점. => HashSet 사용

소스코드

package SWExpert.Implementation;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class Q2819 {
    private static int tc;
    private static int[][] nums;
    private static Set<String> s;
    private static int[] dx = {-1, 0, 1, 0};
    private static int[] dy = {0, 1, 0, -1};

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

        nums = new int[4][4];

        for (int t = 1; t <= tc; t++) {
            sb.append("#").append(t).append(" ");
            s = new HashSet<>();

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

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 4; j++) {
                    findNums(0, i, j, "" + nums[i][j]);
                }
            }
            sb.append(s.size()).append("\n");
        }
        System.out.println(sb);
    }

    public static void findNums(int depth, int x, int y, String num) {
        if (depth == 6) {
            s.add(num);
            return;
        }

        for (int idx = 0; idx < 4; idx++) {
            int nx = x + dx[idx];
            int ny = y + dy[idx];
            if (inRange(nx, ny)) {
                findNums(depth + 1, nx, ny, num + nums[nx][ny]);
            }
        }
    }

    private static boolean inRange(int x, int y) {
        return 0 <= x && x < 4 && 0 <= y && y < 4;
    }
}
/*
1
1 1 1 1
1 1 1 2
1 1 2 1
1 1 1 1
 */

코드 설명

• main 함수
  • BufferedReader와 StringTokenizer를 사용해 빠르게 입력을 처리합니다.
  • 4×4 격자를 2차원 배열 nums에 저장합니다.
  • 격자의 모든 칸을 시작점으로 삼아, (i, j) 위치에서부터 DFS 재귀 함수 findNums를 호출합니다.
• inRange(int x, int y)
  
  • 좌표 (x, y)가 격자 범위(0 이상 4 미만) 내에 있는지 확인하는 함수입니다.
  • 상하좌우로 이동할 때 격자를 벗어나지 않도록 범위 체크에 사용됩니다.
• findNums(int depth, int x, int y, String num)
  재귀 함수, (x, y)를 기준으로 num 선언
  
  • DFS 방식의 재귀 함수입니다.
  • 현재 좌표 (x, y)에서 시작해 문자열 num을 이어 붙이며 탐색합니다.
  • depth == 6이 되면 총 7자리 수가 완성된 것이므로 HashSet에 저장합니다.
  • 상하좌우로 이동하기 위해 dx, dy 배열을 사용하여 다음 위치 (nextX, nextY)를 구하고, 범위 내에 있다면 재귀적으로 계속 탐색합니다.

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

해당 포스팅은 Github Action 사용법 정리입니다.

서론

GitHub Actions는 소프트웨어 워크플로우를 자동화하는 도구입니다. 이를 통해 코드를 빌드하고, 테스트하고, 배포하는 과정을 간소화할 수 있습니다. 특히 GitHub Actions는 YAML 파일을 기반으로 정의되며, 다양한 이벤트(예: push, pull request, cron 등)에 따라 실행됩니다.

이번 포스팅에서는 GitHub Actions의 기본 개념과 함께, API를 기능별로 자동화하거나 Python 프로젝트에서 유용하게 사용할 수 있는 예제를 소개합니다.

Github Actions 기본개념

GitHub Actions를 이해하기 위해 알아야 할 주요 개념은 다음과 같습니다

1. Workflow
   • 자동화된 프로세스의 가장 상위 개념으로, 여러 Job으로 구성됩니다.
   • YAML 파일로 정의되며, .github/workflows 폴더에 저장됩니다.
2. Event
   • Workflow를 실행하는 특정 조건이나 규칙입니다.
     예: 브랜치로의 push, pull_request, schedule(cron) 등.
3. Job
   • 특정 작업 단위를 정의하며, 여러 Step으로 구성됩니다.
   • 독립적으로 실행되거나 다른 Job과 병렬 실행이 가능합니다.
4. Step
   • 각 작업(Job)을 구성하는 단위로, 커맨드 실행 또는 액션 사용이 가능합니다.
5. Action
   • Workflow의 재사용 가능한 가장 작은 구성 요소입니다.
     예: actions/checkout@v2를 사용하여 리포지토리를 체크아웃.

Workflow 정의 방법

GitHub Actions의 Workflow는 .github/workflows 디렉토리에 .yml 파일로 작성됩니다. 아래는 간단한 Workflow 예제입니다.

on:
    push:
      branches: [ master ]
    pull_request:
      branches: [ master ]

• on (이벤트 정의)
  Workflow를 Trigger(실행)하는 조건을 정의합니다.
  • 주요 이벤트:
    • push: 특정 브랜치나 태그로 코드가 푸시될 때 실행.
    • pull_request: 특정 브랜치로 PR(Pull Request)이 생성되거나 업데이트될 때 실행.
    • schedule: 특정 시간에 반복적으로 실행(Cron 표현식 사용).
    • 여러 이벤트를 정의할 수 있으며, 배열로 작성 가능합니다.

jobs:
    build:
      runs-on: ubuntu-latest

      steps:
      - uses: actions/checkout@v2
      - name: Run a one-line script
        run: echo Hello, world!

      - name: Run a multi-line script
        run: |
          echo Add other actions to build,
          echo test, and deploy your project.

• jobs
  Workflow는 여러 Job으로 구성되며, 각 Job은 독립적으로 실행됩니다.
  
  • 병렬 실행: 기본적으로 여러 Job은 병렬로 실행됩니다.
  • build라는 job을 생성하고, 그 아래에 2개의 step이 존재하는 구조
    • runs-on은 어떤 OS에서 실행될지 지정
    • name: Job의 이름을 지정.
    • runs-on: Job이 실행될 운영 체제(OS) 환경을 지정
    • env: 환경변수 등록Job의 주요 요소:
  • steps의 uses는 어떤 액션을 사용할지 지정함. 이미 만들어진 액션을 사용할 때 지정

기본 Workflow 예제

name: CI workflow

on:
  push:
    branches:
      - dev
  pull_request:
    branches:
      - dev

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '17'

      - name: Grant execute permission for gradlew
        run: chmod +x ./gradlew

      - name: Build with Gradle
        run: ./gradlew clean build --info

      - name: Upload Artifact
        uses: actions/upload-artifact@v3
        with:
          name: spring-app
          path: build/libs/*.jar

  deploy:
    needs: build
    runs-on: ubuntu-latest

    steps:
      - name: Download Artifact
        uses: actions/download-artifact@v3
        with:
          name: spring-app

      - name: Deploy JAR to AWS
        uses: appleboy/scp-action@v0.1.4
        with:
          host: ${{ secrets.AWS_SERVER_IP }}
          username: ${{ secrets.AWS_USERNAME }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          source: "*.jar"
          target: "~/proj"

      - name: Restart Application on AWS
        uses: appleboy/ssh-action@v0.1.10
        with:
          host: ${{ secrets.AWS_SERVER_IP }}
          username: ${{ secrets.AWS_USERNAME }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            # Define variables
            DEPLOY_DIR=~/proj
            JAR_FILE=server-0.0.1-SNAPSHOT.jar

            # Kill process on port 8080
            echo "Stopping existing server..."
            PID=$(sudo lsof -t -i:8080)
            if [ -n "$PID" ]; then
              sudo kill -9 $PID
            fi

            # Navigate to deployment directory
            cd $DEPLOY_DIR || exit

            # Start the new server
            echo "Starting new server..."
            nohup java -jar $JAR_FILE > app.log 2>&1 &
            echo "Server restarted. Logs can be found in $DEPLOY_DIR/app.log"

YAML 파일 설명

해당 yaml은 dev 브랜치에 이벤트가 발생할 때마다 AWS 서버에 실행 중인 서버를 껏다가 업데이트 된 것으로 실행하는 workflow입니다.

1. build Job:
   • GitHub Actions에서 코드 체크아웃, JDK 설치, 빌드, 그리고 생성된 JAR 파일을 아티팩트로 업로드합니다.
2. deploy Job:
   • 빌드된 JAR 파일을 다운로드하여 AWS 서버로 전송한 후, 애플리케이션을 재시작합니다.
   • 기존 서버 프로세스를 종료하고 새 JAR 파일로 서버를 실행합니다.

분석

이벤트 트리거

• on:
  • push 또는 pull_request 이벤트가 dev 브랜치에서 발생하면 Workflow가 실행됩니다.

build Job

• runs-on:
  • Job이 실행될 환경으로 ubuntu-latest를 사용합니다.
• steps:
  1. actions/checkout: 리포지토리를 체크아웃합니다.
  2. actions/setup-java: JDK 17을 설치합니다.
  3. gradlew clean build: Gradle을 사용해 소스 코드를 빌드합니다.
  4. actions/upload-artifact: 빌드 결과물(JAR 파일)을 업로드합니다.
• with:
  1. uses로 지정한 Action에 인자(Arguments)를 전달할 때 사용됩니다.
  2. Action의 동작을 세부적으로 설정하는 데 필요합니다.

deploy Job

• needs:
  • build Job이 성공적으로 완료된 후 실행됩니다.
• steps:
  1. actions/download-artifact: 빌드된 JAR 파일을 다운로드합니다.
  2. appleboy/scp-action: 다운로드된 JAR 파일을 AWS 서버로 전송합니다.
  3. appleboy/ssh-action:
     • 기존 서버 프로세스를 종료합니다.
     • 새로운 JAR 파일로 서버를 시작합니다.
• run:
  1. 정의:
  2. Job에서 실행할 커맨드(Command)를 지정합니다.
  3. 단일 명령어 또는 여러 줄 명령어를 실행할 수 있습니다.

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링 정리를 위한 포스팅입니다.
해당 포스팅은 @Slf4j 정리입니다.

로그가 뭐야?

로그(Log)는 애플리케이션이 실행되면서 발생하는 이벤트, 오류, 상태 정보 등을 기록하는 중요한 데이터입니다.
프로그램의 실행 흐름을 추적하고, 문제 발생 시 원인을 분석하는 데 필수적인 요소입니다.

로그가 중요한 이유

1. 디버깅 & 문제 해결
   • 애플리케이션에서 오류가 발생했을 때, 로그를 통해 원인을 분석하고 해결할 수 있습니다.
   • 예를 들어, 사용자가 API 요청을 보냈을 때 응답이 늦거나 실패하는 경우 로그를 확인하면 어느 단계에서 문제가 발생했는지 파악할 수 있습니다.
2. 운영 모니터링 & 시스템 분석
   • 운영 중인 서비스의 성능을 추적하고, 장애 발생 가능성을 미리 감지할 수 있습니다.
   • 로그 데이터는 시스템의 상태를 분석하고 최적화하는 데 중요한 역할을 합니다.
3. 보안 & 감사(Audit Logging)
   • 사용자 활동 기록(로그인, 결제, 데이터 변경 등)을 남겨 보안 감사(Audit) 및 문제 발생 시 추적할 수 있습니다.
   • 보안 로그는 악의적인 접근을 감지하고, 사이버 공격을 방어하는 데 사용됩니다.

로그를 남기는 방법

• Java에서는 System.out.println()을 사용하여 로그를 출력할 수 있지만, 이는 성능 저하 및 유지보수 어려움 등의 단점이 있습니다.
• 대신, Slf4j와 같은 로깅 프레임워크를 활용하면 효율적이고 확장성 있는 로깅 시스템을 구축할 수 있습니다.

Slf4j란?

Slf4j(Simple Logging Facade for Java)는 Java 애플리케이션에서 로깅을 위한 추상화 인터페이스입니다.
쉽게 말해, 특정 로깅 프레임워크(Logback, Log4j 등)에 종속되지 않고 Slf4j를 통해 원하는 로깅 시스템을 선택하여 사용할 수 있도록 도와주는 역할을 합니다.

💡 Slf4j는 로깅을 위한 "추상화 인터페이스"이며, 실제 로깅은 Logback, Log4j와 같은 구현체가 수행합니다.

Slf4j와 Logback 관계

Slf4j를 사용하는 이유

• 특정 로깅 프레임워크에 종속되지 않음
  1. Slf4j를 사용하면 코드 수정 없이 Logback, Log4j 등 원하는 로깅 프레임워크를 쉽게 교체할 수 있습니다
• System.out.println()보다 성능 우수
  
  1. System.out.println()은 단순한 콘솔 출력이지만, Slf4j는 다양한 출력 대상(파일, DB, 원격 서버 등)에 기록할 수 있습니다
  2. System.out.println()은 실행 속도가 느리지만, Slf4j는 비동기 로깅 및 레벨 제어가 가능하여 성능 최적화에 유리합니다.
• 로그레벨 지원
  
  1. Slf4j는 로그의 중요도에 따라 TRACE, DEBUG, INFO, WARN, ERROR 등의 로그 레벨을 제공하여 필요한 정보만 기록할 수 있도록 합니다.

로그 레벨설명

Slf4j 사용법

Lombok에서는 @Slf4j를 지원하여 간편하게 사용할 수 있습니다.
@Slf4j는 AOP(Aspect-Oriented Programming) 기능을 활용하여 자동으로 Logger 객체를 생성해줍니다.

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j // Logger 객체 자동 생성
@RestController
public class LogController {

    @GetMapping("/log")
    public String logExample(@RequestParam String message) {
        log.info("INFO 로그: {}", message);
        log.warn("WARN 로그: {}", message);
        log.error("ERROR 로그: {}", message);
        return "로그 출력 완료!";
    }
}

결과

Slf4j는 Spring Boot에서 로깅을 더욱 유연하고 효율적으로 관리할 수 있도록 도와주는 필수적인 라이브러리입니다.
로깅은 디버깅, 모니터링, 보안, 성능 분석 등 여러 측면에서 필수적인 요소이므로, 올바르게 활용하는 것이 중요합니다.

이제 프로젝트에서 Slf4j를 적극 활용하여 가독성 높은 로그 관리를 해보세요!

코드

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링 정리를 위한 포스팅입니다.
해당 포스팅은 직렬화, 역직렬화 어노테이션 정리입니다.

직렬화? 역직렬화?

직렬화(Serialization)

직렬화란 객체를 JSON, XML, 바이너리 등 데이터 형식으로 변환하는 과정을 의미합니다.

이 과정을 통해 데이터를 네트워크로 전송하거나 데이터 스트림으로 전송하는데에 사용되빈다.

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        User user = new User("testUser", "password123");
        ObjectMapper objectMapper = new ObjectMapper();

        // 직렬화 (객체 → JSON)
        String json = objectMapper.writeValueAsString(user);
        System.out.println(json);
    }
}

// 출력
{
    "username": "testUser",
    "password": "password123"
}

역직렬화(Deserialization)

역직렬화란 JSON, XML, 바이너리 데이터를 객체로 변환하는 과정을 의미합니다.

이를 통해 비즈니스 로직에서 객체를 활용하여 사용할 수 있습니다.

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        String json = "{\"username\":\"testUser\",\"password\":\"password123\"}";
        ObjectMapper objectMapper = new ObjectMapper();

        // 역직렬화 (JSON → 객체)
        User user = objectMapper.readValue(json, User.class);
        System.out.println(user.getUsername());
    }
}

// 출력
testUser

@JsonIgonre

@JsonIgonre은 JSON 변환 과정에서 특정 필드를 제외할 때 사용됩니다.

import com.fasterxml.jackson.annotation.JsonIgnore;

public class User {
    private String username;

    @JsonIgnore
    private String password; // JSON 변환 시 제외됨

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
    
    public String getUsername() { return username; }
    public String getPassword() { return password; }
}

// 출력
{
    "username": "testUser"
}

password 필드가 포함되지 않는 이유가 @JsonIgnore로 때문입니다.

보안 뿐만 아니라 무한 루프 방지 등의 용도로도 사용할 수 있습니다.

@JsonProperty

@JsonProperty는 직렬화 또는 역직렬화할 때 필드의 JSON 키 이름을 변경하는데 사용할 수 있습니다.

특정 조건에서만 JSON 처리를 제어할 수 있기에 더욱 활용도가 높습니다.

import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
    private String username;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY) // 역직렬화만 허용
    private String password;
}

// 출력
{
    "username": "testUser"
}

password는 API 응답에서는 제외되지만, JSON 응답을 받을 때는 사용이 가능합니다.

이렇게 내부적으로 보안을 위한 경우에도 사용할 수 있습니다. 

@JsonInclude

@JsonInclude는 특정 조건을 만족하는 필드만 JSON에 포함 할 수 있습니다. 예를 들어 null을 가진 필드를 제외하려면

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
    private String username;
    private String email;
}

// 출력: email이 null일 때
{
    "username": "testUser"
}

와 같이 구현할 수 있습니다.

@JsonIgnoreType

@JsonIgnoreType는 특정 타입의 모든 필드를 JSON 변환에서 제외할 수 있습니다.

객체 내부에 사용되는 숨겨야하는 필드에 대해서 JSON 변환을 제외합니다.

import com.fasterxml.jackson.annotation.JsonIgnoreType;

@JsonIgnoreType
public class SecretData {
    public String key = "secret";
}

public class User {
    public String username = "testUser";
    public SecretData secretData = new SecretData();
}

// 출력
{
    "username": "testUser"
}

결과

코드

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는
1. 프로젝트 초기화
2. 쿠키를 이용한 로그인 구현
3. 세션을 이용한 로그인 구현
4. JWT 토큰을 활용한 로그인 구현
입니다. 

네번째는 Security + JWT Token 로그인 구현입니다.

JwtProvider

Spring Security에서 JWT를 생성, 검증, 토큰 해석을 하는 클래스 입니다.

사용자 로그인이 완료되면 JWT 토큰을 생성하거나 인증정보를 확인합니다.

생성자

public JwtProvider(@Value("${hiro.jwtSecret}") String jwtSecret,
                   @Value("${hiro.jwtAccessExpiration}") int jwtAccessExpiration,
                   @Value("${hiro.jwtRefreshExpiration}") int jwtRefreshExpiration
) {
    this.jwtSecret = jwtSecret;
    this.jwtAccessExpiration = jwtAccessExpiration;
    this.jwtRefreshExpiration = jwtRefreshExpiration;

    this.key = Keys.hmacShaKeyFor(this.jwtSecret.getBytes());
}

• @Value 어노테이션을 통해 설정 파일(application.properties 또는 application.yml)에 저장된 JWT 관련 설정 값을 주입합니다.
  • hiro.jwtSecret → JWT 서명을 위한 비밀키
  • hiro.jwtAccessExpiration → 액세스 토큰 만료 시간(ms)
  • hiro.jwtRefreshExpiration → 리프레시 토큰 만료 시간(ms)
  • 해당 값들은 노출되면 안되기에 환경변수로 저장하는 것이 안전합니다.
• HMAC SHA 알고리즘을 사용하여 JWT 서명에 사용할 키를 생성

generateJwtToken

public String generateJwtToken(Authentication authentication) {
    String roles = authentication.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.joining(","));

    return Jwts.builder()
            .setSubject(authentication.getName())  // JWT의 subject 설정 (사용자명)
            .claim("role", roles)                  // 사용자의 역할(권한) 저장
            .setIssuedAt(new Date())               // 발급 시간
            .setExpiration(new Date((new Date()).getTime() + jwtAccessExpiration)) // 만료 시간 설정
            .signWith(key, SignatureAlgorithm.HS256) // 서명 알고리즘 사용
            .compact();
}

Jwts 클래스는 Java에서 JWT를 생성하고 파싱하는데 사용하는 JJWT의 클래스입니다.

빌더 패턴을 이용하여 토큰을 생성하고 토큰을 검증하고 해석할 때에는 Jwts.parserBuilder()를 이용합니다.

JWT 구조

header.payload.signature

• Header
  • 사용화 알고리즘과 토큰 유형
• Payload(Claims)
  • sub (Subject): 토큰을 발급받은 사용자 ID
  • role: 사용자의 역할 정보 (ex: ROLE_USER, ROLE_ADMIN)
  • iat (Issued At): 토큰 발급 시간 (Unix Timestamp)
  • exp (Expiration): 토큰 만료 시간 (Unix Timestamp)
• Signature(서명)
  • 서명(Signature)은 JWT의 무결성을 보장하기 위해 사용됩니다.

주요 필드 설명

• authentication.getAuthorities() → 사용자의 권한(ROLE_USER, ROLE_ADMIN 등)을 가져옴.
• setSubject(authentication.getName()) → JWT의 subject(보통 사용자 ID/username) 설정.
• claim("role", roles) → 사용자 역할 정보를 JWT의 Claims에 추가.
• setExpiration(...) → 액세스 토큰의 만료 시간을 설정.
• signWith(key, SignatureAlgorithm.HS256) → HMAC SHA256 알고리즘을 사용하여 JWT 서명.

getAuthentication

public Authentication getAuthentication(String token) {
    try {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token)
                .getBody();

        Collection<? extends GrantedAuthority> authorities = Arrays.stream(claims.get("role").toString().split(","))
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());

        return new UsernamePasswordAuthenticationToken(claims.getSubject(), token, authorities);
    } catch (MalformedJwtException e) {
        log.error("Invalid JWT token: {}", e.getMessage());
    } catch (ExpiredJwtException e) {
        log.error("JWT token is expired: {}", e.getMessage());
    } catch (UnsupportedJwtException e) {
        log.error("JWT token is unsupported: {}", e.getMessage());
    } catch (IllegalArgumentException e) {
        log.error("JWT claims string is empty: {}", e.getMessage());
    }

    return null;
}

• Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody()
  → JWT를 파싱하여 Claims(토큰의 정보)를 추출.
• claims.get("role").toString().split(",")
  → JWT에 저장된 사용자 권한(role)을 가져와서 리스트로 변환.
• new UsernamePasswordAuthenticationToken(claims.getSubject(), token, authorities);
  → JWT에서 가져온 사용자 정보를 기반으로 Authentication 객체 생성.
  -> UsernamePasswordAuthenticationToken은 Authentication 객체의 구현체

validateToken

public boolean validateToken(String token) {
    try {
        Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token);
        return true;
    } catch (SecurityException | MalformedJwtException e) {
        log.info("Invalid JWT Token", e);
    } catch (ExpiredJwtException e) {
        log.info("Expired JWT Token", e);
    } catch (UnsupportedJwtException e) {
        log.info("Unsupported JWT Token", e);
    } catch (IllegalArgumentException e) {
        log.info("JWT claims string is empty.", e);
    }
    return false;
}

• parseClaimsJws(token)을 호출하여 토큰이 유효한지 검사.
• 예외 처리:
  • SecurityException | MalformedJwtException: 토큰이 변조되었거나 잘못된 형식인 경우.
  • ExpiredJwtException: 토큰이 만료된 경우.
  • UnsupportedJwtException: 지원되지 않는 JWT 형식.
  • IllegalArgumentException: 토큰이 비어있거나 유효하지 않은 경우.

JwtFilter

@Component
public class JwtFilter extends OncePerRequestFilter {

    private final JwtProvider jwtProvider;

    public JwtFilter(JwtProvider jwtProvider) {
        this.jwtProvider = jwtProvider;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");

        if (authHeader == null) {
            filterChain.doFilter(request, response);
        } else {
            String jwtToken = authHeader.split(" ")[1];
            if (jwtProvider.validateToken(jwtToken)) {
                Authentication authentication = jwtProvider.getAuthentication(jwtToken);
                SecurityContextHolder.getContext().setAuthentication(authentication);
                filterChain.doFilter(request, response);
            }
        }
    }
}

OncePerRequestFilter

oncePerRequestFilter는 Spring Security에서 제공되는 필터로 HTTP 요청마다 단 한번만 실행되는 필터를 구현할 때 사용됩니다.
(여러번 실행되지 않도록 보장)

따라서 JWT 검증하는 filter로 적절합니다.(요청 때 한번만 검증)

• HttpServletRequest에서 Header("Authorization")을 확인
  • 클라이언트가 보낸 HTTP 요청에서 Authorization 헤더를 가져옵니다.
  • JWT는 일반적으로 "Bearer <토큰값>" 형식으로 전달됩니다.
• authHeader == null
  • 다음 필터로 넘김.
  • 로그인, 회원가입, 공개 API 요청 등
• else => 토큰 값 읽어오기
  • Bearer <토큰값> 형식에서 공백(" ")을 기준으로 split하여 토큰만 추출.
  • authHeader.split(" ")[0] → "Bearer"
  • authHeader.split(" ")[1] → "<토큰값>"
• jwtProvider로 validateToken()를 통해 Token을 검증
  • 유효하지 않으면(만료됨, 변조됨 등) 인증을 진행하지 않고 요청을 그대로 통과.
• 인증 객체 생성 및 설정
  • jwtProvider.getAuthentication(jwtToken)을 호출하여 JWT에서 사용자 정보를 추출하고 Authentication 객체를 생성.
  • SecurityContextHolder.getContext().setAuthentication(authentication);
    → Spring Security의 SecurityContext에 인증 객체를 저장하여 이후 요청에서 인증된 사용자로 처리.

SecurityConfig

SecurityConfig는 Security의 보안 설정을 구성하는 역할을 합니다.

사용자의 권한에 따라서 API 접근 권한을 설정할 수 있고(RBAC) HttpMethod에 따라서도 설정이 가능합니다.

해당 클래스를 위해서는 @EnableWebSecurity 어노테이션이 필요합니다

@EnableWebSecurity

Spring Security를 활성화하고, 보안 구성을 정의할 수 있도록 해주는 어노테이션입니다.

• Spring Security의 기본 보안 설정을 비활성화하고, 개발자가 직접 설정을 정의할 수 있도록 함.
• SecurityFilterChain을 통해 보안 규칙을 커스터마이징할 수 있도록 해줌.

PasswordEncoder

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

PasswordEncoder는 Spring Security에서 비밀번호를 안전하게 암호화하고, 검증하는 인터페이스입니다.

비밀번호를 평문(Plain Text)으로 저장하는 것은 보안적으로 위험하기 때문에, 해싱(Hashing) 알고리즘을 사용하여 비밀번호를 암호화하고, 로그인 시 입력된 비밀번호와 저장된 해시 값을 비교하여 검증하는 역할을 합니다.

• BCryptPasswordEncoder는 BCrypt 알고리즘을 사용하여 비밀번호를 안전하게 암호화합니다.
• @Bean을 사용하여 Spring 컨텍스트에서 PasswordEncoder 빈으로 관리하도록 설정함.

BCryptPasswordEncoder의 특징

• Salt를 자동으로 추가하여 해싱
  • 동일한 비밀번호라도 해싱 결과가 항상 다르게 생성됨 → Rainbow Table 공격 방어 가능
• 반복 연산(Work Factor) 조절 가능
  • 기본적으로 10번의 해싱 작업 수행 (BCryptPasswordEncoder(10))
  • 연산 횟수를 증가시켜 보안성을 강화할 수 있음
• 비밀번호 검증 기능 제공
  • matches(rawPassword, encodedPassword): 입력된 비밀번호와 암호화된 비밀번호 비교

AuthenticationManager

@Bean
public AuthenticationManager authenticationManager(
        AuthenticationConfiguration authConfig) throws Exception {
    return authConfig.getAuthenticationManager();
}

AuthenticationManager는 Spring Security에서 인증(Authentication) 요청을 처리하는 핵심 인터페이스입니다.

• 사용자의 로그인 요청을 받아 인증을 수행하고, 결과를 반환하는 역할을 합니다.
• 인증 과정에서 UserDetailsService를 이용해 사용자 정보를 조회하고, 비밀번호를 검증하는 등의 작업을 수행합니다.
• 해당 AuthenticationManager가 CustomDetailsService()를 호출하게 됩니다.

1. Spring Security의 AuthenticationManager 빈을 생성하는 역할
2. AuthenticationConfiguration을 통해 Spring Security의 기본 인증 설정을 가져와 AuthenticationManager를 반환
   1. Spring Security에서 AuthenticationManager의 기본 구현체는 DaoAuthenticationProvider 입니다.
   2. 따라서 여기서는 Spring Security가 자동으로 생성한 ProviderManager 인스턴스를 반환합니다.

SecurityFilterChain

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
            .csrf(AbstractHttpConfigurer::disable)
            .headers(headersConfigurer -> headersConfigurer.frameOptions(HeadersConfigurer.FrameOptionsConfig::disable))
            .formLogin(AbstractHttpConfigurer::disable)
            .httpBasic(AbstractHttpConfigurer::disable)
            .sessionManagement((sessionManagement) ->
                    sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> {
                auth.requestMatchers(permitAllUrl).permitAll();
                auth.requestMatchers(permitAdminUrl).hasRole("ADMIN");
                auth.anyRequest().authenticated();
            })
            .addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class)
            .addFilter(webConfig.corsFilter())
            .build();
}

해당 메소드는 Spring Security의 SecurityFilterChain을 구성하여 애플리케이션의 보안 규칙을 설정합니다.

• CSRF 보호 비활성화 (csrf().disable())
  • REST API는 주로 JWT를 사용하여 상태(State) 없이 인증을 수행하므로 CSRF 보호가 필요 없음
  • CSRF는 세션 기반 인증에서 주로 필요하지만, JWT 인증을 사용할 경우 불필요
• X-Frame-Options 비활성화 (frameOptions().disable())
  
  • H2 데이터베이스 콘솔 같은 프레임 기반 UI를 허용하기 위해 설정
• 폼 로그인 비활성화 (formLogin().disable())
  
  • JWT 기반 인증을 사용하기 때문에 기본 로그인 폼을 사용하지 않도록 설정
• HTTP Basic 인증 비활성화 (httpBasic().disable())
  • HTTP Basic 인증(아이디 & 비밀번호를 요청 헤더에 포함하여 전송하는 방식)을 비활성화
  • JWT 인증 방식을 사용할 것이므로 필요 없음
• SessionCreationPolicy.STATELESS
  • 세션을 사용하지 않는 Stateless 인증 방식 적용
  • SessionCreationPolicy.STATELESS → Spring Security가 세션을 생성하거나 저장하지 않도록 설정
• authorizeHttpRequest -> HTTP 요청에 대한 권한 설정
  • requestMatchers(permitAllUrl).permitAll();
    → 특정 URL(로그인, 회원가입, Swagger 등)은 인증 없이 접근 허용
  • requestMatchers(permitAdminUrl).hasRole("ADMIN");
    → 관리자 페이지(예: /status/admin)는 "ADMIN" 역할이 있는 사용자만 접근 가능
  • anyRequest().authenticated();
    → 그 외 모든 요청은 인증이 필요함
• JWT Filter 및 CORS 필터 추가
  • addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class)
    → JWT 필터(JwtFilter)를 UsernamePasswordAuthenticationFilter 앞에 추가
    • Spring Security의 기본 로그인 방식(폼 로그인, 세션 로그인 등)보다 먼저 JWT를 확인하도록 설정
  • .addFilter(webConfig.corsFilter())
    → CORS 필터 추가

UserDetails

@RequiredArgsConstructor
public class UserDetailsImpl implements UserDetails {

    @Getter
    private final Long id;
    private final String username;
    private final String password;
    private final Collection<? extends GrantedAuthority> authorities;

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public static UserDetailsImpl build(Member member) {
        List<GrantedAuthority> authorities = member.getRoles().stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role.name()))
                .collect(Collectors.toList());

        return new UserDetailsImpl(
                member.getId(),
                member.getUsername(),
                member.getPassword(),
                authorities
        );
    }
}

커스텀한 UserDetails 클래스를 생성합니다.

UserDetailsImpl이 필요한 이유

• Spring Security는 UserDetailsService를 통해 사용자 정보를 불러오며,
  이때 UserDetails를 구현한 클래스(UserDetailsImpl)가 필요
• UserDetailsImpl은 Spring Security에서 인증된 사용자의 정보를 저장하는 역할을 함.

UserDetailsService

@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {

    private final MemberRepository memberRepository;

    @Override
    @Transactional
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Member member = memberRepository.findByUsername(username);

        return UserDetailsImpl.build(member);
    }
}

UserDetailsService는 Spring Security의 UserDetailsService 인터페이스를 구현한 클래스로,
Spring Security가 로그인 요청을 처리할 때 사용자 정보를 불러오는 역할을 합니다.

• Spring Security가 로그인 요청을 받을 때 자동으로 실행되는 메서드
  • 해당 메소드는 AuthenticationManager가 로그인 요청을할 때 UserDetailsService를 호출합니다.
• username을 이용해 DB에서 사용자 정보를 조회 (memberRepository.findByUsername(username))
• 조회된 Member 엔티티를 Spring Security에서 사용할 수 있도록 UserDetailsImpl로 변환
  • UserDetailsService를 구현해야 Spring Security가 사용자 인증을 수행할 수 있습니다.

AuthService

public JwtResponse loginMember(String username, String password) {
    if (!repository.existsByUsername(username)) {
        throw new RuntimeErrorException(new Error("not Found Member"));
    }
    log.info("login Member");

    final Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(username, password)
    );

    final String jwtAccessToken = jwtProvider.generateJwtToken(authentication);
    final String jwtRefreshToken = null;

    final UserDetailsImpl userDetails = (UserDetailsImpl) authentication.getPrincipal();
    List<String> roles = userDetails.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority).toList();

    return new JwtResponse(jwtAccessToken, jwtRefreshToken, userDetails.getUsername(), roles);
}

로그인 화면

다음와 같이 정상 동작하는 것을 확인할 수 있습니다.

프론트에서는 다음에 헤더에 accessToken을 추가하면 Security가 설정된 프로젝트와 통신을 할 수 있습니다.

깃허브 및 참조

제가 공부한 내용을 정리하는 블로그입니다.
아직 많이 부족하고 배울게 너무나도 많습니다. 틀린내용이 있으면 언제나 가감없이 말씀해주시면 감사하겠습니다😁

스프링부트와 리액트를 활용해 로그인을 구현 프로젝트를 진행합니다. 순서는
1. 프로젝트 초기화
2. 쿠키를 이용한 로그인 구현
3. 세션을 이용한 로그인 구현
4. JWT 토큰을 활용한 로그인 구현
입니다. 

네번째는 Security 이론입니다.

Spring Security란

스프링 보안은 강력하고 고도로 사용자 지정 가능한 인증 및 액세스 제어 프레임워크입니다. 스프링 기반 애플리케이션을 보호하기 위한 사실상의 표준입니다.

Spring Security는 Java 애플리케이션에 인증과 권한 부여를 모두 제공하는 데 중점을 둔 프레임워크입니다. 모든 Spring 프로젝트와 마찬가지로 Spring Security의 진정한 힘은 사용자 지정 요구 사항을 충족하기 위해 얼마나 쉽게 확장할 수 있는지에서 찾을 수 있습니다
- Spring Security 공식 docs

Spring Security는 Spring 기반 애플리케이션의 인증, 권한관리 그리고 데이터 보호기능을 포함하는 프레임워크입니다. 인증(Authentication), 권한 부여(Authorization), 데이터 보호 등의 기능을 제공하여 애플리케이션의 보안 요구 사항을 쉽게 해결할 수 있도록 돕습니다. 특히 웹 애플리케이션의 다양한 보안 위협(CSRF, XSS 등)을 방어하고, 사용자가 인증된 상태에서 적절한 리소스 접근 권한을 갖도록 제어합니다.

Spring Security의 핵심 역할은 다음과 같습니다:

• 사용자가 누구인지 확인(인증)
• 사용자가 무엇을 할 수 있는지 결정(권한 부여)
• 웹 애플리케이션의 데이터를 안전하게 보호

Spring Security를 사용하는 이유

1. 보안 위협 방어
   • Spring Security는 CSRF(Cross-Site Request Forgery), XSS(Cross-Site Scripting), 세션 고정 공격(Session Fixation) 등 다양한 보안 위협에 대한 기본 방어 기능을 제공합니다.
2. 인증과 권한 관리의 편의성
   • 기본적으로 제공되는 인증 및 권한 부여 로직을 활용하거나, 커스터마이징하여 복잡한 보안 요구 사항을 구현할 수 있습니다.
3. 손쉬운 통합
   • Spring Security는 Spring Framework 및 Spring Boot와 자연스럽게 통합되며, 설정과 구성이 간단합니다.
4. 확장성과 커스터마이징
   • 사용자 정의 인증, 권한 정책, 필터 등을 구현하여 프로젝트 요구 사항에 맞는 보안 구조를 설계할 수 있습니다.
   • IoC/DI 패턴과 같은 확장 패턴을 염두하여 개발이 가능하였습니다.
5. 업계 표준 준수
   • OAuth2, JWT, OpenID Connect 등 표준 보안 프로토콜을 지원하여 최신 보안 트렌드에 맞는 애플리케이션을 개발할 수 있습니다.

Spring Security 주요 개념

1. Authentication (인증)
   인증은 사용자가 본인이 맞는지를 확인하는 과정입니다. 사용자가 올바른 자격 증명(예: 아이디와 비밀번호)을 제공했는지 확인합니다.
   • AuthenticationManager: 인증 처리를 담당하는 인터페이스.
   • UserDetailsService: 사용자 정보를 로드하는 서비스.
   • PasswordEncoder: 비밀번호 암호화 및 검증 처리.
   • 인증방식
     • credential 방식: username, password를 이용하는 방식
       principal -> 아이디(username), credential -> 비밀번호(password)
     • 이중 인증(twofactor 인증): 사용자가 입력한 개인정보를 인증 후, 다른 인증 체계를 이용하여 두가지의 조합으로 인증하는 방식
     • 하드웨어 인증: 자동차 키와 같은 방식
2. Authorization (인가)
   권한 부여는 사용자가 특정 리소스나 작업을 수행할 권한이 있는지 확인하는 과정입니다.
   • GrantedAuthority: 사용자의 권한 정보.
   • AccessDecisionManager: 권한 부여 판단을 담당.
3. Security Context
   SecurityContextHolder를 통해 애플리케이션 전반에서 현재 사용자의 인증 및 권한 정보를 관리합니다.
   
   
4. Filter Chain
   Spring Security는 HTTP 요청을 처리하기 위해 여러 필터를 체인 형태로 연결합니다.
   주요 필터:
   • UsernamePasswordAuthenticationFilter: 사용자 인증 처리.
   • BasicAuthenticationFilter: HTTP Basic 인증 처리.
   • CsrfFilter: CSRF 보호.

Spring Security 동작 원리

아키텍처

1. 클라이언트가 서버에 요청을 보냅니다.
2. AuthenticationFilter가 요청을 인터셉트하고 이를 AuthenticationManager에 전달합니다.
3. AuthenticationManager는 등록된 AuthenticationProvider를 탐색하여 인증 처리를 위임합니다.
4. AuthenticationProvider는 사용자 데이터를 확인하고, 인증된 UserDetails 객체를 반환합니다.
5. 인증 결과는 SecurityContextHolder에 저장되며, 저장된 사용자 정보는 Spring Controller에서 활용할 수 있습니다.

참조