첫번째, ServiceTest 클래스 상단에 모키토 선언, 안에 테스트 대상인 service에 @InjectMocks 선언, 테스트 시 주입될 클래스는 레포지토리이므로 @Mock 선언,

두번째, 이후에는 각 메서드 마다 단위테스트를 만드는데 이때, (예를들어 create) AAA패턴에 맞게 given, when, then. given으로 입력될 데이터를 미리 대본처럼 만들고, when으로 서비스의 메서드를 호출하고, then의 assert/verify를 이용하여 결과값/메서드가 잘 반환/실행 되었는지 테스트한다.

핵심 개념

기본 세팅 핵심 개념 3개

1. Mock : 가짜 객체
2. Stubbing : 대본 써주는 것(이 메서드가 호출되면 이렇게 답해!)
3. Verify(검증) : 호출 자체를 확인(정말 그 메서드를 그 횟수만큼 불럿나?)

• @ExtendWith(MockitoExtension.class) : 모키토 준비 완료! 클래스 상단에 선언해줘야 한다.
• @Mock : 가짜 객체 표시, ServiceTest 단에서는 Repository가 가짜로 만들어진다.
• @InjectMocks : 진짜로 테스트할 대상, Service를 테스트할 예정이므로

@InjectMocks
BoardService boardService;

AAA패턴 : 테스트의 뼈대

1. Given(준비) : 입력 데이터 만들기
2. When(실행) : 서비스 메서드 호출
3. Then(검증) : 리턴값 검사(assert...) + 레포지토리 호출 검사(verify...)

내가 사용한 문법 정리

1. 스텁(BDD 스타일)

   given(mock.메서드(인자))).willReturn(값);
   given(mock.메서드(인자))).willThrow(예외);

2. 검증(호출 확인)

   verify(mock, times(1)).메서드(인자);
   verify(mock, never()).메서드(...);
   verifyNoMoreInteractions(mock); <= 더 이상 건드리지 않았는지.

3. 리턴 값 검사

   assertNotNull(x);
   assertEquals(a, b);
   assertThrows(예외.class, ()-> 실행);

4. 매처 (인자 아무거나/정확히)

   any(Board.class)
   anyString()
   eq("고정값")

