[복습] 2025.03.12

[Yumi-Park996]

이 문서는 LLM API 호출과 Slack 연동을 중심으로 로거와 멀티스레드의 개념을 설명하는 교안입니다.
이 문서를 통해, 다음 내용을 쉽게 이해할 수 있습니다.

1. LLM API를 호출하고 응답을 처리하는 과정
2. Slack을 이용해 결과를 전송하는 과정
3. 로깅(Logger) 시스템을 활용하는 방법
4. 멀티스레드를 사용해 성능을 최적화하는 방법

---

1. 전체적인 동작 흐름

📌 프로그램이 어떻게 동작하는지 한눈에 보기

이 프로그램의 전체적인 흐름을 도식화하면 다음과 같습니다.

+-----------------------------+
|      Application 실행       |
+-----------------------------+
        |    |    |
        V    V    V
 +-------------------------+
 |  3개의 LLM 요청 실행   |
 | (멀티스레드 동작)       |
 +-------------------------+
        |    |    |
        V    V    V
+-----------------------------+
|   AI 응답을 Slack으로 전송  |
+-----------------------------+

📌 핵심 개념
1️⃣ 사용자가 입력한 질문을 LLM API에 보냄
2️⃣ 멀티스레드를 사용해 3개의 요청을 동시에 실행
3️⃣ 응답을 받아 Slack으로 메시지 전송

---

2. 프로그램의 주요 기능

이 프로그램은 여러 개의 클래스로 구성되어 있으며, 각 파일의 역할을 정리하면 다음과 같습니다.

파일명	역할
Application.java	프로그램의 메인 실행 코드
LLM.java	LLM API 요청을 처리하는 클래스
ModelCategory.java	사용할 LLM 모델 종류를 정의하는 Enum 클래스
Slack.java	Slack으로 메시지를 보내는 클래스
MyLogger.java	로그를 기록하는 유틸리티 클래스 (싱글톤)
MySecret.java	API 키를 관리하는 환경 변수 유틸리티 클래스
WebClient.java	HTTP 요청을 처리하는 유틸리티 클래스 (싱글톤)

---

3. 주요 개념 설명

(1) LLM API란?

LLM (Large Language Model) API는 ChatGPT와 같은 AI 모델과 대화할 수 있도록 도와주는 인터페이스입니다.

이 프로그램에서는 LLM API를 통해 질문을 보내고 답변을 받는 기능을 수행합니다.

📌 LLM API 요청 방식

• 요청 방식: HTTP POST
• 요청 예시:

{
    "model": "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
    "messages": [{
        "role": "user",
        "content": "What is Java?"
    }],
    "max_tokens": 2048
}

• 응답 예시:

{
    "choices": [{
        "message": {
            "role": "assistant",
            "content": "Java is a programming language..."
        }
    }]
}

📌 핵심 개념
1️⃣ 사용자의 질문을 JSON 형식으로 LLM API에 보냄
2️⃣ AI 모델이 응답을 생성하고 반환

---

(2) Slack 메시지 전송

Slack 메시지는 특정 웹훅 URL을 통해 전송됩니다.
이 프로그램에서는 Slack.java 클래스에서 Slack 메시지를 전송하는 기능을 수행합니다.

• 요청 데이터 예시:

{
    "text": "Java is a programming language...",
    "attachments": [{
        "image_url": "https://image.example.com/java.png"
    }]
}

📌 핵심 개념
1️⃣ API를 이용해 Slack으로 메시지를 보냄
2️⃣ 텍스트와 이미지를 함께 전송 가능

---

4. 로거 (Logger) 개념

📌 로깅(Log) 이란?

로깅이란 프로그램 실행 정보를 저장하여 디버깅과 오류 분석을 쉽게 만드는 것입니다.

📌 로그 레벨(Log Level)

로그 레벨	설명
DEBUG	상세한 디버깅 정보
INFO	일반적인 실행 정보
WARN	경고 메시지 (큰 문제는 아니지만 주의 필요)
ERROR	오류 발생 시 기록

📌 코드 예시 (MyLogger.java)

public class MyLogger {
    private static MyLogger instance;  // ✅ 유일한 인스턴스를 저장할 변수
    // static 키워드는 클래스가 로드될 때 한 번만 메모리에 할당됨
    // 따라서, instance 변수는 프로그램이 실행되는 동안 단 하나만 유지
    private final Logger logger;  // Java 기본 제공 Logger

    // ✅ private 생성자 (외부에서 new MyLogger()를 사용 못하게 막음)
    private MyLogger() {
        logger = Logger.getLogger(MyLogger.class.getName());
    }

    // ✅ getLogger() 메서드를 통해 단 하나의 인스턴스만 반환
    public static MyLogger getLogger() {
        if (instance == null) {  // 🔹 객체가 아직 생성되지 않았다면
            instance = new MyLogger();  // 🔹 객체를 생성
        }
        return instance;  // 🔹 이미 생성된 객체를 반환
    }

    // ✅ 로그 출력 함수
    public void info(String msg) {
        this.logger.info(msg);
    }
}

📌 싱글톤 패턴 적용
1️⃣ static 변수 instance로 단 하나의 객체만 유지
2️⃣ getLogger()를 통해 항상 같은 객체를 반환

---

5. 멀티스레드 (Multi-threading) 개념

📌 멀티스레드란?

멀티스레드란 여러 개의 작업을 동시에 실행하여 속도를 빠르게 하는 기법입니다.

📌 단일 스레드 vs 멀티스레드

방식	특징
단일 스레드	한 번에 하나의 작업만 실행 (응답이 느릴 수 있음)
멀티스레드	여러 개의 작업을 동시에 실행 (응답 속도 향상)

---

📌 멀티스레드 흐름도

+-----------------------------+
|        Main Thread          |
+-----------------------------+
        |    |    |
        V    V    V
+-----------------------------+
| 3개의 LLM 요청 실행 (병렬) |
+-----------------------------+
        |    |    |
        V    V    V
+-----------------------------+
|        응답 수집 후 Slack 전송        |
+-----------------------------+

📌 멀티스레드 코드 예시

ExecutorService executor = Executors.newFixedThreadPool(3);

Future<String> imageFuture = executor.submit(new LLMTask(ModelCategory.FLUX, "Create an image for Java."));
Future<String> reasoningFuture = executor.submit(new LLMTask(ModelCategory.R1, "Explain Java in detail."));
Future<String> reasoningFuture2 = executor.submit(new LLMTask(ModelCategory.R1, "Give Java job interview tips."));

String imageResult = imageFuture.get();
String reasoningResult = reasoningFuture.get();
String reasoningResult2 = reasoningFuture2.get();

executor.shutdown();

📌 핵심 개념
1️⃣ Executors.newFixedThreadPool(3); → 최대 3개의 작업을 동시에 실행
2️⃣ executor.submit(new LLMTask(...)); → 스레드에서 LLM 요청 실행
3️⃣ Future.get(); → 작업이 끝날 때까지 기다림

---

6. 마무리

✅ 로거: 프로그램 실행을 기록하고 디버깅을 돕는 도구
✅ 멀티스레드: 여러 작업을 동시에 실행하여 속도를 향상
✅ LLM API + Slack 연동: AI 응답을 Slack으로 전송

---

---

📌 API란?

1. API (Application Programming Interface)란?

API(Application Programming Interface)는 **소프트웨어 간의 상호 작용을 가능하게 하는 인터페이스(접점)**입니다.
즉, 프로그램이나 서비스가 서로 데이터를 주고받거나 기능을 호출할 수 있도록 해주는 규칙 및 프로토콜을 의미합니다.

---

2. API의 주요 역할

1️⃣ 데이터 교환: 한 시스템에서 다른 시스템으로 데이터를 요청하고 응답받을 수 있음
2️⃣ 기능 제공: 특정 기능(예: AI 모델 호출, 결제 시스템 등)을 외부에서도 사용할 수 있도록 제공
3️⃣ 보안 유지: API를 통해 제한된 데이터만 노출하고, 인증을 요구하여 보안성을 유지
4️⃣ 추상화(Abstract): 내부 구현 방식을 숨기고, 사용자가 쉽게 기능을 호출할 수 있도록 함

---

3. API의 종류

1️⃣ Web API (REST API, GraphQL API 등)

• 인터넷을 통해 요청을 보내고 응답을 받는 API
• HTTP 프로토콜을 사용하여 데이터를 주고받음
• 예: GitHub API, OpenAI API, Google Maps API 등

2️⃣ Library API

• 특정 라이브러리의 기능을 사용할 수 있도록 제공하는 API
• 예: Java의 Math 라이브러리 API

3️⃣ Operating System API

• 운영체제(OS) 기능을 활용할 수 있도록 제공하는 API
• 예: Windows API, POSIX API

---

4. Web API에서 HTTP 요청 방식 (GET vs POST)

Web API는 주로 HTTP 프로토콜을 통해 데이터를 요청하거나 전송하는데,
대표적인 HTTP 요청 방식은 GET과 POST입니다.

요청 방식	설명
GET	데이터를 조회 (읽기)
POST	데이터를 생성 및 전송 (쓰기)
PUT	기존 데이터를 수정
DELETE	데이터를 삭제

---

📌 GET vs POST 차이점

1. GET 요청