5. void 메서드 예외 스텁(save 처럼 리턴 있으면, given...로 충분하지만 리턴 없는 void는

   doThrow(new SomeEx()).when(mock).voidMethod(args);

내가 작성한 Create Test

Users users = mock(Users.class);
given(usersRepository.findByUsername("tester")).willReturn(Optional.of(users));
given(users.getUserId()).willReturn(10L);

• Users는 DB 엔티티라 가짜로 만들었고
• 서비스가 tester로 유저를 조회하면 있다고 응답
• 그 유저의 id는 10L라고 대본을 줌

given(boardRepository.existsByTitle("제목")).willReturn(false);

• 제목 중복 검사 결과: 중복 아님(false) -> 그래서 save까지 진행 가능

given(boardRepository.save(any(Board.class))).willReturn(
    new Board(1L, 10L, "제목", "내용", LocalDateTiem.now(), LocalDateTime.now())
);

• 실제 저장은 안 하지만 save 부르면 이런 엔티티가 나온다라고 가짜 결과를 줌

BoardCreateDto result = boardService.create(boardCreateCommand, "tester");

• 여기서만 진짜 로직이 실행 됨(서비스 메서드)
• 내부에서 위의 스텁들을 쭉 호출하게 됨

assertNotNull(result);
assertEquals("제목", result.getTitle());
assertEquals("내용", result.getContent());

• 리턴 DTO가 제대로 나왔는지 확인

verify(usersRepository, times(1)).findByUsername("tester");
verify(boardRepository, times(1)).existsByTitle("제목");
verify(boardRepository, times(1)).save(any(Board.class));

• 서비스 흐름이 우리가 의도한 순서대로 레포지토리를 불렀는지 확인

여기까지가 완벽한 AAA 패턴이라고 볼 수 있다.

핵심: 객체를 만들 때부터 그 용도나 상태를 지정해주는 것

원래였던 것
User user = new User("한솔",20);

정적 팩터리 메서드
User guest = User.guest(); // 비회원 상태로 초기화된 객체
User admin = User.admin(); // 관리자 권한을 가진 객체

정적 팩토리 메서드 원칙 1. static 키워드 사용 2. 내부에서 new로 객체 생성 후 반환 3. 메서드명이 의미를 설명함 4. 타입 매개변수 <T> 지원 (제네릭)

public static <T> 반환타입 메서드명(매개변수들) {
    return new 생성자호출(매개변수);
}

public static <T> ApiResponse<T> of(T data) {
    return new ApiResponse<>(data);
}

public static <- 정적이라 객체 없이 호출이 가능하다(ApiResponse.OK() 형태) return new AipResponse<>() <- factory 역할(객체를 만들어서 반환) 즉 생성자를 감싸서 좀 더 명확한 이름과 제어를 부여한 형태

요약하자면 정적 팩토리 메서드는 객체 생성을 대신 수행하는 정적(static)메서드다. 생성자보다 의미 있는 이름을 줄 수 있고 캐싱이나 싱글톤 처리 등 객체 생성을 통제하기에 좋다. 지금 코드의 OK()와 fail()이 그 예시다.

예시 코드

public class User{
    private String name;
    private String role;

    private User(String name, String role){
        this.name=name;
        this.role=role;
    }

    // 정적 팩터리 메서드
    public static User guest(){ 
        return new User("GUEST","GUEST");
    }
    public static User admin(){
        return new User("ADMIN","ADMIN");
    }
    public static User of(String name){ // static은 객체 없이도 호출이 가능하다는 점.
        return new User(name,"USER"); //User.of("한솔")이렇게 클래스 이름으로 바로 호출이 가능하다. 생성자처럼 new 안 써도 됨

        // of: ~로부터 객체를 만들어낸다.
        // 즉 User객체를 만들어서 돌려주겠다는 뜻
        // 표준 라이브러리에서도 많이 씀
        // List.of(), Optional.of() 등
    }
}

사용 시

User u1 = User.guest(); // 이미 게스트 상태로 만들어짐
User u2 = User.admin(); // 이미 관리자 상태로 만들어짐

JVM

Java Virual Machine은 자바 바이트코드(.class)를 운영체제/CPU와 상관없이 실행해 주는 가상 컴퓨터.

내 노트북이든 EC2리눅스든 같은 .jar를 돌릴 수 있게 해 주는 번역기+실행기

자바 프로그램을 실행시키는 가상 컴퓨터

JVM이 하는 일

• 바이트코드 실행

  • 자바 코드를 .java → javac 컴파일 → .class 바이트코드

  • JVM은 이 바이트코드를 읽어서 OS/CPU가 이해할 수 있는 명령으로 변환

• 메모리 관리

  • JVM은 프로그램 실행에 필요한 메모리를 나눠서 관리

    • Heap 영역: 객체 저장

    • Stack 영역: 메서드 호출, 지역변수 저장

    • Method 영역: 클래스 코드, 메서드, 상수 저장

MyCode.java ──(javac 컴파일)──> MyCode.class(바이트코드)
                         ↓
                    JVM이 읽음
     [클래스 로더] → [실행 엔진(인터프리터+JIT)] → [OS/CPU]
                         │
                      [메모리 관리(GC)]

JVM 안의 핵심 부품(이름 정도만 기억하자)

클래스 로더

.class 파일을 JVM메모리로 적재

실행엔진

• 인터프리터: 바이트코드를 한 줄씩 읽어 즉시 싱행(빠른 시작)
• JIP 컴파일러: 자주 실행되는 코드를 기계어로 바꿔 캐시해 둠(따듯해질수록 빨리 사라짐)

런타임 메모리 구역

• 스택(stack): 메서드 호출/ 지역변수(원시타입 int, long등). 매우 빠르지만 짧게 씀

  • 너무 깊게 재귀 돌리면 stackOverFlowError

• 힙(Heep): new로 만든 객체들이 오래 사는 공간, GC가 치워줌

  • 다 차면 OutOfMemoryError: Java heap space

• 메타스페이스(Metaspace): 클래스의 설계도 정보

  • 이게 차면 OutOfMemoryError: Metaspace

포인트

• 스택=짧고 빠름
• 힙=객체가 모여 사는 곳
• GC=힙 청소부

GC(가비지 컬렉션)

GC는 더 이상 쓰지 않는 객체(어느 곳에서도 참조하지 않음)를 자동으로 찾아서 힙에서 채워주는 기능 메모리 안정성, 개발속도가 향상된다.

기본 동작 원리(진짜 핵심만)

• “GC 루트(실행 중인 스레드 스택, static 변수 등)”에서 닿을 수 없는 객체는 쓰레기다 → 청소

• 청소할 때는 잠깐 stop-the-world(모든 스레드 멈춤) 구간이 꼭 생김

• 세대별(Generational) GC: Young(금방 생긴 객체; 금방 죽음) / Old(오래 사는 객체)로 나눠 효율적으로 청소

  • Minor GC: Young만 빠르게 치움
  • Major/Full GC: Old 포함 큰 청소 (보통 더 무거움)

GC 종류(이름만 익히기)

• Serial/Parallel: 옛날 방식, 단순/스루풋 지향

• G1 GC: 요즘 기본값(자바 9+ 핫스팟)—적당히 빠르고 멈춤시간 짧게 만들려고 고안됨

• ZGC / Shenandoah: 아주 짧은 멈춤시간이 필요할 때(고급/특수 상황)

현업 기본값: 그냥 G1 쓰고 힙 크기만 맞추면 90%는 충분합니다.

왜 자바로 프로그래밍할까?

장점

• 한 번 빌드하면 어디서나 실행(JVM 덕분) — 윈도우/리눅스/ECS/EC2 가리지 않음

• GC로 메모리 안전성 확보 — 메모리 해제 실수로 뻗을 일이 적음

• 성능 안정성 — JIT로 뜨거워질수록 빠름, 서버에서 충분히 고성능

• 거대한 생태계 — Spring Boot, Maven/Gradle, 라이브러리, 예제가 넘침

• 채용/학습 자료 풍부 — 팀 꾸리기, 유지보수, 문서, 커뮤니티가 매우 강함

• 장기 지원(LTS) — JDK 17/21 같은 장기 버전으로 안정적 운영

단점

• GC 멈춤이 아예 0은 아님(튜닝으로 줄임)

• 메모리 사용량이 비교적 큼

• “처음 기동”이 스크립트 언어보다 느릴 수 있음(하지만 서버는 오래 떠 있음)

결론: 서비스를 오래, 안정적으로, 많은 사람이 협업해야 한다? → 자바/스프링은 매우 안전한 선택.

public static void main(String[] args) {
        exampleList();
        exampleSet();
        exampleMap();
        exampleStackUsingDeque();
        exampleQueueUsignDeque();
        examplePriorityQueue();
    }

각 메서드를 만들어서 컬렉션에 대해 다뤄보도록 하겠다.

이번 목표는 개념을 이해하고 상황에 맞게 적절한 활용 예시이다.

list

에시: 쇼핑몰 장바구니 기능

private static void exampleList() {
        System.out.println("-------List start-------");

        List<String> list = new ArrayList<>();
        list.add("zebra");
        list.add("apple");
        list.add("monkey");
        list.add("banana");
        list.add("cherry"); //중복 가능, 순서 o
        System.out.println("////List :" + list);
        System.out.println("////List 1번째 :" + list.get(1));
        // 삽입
        list.add(1, "X");
        System.out.println("////List 1삽입 :" + list); // 결과: 삽입하고 뒤에 밀림
        // 삭제
        list.remove(2);
        System.out.println("////List 2삭제 :" + list);
        System.out.println();
    }

why? 사용자가 같은 상품을 두 번 담을 수 있다(중복 허용) 첫 번째 담은 상품처럼 인덱스로 접근이 가능해야 한다.

List<String> cart = new ArrayList<>();
cart.add("노트북");
cart.add("마우스");
cart.add("노트북"); // 중복 허용
System.out.println("장바구니: " + cart); // [노트북, 마우스, 노트북]
System.out.println("첫 번째 상품: " + cart.get(0)); // 노트북

Set

에시: 콘서트 예매 서비스에서 좌석 번호를 관리할 경우, 같은 좌석이 중복 예약되면 안됨

    private static void exampleSet() {
        System.out.println("=== Set (HashSet / LinkedHashSet / TreeSet) ===");

        // HashSet: 가장 흔함, 빠름, '순서 없음'
        Set<String> hashSet = new HashSet<>();
        hashSet.add("B");
        hashSet.add("A");
        hashSet.add("B"); // 중복은 무시
        System.out.println("HashSet (순서X) = " + hashSet);

        // LinkedHashSet: '입력 순서 유지'
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("B");
        linkedSet.add("A");
        linkedSet.add("B"); // 중복 무시
        System.out.println("LinkedHashSet (입력순서 유지) = " + linkedSet); // [B, A]

        // TreeSet: '자동 정렬' (기본 오름차순), null 불가
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("B");
        treeSet.add("A");
        treeSet.add("C");
        System.out.println("TreeSet (정렬됨) = " + treeSet); // [A, B, C]

        // 언제 쓰나: 중복을 자동으로 제거해야 할 때(유니크한 값 모으기: 이메일, 태그 등)
        // 주의: HashSet은 출력 순서가 예측 불가 → 화면 표시용이면 LinkedHashSet 사용
        System.out.println();
    }

why? 중복 자동 제거, 순서 필요없다는 특징

Set<String> seats = new HashSet<>();
seats.add("A1");
seats.add("A2");
seats.add("A1"); // 중복 -> 무시됨

System.out.println("예약된 좌석: " + seats); // [A1, A2]

입력 순서를 유지해야 한다면 LinkedHashSet 좌석 번호를 자동 정렬하려면 TreeSet을 사용하면 된다.

    private static void exampleMap() {
        System.out.println("=== Map (HashMap / LinkedHashMap / TreeMap) ===");

        // HashMap: 빠름, 순서 없음
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("apple", 3);   // 키 "apple" → 값 3
        hashMap.put("banana", 1);
        hashMap.put("apple", 10);  // 같은 키에 put → 기존 값 3을 10으로 '덮어쓰기'
        System.out.println("HashMap size = " + hashMap.size());         // 2
        System.out.println("HashMap get('apple') = " + hashMap.get("apple")); // 10

        // LinkedHashMap: 입력 순서 유지(화면 표시용에 좋음)
        Map<String, Integer> linkedMap = new LinkedHashMap<>();
        linkedMap.put("apple", 3);
        linkedMap.put("banana", 1);
        linkedMap.put("cherry", 2);
        System.out.println("LinkedHashMap (입력순서 유지) = " + linkedMap); // {apple=3, banana=1, cherry=2}

        // TreeMap: 키 기준 정렬(사전순 등)
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("banana", 1);
        treeMap.put("apple", 3);
        treeMap.put("cherry", 2);
        System.out.println("TreeMap (키 정렬) = " + treeMap); // {apple=3, banana=1, cherry=2}

        // Map 순회: entrySet()으로 키와 값을 함께 꺼내면 편함
        System.out.println("Iterate LinkedHashMap:");
        for (Map.Entry<String, Integer> e : linkedMap.entrySet()) {
            System.out.println("  " + e.getKey() + " -> " + e.getValue());
        }

        // 언제 쓰나: 기준(키)로 빠르게 찾아야 할 때(아이디→회원정보, 상품코드→상품)
        // 주의: 같은 키 put 시 덮어쓰기, HashMap은 순서X, TreeMap은 null 키 불가
        System.out.println();
    }

• 학생 이름으로 점수를 관리할 경우, 이름(Key)->점수(value)

why? 키를 통해 빠르게 값 검색, 같은 이름이 들어오면 점수 덮어씀

단, 동명이인일 경우에는?? -> Map은Key가 유일해야 한다는 규칙이 있다. 그래서 HashMap, TreeMap, LinkedHashMep 전부 동일한 키가 들어오면 기존 값을 덮어쓴다. 그래서 동명이인일 경우에는 이름을 Key로 쓰지 않고 학번, ID같은 고유 식별자를 Key로 두면 된다.

Stack

에시: 텍스트 편집기에서 실행 취소 기능 구현 시

     // - 레거시 java.util.Stack 대신 Deque(ArrayDeque) 권장
    private static void exampleStackUsingDeque() {
        System.out.println("=== Stack (using Deque/ArrayDeque) ===");

        // Deque을 스택처럼 사용: push/pop/peek
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(1); // 맨 위에 1
        stack.push(2); // 맨 위에 2
        stack.push(3); // 맨 위에 3 (최상단)

        System.out.println("pop() -> " + stack.pop());  // 3 (가장 나중에 넣은 것)
        System.out.println("peek() -> " + stack.peek()); // 2 (위에 무엇이 있는지 보기만)

        // 언제 쓰나: 실행취소(UNDO), 역순 처리, 괄호검사 등 LIFO 로직
        // 왜 Deque? Stack은 동기화 등 오버헤드가 있고 레거시라 비권장. Deque가 더 가볍고 빠름.
        System.out.println();
    }

why? 마지막 동작부터 취소해야 함(LIFO)

 Deque<String> undoStack = new ArrayDeque<>();
undoStack.push("글자 입력");
undoStack.push("굵게 적용");
undoStack.push("밑줄 적용");

System.out.println("실행 취소: " + undoStack.pop()); // 밑줄 적용 취소
System.out.println("다음 취소: " + undoStack.peek()); // 굵게 적용 (보기만)

Queue

예시: 은행 창구 대기 시스템, 먼저 온 손님이 먼저 처리되어야 함

    // - 보통 Deque(ArrayDeque)로 큐 연산(offer/poll/peek)
    private static void exampleQueueUsingDeque() {
        System.out.println("=== Queue (using Deque/ArrayDeque) ===");

        Deque<String> queue = new ArrayDeque<>();
        queue.offer("A"); // 뒤로 A
        queue.offer("B"); // 뒤로 B
        queue.offer("C"); // 뒤로 C

        System.out.println("poll() -> " + queue.poll()); // A (가장 먼저 들어온 것)
        System.out.println("peek() -> " + queue.peek()); // B (앞에 무엇이 있는지 보기만)

        // 언제 쓰나: 작업 대기열, BFS, 생산자-소비자(동시성 환경에서는 BlockingQueue 계열 사용)
        System.out.println();
    }

why? FIFO구조가 딱 맞음

Deque<String> waitingQueue = new ArrayDeque<>();
waitingQueue.offer("손님1");
waitingQueue.offer("손님2");
waitingQueue.offer("손님3");

System.out.println("처리: " + waitingQueue.poll()); // 손님1
System.out.println("다음 대기: " + waitingQueue.peek()); // 손님2

PriorityQueue

예시: 고객센터에서 VIP고객 문의-> 일반 고객문의 순으로 처리해야 할 경우

        System.out.println("=== PriorityQueue (기본 오름차순) ===");

        // 작은 값이 먼저 나온다(기본 자연 순서)
        Queue<Integer> pq = new PriorityQueue<>();
        pq.offer(5);
        pq.offer(1);
        pq.offer(3);

        // poll()할 때마다 가장 '작은' 값부터 빠짐 → 1, 3, 5
        System.out.print("poll order = ");
        while (!pq.isEmpty()) {
            System.out.print(pq.poll() + " ");
        }
        System.out.println();

        // 내림차순 우선순위가 필요하면 Comparator 넘기기
        Queue<Integer> maxPq = new PriorityQueue<>(Comparator.reverseOrder());
        maxPq.offer(5);
        maxPq.offer(1);
        maxPq.offer(3);
        System.out.print("reverse poll order = ");
        while (!maxPq.isEmpty()) {
            System.out.print(maxPq.poll() + " "); // 5, 3, 1
        }
        System.out.println();

        // 언제 쓰나: “중요한 것 먼저 처리” (예: 가장 높은 점수, 가장 긴 대기시간 등)
        System.out.println();
    }
}