• 목적: 데이터를 가져올 때(조회) 사용
• 데이터 전달 방식: URL의 **쿼리 스트링(Query String)**에 포함됨
• 특징:
  ✔ 브라우저에서 직접 URL 입력하여 요청 가능
  ✔ 요청을 캐시(Cache)할 수 있음
  ✔ 요청 데이터가 URL에 노출되므로 보안에 취약

📌 GET 요청 예시 (브라우저에서 요청 가능)

https://api.example.com/user?id=123

📌 Java 코드 예제

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/user?id=123"))
    .GET()
    .build();

✔ 서버는 id=123에 해당하는 사용자의 정보를 반환함

---

2. POST 요청

• 목적: 새로운 데이터를 서버에 전송하고 생성할 때 사용
• 데이터 전달 방식: 요청의 **본문(Body)**에 포함됨
• 특징:
  ✔ 데이터를 직접 URL에 포함하지 않음 → 보안성이 높음
  ✔ 요청 본문을 통해 대량의 데이터 전송 가능
  ✔ 요청을 캐시할 수 없음

📌 POST 요청 예시 (JSON 데이터 포함)

POST https://api.example.com/user
{
    "name": "Alice",
    "email": "alice@example.com"
}

📌 Java 코드 예제

String json = """
    {
        "name": "Alice",
        "email": "alice@example.com"
    }
""";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/user"))
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .header("Content-Type", "application/json")
    .build();

✔ 서버는 새로운 사용자를 데이터베이스에 추가하고, 성공 응답을 반환함

---

📌 LLM API 요청이 왜 POST 방식인가?

1. LLM API 요청 방식

LLM (Large Language Model) API는 사용자가 질문을 입력하면 AI 모델이 답변을 생성하는 API입니다.
이때 POST 요청을 사용해야 하는 이유는 다음과 같습니다.

📌 LLM API 요청 예시 (POST)

POST https://api.together.xyz/v1/chat/completions
{
    "model": "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
    "messages": [{
        "role": "user",
        "content": "What is Java?"
    }],
    "max_tokens": 2048
}

---

2. LLM API가 POST를 사용하는 이유

이유	설명
① 질문 데이터가 길어질 수 있음	GET은 URL에 데이터를 포함하지만, 긴 질문을 URL에 포함하면 제한이 있음.
② 데이터 보안	GET 요청은 URL에 데이터가 포함되므로 질문 내용이 노출될 수 있음. POST는 본문(Body)에 포함되므로 보안성이 높음.
③ 문맥 유지 필요	AI 모델과의 대화는 이전 메시지를 포함하여 전달해야 함, 따라서 본문(Body)로 여러 개의 메시지를 한 번에 보낼 필요가 있음.
④ API 설계 원칙	POST는 새로운 데이터를 생성하는 역할을 하며, AI 응답은 새로운 데이터를 생성하는 과정이므로 적절함.

---

3. LLM API 요청이 GET이면 어떤 문제가 발생할까?

📌 GET 요청을 사용할 경우

https://api.together.xyz/v1/chat/completions?model=meta-llama&messages=What is Java?

✔ URL이 너무 길어질 수 있음 (브라우저의 URL 길이 제한 초과 가능)
✔ 질문 내용이 URL에 그대로 노출됨 (보안 위험)
✔ 과거 메시지를 포함하여 요청하는 것이 어려움 (대화 문맥 유지 불가)

📌 POST 요청을 사용할 경우
✔ 본문(Body)에 데이터를 포함하여 URL 제한 없음
✔ 데이터가 노출되지 않아 보안성이 높음
✔ 과거 메시지 포함 가능 → 문맥을 유지한 대화 가능

---

📌 5. 정리

✅ API란?

✔ API는 프로그램 간의 데이터 교환을 가능하게 하는 인터페이스
✔ Web API는 HTTP 요청을 사용하여 데이터를 요청하거나 전송

✅ HTTP 요청 방식 (GET vs POST)

요청 방식	설명
GET	데이터를 조회할 때 사용 (URL에 데이터 포함)
POST	새로운 데이터를 생성할 때 사용 (HTTP 본문에 데이터 포함)

✅ LLM API는 왜 POST 방식을 사용하는가?

✔ 질문 데이터가 길어질 수 있음 → URL의 제한을 피하기 위해 POST 사용
✔ 보안 문제 → GET 요청이면 질문 내용이 URL에 노출되므로 위험
✔ AI 모델과의 대화는 문맥을 유지해야 함 → 여러 개의 메시지를 본문에 포함 가능해야 함
✔ 새로운 응답을 생성하는 과정이므로 POST가 적절함

---

---

📌 멀티스레드를 사용한 실행 흐름

1️⃣ Main Thread 실행

• ExecutorService를 생성하여 3개의 스레드를 실행할 준비를 함

2️⃣ 3개의 작업이 비동기적으로 실행됨

• Task 1 (이미지 생성) 시작 → Task 2 (상세 설명 생성) 시작 → Task 3 (인터뷰 팁 생성) 시작
• 각 작업이 동시에 실행됨 (병렬 실행)

3️⃣ 작업 완료 후 결과를 수집

• imageFuture.get(), reasoningFuture.get(), reasoningFuture2.get() 호출하여 완료된 결과를 가져옴

4️⃣ Executor 종료

• 모든 작업이 끝나면 executor.shutdown()을 호출하여 ExecutorService를 종료

---

📌 왜 처음부터 멀티스레드를 사용하지 않았을까?

1. 단일 스레드의 기본적인 동작

보통 프로그램은 **단일 스레드(Single Thread)**로 동작합니다.
즉, 한 번에 하나의 작업만 실행하고, 작업이 끝날 때까지 다음 작업을 실행하지 않음.

String imageResult = generateImage("Java");
String reasoningResult = generateReasoning("Java 설명");
String reasoningResult2 = generateInterviewTips("Java 면접 팁");

// 실행 흐름:
// 1. 이미지 생성 → 완료될 때까지 대기
// 2. 설명 생성 → 완료될 때까지 대기
// 3. 면접 팁 생성 → 완료될 때까지 대기

✔ 한 작업이 끝날 때까지 기다려야 하므로 실행 속도가 느림.
✔ 하지만 코드가 직관적이고 디버깅이 쉬움.

---

2. 멀티스레드 도입이 필요한 이유

LLM API를 호출하는 작업은 **네트워크 요청(HTTP 요청)**이 포함됨.
✔ 네트워크 응답 시간이 길어질 수 있음 (수백 ms ~ 수 초)
✔ 단일 스레드에서는 하나의 요청이 끝날 때까지 다음 작업이 시작되지 않음

📌 멀티스레드를 사용하면?

ExecutorService executor = Executors.newFixedThreadPool(3);

Future<String> imageFuture = executor.submit(new LLMTask(ModelCategory.FLUX, "Create an image for Java."));
Future<String> reasoningFuture = executor.submit(new LLMTask(ModelCategory.R1, "Explain Java in detail."));
Future<String> reasoningFuture2 = executor.submit(new LLMTask(ModelCategory.R1, "Give Java job interview tips."));

// 각 작업이 병렬로 실행됨 → 총 실행 시간이 단축됨
String imageResult = imageFuture.get();
String reasoningResult = reasoningFuture.get();
String reasoningResult2 = reasoningFuture2.get();

executor.shutdown();

✔ 모든 요청이 동시에 실행됨 → 실행 속도 향상
✔ Future.get()을 호출하면 해당 작업이 완료될 때까지 대기하지만, 이미 여러 작업이 동시에 실행되고 있으므로 기다리는 시간이 줄어듦

---

📌 정리

✅ 처음에는 단일 스레드를 사용했음 → 코드가 단순하고 이해하기 쉬움
✅ LLM API 요청은 네트워크 지연이 발생할 수 있음 → 응답 시간이 길어질 가능성이 있음
✅ 멀티스레드를 사용하면 여러 작업을 동시에 실행 가능 → 실행 속도가 빨라짐
✅ ExecutorService를 사용하여 3개의 작업을 동시에 처리함 → 네트워크 요청을 효율적으로 수행

[Yumi-Park996]

📌 1. 이 교안의 목적

이 문서는 포켓몬 API를 호출하고, JSON 데이터를 변환하여 활용하는 방법을 초보자가 이해할 수 있도록 설명하는 자료입니다.
이 문서를 통해 다음 개념을 익힐 수 있습니다.

✅ 포켓몬 API를 사용해 데이터를 가져오는 과정
✅ Java의 HttpClient를 사용해 HTTP 요청을 보내는 방법
✅ Jackson 라이브러리를 활용해 JSON 데이터를 Java 객체로 변환하는 방법
✅ 어노테이션을 사용하여 JSON 데이터를 매핑하는 방법 (@JsonProperty, @JsonIgnoreProperties)
✅ 랜덤으로 포켓몬 정보를 가져오고 출력하는 과정

---

📌 2. 전체적인 동작 흐름

📌 이 프로그램이 실행되는 과정을 도식화하면 다음과 같습니다.

+-----------------------------+
|        프로그램 실행        |
+-----------------------------+
        |    |    
        V    V    
+-----------------------------+
| 1️⃣ 랜덤 포켓몬 번호 생성  |
+-----------------------------+
        |
        V    