why? 우선순위 높은 요소 먼저 꺼내야 함

class Customer {
    String name;
    int priority; // 숫자가 작을수록 우선순위 높음
    Customer(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
    public String toString() { return name; }
}

PriorityQueue<Customer> pq = new PriorityQueue<>(Comparator.comparingInt(c -> c.priority));
pq.offer(new Customer("일반 고객", 5));
pq.offer(new Customer("VIP 고객", 1));
pq.offer(new Customer("일반 고객2", 3));

while (!pq.isEmpty()) {
    System.out.println("응대: " + pq.poll()); // VIP → 일반 고객2 → 일반 고객
}

내가 이번에 할 시나리오는 임시 레포를 CICD를 이용하여 서버에 배포하는 법을 익힐 것이다. 지난 시간에 기존 팀프로젝트를 AWS에 EC2를 이용하여 수동으로 배포해본 적이 있다. 성공적이었고 이제 CICD으로 전환해 주면 되는데 이건 내가 배운 적이 없어서 test용으로 할 생각이다.

새로운 인스턴스 생성하면 보안그룹을 추가해야한다.

보안그룹 & SSH 접근

• SSH (22): 기본 열려 있음 (터미널 접속)
• HTTP (80): 웹 요청
• 사용자 정의 TCP (8080): 스프링 서버 실행 시

접근 시 명령어는

ssh -i "C:\Users\user\Desktop\.ssh\hansolKey.pem" ec2-user@퍼블릭IP

이제 배포할 프로젝트에 맞게 세팅을 해줘야 한다.

1. Java 설치

sudo dnf install -y java-17-amazon-corretto

AL2023에선 amazon-corretto 패키지 사용해야 한다.

// 출력예시
openjdk version "17.0.16" 2025-07-15 LTS
OpenJDK Runtime Environment Corretto-17.0.16.8.1 (build 17.0.16+8-LTS)
OpenJDK 64-Bit Server VM Corretto-17.0.16.8.1 (build 17.0.16+8-LTS, mixed mode, sharing)

버전을 확인해 주면 위 코드와 같이 나온다.

2. MySQL

내가 사용한 DB는 MySQL이다.

먼저 OS 확인해 줘야 한다.

 cat /etc/os-release

다음으로 해줘야 할 건 MySQL 저장소 등록이다.

 sudo rpm -Uvh https://repo.mysql.com/mysql80-community-release-el9-1.noarch.rpm

이제 설치 및 실행을 진행하면 된다.

sudo dnf install -y mysql-community-server

sudo systemctl enable --now mysqld
systemctl status mysqld --no-pager

 -u root -p

이때 비밀번호를 넣으면 된다. 입력 시 아무것도 안 보이는 게 당연하다.

그러나 에러가 났다.

ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

임시 비밀번호를 받자