+-----------------------------+
| 2️⃣ 첫 번째 API 요청 (포켓몬 정보) |
+-----------------------------+
        |
        V    
+-----------------------------+
| 3️⃣ JSON 데이터를 자바 객체로 변환  |
+-----------------------------+
        |
        V    
+-----------------------------+
| 4️⃣ 두 번째 API 요청 (포켓몬 이름) |
+-----------------------------+
        |
        V    
+-----------------------------+
| 5️⃣ 한국어 포켓몬 이름 출력 |
+-----------------------------+

📌 핵심 개념
1️⃣ 랜덤으로 포켓몬 번호(1~151) 생성
2️⃣ 첫 번째 API 요청 → 포켓몬 이미지 URL 가져오기
3️⃣ JSON 데이터를 Java 객체로 변환 (Jackson 라이브러리 사용)
4️⃣ 두 번째 API 요청 → 포켓몬의 다국어 이름 목록 가져오기
5️⃣ 한국어 이름을 찾아 출력

---

📌 3. 프로그램의 주요 기능

이 프로그램은 여러 개의 클래스로 구성되어 있으며, 각 파일의 역할을 정리하면 다음과 같습니다.

파일명	역할
Main.java	프로그램의 메인 실행 코드
Pokemon.java	포켓몬 기본 정보를 저장하는 클래스 (이미지 URL 포함)
PokemonSpecies.java	포켓몬의 다국어 이름 목록을 저장하는 클래스

---

📌 4. 주요 개념 설명

📌 (1) 포켓몬 API 호출

**포켓몬 API(PokeAPI)**는 포켓몬의 정보를 제공하는 공개 API입니다.
이 API를 이용하면 포켓몬의 이미지, 이름, 능력치 등을 가져올 수 있습니다.

📌 API 엔드포인트
1️⃣ 포켓몬 기본 정보 조회

• API URL: https://pokeapi.co/api/v2/pokemon/{포켓몬 번호}
• 예제: https://pokeapi.co/api/v2/pokemon/25 (피카츄 데이터)

2️⃣ 포켓몬 종(species) 정보 조회

• API URL: https://pokeapi.co/api/v2/pokemon-species/{포켓몬 번호}
• 예제: https://pokeapi.co/api/v2/pokemon-species/25 (피카츄 다국어 이름)

---

📌 5. 코드 상세 분석

📌 (1) Main.java (프로그램 실행)

이 코드의 역할:

• 랜덤으로 포켓몬 번호를 선택
• API 요청을 통해 포켓몬 데이터를 가져옴
• JSON 데이터를 Java 객체로 변환
• 한국어 포켓몬 이름을 찾아 출력

import com.fasterxml.jackson.databind.ObjectMapper;  // JSON 데이터를 Java 객체로 변환하는 라이브러리
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.Random;

public class Main {  
    public static void main(String[] args) throws IOException, InterruptedException {
        String apiUrl = "https://pokeapi.co/api/v2/pokemon/%d";  // 포켓몬 기본 정보 API URL

        HttpClient client = HttpClient.newHttpClient();  // HTTP 요청을 보낼 클라이언트 객체 생성

        Random rand = new Random();
        int pokemonId = rand.nextInt(1, 152);  // 1부터 151까지의 랜덤 포켓몬 번호 생성

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(apiUrl.formatted(pokemonId)))  // 최종 API URL 생성
                .GET()
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());  
        // API 요청을 보내고 JSON 응답을 문자열로 받음

        ObjectMapper mapper = new ObjectMapper();  // JSON 데이터를 Java 객체로 변환하는 ObjectMapper 객체 생성
        Pokemon pokemon = mapper.readValue(response.body(), Pokemon.class);
        // JSON 응답을 Pokemon 객체로 변환

        System.out.println(pokemon.sprites.frontDefault);  // 포켓몬 이미지 URL 출력

        // 2번째 API 요청 (포켓몬 이름 가져오기)
        String apiUrl2 = "https://pokeapi.co/api/v2/pokemon-species/%d";  
        HttpRequest request2 = HttpRequest.newBuilder()
                .uri(URI.create(apiUrl2.formatted(pokemonId)))  
                .GET()
                .build();

        HttpResponse<String> response2 = client.send(request2, HttpResponse.BodyHandlers.ofString());
        PokemonSpecies pokemonSpecies = mapper.readValue(response2.body(), PokemonSpecies.class);
        // JSON 응답을 PokemonSpecies 객체로 변환

        // 한국어 이름 찾기
        System.out.println(
            pokemonSpecies.names.stream()
                    .filter(el -> el.language.name.equals("ko"))  
                    .map(el -> el.name)  
                    .findFirst()
                    .orElseThrow()  
        );  // 한국어 포켓몬 이름 출력
    }
}

---

📌 (2) Pokemon.java (포켓몬 기본 정보)

📌 이 클래스는 포켓몬의 이미지 URL을 저장하는 역할을 합니다.

@JsonIgnoreProperties(ignoreUnknown = true)  
class Pokemon {
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Sprites {
        @JsonProperty("front_default")  
        public String frontDefault;  
    }
    public Sprites sprites;
}

📌 어노테이션 설명
✔ @JsonIgnoreProperties(ignoreUnknown = true) → JSON 데이터 중 매핑되지 않은 필드를 무시
✔ @JsonProperty("front_default") → JSON의 front_default 필드를 frontDefault 변수에 매핑

---

📌 (3) PokemonSpecies.java (포켓몬 종 정보)

📌 이 클래스는 포켓몬의 다국어 이름 정보를 저장하는 역할을 합니다.

@JsonIgnoreProperties(ignoreUnknown = true)
class PokemonSpecies {
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Name {
        public String name;
        @JsonIgnoreProperties(ignoreUnknown = true)
        public static class Language {
            public String name;
        }
        public Language language;
    }
    public List<Name> names;
}

📌 어노테이션 설명
✔ @JsonIgnoreProperties(ignoreUnknown = true) → JSON 데이터에서 필요 없는 필드는 무시
✔ name.language.name.equals("ko") → JSON에서 언어가 "ko"인 데이터를 찾음

---

📌 6. 마무리

✅ 포켓몬 API를 이용해 데이터를 가져오는 방법 학습
✅ HttpClient를 사용해 HTTP 요청을 처리하는 과정 이해
✅ Jackson을 이용해 JSON을 Java 객체로 변환하는 방법 익힘
✅ 어노테이션을 활용해 JSON 필드와 Java 필드를 연결하는 방법 학습

[Yumi-Park996]

📌 1. 교안의 목적

이 문서는 Java를 사용하여 GitHub TIL 데이터를 가져오는 방법을 설명하는 자료입니다.
이 프로젝트를 통해 다음 개념을 익힐 수 있습니다.

✅ CSV 파일에서 데이터를 읽어오는 방법
✅ GitHub API를 사용하여 데이터를 가져오는 방법
✅ Java의 HttpClient를 활용한 HTTP 요청 처리 방법
✅ JSON 데이터를 Java에서 활용하는 방법
✅ DTO(Data Transfer Object)란 무엇이며, 왜 사용하는지 이해
✅ TIL 데이터를 유저별로 분류하여 저장하는 방법

---

📌 2. 전체적인 동작 흐름

📌 이 프로그램이 실행되는 과정을 도식화하면 다음과 같습니다.

+-----------------------------+
|        프로그램 실행        |
+-----------------------------+
        |
        V    
+-----------------------------+
| 1️⃣ CSV 파일에서 Repo 데이터 읽기  |
+-----------------------------+
        |
        V    
+-----------------------------+
| 2️⃣ Repo 데이터에서 GitHub API 요청  |
+-----------------------------+
        |
        V    
+-----------------------------+
| 3️⃣ JSON 응답에서 필요한 데이터 추출  |
+-----------------------------+
        |
        V    
+-----------------------------+
| 4️⃣ 유저별 TIL 데이터를 저장  |
+-----------------------------+

📌 핵심 개념
1️⃣ CSV 파일에서 저장된 Repo 데이터를 읽어옴
2️⃣ GitHub API를 통해 특정 저장소의 TIL 데이터를 가져옴
3️⃣ JSON 응답을 Java에서 처리하여 원하는 정보만 추출
4️⃣ 유저별로 TIL 데이터를 파일에 저장

---

📌 3. DTO(Data Transfer Object)란?

DTO란 무엇인가?

DTO는 **Data Transfer Object(데이터 전송 객체)**의 약자로,
데이터를 한 곳에서 다른 곳으로 전달하는 데 사용하는 객체입니다.

📌 DTO의 주요 역할
✔ 데이터 캡슐화 → 데이터를 안전하게 전달
✔ 재사용성 증가 → 한 번 정의한 DTO는 여러 곳에서 사용 가능
✔ 가독성 향상 → 데이터를 명확한 구조로 표현
✔ 서비스와 데이터베이스 간의 연결을 단순화

📌 DTO와 일반 객체(Class)의 차이

구분	일반 객체 (Entity)	DTO (Data Transfer Object)
목적	데이터베이스 저장	데이터 전달
변경 가능 여부	보통 변경 가능 (mutable)	변경 불가능 (immutable)
로직 포함 여부	비즈니스 로직 포함 가능	로직 없음

📌 DTO 예제

public record UserDTO(String name, int age) {}