 sudo grep -n "temporary password" /var/log/mysqld.log | tail -1

이렇게 치면 코드가 한 줄 나오는데, 맨 끝에 코드를 암기하자.

r!Lwso-f70PU

나같은 경우 위처럼 생긴 임시 비밀번호를 받았다.

mysql -u root -p

다시 이 명령어를 쳐서 임시 비밀번호를 넣으면 MySQL에 접근이 가능해진다. 접근 성공했으니 비밀번호를 반드시 변경하자.

ALTER USER 'root'@'localhost' IDENTIFIED BY '새비밀번호';
FLUSH PRIVILEGES;

변경을 완료했으면 정상적으로 변경 했는지 확인해야한다.

MySQL에서 빠져나와서 다시

mysql -u root -p

를 입력하여 변경한 비밀번호를 입력하면 된다.

다음으로 할 건 스키마 생성이다.

내 프로젝트의 스키마 이름은 awsTest니까 그대로 진행하겠다.

CREATE DATABASE IF NOT EXISTS awsTest
  DEFAULT CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;

생성된 걸 확인하려면 아래 명령어를 치면된다.

SHOW DATABASES;

3. redis

우리 프로젝트는 redis를 사용하였으니 아마존 리눅스 역시 똑같이 설치해주면 된다.

어째서인지 설치가 너무 간단했다.

설치 명령어

sudo dnf install -y redis6
sudo systemctl enable --now redis6

상태 확인

systemctl status redis6 --no-pager

Ping 테스트

redis6-cli ping

했더니 PONG 정상 설치 완료하였다..

4. git

깃을 설치해야 한다는 걸 빼먹어서 뒤늦게라도 설치했다.

# 1) git 설치
sudo dnf install -y git

# 2) 리포 내려받기 (홈에 awsTest 폴더로)
git clone https://github.com/hansolChoi29/awsTest.git ~/awsTest

cd ~/awsTest

# gradlew에 실행권한 (안 돼도 true로 무시)
chmod +x gradlew || true

# 빌드 (빠르게 하려면 테스트 생략)
./gradlew clean bootJar -x test

빌드 (Gradle Wrapper 사용)

chmod +x gradlew || true
./gradlew clean bootJar -x test

JAR 실행

# 만들어진 JAR 확인
ls -al build/libs

# plain 제외한 실제 JAR 선택
JAR=$(ls build/libs/*.jar | grep -v 'plain' | head -n 1)
echo "JAR=$JAR"

# 기존 프로세스 종료(있으면) 후 실행
pkill -f "java.*$(basename "$JAR")" || true
nohup java -jar "$JAR" --spring.profiles.active=prod > app.log 2>&1 &

# 기동 확인 + 로그 보기
sleep 3
pgrep -f "$(basename "$JAR")" && echo "App RUNNING" || echo "App NOT running"
tail -n 200 app.log

잘 설치가 되었는지 최종확인

1. 자바

   java -version

출력예시
penjdk version "17.0.16" 2025-07-15 LTS
OpenJDK Runtime Environment Corretto-17.0.16.8.1 (build 17.0.16+8-LTS)
OpenJDK 64-Bit Server VM Corretto-17.0.16.8.1 (build 17.0.16+8-LTS, mixed mode, sharing)

2. MySQL

systemctl status mysqld --no-pager

출력예시 - 마지막 줄만 보면 됨
Started mysqld.service - MySQL Server.

mysql --version

출력예시

mysql  Ver 8.0.43 for Linux on x86_64 (MySQL Community Server - GPL)

로그인확인

mysql -u root -p

비밀번호 입력 후 데이터베이스 확인

SHOW DATABASES;

출력 예시
+--------------------+
| Database           |
+--------------------+
| awsTest            |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.05 sec)

3. redis 확인

systemctl status redis6 --no-pager

출력예시 - 아래 키워드만 체크해 주면 됨
- Active: active (running) → 현재 실행 중
- Status: "Ready to accept connections" → 클라이언트 연결 받을 준비 완료
- Main PID: 30252 (redis6-server) → Redis 서버 프로세스 번호
- 포트: `127.0.0.1:6379` → 로컬호스트에서 6379 포트로 대기 중

redis6-cli ping

출력 예시
PONG

CICD : git Action

왜 이해를 못했냐면

*NPE를 예방하기 위해서라면, 결국 에러 발생되게 만드는 용도아닌가?란 생각이 들었고, 에러를 임의로 발생시키도록 하는 예외처리가 따로 있는데. 그리고 null이던 말던 왜 신경을 써야 하는지에 대해 불만이 있었다.

NPE(nullPointerException)
아무 객체도 가리키지 않는 참조에서 메서드나 필드에 접근하려 할 때 발생하는 자바 런타임 에러.
왜 발생하는데?=> 자바는 null이라는 특별 값에 대해 아무것도 없다라고 표시하는데, 
그 상태에서 length(), toUpperCase(), .charAt(0)같은 메서드를 호출하면 
자바가 어떻게 실행하지?하고 터뜨리는 에러가 NPE.

그러나 Java에서는 null을 그대로 냅두게 되면, 여러문제를 일으킬 수 있다.

Java에서 null 참조를 그대로 두면 어디서 NPE가 터질지 모르는 문제와 중첩된 if (x != null) 처리의 복잡함을 야기한다. Optional은 ‘값 없음’을 안전하게 캡슐화해서, NPE 없이 깔끔하게 널 체크 흐름을 작성할 수 있게 도와준다.

위 내용을 정리해보면

• null이면 메서드 호출 때 NullPointerException이 발생된다.
• 이걸 일일이 if(x!=null)으로 막으면 코드가 길어진다.
• 그래서 Optional.ofNullable(str)해야 하며, 코드는 간결해진다.

주의사항

• 절대 get()만 믿고 쓰지 말 것, 반드시 isPresent()나 orElse...계열로 안전하게 처리 할 것.
• 필드나 파라미터 타입으로 Optional 남발은 피하고 주로 메서드 반환용으로 사용 할 것.
• of() vs ofNullable() 처리를 명확히 인지 할 것.

위 내용에 대해 설명하고자 한다.

1) 절대 get() 만 믿고 쓰지 말 것 (isPresent()/ orElse.. 함께 사용 권장)

• opt.get()은 Optional 내부에 값이 있을 때는 그 값을 꺼내주지만, 값이 없을 경우에는 호출하는 순간 NoSuchElementException이 터진다.
• 그래서 안전하게 쓰려면 아래 코드와 같다

if(opt.isPresent()){
    String v=opt.get();
}

• 혹은

// 값이 있으면 그대로, 없으면 기본값 반환
String v=opt.orElse("기본");

String v=opt.orElseGet(()->"기본");

요약하자면, get() 단독 사용은 예외 위험이 크니 항상 "값 있음" 여부를 확인하거나 isPresent() 아니면 기본값을 지정해주는 orElse/ orElseGet 방식을 쓰라는 말이다.

2) 필드나 파라미터 타입으로 Optional 남발은 피하고 주로 메서드 반환용으로 사용 할 것.

• 필드(클래스 변수)나 메서드 파라미터에 Optional을 쓰면 오히려 코드가 복잡해지고 직렬화나 테스트 작성 시 번거로워 진다.

// 권장하지 않는 예시코드
public class User{
    private Optional<String> middleName;
    public void setMiddleNaem(Optional<String> m){...}
}

• 대신 Optional은 "이 메서드는 값이 없을 수도 있을 수도 있다."를 표현하는 용도로 메서드 반환타입에만 사용하는 것이 일반적인 관례다.

//권장되는 예시 코드
public Optional<User> findUserByEmail(String email){...}

요약하자면, Optional을 필드, 파라미터로 쓰면 오히려 부작용이 많으니 메서드 리턴으로만 쓰고 ** 내부 구현이나 호출 시에는 일반 Null체크를 쓰는 걸 추천*한다.

*내부 구현이나 호출 시에는 일반 Null체크를 쓰는 걸 추천, 
일반 null체크란? 참조형 변수가 null인지 if문으로 먼저 확인한 뒤에야 안전하게 사용하는 방식이다.
예를들면 필드처리, 메서드 파라미터, 호출.

즉, 여기서 내부 구현이란, 클래스 안에서 필드나 파라미터에 Optioanl을 쓰지않고
if(param != null)/ if(field != null)으로 단순히 널 여부만 체크하는 방식을 말한다.
호출 시에만 Optional API를 사용해 주면, 인터페이스 설계와 구현이 깔끔하게 분리된다.

잠시 필드처리, 메서드 파라미터, 호출에 대해 설명해보자면 아래와 같다.

일반 Null 체크 1)필드 처리 예시

• 잘못된 예 (Optional 필드 남발)

  public class User{
  //Optional을 필드로 쓰면 직렬화·테스트·가독성이 모두 불편해짐
    private Optional<String> middleName;
  
    public User(Optional<String> middleName){
        this.middleName=middleName;
    }
  
    public Optional<String> getMiddleName(){
        return middleName;
    }
  }

• 권장 예(null 체크로 간단히)

public class User{
    private String middleName;

    public User(String middleName){
        this.middleName=middleName != null?middleName:"";
    }

    public String getMiddleName(){
        return middleName != null && !middleName.isEmpty()
        ?middleName
        :"정보 없음";
    }
}

일반 Null 체크 2) 메서드 파라미터 예시

잘못된 예(Optional 파라미터)

public void updateName(Optional<String> newNameOpt){
    newNameOpt.ifPresent(n->this.name=n);
}

권장 예(null체크 파라미터)

public void updateName(String newName){
//호출 시 null인지 직접 검사
    if(newName !=null && !newName.isBlack()){
        this.name=newName;
    }//else: 그대로 두거나 기본 처리.
}

일반 Null 체크 3) 호출 시 예시

// Optional 반환 메서드
public Optional<User> findUserById(String id){...}

//호출할 때
Optional<User> userOpt=repo.findUserById(id);

// ->Optional API로 안전하게 처리
if(userOtp.isPresent()){
    User u=userOpt.get();
    //내부적으로는 null 체크 없이 바로 사용 가능
    System.out.println(u.getName());
}else{
    System.out.println("사용자를 찾을 수 없습니다.");
}

일반 NULL체크에 대한 설명은 여기서 마무리하고 본론으로 돌아가자.

3) of() vs ofNullable() 처리를 명확히 인지 할 것

1. Optional.of(value)

• value가 절대 null이 아님을 보장할 때만 사용한다.
• 만약 value가 null이면 NPE발생!

2. Optional.ofNullable(value)

• value가 null일 수도 아닐 수도 있을 때 사용한다.
• value가 null이면 빈 Optional(Optional.empty())이 생성되고
• value가 null이 아니면, 값을 담은 Optional이 생성된다.

요약하자면, null이 아님이 확실할 때 of() 사용, null 가능성이 조금이라도 있으면 ofNullable() 사용해주면 된다.

따라서

• NPE을 예방하기 위해서라면, 결국 에러 발생시키는 용도 아닌가?란 생각이 들었고, ⇒ Optional은 에러 대신 “값 없음”을 반환해 주며, NPE를 아예 없애준다.
• 에러를 임의로 발생시키도록 하는 예외처리가 따로 있는데. ⇒ 예외처리는 비정상 상황 대응용, Optional은 정상 흐름에서 값 부재를 처리하는 API이다.
• 그리고 null이던 말던 왜 신경을 써야 하는지에 대해 불만이 있었다. ⇒ null 방치는 예측 불가능한 NPE를 유발하므로, Optional로 사전에 “값 없음”을 명시해 안정성을 높여야 한다.

문제 풀다가 추가적으로, 이해할 필요가 있겠다란 코드가 보였다.

Optional<String> optEmpty = Optional.ofNullable(null);

// orElse는 기본값을 즉시 호출합니다.
String a = optEmpty.orElse(defaultValue());  
// "기본값 생성"이 즉시 출력되고 "DEF" 반환

// orElseGet은 기본값을 필요할 때만 호출합니다.
String b = optEmpty.orElseGet(() -> defaultValue());  
// "기본값 생성"이 "DEF" 반환 시점에 출력

예제코드

        // 1) of() – null이 절대 아닐 때만
        Optional<String> optA = Optional.of("A값");
        // get단독사용한 이유: null 아님이 100%이기 때문.
        System.out.println("optA: " + optA.get());  // safe, 값 있음

        // 2) ofNullable() – null 가능
        String maybeB = null;
        Optional<String> optB = Optional.ofNullable(maybeB);

        // 3) empty() – 빈 Optional
        Optional<String> optEmpty = Optional.empty();

        System.out.println("-----------");

        // 4) isPresent() + get() => null 가능성이 조금이라도 있기 때문에 
        //isPresent로 먼저 확인 후 get씀
        if (optA.isPresent()) {
            System.out.println("optA 존재: " + optA.get());
        }
        if (!optB.isPresent()) {
            System.out.println("optB 비어있음");
        }

        System.out.println("-----------");

        // 5) ifPresent() – 값 있을 때만 실행
        optA.ifPresent(v -> System.out.println("ifPresent optA: " + v));
        optB.ifPresent(v -> System.out.println("ifPresent optB: " + v));  // 실행 안 됨

        System.out.println("-----------");

        // 6) orElse() – 값 없으면 기본값
        System.out.println("optB orElse: " + optB.orElse("기본B"));

        // 7) orElseGet() – 값 없을 때만 supplier 실행
        System.out.println("optEmpty orElseGet: " +
            optEmpty.orElseGet(() -> {
                System.out.println("  supplier 실행!");
                return "Lazy기본";
            })
        );

        System.out.println("-----------");

        // 8) filter() + map()
        Optional<String> optNum = Optional.of("123");
        Optional<Integer> optLen = optNum
            .filter(s -> s.length() > 2)  // 길이 > 2만 통과
            //map(s -> s.length())와 map(String::length); 일치 함
            .map(String::length);         // 길이를 Integer로 매핑
        System.out.println("filter+map 결과: " + optLen.orElse(0));

// 출력결과
optA: A값
-----------
optA 존재: A값
optB 비어있음
-----------
ifPresent optA: A값
-----------
optB orElse: 기본B
  supplier 실행!
optEmpty orElseGet: Lazy기본
-----------
filter+map 결과: 3

옵셔널 관련 문제

// 문제 4-1: Optional 입력값 처리
// 1) Scanner로 사용자로부터 문자열 input을 한 줄 입력받으세요.
// 2) Optional.ofNullable(input)으로 Optional<String> opt을 생성하세요.
// 3) opt.ifPresentOrElse를 사용해
//    값이 있으면 "입력값: {값}"을, 없으면 "값이 없습니다."를 출력하세요.

import java.util.Optional;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 여기에 코드 작성하세요


        sc.close();
    }
}

// 문제 4-2: Optional.of() 예외 확인
// 1) Optional<String> optA = Optional.of("ABC"); 선언
// 2) try-catch 구문 안에서 Optional.of(null)을 호출해 보세요.
// 3) catch(NullPointerException e) 블록에서
//    "of(null) 호출 시 예외 발생!"을 출력하세요.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // 여기에 코드 작성하세요
    }
}

// 문제 4-3: orElse vs orElseGet 비교
// 1) Optional<String> optEmpty = Optional.ofNullable(null); 선언
// 2) String a = optEmpty.orElse(defaultValue());
// 3) String b = optEmpty.orElseGet(() -> defaultValue());
// 4) defaultValue() 메서드를 정의하고,
//    내부에서 "기본값 생성"을 출력한 뒤 "DEF"를 반환하세요.
// 5) a와 b를 차례로 출력해 보세요.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // 여기에 코드 작성하세요
    }

    // 여기에 defaultValue() 메서드 작성
}

//[TIP]
// orElse(): 객체에 값이 없을때 지정한 기본값을 즉시 반환
//여기서 defaultValue()메서드는 orElse()가 호출될 때 즉시 실행됨

//orElseGet() :  객체에 값이 없을 때 람다식 사용하여 기본값을 계산하는 방식
//defaultValue()는 기본값을 반환하는 메서드,값이 없을 때 대체할 기본값을 생성하는 메서드

//람다식을 사용하면, orElse()와는 달리 값이 없을 때만 defaultValue() 메서드를 실행하게 됩니다.
// 그렇기 때문에 값이 있을 경우에는 defaultValue() 메서드가 호출되지 않습니다.

// 문제 4-4: Optional 필터 및 매핑
// 1) Optional<String> emailOpt = Optional.ofNullable("user@example.com"); 선언
// 2) filter(e -> e.contains("@"))로 검증 후
// 3) map(e -> e.substring(e.indexOf("@") + 1))로 도메인만 추출하세요.
// 4) orElse("도메인 없음")으로 최종 결과를 출력하세요.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // 여기에 코드 작성하세요
    }
}

// 문제 4-5: 중첩 Optional 처리 (flatMap)
// 아래 Address, User 클래스를 정의하고
// 1) User user = new User("홍길동", null); 생성
// 2) Optional.ofNullable(user)
//       .flatMap(u -> Optional.ofNullable(u.addr))
//       .map(a -> a.city)
//       .orElse("주소 정보 없음")
//    를 이용해 결과를 출력하세요.

import java.util.Optional;

class Address {
    String city;
    Address(String city) { this.city = city; }
}

class User {
    String name;
    Address addr;
    User(String name, Address addr) {
        this.name = name;
        this.addr = addr;
    }
}

public class Main {
    public static void main(String[] args) {
        // 여기에 코드 작성하세요
    }
}

Lambda(람다식)이란?

자바에서 함수를 간결하게 표현하는 문법이다. 익명클래스의 축약버전. 쉽게 말해, 함수나 메서드를 변수처럼 넘길 수 있게 해주는 문법이다.

(매개변수) -> { 실행문 }

왜 람다를 쓰는가?

• 코드가 짧고 직관적
• 익명 객체(new Runnable() {...})보다 간결함
• 함수형 인터페이스와 함께 사용하여 전달/실행 구조 가능

// 기존 방식
Runnable r = new Runnable() {
    public void run() {
        System.out.println("Hi");
    }
};

// 람다 방식
Runnable r = () -> System.out.println("Hi");

람다의 기초문법

1) 매개변수 없을 경우

() -> System.out.println("Hi")

2) 매개변수 1개 있을 경우

x -> x * x

3) 매개변수 2개 있을 경우

(a, b) -> a + b

4) 매개변수 다수 있을 경우

(x) -> { int y = x+1; return y; }

함수형 인터페이스

자바는 원래 함수만 따로 전달 될 수 없다. 모든 걸 객체로 다뤄야 해서 함수를 쓰고 싶다면 결국 객체의 메서드로 만들어야 한다.

그래서 인터페이스로 대신하는데, 예전에는 아래와 같이 사용했다.

public interface MyFunction {
    void run();
}

MyFunction f = new MyFunction() {
    public void run() {
        System.out.println("실행!");
    }
};

f.run()을 호출하면 마치 함수처럼 넘긴 것처럼 쓸 수 있는데 이 방식이 너무 길다는 단점이 있다.

이때 등장한 게 람다.

// 위 코드를 간단히 줄이면
MyFunction f = () -> System.out.println("실행!");

함수형 인터페이스란? 추상 메서드가 하나만 있는 인터페이스

람다식은 함수처럼 생긴 코드지만, 실제로는 자바에서 객체다. 이 객체는 반드시 함수형 인터페이스를 기반으로 만들어져야 한다. 즉, 람다는 클래스 없이도 메서드만 전달할 수 있게 도와주는 문법이며 실제로는 자바가 자동으로 해당 인터페이스의 익명 구현 객체로 변환해주는 것이다.

람다식은 무조건 추상 메서드 하나만 있는 인터페이스를 기반으로 동작한다. 이걸 함수형 인터페이스라고 부르는데 자바에서는

람다=함수형 인터페이스의 익명 구현체를 간단히 줄인 문법이라고 이해하면 쉽다.

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

잠깐! 인터페이스는 규칙(틀)인데 람다랑 뭔 상관임?

interface Animal {
    void sound();
}

위 코드는 sound라는 메서드를 꼭 만들어!라고 규칙만 정해놓은 건데, 실제 동작(내용)은 누가 구현해줘야 한다.

그런데 람다식도 결국 "어떤 동작(기능)"을 전달하는 방식이다.

x -> x + 1

이건 숫자 하나 받아서 1 더하는 동작을 말하는 건데,

문제는 동작만 따로 전달하지 못한다. 자바는 함수만 덜렁 넘길 수 없고 무조건 객체로 전달해야 함을 명심하자.

그래서 람다식을 사용할 수 있는 방법으로 함수형 인터페이스를 규칙처럼 만든 거다.

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}
// 어떤 계산 로직 하나를 전달해줘.
// 근데 그 계산은 int a, int b 받아서 int 리턴.

위 코드에 의해 람다식이 이렇게 쏙~ 들어간다.

Calculator add = (a, b) -> a + b;

함수형 인터페이스 vs 일반 인터페이스 예시

// 함수형 인터페이스 - 람다식 사용 가능
@FunctionalInterface
interface Printable {
    void print();
}

// 일반 인터페이스 - 추상 메서드 2개 → 람다식 불가능
interface NotFunctional {
    void methodA();
    void methodB();
}

Streams

Stream이란? 자바 컬렉션(List, Set 등)을 함수형 스타일로 처리할 수 있도록 해주는 API. 필터링, 매핑, 집계 등 연산을 간결하게 수행.

스트림의 구조

list.stream()         // 스트림 생성
    .filter(...)       // 필터링
    .map(...)          // 값 변환
    .collect(...)      // 결과 수집

• filter는 조건을 만족하는 요소만 통과시킴 true인 애만 살아남음
• map은 요소의 값을 변환함 소문자->대문자
• collect는 스트림 결과를 리스트, 집합 등으로 다시 모아주는 과정

이해를 돕기 위한 예제 코드

List<String> names = List.of("Tom", "Jerry", "Bob");

List<String> result = names.stream()
    .filter(name -> name.length() <= 3)
    .map(name -> name.toUpperCase())
    .collect(Collectors.toList());

// 출력: [TOM, BOB]

Stream은 중간 연산과 최종 연산으로 나뉜다.

• 중간연산: .filter(), .map() 등 연결만 하고 실제 실행은 안함.
• 최종연산: .collect(), .forEach() 등 이때서야 실행됨 즉, 스트림은 *게으른 평가를 하므로 collect 같은 최종 연산이 와야 동작이 끝난다.

*게으른 평가란? 스트림은 .filter, .map같은 중간 연산만으로는 아무것도 실행되지 않고 collect()나 forEach() 같은 최종 연산이 와야 실행된다.

List<String> names = List.of("Tom", "Jerry", "Bob");

// 실행 안 됨 (아무 결과도 없음)
names.stream()
     .filter(name -> name.length() <= 3)
     .map(String::toUpperCase); // 결과 없음

// 실행됨
names.stream()
     .filter(name -> name.length() <= 3)
     .map(String::toUpperCase)
     .collect(Collectors.toList()); // 실행O

// 또는 실행됨
names.stream()
     .filter(name -> name.length() <= 3)
     .map(String::toUpperCase)
     .forEach(System.out::println); // 실행O, 출력됨

collect()와 forEach() 는 둘 다 스트림을 실행시키는 최종 연산이다. 둘 다 있으면 실행되고, 둘 중 하나만 있어도 실행된다. 차이는 하나는 데이터 수집, 하나는 즉시 실행이다. 람다는 스트림 내부에서 이런 연산들을 표현하는 문법 역할을 한다.

람다 & 스트림 주의사항

• 람다는 오직 함수형 인터페이스에만 쓸 수 있음
• 스트림은 내부 반복(iteration)이며, 원본 컬렉션은 변경되지 않음
• .collect(), .forEach(), .reduce() 등 중간/최종 연산 구분 필요

그래서 람다랑 스트림, 무슨 관계인데??

• Stream 내부에서는 대부분 람다식을 써야 한다.
• .filter(), .map(), .forEach()는 매개변수로 함수형 인터페이스를 받기 때문임.
• 람다는 이 함수형 인터페이스를 간단하게 표현하는 방식이니까 → 자연스럽게 스트림=람다 활용의 대표 사례

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Tom", "Jerry", "Bob");

        // 람다 + 스트림 + forEach (최종 연산)
        names.stream()
            .filter(name -> name.length() <= 3)         // 조건 필터링
            .map(name -> name.toUpperCase())            // 대문자로 변환
            .forEach(name -> System.out.println(name)); // 하나씩 출력
    }
}
// 출력: TOM
// 출력: BOB

forEach간단 예제 (collect 없이)

List<String> names = List.of("Tom", "Jerry", "Bob");

names.stream()
    .filter(name -> name.startsWith("J"))
    .forEach(name -> System.out.println(name)); // 출력: Jerry

질문사항

Q1. 람다식은 메서드랑 뭐가 다른가?

=> 메서드를 변수처럼 전달 가능. *익명 구현체의 축약형

*익명 구현체가 뭔데 (별로 안중요한데 궁금해서 알아봄) 이름이 없는 클래스. 인터페이스나 추상 클래스를 구현하면서 이름없이 바로 쓰는 클래스다.

// Runnable이라는 인터페이스를 구현하고 싶을 때
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hi");
    }
};
r.run();

위 코드에서 Runnable은 인터페이스다.(void run()이라는 메서드 하나만 있음)

그런데 클래스 만들지 않고 바로 new Runnable(){}해서 구현한 건데, 이게 바로 익명 구현 객체(익명 클래스의 인스턴스)

문제는 너무 길고 보기 힘듦=> 그래서 나온 게 람다식

// 위 코드를 람다식으로 바꾸면
Runnable r = () -> System.out.println("Hi");

Q2. 함수형 인터페이스는 왜 쓰는가?

=> 람다식이 동작하려면 반드시 1개의 추상메서드가 필요해서.

Q3. filter()와 map() 차이는?

=> filter는 조건 판별(걸러냄), map은 값 변환(바꿈).

Q4. 스트림 쓸 때 꼭 collect() 해야 해?

=> 최종연산 필요. 결과로 List 등 만들려면 collect() 필요.

public enum OperatorType{
    ADD('+'), ...
}

내부에 필드, 생성자, 메서드 다 넣을 수 있다? => enum클래스 enum은 상수들의 모음+부가정보를 담기위한 특수 클래스라고 생각하면 이해하기 쉽다.

 public enum OperatorType{
    ADD('+'),
    SUBTRACT('-'),
    MULTYPLY('*'),
    DIVIDE('/'),
    MOD('%');

    private final char symbol;
    // 각 연산자 타입이 가질 기호를 저장할 필드


    OperatorType(char symbol){
    //생성자임. enum상수가 만들어질 때마다 기호를 저장해주는 역할
        this.symbol=symbol;
    }

    public char getSymbol(){
    //원래 getter는 파라미터 안받음: 읽기 전용이기 때문.
    // 외부에서 기호를 읽어올 수 있도록 getter제공
        return symbol;
    }

    public static OperatorType fromChar(char ch){
    // static: 객체 만들지 않고 클래스 이름으로 바로 호출 가능

    // 왜 static으로 했는가?: 외부에서 + 같은 값을 던졌을 때, 
    // 바로 enm상수를 찾아주는 문 입구같은 메서드.

    // OperatorType: enum값 중 하나를 리턴할 거임
    // ch: 입력받은 연산 문제 
    // fromChar=메서드명

        for(OperatorType op: OperatorType.values()){
        //OperatorType.values()는 [ADD, SUBTRACT, MULTYPLY, DIVIDE, MOD]
        // op는 순서대로 ADD, SUBTRACT, MULTYPLY, DIVIDE, MOD 반복

            if(op.symbol==ch) return op;
            // 입력한 문자와 ch 같다면 return 
        }
        throw new ArithmeticException("지원하지 않는 연산자");
        //반복문 다 돌았는데도 일치하는 symbol이 없으면 에러 던짐

    }
}

위 코드 안에 주석으로 설명 달아놓긴 했는데 와닿지가 않아서 구조를 분해해 보며 이해해 보기로 했다.

public enum OperatorType

 public enum OperatorType {
    ADD, SUBTRACT, MULTIPLY, DIVIDE, MOD
}

+, - 같은 기호값이 없음, 단지 이름만 있고 실제 연산 기호는 if/switch 에서 따로 비교해야 한다. 쓰는 쪽에서 쓸데없이 연산자 기호와 enum을 따로 관리해야 해서 불편하기까지 한다. 그래서 기호에 따라 아래와 같이 switch문을 이용하여 해결해주면 된긴한데..

char giho = '+';
OperatorType opType;

switch (giho) {
    case '+': opType = OperatorType.ADD; break;
    case '-': opType = OperatorType.SUBTRACT; break;
    // ... 직접 다 써야 함
}

이렇게 만들게 되면 번거롭고 직관적으로 예쁘지도 않기 때문에 enum을 활용해주면 아주 예쁜 모양이 나온다.

 char giho = '+';
OperatorType opType = OperatorType.fromChar(giho);

아래코드와 같이 완성된 모습을 볼 수 있다.

 public static OperatorType fromChar(char ch) {
    for (OperatorType op : OperatorType.values()) {
        if (op.getGiho() == ch) {
            return op;
        }
    }
    throw new ArithmeticException("지원하지 않는 연산자: " + ch);
}

즉, 위 코드와 아래 코드와 같은 기능을 한다.

 '+' → OperatorType.ADD
'-' → OperatorType.SUBTRACT
... 이런 "변환 작업"이 필요함!

enum 활용하면서 fromChar을 만들어야겠다까지 생각을 못 했다. 그래서 enum사용 시 팁을 적어보자면 아래와 같다

num을 만들고,
enum이 외부 입력(char, String, int)을 받아서
자기 자신(enum 상수)을 "찾아주는" 역할이 필요하면
무조건 fromXxx() 메서드 만든다고 기억하자!

OperatorType.values()

for (OperatorType op : OperatorType.values()) { ... }

enum 클래스가 자동으로 만들어주는 메서드인데, ADD, SUBTRACT,...이런 모든 enum상수들을 배열로 반환해준다.

 OperatorType.values() 
// → [ADD, SUBTRACT, MULTIPLY, DIVIDE, MOD]

private final char symbol;

 private final char symbol;

enum은 불변하기 때문에 final.

getter는 왜 있고, setter는 왜 없냐?

enum은 상수이기 때문에 절대 바뀌면 안된다. setter가 필요없다. getter만 있으면 되는데 외부에서 giho를 읽기 전용으로 제공해준다.

따라서 enum은 setter사용 금지, getter사용 필수.

제네릭이란?

List에서 <> 안의 String. 자료형(타입)을 코드가 실행되기 전에 미리 고정하지 않고 외부에서 나중에 넣게끔 설계하는 문법이다. 쉽게 말하면 자료형을 직접 넣지 말고 <>로 비워두고 나중에 이건 String이야, 이건 Integer야 라고 지정하게 하자.

왜 제네릭을 쓰는가?

타입마다 클래스를 일일이 만들면 중복이 심하고 유지보수도 어려움.
제네릭은 하나의 클래스만 정의해두고 모든 타입에 재사용 가능하게 해준다.

→ 아래 제네릭 전/후 예시 참고.

public class StringBox {
    private String item;

    public void set(String item) {
        this.item = item;
    }

    public String get() {
        return item;
    }
}

위 코드와 같은 클래스가 있다고 가정해보자. 이거는 String 만 담을 수 있는 박스. 그럼 int도 담고 싶을 때 또 만들어야 하나?라는 생각을 할 수 있다.

public class IntegerBox {
    private Integer item;
    public void set(Integer item) { this.item = item; }
    public Integer get() { return item; }
}

public class DoubleBox {
    private Double item;
    public void set(Double item) { this.item = item; }
    public Double get() { return item; }
}

public class BooleanBox {
    private Boolean item;
    public void set(Boolean item) { this.item = item; }
    public Boolean get() { return item; }
}

이건 타입마다 클래스를 일일이 새로 만들어야 한다. 중복이 너무 심함.

그래서 이런 중복을 없애고 하나의 클래스로 모든 타입을 처리할 때 제네릭.

public class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

따라서 제네릭은 재사용 가능한 코드를 만들기 위해 필수

또한 List는 내부 요소의 타입을 모르는 상태로 만들어진다. 그래서 타입 매개변수를 필요로 함.

그래서 List 이런 식으로 선언되어 있고 사용 시 List처럼 구체적인 타입을 만들어줘야 한다.

즉, List, Map, Set같은 컬렉션은 내부적으로 제네릭으로설계되어 있다.

생성된 제네릭은 아래 코드와 같이 사용하면 된다.

Box<String> strBox = new Box<>();       // StringBox 역할
Box<Integer> intBox = new Box<>();      // IntegerBox 역할
Box<Double> doubleBox = new Box<>();    // DoubleBox 역할
Box<Boolean> boolBox = new Box<>();     // BooleanBox 역할

제네릭의 기초 문법

  class Box<T> {
    private T item;

    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

T는 타입 매개변수(Type parameter)

클래스나 메서드가 어떤 타입을 받을지 미정인 상태로 설계 가능하다.

  Box<String> strBox = new Box<>();
strBox.set("Hello");
String val = strBox.get(); // 형변환 없이 사용 가능!

제네릭 클래스 vs 제네릭 메서드

제네릭 클래스

  class Container<T> {
    T data;
}

제네릭 메서드

  public class Util {
    public static <T> void print(T value) {
        System.out.println(value);
    }
}

가 리턴 타입 앞에 있다. 메서드 자체가 제네릭이라는 뜻이다.

제네릭 사용 시 주의 사항

    class MyClass<T> { ... }   // 제네릭 클래스
<T> void myMethod(T val)   // 제네릭 메서드

  List<int> list = new ArrayList<>();  // 오류 (원시 타입 불가)

Box<String> b = new Box<>();
b.set("hi"); // ok
b.set(123);  // 오류 (String만 허용)

질문사항

Q1. <> 안엔 꼭 T여야 해?

No. 관례적으로 T를 많이 씀

Q2. <?>는 뭐야?

와일드카드. “모르겠지만 뭔가 타입이 있을 거야” 라는 뜻. 제한을 줄 수 있음 → <? extends Number>, <? super Integer>

Q3. 제네릭은 형변환 안 해도 된다고?

Yes 제네릭은 컴파일 타임에 타입을 검사해줌 → 실수 예방, 가독성 향상

List names = new ArrayList(); // 제네릭 미사용
names.add("hi");
String name = (String) names.get(0); // 형변환 필요 x 위험

List<String> names = new ArrayList<>(); // 제네릭 사용
String name = names.get(0); // 형변환 필요 없음 안전

Q4. 제네릭 클래스 vs 제네릭 메서드 구분 맞아?

Yes,

• 제네릭 클래스

public class Box<T> {
    T item;
}
// → T는 클래스 전체에 적용

• 제네릭 메서드

public class Util {
    public static <T> void print(T value) {
        System.out.println(value);
    }
}
// → <T>가 메서드 안에서만 사용됨. 클래스 전체는 제네릭 아님.

동기처리는 작업을 순차적으로 처리하는 방식으로 하나의 작업이 끝난 후에야 다음 작업이 실행된다. 단점으로는 시간이 오래 걸리는 작업이 있으면 전체 프로그램의 실행이 지연될 수 있다.

비동기 처리는 작업을 병렬로 처리하며 하나의 작업을 기다리지 않고 다른 작업을 동시에 실행한다. 예를들어, 네트워크요청을 보낸 후 결과를 기다리는 동안 다른 일을 할 수 있다. 비동기처리는 주로 I/O작업에서 사용되며 프로그램의 효율성을 높여준다.

즉 동기처리는 순차적실행, 비동기처리는 동시에 여러 작업을 실행할 수 있다는 차이가 있다.

상속은 부모클래스의 속성과 메서드를 자식 클래스가 물려받는 것으로 코드 재사용을 가능하게 한다.

캡슐화는 객체의 속성을 숨기고 외부에서 안전하게 다룰 수 있게 하는 개념이다.

다형성은 같은 이름의 메서드가 다른 동작을 하게 만드는 원리로 여러 클래스에서 같은 메서드를 다르게 구현할 수 있게 해준다.

반면 타입스크립트는 정적 타이핑을 지원하는 언어다. 즉 변수에 타입을 명시적으로 지정할 수 있으며 컴파일 타임에 타입오류를 미리 확인 할 수 있다. 타입스크립트는 자바스크립트의 기본 타입을 그대로 사용하면서도 any, unknown, never, tuple, enum과 같은 추가적인 타입을 제공하며 코드의 안정성을 높이고 유지보수를 용이하게 한다. 예를들어 any는 어떤 타입이든 허용되지만 타입스크립트는 이를 사용하는 대신 unknown을 사용해 타입체크를 강제하여 더 안전한 코드를 작성할 수 있다.

따라서 자바스크립트는 실행중에 오류가 발생할 수 있는 동적타입언어인 반면, 타입스크립트는 개발과정에서 타입을 명시적으로 정의하고 오류를 미리 예방할 수 있는 정적타입언어다.

프론트엔드 애플리케이션에서 에러는 사용자의 경험을 크게 저하시킬 수 있습니다. 에러를 빠르게 파악하고 해결하는 것이 중요하며, 이를 위한 효율적인 도구로 Sentry를 활용할 수 있습니다. 본 글에서는 Sentry를 기반으로 애플리케이션의 에러 모니터링을 어떻게 설정하고 활용할 수 있는지, 그리고 배포 과정에서 Vercel을 이용한 배포 방법에 대해 다룹니다.

Sentry 기반 애플리케이션 에러 모니터링 Sentry는 애플리케이션의 에러를 실시간으로 추적할 수 있는 강력한 도구입니다. React를 포함한 다양한 프레임워크에서 발생할 수 있는 에러를 자동으로 추적하고, 자세한 에러 로그를 제공합니다. 이를 통해 개발자는 에러 발생 원인을 빠르게 파악하고, 신속하게 문제를 해결할 수 있습니다.

1. 에러 예시 1: Target container is not a DOM element

문제: React 애플리케이션에서 ReactDOM.createRoot를 호출할 때, 잘못된 DOM 요소를 참조하면 Target container is not a DOM element라는 에러가 발생할 수 있습니다. 이는 일반적으로 ReactDOM.createRoot에서 지정한 컨테이너가 실제로 DOM에 존재하지 않거나 잘못된 참조일 때 발생합니다.

Sentry에서의 에러 로그: 에러 메시지: Target container is not a DOM element 문제 발생 위치: /src/main.tsx (line 40) Stack Trace: 에러가 발생한 파일과 라인 정보를 제공하여, 빠르게 문제를 추적할 수 있습니다.

해결 방법: Sentry가 제공하는 에러 상세 정보를 통해 createRoot 메소드가 참조하는 DOM 요소가 올바르게 설정되었는지 확인할 수 있습니다. 잘못된 DOM 요소 참조를 수정하면 이 에러를 해결할 수 있습니다.

2. 에러 예시 2: TypeError - Object [object Object] has no method 'updateFrom'

문제: 이 에러는 객체에 updateFrom 메소드가 정의되어 있지 않거나 잘못된 객체에 해당 메소드가 호출되었을 때 발생합니다. 특히, raven.js와 관련된 코드에서 이런 문제가 발생하는 경우가 많습니다.

Sentry에서의 에러 로그: 에러 메시지: TypeError - Object [object Object] has no method 'updateFrom' 문제 발생 위치: views.js (line 389)

해결 방법: 에러 발생 위치와 객체를 추적하여, 해당 객체가 올바르게 메소드를 호출할 수 있도록 수정해야 합니다. Sentry의 디버깅 정보를 통해 코드 흐름을 쉽게 파악할 수 있습니다.

Sentry를 통한 에러 추적의 장점

Sentry는 다음과 같은 기능을 제공합니다:

자동 에러 추적: 애플리케이션에서 발생한 에러를 자동으로 수집하여 실시간으로 추적할 수 있습니다. Stack Trace: 에러가 발생한 정확한 파일과 라인 정보를 제공합니다. 이를 통해 개발자는 에러 발생 지점을 빠르게 찾을 수 있습니다. 브라우저 및 환경 정보: 에러 발생 시 사용자의 브라우저, 운영 체제 정보 등을 제공하여, 특정 환경에서만 발생하는 문제를 파악할 수 있습니다. 세션 리플레이: 사용자가 에러를 발생시키는 시점을 녹화하여 재생할 수 있어, 문제를 재현하고 디버깅하는 데 도움이 됩니다.

Vercel을 이용한 배포

Vercel은 React 애플리케이션을 빠르고 쉽게 배포할 수 있는 플랫폼입니다. Vercel은 자동으로 빌드 및 배포를 처리해 주므로, 개발자는 배포 과정을 신경 쓰지 않고 개발에 집중할 수 있습니다.

Vercel 배포 방법:

Vercel에 가입하고 로그인: Vercel 공식 사이트에서 계정을 생성하고 로그인합니다. GitHub 연동: Vercel은 GitHub과 통합되어 있어, 리포지토리를 선택하여 배포할 수 있습니다. 배포: 배포할 프로젝트를 선택하고, Vercel이 자동으로 빌드 및 배포를 진행합니다. 배포가 완료되면, 자동으로 배포된 사이트의 URL을 제공합니다.

유닛 테스트란?

유닛 테스트는 작은 코드 단위(함수나 컴포넌트)가 제대로 작동하는지 확인하는 작업입니다. 예를 들어, 웹사이트에서 "버튼을 클릭하면 텍스트가 바뀌는지" 이런 동작들이 정확한지 체크할 수 있습니다. 이렇게 테스트를 해두면, 나중에 코드를 수정할 때 "이게 정말 잘 작동할까?"라는 걱정을 덜 수 있습니다.

왜 유닛 테스트가 필요한가?

유닛 테스트를 하는 이유는 버그(문제)를 미리 찾아내고 예방하기 위해서입니다. 예를 들어, 나중에 코드를 수정했을 때 그 수정으로 인해 문제가 생겼다면, 유닛 테스트가 이미 이를 알려줄 수 있게됩니다. 그래서 안전하게 코드를 수정하거나 새 기능을 추가할 수 있게 돕습니다.

유닛 테스트 라이브러리

Jest: Jest는 가장 많이 사용되는 유닛 테스트 도구 중 하나입니다. 설정이 간단하고, React나 JavaScript에서 사용됩니다. 또한 빠르게 테스트를 실행하고, 실패한 테스트는 쉽게 찾을 수 있게 도와줍니다.

Mocha: Node.js 환경에서 많이 사용됩니다. 비동기 테스트에 강점이 있어서 서버 관련 테스트에 유용합니다.

Chai: Chai는 Mocha와 함께 사용되는 라이브러리로, 테스트 결과를 좀 더 직관적으로 표현할 수 있게 도와줍니다. 어떤 값이 맞는지 확인하는 assertion을 쉽게 작성할 수 있습니다.

유닛 테스트: 두 번째 테스트 작성하기

import { render, screen, fireEvent } from '@testing-library/react';
import MyComponent from './MyComponent';

test('버튼을 클릭하면 텍스트가 바뀐다', () => {
  render(<MyComponent />);
  const button = screen.getByRole('button');
  fireEvent.click(button);
  const changedText = screen.getByText('텍스트 변경됨');
  expect(changedText).toBeInTheDocument();
});

이 코드는 "버튼을 클릭했을 때 텍스트가 '텍스트 변경됨'으로 바뀌는지"를 테스트해요. 테스트가 성공하면, 이 버튼이 제대로 동작합니다.

지금까지 Jest로 유닛 테스트를 작성하고 있었고, Day 2에서 작성했던 컴포넌트에 대해서도 테스트를 진행해야 한다고 했습니다. 방금 전에 작성한 코드처럼 버튼을 클릭하면 텍스트가 바뀌는지 같은 간단한 테스트를 할 수 있습니다.

1. 첫 번째 테스트: SignIn 테스트

import { render, screen, fireEvent } from '@testing-library/react';
import SignIn from '../SignIn';  

test('로그인 버튼을 클릭하면 로그인 폼이 제출된다', () => {
  render(<SignIn />);  

  const usernameInput = screen.getByLabelText(/사용자 이름/i);  
  // 사용자 이름 입력 필드 찾기
  const passwordInput = screen.getByLabelText(/비밀번호/i);  
  // 비밀번호 입력 필드 찾기
  const submitButton = screen.getByRole('button', { name: /로그인/i });  
  // 로그인 버튼 찾기

  // 입력 필드에 값 넣기
  fireEvent.change(usernameInput, { target: { value: 'testuser' } });
  fireEvent.change(passwordInput, { target: { value: 'password123' } });

  // 로그인 버튼 클릭
  fireEvent.click(submitButton);

  // 로그인 성공 메시지 확인 (혹은 화면 변화 확인)
  const successMessage = screen.getByText(/로그인 성공/i);
  expect(successMessage).toBeInTheDocument();
});

SignIn.test.tsx에서 우리는 로그인 화면을 테스트했던 것 같아요. 사용자가 로그인 폼을 올바르게 제출할 수 있는지, 그리고 로그인에 필요한 필드들이 제대로 동작하는지 확인하는 내용입니다. 이 코드는 SignIn 컴포넌트에서 사용자 이름과 비밀번호를 입력하고 로그인 버튼을 클릭했을 때, 로그인 성공 메시지가 나타나는지 테스트하는 내용입니다. fireEvent.change()로 입력 필드에 값을 넣고, fireEvent.click()으로 버튼을 클릭하는 동작을 처리하고 있습니다.

2. 두 번째 테스트: Header 테스트

import { render, screen, fireEvent } from '@testing-library/react';
import Header from '../Header';  

test('헤더에서 로그인/회원가입 버튼을 클릭하면 해당 페이지로 이동한다', () => {
  render(<Header />);  

  const loginButton = screen.getByRole('button', { name: /로그인/i });  
  // 로그인 버튼 찾기
  const signUpButton = screen.getByRole('button', { name: /회원가입/i });  
  // 회원가입 버튼 찾기

  // 로그인 버튼 클릭
  fireEvent.click(loginButton);
  // 로그인 페이지로 이동했다고 가정하고, 해당 페이지의 요소가 있는지 확인
  expect(screen.getByText(/로그인 페이지/i)).toBeInTheDocument();

  // 회원가입 버튼 클릭
  fireEvent.click(signUpButton);
  // 회원가입 페이지로 이동했다고 가정하고, 해당 페이지의 요소가 있는지 확인
  expect(screen.getByText(/회원가입 페이지/i)).toBeInTheDocument();
});

이 테스트는 로그인과 회원가입 버튼이 클릭될 때 해당 페이지로 잘 이동하는지를 확인하는 테스트입니다. fireEvent.click()으로 버튼 클릭을 시뮬레이션하고, 페이지 이동을 확인하는 방식입니다.

이렇게 SignIn과 Header 컴포넌트에 대한 유닛 테스트를 작성함으로써, 중요한 동작들이 잘 동작하는지 자동으로 확인할 수 있습니다. Jest를 사용하면 사용자와의 상호작용을 테스트하고, 컴포넌트가 올바르게 작동하는지 쉽게 검증할 수 있습니다.

Access Token과 Refresh Token의 개념

1. Access Token Access Token은 사용자가 로그인했음을 증명하는 출입증과 같다. 이를 가지고 있어야 서버에서 데이터를 요청할 수 있다.

특징

• 로그인하면 발급됨
• 짧은 유효기간(보통 15분~1시간)
• API요청 시 Authorization: Bearer 에 포함해 사용
• 탈취되면 보안 위험이 있음

2. Refresh Token Refrech Token은 Access Token이 만료되었을 때, 새로운 Access Token을 발급받기 위한 갱신 키 역할을 한다.

특징

• 로그인하면 Access Token과 함께 발급됨
• 유효기간이 길다(7일~30일)
• 만료된 Access Token을 갱신하는 역할
• 탈취 시 보안 위험이 크므로 안전하게 보관해야 함

JWT가 동작하는 방식

1. 사용자가 로그인하면 서버가 Access Token과 Refresh Token 발급함
2. 클라이언트(웹/앱)가 Access Token을 API요청에 포함해 서버에 전송함
3. 서버가 Access Token을 검증하고 요청을 처리함
4. Access Token이 만료되면 클라이언트가 Refrech Token을 사용해 새로운 Access Token을 요청함
5. 서버가 Refresh Token을 확인하고 새로운 Access Token을 발급함
6. Refresh Token까지 만료되면 사용자는 다시 로그인해야 함

안전한 JWT관리법

1. Access Token 저장방식

• 메모리저장(권장)-> XSS 공격을 방어할 수 있음
• HTTP-Only쿠키 저장-> 브라우저에서 접근할 수 없도록 보호
• LocalStorage(비추천)->XSS공격에 취약함

2. Refresh Token저장방식

• Secure HTTP-Only쿠키(권장)-> 쿠키에 저장하고 httpOnly설정
• 데이터베이스 저장-> 서버에서 관리하고 요청할 때 검증
• Redis사용-> 빠른 접근과 관리가 가능

3. 보안강화 전략

• Refresh Token을 한 번만 사용하도록 설정(재사용 방지)
• 로그아웃하면 Refresh Token을 즉시 폐기
• JWT 서명을 검증해 변조 여부 확인
• IP 및 User-Agent변경 감지 후 추가 인증요구

JWT 사용 시 주의할 점

• Access Token의 유효기간을 짧게 설정해 탈취위험을 줄이기
• Refresh Token은 서버에서 안전하게 보관하기
• HTTPS를 사용해 네트워크에서 토큰이 노출되지 않도록 하기