✔ record를 사용하면 DTO를 간결하게 정의할 수 있음

---

📌 4. 프로그램의 주요 클래스 및 역할

이 프로그램은 여러 개의 클래스로 구성되어 있으며, 각 파일의 역할을 정리하면 다음과 같습니다.

파일명	역할
Application.java	프로그램의 메인 실행 코드
Repo.java	저장소 정보를 담는 DTO 클래스
RepoType.java	저장소의 타입(GITHUB, TISTORY, VELOG)을 구분하는 Enum
TIL.java	TIL 정보를 담는 DTO 클래스
TILService.java	TIL 데이터를 가져오는 서비스 인터페이스
TILServiceImpl.java	GitHub API에서 데이터를 가져오는 구현체
CSVReader.java	CSV 파일을 읽는 기능을 제공하는 인터페이스
CSVReaderImpl.java	CSV 파일에서 데이터를 읽어 Repo 리스트를 반환하는 구현체

---

📌 5. 코드 상세 분석

📌 (1) Repo.java (저장소 정보를 저장하는 DTO)

📌 이 클래스는 저장소의 기본 정보를 저장하는 역할을 합니다.

public record Repo(
   String name,    // 저장소 이름
   String link,    // 저장소 링크
   String category,  // 저장소 카테고리
   RepoType repoType  // 저장소 타입(GITHUB, TISTORY, VELOG)
) {
   // 저장소 타입 자동 설정 (기본값)
   public static Repo makeRepo(String name, String link) {
       return new Repo(name, link, "", handleRepoType(link));
    }

   // 저장소 타입 자동 설정 (카테고리 포함)
    public static Repo makeRepo(String name, String link, String category) {
        return new Repo(name, link, category, handleRepoType(link));
    }

    // URL에 따라 저장소 타입을 자동 감지
    private static RepoType handleRepoType(String link) {
        if (link.contains("github")) {
            return RepoType.GITHUB;
        } else if (link.contains("tistory")) {
            return RepoType.TISTORY;
        } else if (link.contains("velog")) {
            return RepoType.VELOG;
        }
        throw new IllegalArgumentException();  // 지원되지 않는 URL일 경우 예외 발생
    }
}

📌 핵심 개념
✔ record 키워드를 사용하여 DTO 생성
✔ handleRepoType() 메서드를 사용해 저장소 타입 자동 감지

---

📌 (2) TILServiceImpl.java (GitHub API에서 TIL 데이터를 가져오는 구현체)

📌 이 클래스는 GitHub API를 호출하여 TIL 데이터를 가져옵니다.

public class TILServiceImpl implements TILService {
    @Override
    public List<TIL> getTIL(Repo repo) throws Exception {
        Logger logger = Logger.getLogger("service.github");
        HttpClient client = HttpClient.newHttpClient();
        switch (repo.repoType()) {
            case GITHUB:
                String[] tokens = repo.link().split("/");
                logger.info(Arrays.toString(tokens));
                HttpResponse<String> response = client.send(HttpRequest.newBuilder()
                        .uri(URI.create("https://api.github.com/repos/%s/%s/issues".formatted(tokens[3], tokens[4])))
                        .header("Accept", "application/vnd.github+json")
                        .build(), HttpResponse.BodyHandlers.ofString());
                logger.info("%d".formatted(response.statusCode()));

                Pattern pattern = Pattern.compile("\"body\":\"(.*?)\",\"");
                Matcher matcher = pattern.matcher(response.body());
                while (matcher.find()) {
                    logger.info(matcher.group(1));
                }
                break;
            case VELOG:
            case TISTORY:
                throw new Exception("지원하지 않는 종류");
        }
        return List.of();
    }
}

📌 핵심 개념
✔ HttpClient를 사용하여 GitHub API 호출
✔ Pattern.compile()을 사용하여 JSON 데이터에서 원하는 정보 추출

---

📌 (3) Application.java (메인 실행 파일)

public class Application {
    static List<Repo> repos;

    public static void main(String[] args) {
        Logger logger = Logger.getLogger(Application.class.getName());
        CSVReader reader = new CSVReaderImpl();

        try {
            repos = reader.read("til.csv");
            logger.info(repos.toString());
        } catch (FileNotFoundException e) {
            logger.severe(e.getMessage());
        }

        TILService service = new TILServiceImpl();
        for (Repo repo : repos) {
            try {
                service.getTIL(repo);
            } catch (Exception e) {
                logger.severe(e.getMessage());
            }
        }
    }
}

📌 핵심 개념
✔ CSV에서 Repo 데이터 읽기
✔ GitHub API 요청 실행
✔ 예외 처리 (try-catch 활용)

---

📌 6. 마무리

✅ GitHub API를 사용하여 데이터를 가져오는 방법 학습
✅ CSV 파일에서 데이터를 읽어오는 과정 이해
✅ Java의 HttpClient를 사용한 API 호출 실습
✅ JSON 데이터를 정규 표현식으로 처리하는 방법 학습

[Yumi-Park996]

📌 DTO(Data Transfer Object)가 왜 필요할까?

1. DTO 없이 일반 객체(Entity)만 사용하면 문제가 생길까?

우선 DTO 없이도 데이터를 주고받는 것이 가능합니다.
예를 들어, 데이터베이스에서 사용자 정보를 가져오는 경우를 생각해보겠습니다.

📌 사용자(User) 객체 (Entity)

public class User {
    private String name;
    private String email;
    private String password;  // 비밀번호 (중요한 정보)

    // 생성자
    public User(String name, String email, String password) {
        this.name = name;
        this.email = email;
        this.password = password;
    }

    // Getter & Setter
    public String getName() { return name; }
    public String getEmail() { return email; }
    public String getPassword() { return password; }  // ❌ 비밀번호 노출 위험
}

📌 이 객체를 그대로 클라이언트에 전달하면?

• password 같은 중요한 정보가 노출될 수 있음
• 데이터 변경 시 불필요한 정보까지 함께 전송됨 (비효율적)
• 백엔드와 프론트엔드 간에 필요 없는 데이터까지 공유됨

💡 DTO를 사용하면 해결할 수 있다!

---

2. DTO를 사용하여 문제 해결

DTO를 사용하면 전달할 데이터만 포함하도록 설계할 수 있습니다.

📌 UserDTO (DTO 객체)

public record UserDTO(String name, String email) { }

📌 DTO 사용 예제

public class UserService {
    public UserDTO getUserDTO(User user) {
        return new UserDTO(user.getName(), user.getEmail());  // ✅ 비밀번호 제거
    }
}

이제 UserDTO만 클라이언트에 보내면 비밀번호 노출을 방지할 수 있습니다.

---

3. DTO가 필요한 이유

문제점	DTO 없이 일반 객체(Entity)만 사용할 경우	DTO 사용 시 해결 가능
보안 문제	비밀번호, 민감한 정보가 함께 노출될 위험	필요한 정보만 전달 가능
데이터 과부하	필요하지 않은 데이터까지 함께 전송	최소한의 데이터만 포함
객체의 일관성 유지	객체가 변경될 때 모든 코드 수정 필요	DTO는 특정 목적에 맞춰 유지 가능
유지보수성	비즈니스 로직과 데이터 전송 로직이 섞임	분리하여 관리 가능

---

4. DTO를 활용한 예제 (TIL 데이터 처리)

이제 우리가 만든 GitHub TIL 데이터 처리 코드에서
DTO가 어떻게 활용되는지 살펴보겠습니다.

📌 DTO 없이 일반 객체만 사용하면?

public class TIL {
    private String owner;
    private String url;
    private String title;
    private String content;
    private String date;

    public TIL(String owner, String url, String title, String content, String date) {
        this.owner = owner;
        this.url = url;
        this.title = title;
        this.content = content;
        this.date = date;
    }

    public String getContent() {
        return content;  // ❌ 모든 요청에서 본문 내용이 필요하지 않을 수도 있음
    }
}

👉 모든 API 응답에 content(본문)까지 포함됨
✔ 데이터 과부하 발생
✔ 보안 문제 가능성 (민감한 데이터가 포함될 수도 있음)

---

📌 DTO를 사용하여 필요한 데이터만 전달

public record TILDTO(String owner, String title, String date) { }

📌 DTO 적용 코드

public class TILService {
    public TILDTO convertToDTO(TIL til) {
        return new TILDTO(til.getOwner(), til.getTitle(), til.getDate());
    }
}

✔ content(본문 내용)가 불필요한 경우 전송하지 않음
✔ 네트워크 비용 절감 & 불필요한 데이터 제거

---

📌 5. 정리: DTO를 언제 써야 할까?

✅ DTO를 사용해야 하는 경우

✔ 클라이언트에 보내야 할 데이터가 많을 때
✔ 보안상 특정 정보를 숨겨야 할 때 (예: 비밀번호, 개인 정보)
✔ 백엔드와 프론트엔드 간 전달할 데이터 형식을 제한하고 싶을 때
✔ 비즈니스 로직을 객체(Entity)와 분리하여 관리하고 싶을 때

---

📌 6. 마무리

✅ DTO는 데이터 전달을 위한 객체로, 필요한 정보만 포함
✅ 보안, 네트워크 성능, 유지보수성을 향상시키는 역할
✅ 비즈니스 로직이 들어간 Entity 객체와 분리하여 관리 가능