작심삼일

RAG, 에이전트, 프롬프트: AI 프로젝트 시작을 위한 기술 스택

shoney9254 — Mon, 20 Oct 2025 13:22:34 +0900

AI 프로젝트, 특히 LLM(거대 언어 모델)을 활용한 서비스를 만들 때 고려해야 할 기술들을 정리한 가이드입니다. 각 기술의 개념을 이해하고, 자신의 프로젝트 규모와 목적에 맞는 최적의 조합을 찾아보세요.

1. RAG (Retrieval-Augmented Generation)

RAG는 LLM이 알지 못하는 최신 정보나 특정 분야의 전문 지식(예: 우리 학교 학사 규정, 특정 게임 공략집)을 외부 문서에서 찾아와(Retrieval), 그 내용을 바탕으로 답변을 생성(Generation)하는 기술입니다. LLM의 환각(Hallucination)을 줄이고 답변의 신뢰도를 높이는 가장 핵심적인 기술이죠.

1) 플랫폼

RAG 파이프라인(데이터 준비 → 검색 → 생성)을 쉽게 만들도록 도와주는 도구들입니다.

Makebot LLM Builder: 기업 내부 문서와 LLM을 연결해 빠르게 엔터프라이즈 챗봇을 구축 가능. → 실무 활용도 높음 (예: 고객센터 자동화).
Botgrade: 모델 답변을 자동 평가해 품질 관리. → 사람이 매번 수작업 검증할 필요를 줄여줌.
InstructRAG: 명령 기반 검색·응답. → FAQ, 지식베이스 질의응답에 적합.
ReaRAG: 실시간 검색 + 순환 추론 결합. → 최신 뉴스 요약 같은 실시간성 요구 서비스에 유리.
Haystack: 오픈소스·대규모 문서 처리에 최적화. → 연구·프로토타입 환경에 적합.
RAGFlow: 시각적 파이프라인 UI 제공. → 비개발자도 손쉽게 조합 가능.
txtai: 검색·분류·추천 통합 플랫폼. → 텍스트와 비정형 데이터 동시 활용.
LlamaIndex: 다양한 데이터 타입 지원, 맞춤 검색에 강점.
Verba: 캐싱·하이브리드 검색 강점. → 빠른 응답 필요한 챗봇에 적합.

2) 임베딩 모델

'임베딩'은 텍스트(단어, 문장)를 컴퓨터가 이해할 수 있는 숫자들의 배열, 즉 **벡터(Vector)**로 바꾸는 과정입니다. 좋은 임베딩 모델은 '강아지'와 '멍멍이'처럼 의미가 비슷한 단어들을 벡터 공간에서 가까운 위치에 둡니다.

OpenAI (text-embedding-3): 영어 중심, 저비용·고차원·빠른 추론.
- large(1536차원): 긴 문서·복잡한 맥락 반영 유리.
- small(512차원): 속도·비용 효율적, FAQ 검색 적합.
Cohere (v3.0): 다국어 강점, 의미 밀집 표현 최적화
Hugging Face (BGE/E5/Instructor/MiniLM/MPNet) : 오픈소스 모델의 성지입니다. 특히 한국어 프로젝트를 할 때는 ko-sroberta-multitask 같은 한국어 특화 모델을 무료로 다운받아 사용할 수 있어 매우 유용합니다.
Mistral (mistral-embed/Codestral): 1024차원·다국어·코드 임베딩에 특화·빠른 추론.
VoyageAI (voyage-3/large/lite): 32K 컨텍스트·초저가·한국어 포함 다국어·작은 벡터로 효율적 검색.
Google Gemini-Embedding: SOTA급·68점대 MTEB 다국어 성능·8192 토큰·범용성.
Jina Embeddings v3: 570M 파라미터·8192 토큰·최첨단 다국어 임베딩·오픈소스.
Amazon Titan: 멀티모달(텍스트+이미지)·클라우드 특화.

3) 벡터 차원

임베딩 모델이 문장을 몇 개의 숫자로 표현하는지를 의미합니다. (예: 1536차원 = 1536개의 실수로 이루어진 배열)

차원이 높을수록: 데이터의 세부적인 정보와 특징을 더 잘 반영할 수 있습니다. 예를 들어, 긴 문장이나 복잡한 이미지를 잘 표현하려면 더 높은 차원의 임베딩이 필요합니다.
차원이 낮을수록: 연산량이 줄어들고, 메모리 사용량이 적어집니다. 하지만 차원을 너무 낮추면 중요한 정보를 놓칠 수 있습니다.
결론: 일반적인 문서 검색은 768 ~ 1024차원으로도 충분하며, 사용하는 임베딩 모델이 정해주는 차원을 따르는 것이 일반적입니다.
예: 짧은 FAQ 검색 → 512차원, 논문 검색 → 1536차원.

4) 검색 방식

사용자 질문과 가장 관련 있는 문서를 어떻게 찾을지에 대한 방법론입니다.

BM25 (Sparse Retrieval): 단어 빈도 기반 전통 검색, 빠르고 정확한 키워드 매칭에 강점. → 법률·규정 검색 적합.
DPR (Dense Retrieval) : 임베딩된 벡터 간의 의미적 유사도(코사인 유사도 등)를 계산합니다. 고전적인 dense 모델, 아직도 baseline으로 쓰임.
Contriever (Dense Embedding): 최신 self-supervised dense 모델, 의미 기반 검색에 강점.
Hybrid (Dense + Sparse): BM25와 Dense Embedding 결합, 키워드 정확성과 의미 유사도를 동시에 확보. → FAQ 챗봇, 문서 검색 등에서 가장 널리 사용.

<aside>

[어떤 방식을 선택할까?]

법률 조문, 사내 규정 검색: 키워드가 정확히 일치해야 하므로 BM25가 유리합니다.
"요즘 유행하는 패션 스타일 알려줘": 사용자의 의도를 파악해야 하므로 Dense 검색이 적합합니다.
대부분의 Q&A 챗봇: 두 가지 장점을 모두 취하는 Hybrid Search를 사용하는 것이 가장 안정적입니다. </aside>

5) 백터 인덱스 / 근사검색

수백만 개의 문서 벡터 중에서 내 질문 벡터와 가장 가까운 벡터를 어떻게 '효율적으로' 찾을지에 대한 기술입니다.

Flat (Brute Force): 모든 벡터와 일일이 거리를 계산하는 가장 무식하고 정확한 방법. 데이터가 수천 개 이하라면 쓸 수 있지만, 그 이상이면 속도가 너무 느려져 현실적으로 사용하기 어렵습니다.
IVF (Inverted File Index): 벡터들을 여러 개의 '방(클러스터)'으로 미리 나눠놓고, 질문 벡터가 들어오면 가장 가까운 방 몇 개만 뒤지는 방식입니다.
HNSW (Hierarchical Navigable Small World Graph): 벡터들을 '친구의 친구는 친구' 같은 소셜 네트워크 형태의 그래프로 연결해, 가장 빠른 길을 따라가며 근접 이웃을 찾는 방식입니다. 검색 속도가 매우 빨라 현재 가장 널리 쓰이는 인덱스 방식 중 하나입니다.
PQ (Product Quantization): 벡터를 여러 조각으로 나눠 압축하여 메모리 사용량을 획기적으로 줄이는 기술입니다. 약간의 정확도 손실을 감수하고 메모리 효율을 극대화할 때 사용합니다.

6) 인덱스/벡터 DB

Chroma, Faiss: 파일 기반으로 동작하여 별도의 서버 설치 없이 가볍게 시작할 수 있습니다. 개인 프로젝트나小규모 테스트에 매우 적합합니다. Faiss는 Facebook(Meta)에서 개발했으며, 성능이 매우 뛰어납니다.
- Chroma: Python 친화적, 소규모/중규모 RAG 환경에 최적화.
- Faiss: Facebook 오픈소스, 다양한 인덱스 옵션 지원, 대규모 벡터 검색에 특화.
Milvus, Qdrant, Weaviate, Pinecone: 대규모 서비스를 위한 서버-클라이언트 구조의 벡터 DB입니다. 실시간 데이터 추가/삭제, 필터링, 확장성 등 운영에 필요한 다양한 기능을 제공합니다.
- Pinecone: 클라우드 기반 벡터 DB, 자동 스케일링과 관리형 인프라 제공.
- Milvus: 오픈소스 고성능 벡터 DB, GPU 지원으로 대규모 검색 최적화.
- Qdrant: 실시간 벡터 검색에 강점, ML 모델과 쉽게 통합 가능.
- Weaviate: GraphQL 지원, 메타데이터 기반 필터링과 시맨틱 검색 가능.

7) Chunking 전략

긴 문서를 LLM에 한 번에 넣을 수 없기 때문에, 의미 있는 단위로 잘게 쪼개는 과정입니다. RAG 성능에 가장 큰 영향을 미치는 요소 중 하나입니다.

Fixed-length: 512 토큰(대략 250~300자) 같은 고정된 길이로 무조건 자르는 가장 간단한 방식.
Sliding window (Overlap): 문장의 중간이 잘리는 것을 방지하기 위해 Chunk를 나눌 때 이전 Chunk의 끝부분 일부(e.g., 50 토큰)를 다음 Chunk의 시작 부분에 포함시키는 방식입니다.
Semantic chunking: 문단, 문장 등 의미가 완결되는 단위로 자르거나, 임베딩 벡터의 유사도를 기반으로 의미적 경계를 찾아 자르는 고급 방식입니다.
Hierarchical chunking: 큰 단위 → 작은 단위 순차 검색 (multi-stage retrieval)

8) Re-ranking

초기 검색(Retrieval) 단계에서 찾아온 여러 개의 문서(e.g., 상위 20개)를 LLM에게 넘기기 전에, 질문과 정말로 관련이 높은 문서만 추려내 순서를 다시 매기는 과정입니다. LLM에 들어가는 정보의 질을 높여 최종 답변의 품질을 향상시킵니다.

Cross-encoder (e.g. msmarco-distilbert, bge-reranker) : 검색된 각 (질문, 문서) 쌍을 모델에 함께 입력하여 관련도를 훨씬 정밀하게 계산하는 방식입니다. 속도는 느리지만 정확도가 높습니다.
LLM re-ranker (GPT-4, Claude로 후보 문서 다시 평가) : GPT-4 같은 고성능 LLM에게 직접 후보 문서들을 보여주고, "이 질문에 답하는 데 가장 중요한 순서대로 3개만 골라줘"라고 요청하는 방식입니다.
Statistical Ranking: 단순 스코어 기반

9) 기타 고려사항

성능/비용 trade-off: 고성능 임베딩 모델, 큰 벡터 차원, Re-ranking 등은 성능을 높이지만 API 비용과 응답 시간을 증가시킵니다.
스케일링: 문서가 1만 개일 때와 100만 개일 때의 검색 속도와 시스템 구조는 완전히 달라야 합니다.
검색 파라미터: Top-k(몇 개를 검색할지), 유사도 점수 임계값 등을 조절하며 최적의 값을 찾아야 합니다.
- k (Top-k 검색 개수): 3, 5, 10, 20
- Max marginal relevance (MMR): 중복 줄이기
- Score threshold: 특정 유사도 이상만 채택
- Hybrid Weighting: Sparse vs Dense 비율 조정

2. Agent

에이전트는 단순히 질문에 답하는 것을 넘어, 스스로 사고(Thinking)하고, 계획(Planning)을 세우고, 도구(Tools)를 사용하여 주어진 목표를 달성하는 자율적인 프로그램입니다.

1) 아키텍처 / 프레임워크

프레임워크
- LangChain, LlamaIndex가 에이전트 개발에도 널리 쓰이며, 최근에는 상태(State)와 흐름 제어에 강점이 있는 LangGraph, 여러 에이전트의 협업에 특화된 AutoGen, CrewAI 등이 주목받고 있습니다.
- LangChain, LangGraph, AutoGen, CrewAI, Semantic Kernel, LlamaIndex
실행 모델
- 단일 에이전트 vs 멀티에이전트

2) 상호작용 (Agent Collaboration)

멀티에이전트 상호작용 패턴
- 협력(Cooperative): 각자 맡은 역할을 수행하고 결과를 합치는 방식.
  - 에이전트 3명이 문서 요약 → 최종 합산 요약 결과를 평가
- 경쟁(Competitive): 결과 품질을 겨루고 우승 답변 채택
  - 에이전트 2명이 질문에 대해 독립적으로 답변 → 우승 답변 선택
- 혼합(Hybrid): 경쟁 후 협력적 합의
  - 경쟁 후 합의(Consensus) 단계 추가 → 합의 결과 평가
- 자기 검증형 (Reflective) : 에이전트가 자신의 결과물을 스스로 평가하고 부족한 점을 수정, 보완하는 방식. (마치 코드 리뷰를 스스로 하는 개발자처럼)
의사결정 방식
- 투표(Voting), 합의(Consensus), 평판(Reputation-based) 알고리즘
- deadlock / 무한루프 방지 메커니즘
대규모 시뮬레이션
- 수십 명 에이전트가 가상 사회에서 협업·토론하는 시나리오 (e.g. Social Simulation)

3) 도구 / API 연동 (Tool Use)

에이전트의 능력을 확장하는 핵심 기능입니다. LLM이 할 수 없는 일(e.g., 실시간 정보 검색, 계산, 외부 서비스 연동)을 함수(API)로 구현하여 에이전트에게 제공합니다.

툴 선택 로직
- 단일 툴 선택
- 복수 툴 체이닝 (A → B → C 호출)
  - 예시: '환율 계산 → 해외 결제 금액 추정 → 이메일로 결과 전송' 같이 여러 API를 연결할 필요가 있을 때 체이닝을 사용합니다.
실시간 데이터 연동
- 단순히 내장된 지식이 아닌, 실시간 검색(날씨·금융·주식·뉴스 등)이나 최신 데이터를 API로 가져오는 기능이 요구됩니다.
- API latency가 높거나 불안정할 때 fallback 전략
  - 예시: "날씨 정보 API가 3초 내 응답하지 않으면 다른 날씨 API 호출", "검색 실패 시 가장 최근 데이터 사용".
- Streaming 응답 처리 가능 여부
잘못된 툴 선택(오작동) 검출률 (Tool reliability metrics)
- 에이전트가 잘못된 도구를 선택하거나 API 호출 결과가 실패할 수 있으므로, 오작동(실패) 발생률 모니터링 및 평가 지표가 필요합니다.

4) 상태 관리 / 메모리

단기 메모리 (Session memory)
- 대화 중 맥락 유지, 이전 입력 반영 여부
- 랭그래프에서 상태 관리 전략
장기 메모리 (Long-term memory)
- 이전 대화의 중요한 내용을 Vector DB 등에 요약, 저장해두고 필요할 때 다시 꺼내 쓰는 방식
- RDB 사용 가능

5) 결과 품질 및 제어

추론 Traceability
- “왜 이 결정을 내렸는가?” 설명 가능성 (나중에 물어 봤을 때라도 추론 추적)
- 호출 경로(Which tool, Which agent)를 기록/리플레이 가능 여부
- 또는 결정 내린 히스토리를 어디에다가 데이터화 해놓는 방식
오류 유형
- 할루시네이션 / 무한 루프 / 툴 실패 / Deadlock 발생 빈도
Guardrails
- 정책 위반(PII 노출, 금칙어 등) 차단
- 응답 길이·포맷 강제 여부 (예: JSON schema validation)

6) 멀티모달 에이전트

입력/출력 모달리티
- 텍스트, 음성, 이미지, 비디오, 센서 데이터
Cross-modal reasoning
- 이미지 기반 질문 → 텍스트 답변, 오디오 지시 → 코드 실행
멀티모달

7) 기타 고려사항

오케스트레이션
- Workflow 관리: Prefect, Airflow, Temporal 같은 외부 오케스트레이터 연동
스케일링
- 에이전트 수 증가 시 비용, Latency, Throughput 변화 측정
장애 대응
- 에이전트 일부 실패 시 점진적 기능 축소(graceful degradation) 가능 여부
Observability
- 로그, 메트릭, 이벤트 트레이싱 (Prometheus, OpenTelemetry 연동)

3. 프롬프트

LLM에게 원하는 결과물을 얻어내기 위해 내리는 '지시문'입니다. 좋은 프롬프트는 좋은 결과물의 시작이며, '프롬프트 엔지니어링'은 그 자체로 중요한 기술 분야입니다.

1) 프롬프트 엔지니어링 기법

Prompt chaining: 여러 개의 작은 프롬프트를 연결해 단계별로 처리
예: 질문 요약 → 관련 문서 검색 → 최종 답변 생성
Self-reflection: 모델이 스스로 답변을 검토하고 수정
예: "너의 답변을 다시 읽고, 논리적 오류가 있는지 점검하라"
Few-shot / Zero-shot / Hybrid: 예시 제공 여부에 따른 차이 검증
Reddit 최신 기법
- 1. Recursive Self-Improvement Prompting (RSIP) - 반복적 자기 개선 프롬프트
  - LLM이 자신의 출력물을 반복적으로 평가·비판·수정하며 스스로 품질을 높여가는 방식.
  - 예시: 출력 후 최소 3개 결점 스스로 진단 → 해당 사항 개선하여 재출력 → 선정된 평가 기준별로 단계별 개선 반복 후 최종본 제출.
  - 적용 분야: 창작, 기술 문서, 논증 설계 등(평가 기준별로 단계 개선).
- 2. Context-Aware Decomposition (CAD) - 맥락 기반 복합 문제 분해
  - 복잡한 과제의 핵심 컴포넌트를 분리·분석 후, 각 요소를 맥락과 연결해서 각각 해결하고, 종합적으로 전체 답안을 제시하는 방식.
  - 'Thinking Journal(사고 일지)'로 각 단계별 사고 과정을 기록하여 중간 결과와 통합적 해법 연결.
- 3. Controlled Hallucination for Ideation (CHI) - ‘통제된 환각’ 활용 창의 이데이션
  - LLM의 hallucination을 완전히 억제하지 않고, 창의적 아이디어 도출에 적극 활용.
  - 'Speculative' 결과물 명확 표시 → 아이디어별 이론적 근거, 실제 구현 필요사항, 최종적으로 실현 가능성까지 비평.
- 4. Multi-Perspective Simulation (MPS) - 다관점 시뮬레이션
  - 단순 찬반 구도가 아닌 다섯 개 이상의 복잡한 시각/가정/논리 구조를 생성.
  - 각 관점별로 핵심 가치, 강점/약점, 논리 근거 분석 → 서로 간 대화/합의/비판 → 최종 통합적 시각으로 결론 도출.
- 5. Calibrated Confidence Prompting (CCP) - 신뢰도 등급화 프롬프트
  - LLM이 각 주장이나 정보에 대해 명시적으로 Confidence(신뢰도) 등급을 부여하도록 프롬프트 설계(예: Virtually Certain, Highly Confident, Moderately Confident, Speculative 등).
  - 각 등급별로 증거/불확실성/추가 정보 필요성 명시.
Mirascope Blog
Tree-of-Thought (ToT): 의사결정을 트리 형태로 분기해 탐색
예: 수학 문제 → 여러 풀이 경로 생성 → 최적 해법 선택
Graph-of-Thought (GoT): 노드-엣지 형태로 사고 과정을 네트워크화
예: 복잡한 프로젝트 계획을 여러 경로/연관성으로 연결해 정리
Recall-Augmented Generation
- 외부 지식 DB를 참조하여 기억 기반 답변을 강화함.
Tool-Calling Prompt / Agentic Loop
- 프롬프트 안에 API 호출·서드파티 도구 사용 지시를 포함하여, LLM이 실질적 행동(예: 검색, 연산)을 수행하도록 유도.

2) 프롬프트 표준화

동일한 prompt, 동일한 seed/temperature, 동일한 토큰 한도
재현성 확보: 모델 버전, 토크나이저 버전, DB 버전 기록

3) 프롬프트 옵저버빌리티

Langfuse, PromptLayer 등은 프롬프트 입력, 결과, 비용, 지연 시간 등을 추적/시각화합니다.
비효율적인 프롬프트를 빠르게 탐지·개선할 수 있습니다

4) 기타 고려 사항

정책 준수 검증
- 레드팀 프롬프트(민감정보, jailbreak, 혐오발화) 수행
Fusion 전략
- Late Fusion: 검색(검색된 여러 문서)에 대해 각각 LLM이 답변을 생성한 뒤, 각 문서별로 생성된 여러 답변을 다시 합치는 방식입니다.
- Early Fusion: 검색된 여러 문서의 retrieval 결과를 미리 합친 뒤, 한 번에 LLM에 입력하여 답변을 생성하는 방식입니다.
Retrieval 결과와 LLM 입력을 어떻게 조합해서 최종 답변을 생성할지 결정
평가 자동화
- HELM, EvalScope: 학계나 기업에서 대규모로 LLM의 종합 성능을 벤치마킹하는 프레임워크입니다.
- 테스트케이스 자동화
  - 특정 도메인/업무 상황에 맞춘 테스트 세트를 자동 생성해서 모델에 넣고 결과 검증
  - 예: 고객 문의 100개 → 모델 응답 → 정답셋과 비교하여 pass/fail 체크
  - 소프트웨어 테스트에서의 단위테스트 자동화와 비슷한 개념을 LLM 성능 평가에 적용한 것

통합 지식 관리 포털

shoney9254 — Mon, 20 Oct 2025 13:15:57 +0900

문제 상황 (Scenario): 현재 CoreTech의 기술 자료, 프로젝트 산출물, 개발 노하우 등은 각 팀의 Confluence, Google Drive, 개인 Notion, 심지어는 특정 팀원의 로컬 PC에 흩어져 있습니다. 이로 인해 다음과 같은 심각한 문제들이 발생하고 있습니다.

정보 검색의 어려움: 신규 입사자가 특정 기술 정보를 찾기 위해 여러 채널을 헤매야 하며, 사내 전문가에게 반복적으로 질문하는 상황이 빈번합니다.
지식의 사일로(Silo)화: A팀에서 해결한 장애 경험이나 유용한 개발 팁이 B팀에 공유되지 않아 비슷한 문제를 다시 해결하느라 리소스가 낭비됩니다.
보안 및 접근 제어의 부재: 민감한 프로젝트 정보나 고객 데이터가 포함된 문서가 적절한 통제 없이 공유될 위험이 있습니다.
지식의 비활용: 축적된 데이터가 단순한 '창고'에 머물러, 이를 활용한 기술 동향 분석이나 사내 전문가(SME, Subject-Matter Expert) 발굴 등이 전혀 이루어지지 않고 있습니다.

과제: 당신은 이 문제를 해결하기 위한 '통합 지식 관리 포털(Unified Knowledge Portal)' 구축 프로젝트의 리더로 임명되었습니다. 아래 질문에 대해 당신의 해결 방안을 구체적인 기술 스택과 함께 논리적으로 서술하십시오.

문제 1: 데이터 모델링 및 저장소 설계

산재한 다양한 형태(정형/비정형)의 지식(API 명세, 장애 해결 문서, 회의록, 소스코드 스니펫, 동영상 가이드 등)을 효과적으로 저장하고 관리하기 위한 데이터베이스 스키마와 저장소 아키텍처를 설계하십시오.

[평가 포인트]

문서의 메타데이터(작성자, 태그, 소속 팀, 관련 기술 등)를 어떻게 구조화할 것인가?
본문 검색(Full-Text Search)을 효율적으로 지원하기 위해 어떤 기술(e.g., Elasticsearch, OpenSearch)을 도입하고, RDBMS와 어떻게 연동할 것인가?
대용량 파일(동영상, 이미지) 첨부를 고려한 저장소(e.g., S3, NAS) 설계 방안은 무엇인가?
데이터베이스 모델링 시 확장성(새로운 유형의 지식 추가)을 어떻게 고려했는가?

문제 2: 똑똑한 검색(Smart Search) 기능 구현 방안

사용자가 최소한의 노력으로 원하는 정보를 정확하게 찾을 수 있도록 '똑똑한 검색' 기능을 구현하려고 합니다. 단순히 키워드 매칭을 넘어선 검색 품질 향상 방안을 구체적인 기술과 함께 제시하십시오.

[평가 포인트]

자연어 검색(Semantic Search)을 도입한다면 어떤 임베딩 모델(e.g., SBERT, OpenAI-Ada)을 사용할 것이며, 검색 파이프라인은 어떻게 구성할 것인가?
검색 결과의 랭킹(Ranking)을 어떻게 개선할 것인가? (e.g., 조회 수, '좋아요' 수, 최신성, 작성자 신뢰도 등)
사용자의 검색 의도를 파악하고 연관 지식을 추천해주는 로직을 어떻게 구현할 것인가? (e.g., '이 문서를 본 다른 사람들은 이런 문서도 봤어요')

문제 3: 권한 관리 및 보안 아키텍처 설계

문서별, 팀별로 유연하면서도 강력한 접근 제어(Access Control) 시스템을 구축해야 합니다. 사내 HR 시스템의 조직도/직책 정보와 연동하는 것을 전제로, 권한 관리 모델을 설계하고 발생할 수 있는 보안 위협과 그 대응책을 서술하십시오.

[평가 포인트]

어떤 권한 모델(e.g., RBAC, ABAC)을 선택할 것이며, 그 이유는 무엇인가?
민감 정보(개인정보, API Key 등)가 포함된 문서가 업로드될 경우, 이를 자동으로 탐지하고 마스킹하거나 경고하는 방안은 무엇인가?
API 엔드포인트 설계 시, 발생할 수 있는 보안 취약점(e.g., Insecure Direct Object References)과 방어 전략을 설명하시오.

문제 4: 지식 활용 및 동기 부여 방안

지식 포털이 '죽은 문서'의 무덤이 되지 않고, 살아있는 지식 생태계로 기능하기 위한 기술적/정책적 방안을 제시하십시오.

[평가 포인트]

우수 콘텐츠 작성자나 활발한 답변자에게 동기를 부여할 수 있는 시스템(e.g., 지식 포인트, 뱃지, 랭킹 보드)을 어떻게 구현할 것인가?
정기적으로 특정 기술 분야의 전문가(SME)를 시스템이 자동으로 식별하고 추천해주는 로직을 어떻게 설계할 것인가?
Slack, MS Teams 등 기존 협업 도구와의 연동을 통해 지식 포털의 활용성을 높일 수 있는 구체적인 아이디어(e.g., 특정 채널에 질문 시 관련 지식 링크 자동 추천)를 제안하시오.

문제 1: 데이터 모델링 및 저장소 설계

핵심 해결안 (키워드)

메타데이터 관리: PostgreSQL을 주 데이터베이스로 사용. 문서의 구조화된 정보(ID, 작성자, 생성일, 팀, 태그)는 정규화된 테이블로 관리. 핵심 스키마 외의 유연한 속성은 JSONB 타입을 활용하여 확장성 확보.
본문 검색: Elasticsearch를 검색 엔진으로 도입. 문서 내용은 색인하여 전문 검색(Full-Text Search)을 지원. PostgreSQL의 데이터가 변경될 때마다 CDC(Change Data Capture) 패턴 또는 메시지 큐를 통해 Elasticsearch와 데이터를 동기화.
대용량 파일: AWS S3와 같은 Object Storage 활용. DB에는 파일의 메타데이터와 S3 Object Key만 저장. 애플리케이션은 S3 Pre-signed URL을 생성하여 클라이언트가 직접 파일을 업로드/다운로드하게 하여 서버 부하 최소화.

기술 선택 및 장점 (비교)

PostgreSQL vs. MySQL/NoSQL: JSONB 타입 지원이 강력하여, 정형 데이터의 무결성을 지키면서도 비정형 메타데이터를 유연하게 처리할 수 있습니다. 스키마 변경 없이 새로운 속성을 추가할 수 있어 NoSQL의 장점을 일부 흡수하면서 RDBMS의 안정성을 가져갑니다.
Elasticsearch vs. RDBMS 내장 검색: 단순 LIKE 검색이나 기본적인 Full-Text Search 기능과 비교할 수 없는 수준의 Relevance Scoring(연관도 점수화), 형태소 분석, 동의어/오타 처리 등 고품질의 검색 기능을 제공합니다.
S3 vs. 서버 로컬 저장(NAS/NFS): 무한한 확장성과 비용 효율성, 강력한 내구성(99.999999999%)이 장점입니다. 애플리케이션 서버와 파일 스토너리지를 분리하여 서버를 Stateless하게 유지할 수 있어, 수평 확장에 매우 유리합니다.

문제 2: 똑똑한 검색(Smart Search) 기능 구현

핵심 해결안 (키워드)

검색 방식: 하이브리드 검색(Hybrid Search) 아키텍처 채택.
1. 키워드 검색 (Lexical Search): Elasticsearch의 BM25 알고리즘 기반. 정확한 키워드가 일치할 때 높은 점수를 부여.
2. 벡터 검색 (Vector/Semantic Search): 문장 임베딩 모델(SBERT)을 사용하여 문서 본문과 사용자 질의를 벡터로 변환. 의미적 유사도를 기반으로 검색.
검색 파이프라인: 사용자 질의가 들어오면, 키워드 검색과 벡터 검색을 동시에 실행하고 각 결과의 점수를 조합(e.g., Reciprocal Rank Fusion)하여 최종 랭킹을 결정.
랭킹 부스팅: 최종 랭킹에 문서의 최신성, 조회 수, '좋아요' 수, 작성자의 SME(사내 전문가) 레벨 등의 비즈니스 로직을 가중치로 적용하여 신뢰도를 높임.

기술 선택 및 장점 (비교)

하이브리드 검색 vs. 벡터 검색 Only: 벡터 검색은 문맥적 의미를 잘 파악하지만, NullPointerException, PROD-API-KEY와 같은 고유명사나 기술 용어 검색에 취약할 수 있습니다. 키워드 검색을 결합하면, 의미적 검색의 장점과 키워드 검색의 정확성을 모두 잡아 검색 품질을 극대화할 수 있습니다.
SBERT vs. OpenAI API (Ada-002): 데이터 프라이버시와 비용 통제에 유리합니다. SBERT와 같은 오픈소스 모델은 사내 GPU 서버에 직접 배포하여 민감한 내부 데이터의 외부 유출 없이 사용할 수 있습니다. 초기 구축 비용은 들지만, 장기적으로 API 호출 비용보다 저렴하고, 사내 데이터로 Fine-tuning하여 도메인 특화 성능을 높일 수 있습니다.

문제 3: 권한 관리 및 보안 아키텍처

핵심 해결안 (키워드)

권한 모델: RBAC(역할 기반 접근 제어)를 기본으로, 복잡한 정책을 위해 ABAC(속성 기반 접근 제어)를 보조로 사용.
- RBAC: Admin, TeamLead, Member 등 직관적인 역할을 정의하고, 역할에 권한(읽기/쓰기/삭제)을 부여.
- ABAC: 'A팀 소속의 TeamLead만 "대외비" 태그가 붙은 문서에 접근 가능'과 같이 사용자, 리소스, 환경의 속성을 조합한 동적인 제어 규칙을 적용.
민감정보 탐지: 문서 저장 시 비동기 파이프라인(Message Queue + Worker)을 통해 정규표현식(RegEx) 기반의 패턴 매칭으로 API 키, 개인정보 등을 탐지. 탐지 시 해당 문서에 '민감정보 포함' 플래그를 추가하고 관리자에게 알림.
API 보안: API Gateway를 도입하여 인증/인가를 중앙에서 처리. IDOR(Insecure Direct Object References) 취약점 방지를 위해, GET /documents/123과 같은 직접적인 ID 접근 시 반드시 현재 사용자가 해당 문서(123)에 대한 접근 권한이 있는지 로직을 추가.

기술 선택 및 장점 (비교)

RBAC+ABAC vs. RBAC Only: 순수 RBAC는 'A팀장', 'B팀장' 등 비슷한 권한의 역할이 계속 늘어나는 '역할 폭증(Role Explosion)' 문제를 야기할 수 있습니다. ABAC를 결합하면 역할 수를 최소한으로 유지하면서 속성 기반의 유연하고 세밀한 정책을 적용할 수 있어 관리 효율성이 높습니다.
비동기 처리 vs. 동기 처리: 민감정보 스캔은 시간이 걸릴 수 있는 작업입니다. 이를 동기적으로 처리하면 사용자의 파일 업로드 응답 시간이 길어집니다. 비동기로 처리하면 일단 업로드를 빠르게 완료시킨 후 백그라운드에서 스캔을 수행하므로 사용자 경험(UX)을 해치지 않습니다.

문제 4: 지식 활용 및 동기 부여

핵심 해결안 (키워드)

활성화 방안: 게이미피케이션(Gamification) 도입. 문서 작성, 답변 채택, '좋아요' 획득 시 포인트를 부여하고, 누적 포인트에 따라 뱃지(Best Answer, Top Contributor)와 레벨을 부여하는 시스템 구현.
전문가 발굴: 특정 기술 태그(#Java, #Kubernetes)별로 사용자의 기여도 점수를 주기적으로 계산하는 스케줄링 잡(Job)을 실행. 점수가 가장 높은 사용자를 해당 분야의 SME(사내 전문가)로 자동 추천하고 프로필에 표시.
외부 연동: Slack/Teams 봇(Bot) 개발. 사용자가 채널에서 /knowledge [검색어] 명령어를 입력하면, 지식 포털 검색 API를 호출하여 상위 검색 결과를 채널에 직접 메시지로 요약해서 보여줌. 사용자가 있는 곳으로 지식을 직접 배달하는 컨셉.

기술 선택 및 장점 (비교)

게이미피케이션 vs. 수동 보상: 관리자의 주관적인 판단에 의한 연말 보상보다, 활동에 대한 즉각적이고 투명한 피드백을 제공하여 지속적인 참여 동기를 유발하는 데 훨씬 효과적입니다.
데이터 기반 SME 추천 vs. 직책 기반: 직책이 높다고 항상 특정 기술 전문가인 것은 아닙니다. 실제 지식 기여도를 기반으로 전문가를 식별하는 것이 더 객관적이며, 숨겨진 고수를 발굴할 기회를 제공합니다.
협업 도구 연동 vs. 포털 내 기능만 제공: 개발자는 대부분의 시간을 Slack/Teams와 같은 메신저에서 보냅니다. 별도의 웹사이트를 방문하는 '허들'을 낮추고, 기존 업무 흐름(Workflow)에 자연스럽게 지식 검색을 통합시켜 활용도를 극대화할 수 있습니다.

문제 1: 데이터 모델링 및 저장소 설계 (초안)

핵심 해결안

하이브리드 데이터 아키텍처: RDBMS + Document Search Engine + Object Storage의 3가지 저장소를 목적에 맞게 조합.

키워드 및 기술 선택 이유

메타데이터 및 관계 관리: PostgreSQL (RDBMS)
- 선택 이유: 문서의 소유권, 버전, 권한 등 데이터 무결성이 중요한 정보를 안정적으로 관리하기 위함. ACID 트랜잭션을 보장하여 정합성이 깨질 위험이 적음.
- 타 기술 대비 장점: MongoDB 같은 NoSQL 대비, 복잡한 사용자-팀-문서 간의 관계(Join)를 명확하고 효율적으로 처리할 수 있음. 또한 JSONB 타입을 지원하여 태그(tags)와 같은 유연한 비정형 메타데이터도 효과적으로 저장 가능.
본문 검색(Full-Text Search): Elasticsearch
- 선택 이유: 빠르고 정확한 텍스트 검색이라는 특정 목적에 고도로 특화된 검색 엔진.
- 타 기술 대비 장점: PostgreSQL의 내장 검색 기능보다 훨씬 뛰어난 성능과 검색 품질(Ranking)을 제공. 특히, nori와 같은 한글 형태소 분석기 플러그인을 통해 한국어 검색의 정확도를 극대화할 수 있음.
대용량 파일 저장: AWS S3 (Object Storage)
- 선택 이유: 동영상, 고화질 이미지 등 대용량 바이너리 파일을 비용 효율적이고 확장성 있게 저장하기 위함.
- 타 기술 대비 장점: 파일을 DB에 BLOB 타입으로 저장하거나 서버의 파일 시스템에 직접 저장하는 방식은 DB 성능을 저하시키고, 서버 확장(Scale-out) 시 파일 동기화 문제를 야기함. S3는 이러한 문제를 원천적으로 해결하며, CDN 연동도 용이함.

문제 2: 똑똑한 검색(Smart Search) 기능 (초안)

핵심 해결안

하이브리드 검색: 키워드 검색의 정확성(Precision)과 시맨틱 검색의 재현율(Recall)을 결합하여 검색 품질을 극대화.

키워드 및 기술 선택 이유

시맨틱 검색(Semantic Search): SBERT + FAISS
- 선택 이유: "서버 접속이 안 돼요"라고 검색해도 "Connection Refused 해결 방법" 문서를 찾아주도록, 단순 키워드 매칭이 아닌 문장의 '의미'를 기반으로 검색하기 위함. SBERT는 문장 임베딩에 특화되어 효율적.
- 타 기술 대비 장점: 전통적인 TF-IDF 방식은 동의어나 유의어를 처리하지 못하는 한계가 명확함. SBERT를 통해 생성된 벡터를 FAISS 같은 벡터 DB/라이브러리로 검색하면, 대규모 문서에서도 빠른 속도로 유사도 높은 문서를 탐색할 수 있음.
검색 결과 랭킹 개선: Elasticsearch Function Score
- 선택 이유: 검색 결과의 순위를 비즈니스 로직에 맞게 동적으로 조정하기 위함.
- 타 기술 대비 장점: 단순히 검색어와의 관련도(_score)만으로 정렬하는 것이 아니라, 문서의 최신성, 조회 수, '좋아요' 수, 작성자의 신뢰도 등을 가중치로 반영하여 사용자에게 더 유용하고 신뢰도 높은 결과를 상단에 노출시킬 수 있음.

문제 3: 권한 관리 및 보안 (초안)

핵심 해결안

유연하고 확장 가능한 정책 기반 접근 제어를 구현하고, 민감 정보 유출을 자동화된 방식으로 방지.

키워드 및 기술 선택 이유

권한 모델: ABAC (Attribute-Based Access Control)
- 선택 이유: "A팀의 시니어 개발자만 '인프라' 태그가 붙은 문서를 수정할 수 있다"와 같이 복잡하고 동적인 권한 정책을 유연하게 설정하기 위함.
- 타 기술 대비 장점: RBAC(Role-Based) 모델은 역할(Role)이 증가할수록 관리 복잡도가 기하급수적으로 늘어나는 'Role Explosion' 문제가 발생하기 쉬움. ABAC는 사용자, 리소스, 환경의 '속성(Attribute)'을 기반으로 정책을 만들기 때문에 확장성이 훨씬 뛰어남.
정책 관리: OPA (Open Policy Agent)
- 선택 이유: 권한 정책 로직을 애플리케이션 코드로부터 분리하여, 정책 변경 시 서비스 재배포가 필요 없게 만들기 위함.
- 타 기술 대비 장점: 권한 로직을 코드에 하드코딩하는 방식은 유지보수가 어렵고 변경에 취약함. OPA를 사용하면 정책을 Rego라는 선언형 언어로 관리하여 중앙에서 일관성 있게 정책을 감사하고 업데이트할 수 있음.
민감 정보 탐지: AWS Macie 또는 Google Cloud DLP
- 선택 이유: 사용자가 실수로 문서에 API 키, 주민등록번호, 계좌번호 등 민감 정보를 포함했을 때, 이를 자동으로 탐지하고 마스킹/알림 처리하기 위함.
- 타 기술 대비 장점: 정규표현식(Regex) 기반으로 직접 구현하는 방식은 패턴을 일일이 관리해야 하고 탐지 정확도에 한계가 있음. Macie와 같은 머신러닝 기반의 관리형 서비스를 이용하는 것이 훨씬 정확하고 효율적.

문제 4: 지식 활용 및 동기 부여 (초안)

핵심 해결안

게임화(Gamification) 요소를 도입하고, 기존 업무 워크플로우에 자연스럽게 통합하여 참여를 유도.

키워드 및 기술 선택 이유

동기 부여: 게임화(Gamification) - 포인트, 뱃지, 리더보드
- 선택 이유: 지식 공유 활동에 대한 즉각적이고 가시적인 보상을 제공하여 구성원의 참여 동기를 내재적으로 자극.
- 접근 방식: 문서 작성, 질문에 대한 답변 채택, '좋아요' 획득 등의 활동에 포인트를 부여. 누적 포인트에 따라 뱃지를 수여하고, 주간/월간 리더보드를 통해 선의의 경쟁을 유도. 이는 단순한 금전적 보상보다 성취감과 인정의 욕구를 채워주어 지속적인 참여를 이끌어냄.
전문가 식별: SME(Subject-Matter Expert) Score 알고리즘
- 선택 이유: 특정 기술 분야에 대해 누가 전문가인지 데이터를 기반으로 식별하고, 도움이 필요한 사람과 연결해주기 위함.
- 접근 방식: 특정 태그(#Java, #Kubernetes)가 달린 문서 작성 수, 해당 분야 질문에 대한 채택 답변 수 등을 가중치로 계산하여 점수화. 이를 통해 시스템이 "이 질문은 OOO님에게 물어보세요"라고 추천해줄 수 있음.
워크플로우 통합: Slack / MS Teams Bot 연동
- 선택 이유: 지식 포털에 접속하는 별도의 행동 없이, 매일 사용하는 협업 툴 안에서 지식을 검색하고 공유하게 만들기 위함.
- 타 기술 대비 장점: 이메일 알림은 스팸으로 인식되기 쉽지만, 챗봇은 /knowledge [검색어]와 같은 명령어로 필요한 순간에 즉시 정보를 가져오는(On-demand) 상호작용이 가능. 채널에서 오가는 대화를 분석해 관련 지식 문서를 자동으로 추천하는 등 프로액티브한 기능 구현도 가능함.

3. 검색 및 활용 기능 설계

shoney9254 — Mon, 20 Oct 2025 13:11:52 +0900

효과적인 지식 검색은 **정보 검색(IR)**과 **AI 기반 의미 추론(NLP)**의 결합으로 이루어진다.

(1) 기술 스택 제안

기본 스토리지: PostgreSQL (문서 메타데이터 및 권한 관리)
콘텐츠 저장: Object Storage (예: AWS S3, 내부 NAS)
벡터 검색: Elasticsearch + OpenSearch Vector Store 또는 ChromaDB
임베딩 모델: OpenAI text-embedding-3-small 또는 KoSimCSE (한국어 중심 서비스 시)
애플리케이션 계층: FastAPI + React 기반 Web UI

(2) 검색 알고리즘 구조

사용자가 검색어 입력
키워드 기반 1차 필터링 (Elasticsearch Full Text Search)
입력 쿼리를 임베딩 벡터로 변환 → Knowledge 콘텐츠의 임베딩과 유사도 계산
relevance_score = α * semantic_score + β * keyword_score + γ * popularity_score
(α, β, γ는 가중치 조정 파라미터)
결과 랭킹 후 상위 N개 반환

(3) 검색 품질 향상 방안

사용자 Context 기반 검색 (부서/직무/최근 조회 문서 가중 처리)
문서의 최신성 점수(time decay factor) 적용
결과 설명(Explainability)을 위한 스니펫 생성 오버뷰 제공
“검색 → 열람 → 피드백” 로그를 학습 데이터로 삼아 지속적 재랭킹

이와 같은 설계를 통해 시스템은 단순 검색 툴을 넘어, 지식 발견과 의사결정 지원이 가능한 지능형 포탈로 발전할 수 있다.

RDB, Elasticsearch, 그리고 벡터 시멘틱 검색을 조합해 “하이브리드 검색” 시스템을 구축하면, 사용자는 키워드 기반뿐 아니라 의미(컨텍스트) 기반으로도 원하는 정보를 매우 효과적으로 찾을 수 있다.

하이브리드 검색 시스템 설계 원칙

검색 엔진별 역할 분담
- RDB: 메타데이터 관리 및 권한 제어, 관계성 질의(SQL), 정형 필터링 수행에 특화.
- Elasticsearch: 대량의 텍스트 필드에 대한 빠른 full-text 검색 및 BM25 같은 스코어링 기반 랭킹에 강점.
- 벡터 DB (혹은 Elasticsearch의 벡터 필드): 문서 임베딩 기반 의미 유사성 판단, 연관 정보 추천 등 AI 기반 검색 적용.

통합 검색 프로세스 예시

1차 필터:
RDB에서 사용자 권한·문서 타입·날짜 등 기본 조건으로 후보 문서 집합을 빠르게 추림.
2차 키워드 검색:
Elasticsearch에서 BM25 점수 기반으로 키워드 검색 수행, 후보군을 랭킹.
3차 벡터 임베딩 검색:
쿼리를 임베딩벡터로 변환하여, 문서의 임베딩 벡터와 코사인 유사도/ANN(Approximate Nearest Neighbor) 유사도 기반으로 의미적 스코어 산출.
결과 통합:
두 결과를 normalized score = α * 벡터 유사도 + β * BM25 점수 식으로 조합하거나 Reciprocal Rank Fusion(RRF) 알고리즘 적용.

사용 시 유의사항 및 Best Practice

벡터 임베딩 데이터 관리:
RDB에 embedding 컬럼 추가(예: PostgreSQL pgvector) 후, 텍스트 데이터를 임베딩하여 동기화, 혹은 별도 벡터 DB(Chroma, Pinecone)에 키 기반 연동.
대량 데이터 처리:
임베딩 사전 계산 및 배치 처리로 검색 지연 최소화.
검색 결과 집계/재랭킹:
키워드 일치와 의미 유사도를 함께 고려한 re-ranking 적용, 스코어 normalize 후 가중치 설정.
사용자 Context 활용:
최근 검색, 부서, 업무 이력 등을 바탕으로 랭킹 알고리즘에 가중치 부여.

실제 활용 예시

사용자가 특정 키워드와 자연어 질문(“Python 데이터 분석 실무 문서”)을 입력하면,
1. RDB에서 접근 권한/부서·날짜 필터로 1차 후보 문서 집합 검색
2. Elasticsearch에서 키워드 일치도 기반 랭킹 적용
3. 벡터 DB/Elasticsearch 벡터 기능으로 의미 유사 문서 발견 및 랭킹
4. 둘을 최종 랭킹 알고리즘으로 합쳐 결과 제공
  → 키워드·의미·접근권한·문서 최신성 등 종합적으로 우수한 결과 도출.

지식관리 포탈·엔터프라이즈 검색에선 위와 같은 “하이브리드 검색” 구조가 가장 널리 쓰이며, 실제 대한민국 대기업/글로벌 IT 기업에서 필수적으로 채택하는 모델이다.

2. 정보 구조 설계 (데이터 모델링)

shoney9254 — Mon, 20 Oct 2025 13:10:28 +0900

지식 관리 포탈의 핵심은 콘텐츠를 표준화하고 관계를 정의하는 것이다. 다음은 대표적인 **엔터티 관계 설계(ERD 개요)**이다:

Entity: Knowledge
- 주요 속성: id, title, content, summary, author_id, created_at, updated_at, category_id, version
- 설명: 지식의 기본 단위. 텍스트, 파일, 코드 등 형태를 불문하고 동일 구조로 관리.
Entity: User
- 주요 속성: user_id, name, department, role, email
- 설명: 작성자·검토자·조회자 구분. RBAC(Role Based Access Control)을 지원.
Entity: Tag
- 주요 속성: tag_id, name, description
- 설명: 지식 분류를 위한 보조 체계. 자동 태깅 기능과 수동 태깅 병행.
Entity: Knowledge_Tag (연결 테이블)
- knowledge_id, tag_id
- 설명: N:M 관계를 구현하여 지식과 태그의 다대다 연결 관리.
Entity: Feedback
- 주요 속성: feedback_id, knowledge_id, user_id, rating, comment, created_at
- 설명: 문서 품질 개선을 위한 피드백 및 평판 데이터.
Entity: SearchLog
- 주요 속성: search_id, user_id, keyword, timestamp
- 설명: 검색 사용자 행동 기반 추천이나 인기 문서 분석에 활용.

이 구조의 핵심은 지식(콘텐츠)을 중심으로 관계형 메타데이터를 구성하여 확장성을 유지하는 것이다.
추후 LLM 기반 이벤트 로그나 임베딩 데이터를 별도 테이블(embedding_vector)로 분리하면, 의미 기반 검색에도 대응이 가능하다.

1. 시스템 분석 및 요구사항 정의

shoney9254 — Mon, 20 Oct 2025 13:09:41 +0900

사내에는 다양한 형태의 지식이 부서별로 흩어져 있고, 중복 작성이나 검색의 어려움으로 인해 생산성이 저하되고 있다. 지식 관리 포탈의 목표는 **‘지식을 중앙집중적으로 관리하고, 필요할 때 누구나 쉽게 찾아 활용할 수 있는 환경’**을 구축하는 것이다.

해결해야 할 주요 문제점 및 기능적 요구사항

지식 분산 및 중복 관리 문제
- 문제: 부서별 문서 서버, 메신저 공유 파일, 개인 노트 등 다양한 경로에 지식이 분산되어 있음.
- 요구사항:
  - 문서, 회의록, 코드, 링크 등 다양한 지식 자산을 통합 저장할 수 있는 리포지토리 구축
  - 중복 지식 감지 기능 (문서 유사도 계산 기반)
  - 버전 관리 및 개정 이력 추적
검색 효율성 부족
- 문제: 제목 기반 검색만으로는 관련 문서를 찾기 어려움. 동일 주제도 표현 방식이 다름.
- 요구사항:
  - 키워드 기반 + 의미 기반 통합 검색 기능
  - 태그 자동 부여, 추천 검색어 제공
  - 사용자별 검색 히스토리 및 연관 문서 추천
지식 활용도 저하
- 문제: 작성된 지식이 재활용되지 않고, 문서만 쌓이는 형태로 정체됨.
- 요구사항:
  - 업무 시스템(예: Jira, Slack, Teams)과 연동하여 자동 참조 기능 지원
  - LLM 기반 Q&A 챗봇 메뉴로 검색 보완
  - 지식 평판(추천, 조회 수, 최신성 등) 기반 품질 관리

이를 통해 단순한 문서 관리 수준을 넘어, 지식의 생성 → 저장 → 탐색 → 재활용 → 개선으로 이어지는 피드백 구조를 내재화할 수 있다.

LangGraph란?

shoney9254 — Fri, 21 Mar 2025 15:45:54 +0900

LangGraph – LangChain에서 더 똑똑하게 멀티스텝 처리하는 법

LangChain을 사용하면서 "에이전트가 생각보다 복잡한 작업을 잘 못하네?" 라는 느낌을 받은 적이 있다.

단순 검색이나 API 호출 정도는 잘하지만, 여러 단계에 걸친 작업을 하면 이상한 답을 내놓거나, 비효율적으로 동작하는 경우가 많았다.

최근 프로젝트에서 LangGraph를 살짝 찍먹(?) 해봤는데,

이게 생각보다 LangChain의 부족한 부분을 꽤 잘 보완해줄 수 있는 기능 같아서 정리해본다.

LangGraph란?

LangGraph는 LangChain의 멀티스텝 처리 기능을 강화하기 위한 라이브러리다.

기존 LangChain은 한 번의 프롬프트 → 답변 생성 → 끝 이라는 단순한 흐름으로 동작하는 경우가 많았다.

하지만 현실에서는 AI가 여러 단계를 거쳐야 하는 작업이 많다.

예를 들어,

❓ "서울에서 뉴욕까지 가는 최적의 비행편 찾아줘" 라고 하면,

1️⃣ 먼저 서울에서 뉴욕으로 가는 항공편 검색

2️⃣ 가격 비교

3️⃣ 경유 여부 확인

4️⃣ 가장 좋은 옵션 추천

이런 여러 단계의 작업이 필요하다.

LangGraph는 이런 멀티스텝 프로세스를 쉽게 구성할 수 있도록 돕는 프레임워크다.

LangGraph의 주요 특징

1. 그래프 기반 처리

LangGraph는 이름 그대로 "Graph(그래프)" 구조를 기반으로 동작한다.

기존 LangChain은 단순히 프롬프트를 주고받는 선형 구조였지만, LangGraph는 노드(Node)와 엣지(Edge)를 활용해서 유연한 흐름을 만들 수 있다.

노드(Node): AI가 수행해야 하는 개별 작업 (예: 검색, 데이터 분석, 요약)
엣지(Edge): 작업 간의 연결 관계 (예: 검색 결과를 분석 후, 분석된 데이터를 요약)

즉, AI가 마치 플로우차트처럼 단계별로 작업을 수행할 수 있도록 만든다!

⚡ 2. 병렬 처리 가능

기존 LangChain에서는 하나의 작업이 끝나야 다음 작업이 가능했지만,

LangGraph에서는 여러 작업을 동시에 수행할 수도 있다.

예를 들어,

❓ "오늘 서울과 뉴욕의 날씨를 각각 찾아줘" 라고 하면,

기존 LangChain 방식:

서울 날씨 검색 → 뉴욕 날씨 검색 → 답변 생성

LangGraph 방식:

⚡ 서울 & 뉴욕 날씨 동시에 검색 → 결과 합쳐서 답변

즉, 독립적인 작업을 병렬로 실행할 수 있어 속도가 훨씬 빨라진다.

3. 더 똑똑한 의사결정 가능

LangGraph에서는 AI가 상황에 따라 어떤 노드를 선택할지 동적으로 결정할 수도 있다.

즉, 모든 작업을 일괄적으로 처리하는 게 아니라, 필요한 작업만 선택적으로 실행할 수도 있다.

예를 들어,

❓ "서울의 날씨 알려줘" 라고 했을 때,

검색이 필요하면 날씨 API 호출
데이터가 이미 캐시에 있으면 바로 응답
검색 결과가 이상하면 추가적인 확인 과정 수행

즉, AI가 유연하게 상황을 판단하고, 필요한 작업만 실행할 수 있다!

4. 다양한 AI 시스템과 결합 가능

LangGraph는 LangChain뿐만 아니라, OpenAI, Hugging Face, 기타 AI 프레임워크와도 쉽게 연동 가능하다.

즉, 기존 AI 시스템을 더 똑똑하게 만들기 위한 "업그레이드 키트" 같은 느낌이다.

LangGraph 코드 예제 (간단한 AI 워크플로우 만들기)

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END

# 간단한 State 정의
class WorkflowState:
    user_input: str
    search_result: str = None
    summary: str = None

# LLM 설정
llm = ChatOpenAI(model="gpt-4-turbo")

# 노드 1: 검색 수행
def search(state):
    query = state.user_input
    print(f"  검색 실행: {query}")
    return {"search_result": f"{query}에 대한 가짜 검색 결과"}

# 노드 2: 검색 결과 요약
def summarize(state):
    text = state.search_result
    print(f"  요약 실행: {text}")
    return {"summary": f"{text} 요약된 내용"}

# 그래프 설정
workflow = StateGraph(WorkflowState)
workflow.add_node("search", search)
workflow.add_node("summarize", summarize)

# 검색 후 요약하는 흐름 설정
workflow.set_entry_point("search")
workflow.add_edge("search", "summarize")
workflow.add_edge("summarize", END)

# 실행
app = workflow.compile()
result = app.invoke({"user_input": "LangGraph란 무엇인가?"})
print("최종 결과:", result["summary"])

✅ 코드 설명

WorkflowState: LangGraph에서 사용할 상태를 정의 (user_input → search_result → summary)
search() 노드: 사용자의 입력을 기반으로 가짜 검색 결과를 반환
summarize() 노드: 검색된 결과를 요약
LangGraph의 그래프 생성:
- 검색 수행 → 요약 실행 → 최종 결과 반환하는 흐름을 만든다
*app.invoke()**를 호출하면 전체 워크플로우가 실행됨

이제 AI가 검색 후 요약까지 자동으로 수행할 수 있다!

LangGraph를 활용하면 뭐가 좋아?

✅ 복잡한 AI 플로우를 쉽게 설계 – 멀티스텝 프로세스를 효율적으로 구현 가능

✅ 작업 속도 향상 – 병렬 실행을 통해 처리 속도 개선

✅ 더 스마트한 AI 만들기 – 상황에 맞는 유연한 의사결정 가능

✅ 기존 LangChain 시스템과 연동 가능 – 기존 프로젝트에 바로 적용 가능

LangGraph를 어떻게 활용하면 좋을까?

사용 사례 예제

1. 복잡한 데이터 분석 자동화

데이터를 수집 → 정리 → 분석 → 요약하는 전체 과정을 자동화
예: 뉴스 기사 크롤링 후, 주요 내용을 추출해서 요약

2. AI 비서 시스템

LangGraph를 활용하면 AI 비서가 여러 작업을 동시에 처리하면서 최적의 답을 줄 수 있도록 설계 가능
예: 일정 확인 → 이메일 요약 → 미팅 준비 자동화

3. AI 기반 검색 및 추천 시스템

사용자의 질문을 분석 → 필요한 정보 검색 → 검색 결과 최적화 → 최종 추천
예: 여행 추천 시스템 (날씨, 가격, 비행기 일정 분석 후 최적의 일정 추천)

한줄 요약 ✨

LangGraph는 LangChain의 한계를 극복하고, AI가 더 복잡한 멀티스텝 작업을 할 수 있도록 돕는 강력한 도구다!

지금은 살짝 찍먹한 수준이지만, 앞으로 더 복잡한 AI 프로세스를 설계할 때 LangGraph를 적극 활용해보면 좋을 것 같다.

우리 팀에서도 AI 워크플로우를 만들 때, LangChain만 쓸 게 아니라 LangGraph까지 고려해보면 어떨까?

AI 에이전트 vs LangChain 에이전트

shoney9254 — Fri, 21 Mar 2025 15:10:13 +0900

최근 프로젝트에서 LangChain을 활용해 RAG 기반 검색 시스템을 테스트할 일이 생겼다.

LangChain을 다루다 보니 **"LangChain의 에이전트"**라는 개념이 나왔는데, 처음엔 그냥 "AI 에이전트랑 같은 거 아니야?" 라고 생각했다.

하지만 막상 써보니 LangChain 에이전트는 우리가 흔히 말하는 AI 에이전트랑은 조금 다른 개념이었다.

혹시 팀원들 중에서도 나처럼 헷갈리는 분이 있을까 봐, 이번 기회에 한 번 정리해본다.

AI 에이전트란?

AI 에이전트는 간단히 말하면 **"스스로 판단하고 행동하는 AI 시스템"**이다.

환경에서 정보를 받아들이고, 목표를 달성하기 위해 스스로 판단하여 동작하는 것이 핵심이다.

AI 에이전트의 특징

✅ 자율성 – 사람이 직접 명령하지 않아도 스스로 판단하여 동작

✅ 목표 중심 – 주어진 목표를 달성하기 위해 움직임

✅ 환경과 상호작용 – 입력을 받아서 적절한 반응을 생성

✅ 의사결정 – 단순 규칙이 아니라, 상황에 맞게 최적의 행동을 선택

예제

챗봇 – 사용자의 질문을 이해하고 답변을 제공
AI 비서 – 일정 관리, 이메일 정리, 정보 검색 등
자율주행 AI – 도로 상황을 분석하고 최적의 경로 선택

즉, AI 에이전트는 자율적으로 동작하는 AI 시스템 전반을 의미하는 넓은 개념이다.

LangChain 에이전트란? ️

처음에는 LangChain의 에이전트도 AI 에이전트랑 비슷한 개념이라고 생각했다.

하지만 LangChain을 써보면서 느낀 점은, LangChain 에이전트는 단순한 AI가 아니라, 외부 도구를 활용할 수 있는 강력한 시스템이라는 거였다.

LangChain에서 '에이전트'가 필요한 이유

언어 모델(LLM)은 기본적으로 **"똑똑한 텍스트 생성기"**다.

즉, 질문을 하면 가장 적절한 텍스트를 출력할 수 있지만, 실제로 행동을 수행할 수는 없다.

예를 들어,

❓ "서울 날씨 어때?" 라고 물어보면,

"오늘 서울의 날씨는 맑습니다." 라고 대답할 수 있지만,

실제로 날씨를 검색하는 기능은 없다!

LangChain의 에이전트는 바로 이런 **"행동 수행"**을 가능하게 해준다.

LangChain 에이전트의 동작 방식

LangChain 에이전트는 언어 모델을 추론 엔진으로 사용해서 다음과 같은 과정으로 동작한다.

1️⃣ 어떤 행동을 해야 하는지 결정

"서울의 날씨 알려줘" → 단순 답변이 아니라 "날씨를 검색해야겠군!" 이라고 판단

2️⃣ 필요한 입력을 정리

"날씨를 검색하려면, 검색 엔진에 '서울 날씨'를 입력해야겠어!"

3️⃣ 도구를 사용해서 행동 수행

언어 모델 자체는 검색을 못 하지만, LangChain을 통해 API 호출, 검색 엔진 사용 등 외부 도구를 실행할 수 있음

4️⃣ 결과를 확인하고 추가 행동 결정

"이 정보로 충분한가? 추가 검색이 필요할까?"

5️⃣ 최종적으로 사용자에게 답변 제공

모든 과정이 끝나면 사용자에게 답변 반환

LangChain 에이전트의 강점

LangChain의 에이전트는 단순한 답변 생성기가 아니라, 외부 도구와 결합하여 더 강력한 AI 시스템을 구축할 수 있다.

LangChain 에이전트가 할 수 있는 일

✅ 웹 검색 – 구글 검색을 실행하고 최신 정보를 가져오기

✅ DB 조회 – 내부 데이터베이스에서 필요한 정보 찾기

✅ API 호출 – 특정 API를 호출하여 필요한 데이터 가져오기

✅ 계산 수행 – 단순한 산수부터 복잡한 연산까지 수행 가능

AI 에이전트 vs LangChain 에이전트 차이점

구분 AI 에이전트 LangChain 에이전트

정의	자율적으로 동작하는 AI 시스템	LangChain을 활용해 도구를 사용하는 AI 시스템
기반 기술	머신러닝, 딥러닝, LLM 등 다양함	LLM(GPT 등) + LangChain 프레임워크
자율성	자체적인 학습과 규칙 기반 동작	외부 도구를 사용하여 더 똑똑하게 동작
도구 사용	특정 도구를 직접 사용하지 않음	API, 검색 엔진, 데이터베이스, 계산기 등을 활용
예제	챗봇, AI 비서, 자율주행	검색 엔진 연동, 데이터 조회, 문서 요약

이 글을 쓰게 된 이유...

이번 프로젝트에서 LangChain을 활용하면서 처음엔 **"LangChain 에이전트 = AI 에이전트"**라고 생각했다.

하지만 실제로 LangChain을 사용해보니, 단순한 답변 생성기가 아니라 외부 도구까지 활용할 수 있는 강력한 시스템이라는 걸 깨달았다.

LangChain을 도입하면 AI가 단순히 질문에 답하는 것이 아니라, 직접 정보를 검색하고 데이터를 조회하며 더 똑똑한 응답을 제공할 수 있다.

우리 팀에서도 AI 시스템을 설계할 때, 단순 답변형 AI를 만들지 않을 거라면 LangChain의 에이전트 개념을 적극적으로 활용해보는 게 좋을 것 같다!

한 줄 요약

"AI 에이전트"는 넓은 개념이고, "LangChain 에이전트"는 AI가 외부 도구를 활용할 수 있도록 만든 시스템이다.

혹시 나처럼 헷갈렸던 분이 있었다면, 이 글이 이해하는 데 도움이 되었길!

앞으로 더 깊이 테스트해보고, 팀원들과도 LangChain 활용 방안을 논의해보면 좋을 것 같다.

LangChain Agent vs LangGraph: Super-Sub 에이전트 구조 구현 비교

shoney9254 — Wed, 19 Mar 2025 16:17:11 +0900

LangChain Agent vs LangGraph: Super-Sub 에이전트 구조 구현 비교

들어가며

안녕하세요, 기술 블로그 독자 여러분! 오늘은 AI 에이전트 시스템을 구축할 때 많이 사용되는 두 가지 접근 방식에 대해 알아보려고 합니다. 바로 LangChain Agent만을 사용한 Super-Sub 구조와 LangGraph를 활용한 Super-Sub 구조의 차이점입니다. 두 방식 모두 복잡한 작업을 여러 전문 에이전트에게 분배하는 구조를 가지고

있지만, 구현 방식과 특징에는 큰 차이가 있습니다.

LangChain Agent로 구현하는 Super-Sub 구조

LangChain은 대규모 언어 모델(LLM)을 활용한 애플리케이션 개발을 위한 프레임워크로, 다양한 도구와 에이전트를 쉽게 구현할 수 있게 해줍니다.

구현 방식

LangChain만으로 Super-Sub 구조를 구현할 때는 주로 다음과 같은 방식을 사용합니다:

class SuperAgent:
    def __init__(self, model_name: str = DEFAULT_MODEL):
        self.llm = ChatGoogleGenerativeAI(model=model_name)

        # 서브 에이전트들 초기화
        self.db_agent = DBAgent(self.llm)
        self.search_agent = SearchAgent(self.llm)
        self.rag_agent = RAGAgent()

        # 슈퍼 에이전트용 도구 설정
        self.tools = [
            Tool(
                name="DB_작업",
                func=self.db_agent.run,
                description="데이터베이스 관련 작업이 필요할 때 사용"
            ),
            Tool(
                name="정보_검색",
                func=self.search_agent.run,
                description="웹에서 정보를 검색해야 할 때 사용"
            ),
            Tool(
                name="문서_검색(RAG)",
                func=self.rag_agent.answer_question,
                description="저장된 문서에서 관련 정보를 검색할 때 사용"
            )
        ]

        # 슈퍼 에이전트 생성
        prompt = hub.pull("hwchase17/react")
        self.agent = create_react_agent(self.llm, self.tools, prompt)
        self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=True)

이 방식에서는 슈퍼 에이전트가 Tool 객체 형태로 서브 에이전트들을 관리하며, 사용자 질문에 따라 적절한 도구(서브 에이전트)를 선택하여 작업을 수행합니다.

장점

구현이 간단합니다: LangChain의 Tool과 AgentExecutor를 사용하면 비교적 적은 코드로 구현할 수 있습니다.
직관적인 구조: 슈퍼 에이전트가 도구를 선택하는 방식이 직관적이고 이해하기 쉽습니다.
빠른 프로토타이핑: 새로운 기능이나 에이전트를 추가하기 쉬워 빠르게 프로토타입을 만들 수 있습니다.

단점

복잡한 워크플로우 관리의 어려움: 여러 에이전트 간의 복잡한 상호작용이나 조건부 실행 흐름을 관리하기 어렵습니다.
상태 관리의 한계: 에이전트 간 상태 공유나 복잡한 상태 전이를 구현하기 어렵습니다.
디버깅의 어려움: 복잡한 에이전트 시스템에서 문제가 발생했을 때 디버깅이 어려울 수 있습니다.

LangGraph로 구현하는 Super-Sub 구조

LangGraph는 LangChain 위에 구축된 라이브러리로, 복잡한 에이전트 시스템을 그래프 기반으로 구현할 수 있게 해줍니다.

구현 방식

LangGraph를 사용한 Super-Sub 구조는 다음과 같이 구현할 수 있습니다:

# 상태 정의
class AgentState(TypedDict):
    question: str
    messages: Annotated[Sequence[BaseMessage], operator.add]
    current_agent: str
    agent_results: Dict[str, Any]
    final_answer: Optional[str]
    error: Optional[str]
    iteration_count: int

# 그래프 생성 함수
def create_agent_graph(llm: Optional[BaseLanguageModel] = None) -> StateGraph:
    # 기본 LLM 설정
    if llm is None:
        llm = ChatGoogleGenerativeAI(model=DEFAULT_MODEL)

    # 노드 생성
    super_agent_node = SuperAgentNode(llm)
    db_agent_node = DBAgentNode(llm)
    rag_agent_node = RAGAgentNode()
    error_handler_node = ErrorHandlerNode(llm)

    # 그래프 생성
    workflow = StateGraph(AgentState)

    # 노드 추가
    workflow.add_node(AgentType.SUPER, super_agent_node)
    workflow.add_node(AgentType.DB, db_agent_node)
    workflow.add_node(AgentType.RAG, rag_agent_node)
    workflow.add_node("error_handler", error_handler_node)

    # 조건부 엣지 추가
    workflow.add_conditional_edges(
        AgentType.SUPER,
        lambda state: "error_handler" if state.get("error") else state["current_agent"],
        {
            "error_handler": "error_handler",
            AgentType.DB: AgentType.DB,
            AgentType.RAG: AgentType.RAG,
            END: END
        }
    )

    # 각 에이전트에서 슈퍼 에이전트로 돌아가는 엣지
    workflow.add_edge(AgentType.DB, AgentType.SUPER)
    workflow.add_edge(AgentType.RAG, AgentType.SUPER)

    # 시작 노드 설정
    workflow.set_entry_point(AgentType.SUPER)

    return workflow

이 방식에서는 에이전트 시스템을 그래프로 모델링하며, 각 에이전트는 노드로, 에이전트 간 전환은 엣지로 표현됩니다. 상태(State)를 통해 에이전트 간 정보를 공유하고, 조건부 엣지를 통해 복잡한 워크플로우를 구현할 수 있습니다.

장점

복잡한 워크플로우 관리: 그래프 기반 접근 방식으로 복잡한 에이전트 간 상호작용과 조건부 실행 흐름을 명확하게 모델링할 수 있습니다.
상태 관리의 용이성: TypedDict를 사용한 상태 정의로 에이전트 간 상태 공유와 전이를 체계적으로 관리할 수 있습니다.
시각화 가능: 그래프 구조를 시각화하여 복잡한 에이전트 시스템의 흐름을 쉽게 이해하고 디버깅할 수 있습니다.
에러 처리의 유연성: 에러 처리 노드를 별도로 구현하여 다양한 예외 상황에 대응할 수 있습니다.
반복 실행 제어: 반복 횟수를 추적하고 제한하여 무한 루프를 방지할 수 있습니다.
확장성: 새로운 에이전트나 기능을 그래프에 쉽게 추가할 수 있어 시스템 확장이 용이합니다.

단점

구현 복잡성: LangChain만 사용하는 것보다 초기 구현이 더 복잡하고 코드량이 많습니다.
학습 곡선: 그래프 기반 접근 방식과 상태 관리에 대한 이해가 필요하여 학습 곡선이 높을 수 있습니다.
오버헤드: 간단한 작업에는 불필요한 복잡성과 오버헤드가 발생할 수 있습니다.
디버깅 복잡성: 그래프 구조가 복잡해질수록 디버깅이 어려워질 수 있습니다.

실제 사용 사례 비교

LangChain Agent만 사용한 경우

async def process_message(self, message: str) -> str:
    """메시지 처리 및 응답 생성"""
    # RAG 관련 키워드 확인
    rag_keywords = ["찾아줘", "검색해줘", "관련 정보", "문서에서", "문서 검색"]

    try:
        if any(keyword in message for keyword in rag_keywords):
            # RAG 도구 사용
            context = self.rag_agent.answer_question(message)
            prompt = f"""다음 컨텍스트를 기반으로 질문에 답변해주세요:

            컨텍스트:
            {context}

            질문: {message}
            """
            return await self._generate_response(prompt)

        # 일반적인 에이전트 실행
        result = await self.agent_executor.ainvoke({"input": message})
        return result["output"]

    except Exception as e:
        return f"죄송합니다. 오류가 발생했습니다: {str(e)}"

이 방식에서는 키워드 기반으로 간단하게 에이전트를 선택하거나, AgentExecutor에게 도구 선택을 위임합니다. 구현은 간단하지만, 복잡한 의사결정이나 에이전트 간 상호작용을 구현하기 어렵습니다.

LangGraph를 사용한 경우

def decide_agent(self, state: AgentState) -> Dict[str, Any]:
    """어떤 에이전트를 사용할지 결정하는 함수"""
    # 반복 횟수 확인 - 최대 반복 횟수에 도달하면 강제 종료
    iteration_count = state.get("iteration_count", 0)
    if iteration_count >= 10:
        print(f"[슈퍼 에이전트] 최대 반복 횟수({iteration_count})에 도달하여 현재까지의 결과로 답변합니다.")
        return {
            "reasoning": f"최대 반복 횟수({iteration_count})에 도달하여 현재까지의 결과로 답변합니다.",
            "selected_agent": "super_agent",
            "is_complete": True
        }

    # 현재까지의 에이전트 결과를 문자열로 변환
    agent_results_str = json.dumps(state["agent_results"], ensure_ascii=False, indent=2)

    # 이미 시도한 에이전트 확인
    tried_agents = set(state["agent_results"].keys())

    # DB 에이전트 결과 확인
    if "db_agent" in state["agent_results"]:
        db_result = state["agent_results"]["db_agent"]
        # 결과 분석 로직...

    # RAG 에이전트 결과 확인
    if "rag_agent" in state["agent_results"]:
        rag_result = state["agent_results"]["rag_agent"]
        # 결과 분석 로직...

    # 아직 어떤 에이전트도 시도하지 않았다면, 질문 유형에 따라 에이전트 선택
    if not tried_agents:
        # 프롬프트에 질문과 에이전트 결과 전달
        chain = self.agent_selection_prompt | self.llm | StrOutputParser()
        result = chain.invoke({
            "question": state["question"],
            "agent_results": agent_results_str
        })
        # 결과 파싱 및 반환...

LangGraph를 사용하면 상태 기반으로 복잡한 의사결정 로직을 구현할 수 있습니다. 이전 에이전트의 결과를 분석하고, 반복 횟수를 추적하며, 다양한 조건에 따라 다음 에이전트를 선택할 수 있습니다.

어떤 방식을 선택해야 할까?

LangChain Agent만 사용하는 것이 좋은 경우

간단한 에이전트 시스템: 복잡한 워크플로우가 필요 없는 간단한 에이전트 시스템
빠른 프로토타이핑: 빠르게 개념 증명(PoC)을 구현해야 하는 경우
리소스 제약: 개발 리소스나 시간이 제한적인 경우
단일 에이전트 중심: 여러 에이전트 간 복잡한 상호작용이 적은 경우

LangGraph를 사용하는 것이 좋은 경우

복잡한 워크플로우: 여러 에이전트 간 복잡한 상호작용과 조건부 실행이 필요한 경우
상태 기반 의사결정: 이전 결과와 상태에 기반한 복잡한 의사결정이 필요한 경우
확장성 중시: 시스템이 점진적으로 확장될 것으로 예상되는 경우
엄격한 에러 처리: 다양한 예외 상황에 대한 체계적인 처리가 필요한 경우
반복 실행 제어: 에이전트 간 반복적인 상호작용을 제어해야 하는 경우

결론

LangChain Agent만 사용하는 방식은 구현이 간단하고 직관적이지만, 복잡한 워크플로우와 상태 관리에 한계가 있습니다. 반면 LangGraph를 사용하는 방식은 초기 구현이 복잡하지만, 복잡한 에이전트 시스템을 체계적으로 모델링하고 관리할 수 있습니다.

프로젝트의 복잡성, 확장성 요구사항, 개발 리소스 등을 고려하여 적절한 방식을 선택하는 것이 중요합니다. 간단한 프로젝트는 LangChain Agent만으로 충분할 수 있지만, 복잡한 에이전트 시스템을 구축하려면 LangGraph의 그래프 기반 접근 방식이 더 적합할 수 있습니다.

우리 회사의 경우, 초기에는 LangChain Agent만으로 프로토타입을 빠르게 개발했지만, 시스템이 복잡해지면서 LangGraph로 마이그레이션하여 더 체계적인 에이전트 시스템을 구축할 수 있었습니다. 두 접근 방식의 장단점을 이해하고 프로젝트 요구사항에 맞게 선택하는 것이 성공적인 AI 에이전트 시스템 구축의 핵심입니다.

[AI] LangChain 에이전트 구현하기: ReAct 프레임워크 기반 자동화 시스템

shoney9254 — Thu, 6 Mar 2025 13:06:23 +0900

LangChain을 활용하면 단순한 언어 모델(LLM)을 넘어, 자율적으로 행동하는 AI 에이전트를 만들 수 있습니다.
이번 글에서는 Google Gemini Pro 모델과 ReAct 에이전트 프레임워크를 사용해,
웹 검색과 파이썬 코드 실행이 가능한 스마트 에이전트를 구축하는 방법을 설명하겠습니다.

1. 환경 설정

먼저 필요한 라이브러리를 임포트하고 환경 변수를 설정합니다.
특히, SSL 인증을 비활성화하여 네트워크 요청에서 발생할 수 있는 보안 경고를 방지합니다.

import os
import ssl
from langchain import hub
from langchain_community.utilities.serpapi import SerpAPIWrapper
from langchain_experimental.tools import PythonREPLTool
from langchain_core.tools import Tool
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.agents import create_react_agent, AgentExecutor

# SSL 검증 비활성화
ssl._create_default_https_context = ssl._create_unverified_context

# 환경 변수 설정
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "agent/api-key.json"
os.environ["SERPAPI_API_KEY"] = "YOUR_SERPAPI_KEY"  # SerpAPI에서 무료 API 키 발급
os.environ['PYTHONHTTPSVERIFY'] = '0'

SerpAPI는 검색 엔진을 활용하기 위해 필요한 API입니다.
SerpAPI 공식 사이트에서 무료 키를 발급받아 YOUR_SERPAPI_KEY를 대체하세요.

2. 언어 모델(LLM) 설정

우리는 Gemini Pro 모델을 사용해 에이전트의 "두뇌" 역할을 담당하도록 설정합니다.

# Gemini Pro 모델을 활용한 LLM 초기화
llm = ChatGoogleGenerativeAI(model="models/gemini-1.5-pro")

LangChain은 다양한 LLM을 지원하며, OpenAI의 GPT, Anthropic의 Claude, Google의 Gemini 등 다양한 모델을 연결할 수 있습니다.

3. 에이전트 도구(Tools) 정의

에이전트가 단순한 텍스트 생성기에서 더 똑똑한 AI로 동작하려면, 외부 도구를 사용할 수 있어야 합니다.
이번 프로젝트에서는 웹 검색과 파이썬 코드 실행기를 도구로 추가하겠습니다.

# 에이전트가 사용할 도구 정의
tools = [
    Tool(
        name="웹검색",
        func=SerpAPIWrapper().run,
        description="최신 정보를 검색해야 할 때 사용하는 도구"
    ),
    PythonREPLTool(
        name="파이썬_실행기",
        description="파이썬 코드를 실행해야 할 때 사용하는 도구"
    )
]

도구의 역할

✅ 웹 검색: 검색 엔진을 사용해 최신 정보를 가져옵니다.
✅ 파이썬 실행기: 수학 계산, 데이터 분석, 문자열 처리 등을 수행할 수 있습니다.

4. ReAct 기반 에이전트 생성

이제 LLM과 도구들을 조합하여 ReAct(Reasoning + Acting) 프레임워크 기반의 에이전트를 만듭니다.

# 프롬프트 템플릿 가져오기
prompt = hub.pull("hwchase17/react")

# ReAct 에이전트 생성
agent = create_react_agent(llm, tools, prompt)

# 에이전트 실행기(Agent Executor) 생성
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

ReAct 프레임워크란?

AI가 "생각(Reasoning) → 행동(Acting) → 피드백" 을 반복하는 방식으로 동작하는 프레임워크입니다.
예를 들어, AI가 "GDP 검색 후 원화 환산"을 요청받으면,
① 검색 → ② 환산 계산 → ③ 최종 결과 도출 의 과정을 스스로 수행합니다.

5. 에이전트 테스트

이제 우리가 만든 에이전트가 실제로 어떻게 동작하는지 테스트해보겠습니다.

# 에이전트 테스트 함수
def test_agent():
    # 1️⃣ 파이썬 코드 실행 테스트 - 짝수 출력
    result1 = agent_executor.invoke(
        {"input": "파이썬을 사용해서 1부터 10까지의 숫자 중 짝수만 출력해주세요"}
    )
    print("\n기본 계산 결과:", result1["output"])
    
    # 2️⃣ 파이썬 코드 실행 테스트 - 통계 분석
    result2 = agent_executor.invoke(
        {"input": """다음 데이터의 평균과 표준편차를 계산해주세요: 
        [23, 45, 67, 89, 12, 34, 56, 78, 90, 11]"""}
    )
    print("\n통계 분석 결과:", result2["output"])
    
    # 3️⃣ 문자열 처리 테스트 - 모음 개수 세기
    result3 = agent_executor.invoke(
        {"input": "문자열 'Hello, Python World!'에서 모든 모음(a,e,i,o,u)의 개수를 세어주세요"}
    )
    print("\n문자열 분석 결과:", result3["output"])
    
    # 4️⃣ 복합 작업 테스트 - GDP 검색 후 환산
    result4 = agent_executor.invoke(
        {"input": "대한민국의 2023년 GDP가 얼마인지 검색하고, 이를 달러에서 원화로 환산해주세요 (1달러=1300원 기준)"}
    )
    print("\n복합 작업 결과:", result4["output"])

if __name__ == "__main__":
    test_agent()

실행 결과 예시

기본 계산 결과: [2, 4, 6, 8, 10]

통계 분석 결과: 평균=50.5, 표준편차=28.4

문자열 분석 결과: 모음 개수 = 6

복합 작업 결과: 대한민국 2023년 GDP는 약 1.7조 달러이며, 원화로 환산하면 약 2210조 원입니다.

정리하자면...
✅ 단순한 LLM이 아니라, 직접 행동할 수 있는 AI를 만들었다!
✅ 웹 검색을 통해 실시간 정보를 얻고, 파이썬 실행기로 데이터를 처리할 수 있다!
✅ ReAct 프레임워크를 활용해 AI가 스스로 생각하고, 판단하고, 실행한다!

마무리

이번 글에서는 LangChain을 활용해 스스로 검색하고 계산하는 AI 에이전트를 만들었습니다.
이를 확장하면 "AI 자동 보고 시스템", "데이터 분석 도우미", "스마트 챗봇" 등 다양한 응용이 가능합니다!

✨ 앞으로의 확장 아이디어

✅ 추가적인 도구(Tool) 연결 → 데이터베이스 조회, API 호출 등
✅ 더 강력한 모델 적용 → GPT-4, Claude-3, Mixtral 등
✅ 자연어 처리 강화 → 복잡한 요청을 더 정확하게 분석

다음에도 더 흥미로운 LangChain 활용법을 소개하겠습니다!
궁금한 점은 댓글로 남겨주세요!

[AI] Google Generative AI 모델 사용하기: 모델 리스트 조회 및 프롬프트 테스트

shoney9254 — Thu, 6 Mar 2025 10:38:04 +0900

Google에서 제공하는 Generative AI API를 사용하면 강력한 AI 모델을 활용할 수 있습니다. 이 글에서는 Python 코드를 활용하여 다음과 같은 작업을 수행하는 방법을 설명합니다.

Google AI의 모델 리스트 조회
프롬프트를 사용하여 AI 모델과 상호작용

1. 사전 준비

Google Generative AI API를 사용하기 위해서는 서비스 계정 키 파일이 필요합니다. 이를 환경 변수로 설정해야 합니다.

import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "agent/api-key.json"

위 코드에서 "agent/api-key.json" 파일은 Google Cloud 콘솔에서 생성한 서비스 계정 키 파일입니다. 자신의 키 파일 경로로 수정해야 합니다.

2. 사용 가능한 모델 리스트 조회

먼저, Google AI에서 지원하는 모델 목록을 조회해 보겠습니다.

from google.ai import generativelanguage_v1beta

# 모델 리스트를 가져오기 위한 클라이언트 생성
client = generativelanguage_v1beta.ModelServiceClient()

# 사용 가능한 모델 리스트 출력
try:
    models = client.list_models()
    print("사용 가능한 모델 목록:")
    for model in models:
        print(f"- {model.name}: {model.description}")
except Exception as e:
    print("모델 목록 조회 중 오류 발생:")
    print(str(e))

코드 설명

ModelServiceClient()를 사용하여 모델 리스트를 가져오는 클라이언트를 생성합니다.
list_models() 메서드를 호출하여 사용 가능한 모델 목록을 가져옵니다.
모델의 이름(model.name)과 설명(model.description)을 출력합니다.

실행 결과 예시

사용 가능한 모델 목록:
- models/gemini-1.5-pro: 고급 AI 모델, 자연어 처리에 강함
- models/gemini-1.0-pro: 이전 버전의 고급 AI 모델
...

3. 프롬프트를 활용한 AI 응답 테스트

이제, AI 모델을 사용하여 프롬프트를 입력하고 응답을 받아보겠습니다.

from google.api_core import client_options

# 생성 모델 클라이언트 생성
client = generativelanguage_v1beta.GenerativeServiceClient()

# 테스트할 프롬프트 준비
content = generativelanguage_v1beta.Content()
content.parts = [{"text": "안녕하세요! 당신은 누구인가요?"}]

# 요청 생성
request = generativelanguage_v1beta.GenerateContentRequest(
    model="models/gemini-1.5-pro",  # 사용할 AI 모델 선택
    contents=[content]
)

try:
    response = client.generate_content(request)
    print("\n응답:")
    print(response.candidates[0].content.parts[0].text)
except Exception as e:
    print("오류 발생:")
    print(str(e))

코드 설명

**GenerativeServiceClient()**를 사용하여 AI 생성 모델 클라이언트를 생성합니다.
프롬프트(content.parts)를 설정합니다.
GenerateContentRequest를 생성하여 요청을 보냅니다.
AI의 응답을 출력합니다.

실행 결과 예시

응답:
안녕하세요! 저는 Google AI의 Gemini 모델입니다. 무엇을 도와드릴까요?

4. 마무리

이제 Google AI의 모델을 조회하고, 프롬프트를 테스트하는 방법을 알게 되었습니다. 이 API를 활용하면 다양한 AI 기반 응용 프로그램을 개발할 수 있습니다.

✅ 정리

Google Cloud 서비스 계정 키를 설정해야 합니다.
ModelServiceClient()를 사용하여 지원 모델 리스트를 조회할 수 있습니다.
GenerativeServiceClient()를 사용하여 AI 모델과 상호작용할 수 있습니다.

이제 AI 모델을 활용하여 다양한 자연어 처리(NLP) 프로젝트를 진행해 보세요!

[AI] 에이전트란 무엇인가? - (초보자를 위한 쉬운 설명)

shoney9254 — Wed, 5 Mar 2025 17:40:32 +0900

언어 모델(LLM)은 기본적으로 "똑똑한 텍스트 생성기"입니다. 주어진 질문이나 문장을 기반으로 가장 적절한 텍스트를 출력할 뿐, 실제 행동을 취하는 것은 아닙니다. 예를 들어, "날씨가 어때?"라고 물어보면, "오늘 서울의 날씨는 맑습니다."라고 답할 수 있지만, 실제로 날씨를 검색하는 기능은 없습니다.

LangChain에서 '에이전트'가 필요한 이유

LangChain에서는 이런 언어 모델이 단순한 답변 생성기가 아니라, 스스로 행동할 수 있도록 도와주는 기능을 추가할 수 있습니다. 이 역할을 하는 것이 바로 에이전트(Agent)입니다.

에이전트는 언어 모델을 추론 엔진으로 사용하여 다음과 같은 과정을 수행합니다.

어떤 행동을 해야 하는지 결정
- 예를 들어, "서울의 날씨 알려줘"라고 하면, 단순히 문장을 생성하는 게 아니라, "날씨 정보를 검색하는 행동을 해야겠어!"라고 판단합니다.
필요한 입력을 정리
- "날씨를 찾으려면 검색 엔진에 '서울 날씨'라고 입력해야겠군!"
- 즉, 어떤 정보를 얻기 위해 무엇을 입력해야 하는지를 결정합니다.
도구를 사용해서 행동 수행
- LangChain에서는 언어 모델이 단독으로 행동하지 못하므로, 외부 도구(검색 엔진, 데이터베이스 등)를 사용해서 정보를 가져오도록 도와줍니다.
- 예를 들어, 검색 엔진을 사용해 '서울 날씨'를 실제로 검색합니다.
결과를 다시 확인하고 다음 행동 결정
- 검색 결과를 받아서 "이 정보로 충분한가? 아니면 추가로 다른 행동이 필요한가?" 판단합니다.
- 만약 정보가 부족하면 다시 검색하거나 다른 방법을 시도할 수도 있습니다.
최종적으로 사용자에게 답변 제공
- 모든 과정이 끝나면 사용자에게 최종적인 답을 제공합니다.

예제로 쉽게 이해하기 ✨

LangChain의 에이전트는 여러 도구를 사용할 수 있도록 설정할 수 있습니다. 예를 들어,

도구 1: 로컬 데이터베이스 → 내 컴퓨터에 저장된 정보를 찾아볼 수 있음
도구 2: 검색 엔진 → 구글에서 최신 정보를 검색할 수 있음

즉, 에이전트는 언어 모델이 직접 할 수 없는 일(검색, 데이터 조회 등)을 도와주는 역할을 합니다.

실제 동작 예시:

❓ 질문: "일론 머스크의 최신 트윗이 뭐야?"

에이전트의 판단: "이건 검색이 필요하군! 트위터 검색 도구를 사용해야겠어."

행동: 트위터 검색 엔진을 실행하고 최신 트윗을 가져옴

✅ 결과 확인: 가져온 트윗을 사용자에게 전달

이처럼 LangChain의 에이전트는 언어 모델이 단순히 텍스트만 출력하는 것이 아니라, 실제로 행동을 수행할 수 있도록 만드는 역할을 합니다!

[토큰 관리 방식] 쿠기 vs 로컬/세션 스토리지

shoney9254 — Tue, 4 Mar 2025 14:53:46 +0900

쿠키(Cookie)와 로컬/세션 스토리지(localStorage / sessionStorage)를 사용하여 토큰을 관리하는 방식에는 각각의 장점과 단점이 있다.

✅ 쿠키 vs 로컬/세션 스토리지의 차이점

구분 쿠키 (Cookie) 로컬스토리지 (localStorage) / 세션스토리지 (sessionStorage)

저장 방식	HTTP 요청 시 자동으로 전송	JS를 통해 읽고 쓰기 가능
보안성	HttpOnly 설정 가능 → XSS 방어 가능	XSS 공격에 취약
CSRF 공격	기본적으로 취약 → CSRF 토큰 필요	CSRF 공격에 안전
만료 시간	서버가 설정 가능 (Max-Age, Expires)	개발자가 직접 관리해야 함
도메인 제한	특정 도메인에서만 접근 가능	모든 JS에서 접근 가능
전송 방식	Cookie 헤더를 통해 자동 전송	API 요청 시 Authorization 헤더에 수동으로 추가해야 함
용량 제한	약 4KB 제한	약 5MB 제한

✅ 1. 쿠키로 토큰 관리 (HTTP-Only 쿠키)

✅ 쿠키 관리 방법

서버에서 Set-Cookie를 통해 쿠키에 토큰 저장
클라이언트는 withCredentials: true 옵션을 사용하여 요청
쿠키는 HTTP 요청 시 자동으로 포함됨

예제

서버에서 쿠키 설정

Set-Cookie: access_token=abc123; Path=/; HttpOnly; Secure; SameSite=Strict;

클라이언트 요청 (Axios 예시)

axios.get("https://api.example.com/user", {
  withCredentials: true
});

✅ 장점

✔ 보안성이 높음 (HttpOnly, Secure 옵션 사용 가능)
✔ XSS 공격 방어 가능 (HttpOnly 설정 시 JS에서 접근 불가)
✔ 자동으로 포함되므로 클라이언트에서 토큰을 수동으로 추가할 필요 없음
✔ 서버가 만료 기간을 설정하고 관리 가능

❌ 단점

❌ CORS 설정이 복잡함 (Access-Control-Allow-Credentials: true 필요)
❌ CSRF 공격에 취약할 수 있음 → CSRF 방어를 위한 추가적인 조치 필요
❌ 도메인 간 공유가 어려움 (다른 도메인에서는 접근 불가)

✅ 2. 로컬스토리지 또는 세션스토리지에서 토큰 관리

✅ 로컬스토리지(LocalStorage)와 세션스토리지(SessionStorage)의 차이

저장 방식 설명

localStorage	브라우저가 종료되어도 토큰이 유지됨
sessionStorage	브라우저 또는 탭이 종료되면 토큰이 삭제됨

예제

// 로그인 시 토큰 저장
localStorage.setItem("access_token", "abc123");

// API 요청 시 헤더에 포함
axios.get("https://api.example.com/user", {
  headers: {
    Authorization: `Bearer ${localStorage.getItem("access_token")}`
  }
});

✅ 장점

✔ CSRF 공격에 안전함 (쿠키처럼 자동 전송되지 않음)
✔ CORS 설정이 비교적 간단함
✔ 도메인 간 공유가 가능함 (단, postMessage API를 사용해야 함)
✔ 응답 속도가 빠름 (쿠키보다 I/O 비용이 적음)

❌ 단점

❌ XSS 공격에 취약함 (악성 스크립트가 토큰을 훔칠 수 있음)
❌ 토큰이 자동으로 포함되지 않으므로 매 요청마다 Authorization 헤더에 추가해야 함
❌ 수동으로 만료 시간을 관리해야 함 (쿠키는 서버에서 Max-Age 설정 가능)

✅ 그럼 언제 쿠키를 쓰고, 언제 로컬스토리지를 써야 할까?

✅ 쿠키를 써야 하는 경우

보안이 중요한 경우 (예: 로그인, 금융 서비스 등)
XSS 공격 방어가 필요할 때 (HttpOnly 쿠키 사용)
토큰을 자동으로 요청과 함께 보내야 할 때
서버가 인증을 철저하게 관리해야 할 때

✅ 로컬스토리지/세션스토리지를 써야 하는 경우

CSRF 공격을 막고 싶을 때
CORS 설정이 복잡한 API를 사용할 때
OAuth 2.0의 Authorization: Bearer 토큰을 활용할 때
토큰을 수동으로 관리할 필요가 있을 때 (리프레시 토큰 전략 등)

✅ 결론

선택 기준 쿠키 (HttpOnly) 로컬스토리지 / 세션스토리지

보안	XSS 공격 방어 가능	XSS 공격에 취약
CSRF 공격 방어	별도 방어 필요 (CSRF 토큰)	기본적으로 안전
자동 전송	요청 시 자동 전송 (Cookie 헤더)	Authorization 헤더에 수동 추가 필요
설정 난이도	CORS, 쿠키 설정 필요	비교적 설정이 쉬움
도메인 공유	제한적 (도메인 간 공유 불가)	비교적 자유로움

보안이 중요한 경우 → HttpOnly 쿠키 추천
토큰을 수동으로 관리하고 싶다면 → 로컬/세션스토리지 추천

[java8] 인터페이스의 디폴트 메서드, 스태틱 메서드

shoney9254 — Fri, 14 Jun 2024 14:31:41 +0900

Java 8 인터페이스의 기본 메소드와 스태틱 메소드 가이드

Java 8에서는 인터페이스에 기본 메소드(Default Methods)와 스태틱 메소드(Static Methods)가 추가되었습니다. 이를 통해 인터페이스를 더욱 유연하게 사용하고, 기존 코드를 변경하지 않고도 새로운 기능을 추가할 수 있게 되었습니다. 다음은 이 기능들을 효과적으로 사용하는 방법에 대한 가이드입니다.

1. 기본 메소드 (Default Methods)

기본 메소드란?

기본 메소드는 인터페이스 내에서 메소드 선언뿐만 아니라 구현까지 제공하는 방법입니다. 이를 통해 인터페이스를 구현한 클래스들을 변경하지 않고도 새로운 메소드를 인터페이스에 추가할 수 있습니다.

장점

기존 인터페이스를 구현한 클래스를 깨트리지 않고 새 기능을 추가할 수 있습니다.

주의사항

기본 메소드는 구현체가 모르게 추가된 기능으로 인해 런타임 에러가 발생할 수 있습니다.
반드시 문서화하여 해당 메소드의 구현 명세를 명확히 해야 합니다. (@implSpec 자바독 태그 사용)
Object 클래스가 제공하는 기능(equals, hashCode)은 기본 메소드로 제공할 수 없습니다. 이 경우 구현체가 해당 메소드를 재정의해야 합니다.
자신이 수정할 수 있는 인터페이스에만 기본 메소드를 제공해야 합니다.
인터페이스를 상속받는 인터페이스에서 기본 메소드를 추상 메소드로 변경할 수 있습니다.
인터페이스 구현체가 기본 메소드를 재정의할 수도 있습니다.

예제

기본 메소드 정의

public interface MyInterface {

    /**
     * Perform an action.
     *
     * @implSpec
     * This implementation prints "Default action".
     */
    default void performAction() {
        System.out.println("Default action");
    }

    // Abstract method
    void abstractMethod();
}

인터페이스 구현 클래스

public class MyClass implements MyInterface {

    @Override
    public void abstractMethod() {
        System.out.println("Abstract method implementation");
    }

    // 기본 메소드를 재정의할 수도 있습니다.
    @Override
    public void performAction() {
        System.out.println("Custom action");
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.performAction(); // Output: Custom action
        myClass.abstractMethod(); // Output: Abstract method implementation
    }
}

2. 스태틱 메소드 (Static Methods)

스태틱 메소드란?

인터페이스에 타입 관련 헬퍼 또는 유틸리티 메소드를 제공하기 위해 스태틱 메소드를 사용할 수 있습니다. 이를 통해 인터페이스와 관련된 공통 기능을 인터페이스 자체에 정의할 수 있습니다.

예제

스태틱 메소드 정의

public interface UtilityInterface {

    // 스태틱 메소드 정의
    static void utilityMethod() {
        System.out.println("Utility method");
    }

    // Abstract method
    void anotherMethod();
}

스태틱 메소드 사용

public class UtilityClass implements UtilityInterface {

    @Override
    public void anotherMethod() {
        System.out.println("Another method implementation");
    }

    public static void main(String[] args) {
        UtilityClass utilityClass = new UtilityClass();
        utilityClass.anotherMethod(); // Output: Another method implementation

        // 스태틱 메소드는 인터페이스명으로 직접 호출
        UtilityInterface.utilityMethod(); // Output: Utility method
    }
}

이 가이드는 Java 8의 기본 메소드와 스태틱 메소드를 사용하는 방법에 대해 설명합니다. 기본 메소드는 인터페이스에 새로운 기능을 추가할 때 유용하지만, 문서화와 런타임 에러에 주의해야 합니다. 스태틱 메소드는 유틸리티 메소드를 인터페이스에 추가할 때 유용합니다. 이를 통해 인터페이스를 더욱 유연하고 기능적으로 사용할 수 있습니다.

[Java8] Optional 사용 방법과 예시

shoney9254 — Wed, 12 Jun 2024 22:41:30 +0900

Java 8의 Optional 클래스와 관련된 다양한 메서드들을 정리하고, 각 메서드에 대한 예제를 작성해 보겠습니다.

1. Optional 만들기

Optional.of(): null이 아닌 값을 가지는 Optional을 생성합니다.
Optional.ofNullable(): 값이 null일 수 있는 Optional을 생성합니다.
Optional.empty(): 비어있는 Optional을 생성합니다.

Optional<String> optional1 = Optional.of("Hello"); // "Hello"를 포함하는 Optional 생성
Optional<String> optional2 = Optional.ofNullable(null); // null을 허용하는 Optional 생성
Optional<String> optional3 = Optional.empty(); // 비어있는 Optional 생성

2. Optional에 값이 있는지 없는지 확인하기

isPresent(): 값이 존재하는지 확인합니다.
isEmpty(): 값이 존재하지 않는지 확인합니다. (Java 11부터 제공)

Optional<String> optional = Optional.of("Hello");

if (optional.isPresent()) {
    System.out.println("Value is present");
}

if (optional.isEmpty()) { // Java 11부터 사용 가능
    System.out.println("Value is empty");
}

3. Optional에 있는 값 가져오기

get(): 값을 가져옵니다. 값이 없으면 NoSuchElementException을 던집니다.

Optional<String> optional = Optional.of("Hello");
String value = optional.get(); // "Hello" 반환

4. Optional에 값이 있는 경우에 그 값을 가지고 ~~를 하라

ifPresent(Consumer): 값이 존재하면 Consumer를 실행합니다.

Optional<String> optional = Optional.of("Spring Course");
optional.ifPresent(value -> {
    if (value.startsWith("Spring")) {
        System.out.println("Course ID: 123");
    }
});

5. Optional에 값이 있으면 가져오고 없는 경우에 ~~를 리턴하라

orElse(T): 값이 없으면 기본값을 리턴합니다.

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElse("Default Course"); // "Default Course" 반환

6. Optional에 값이 있으면 가져오고 없는 경우에 ~~를 하라

orElseGet(Supplier): 값이 없으면 Supplier를 실행하여 값을 리턴합니다.

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElseGet(() -> "Created New Course"); // "Created New Course" 반환

7. Optional에 값이 있으면 가져오고 없는 경우 에러를 던져라

orElseThrow(): 값이 없으면 예외를 던집니다.

Optional<String> optional = Optional.ofNullable(null);
String value = optional.orElseThrow(() -> new IllegalArgumentException("No value present"));

8. Optional에 들어있는 값 걸러내기

filter(Predicate): 값이 Predicate를 만족하면 값을 포함하는 Optional을 반환합니다.

Optional<String> optional = Optional.of("Spring Course");
optional.filter(value -> value.startsWith("Spring"))
        .ifPresent(System.out::println); // "Spring Course" 출력

9. Optional에 들어있는 값 변환하기

map(Function): 값을 변환하여 새로운 Optional을 반환합니다.
flatMap(Function): Optional 안에 들어있는 인스턴스가 Optional인 경우 사용합니다.

Optional<String> optional = Optional.of("Spring Course");

// map 사용 예
Optional<Integer> lengthOptional = optional.map(String::length);
lengthOptional.ifPresent(System.out::println); // 13 출력

// flatMap 사용 예
Optional<Optional<String>> nestedOptional = Optional.of(Optional.of("Nested Value"));
nestedOptional.flatMap(Function.identity())
              .ifPresent(System.out::println); // "Nested Value" 출력

종합 예제

다양한 Optional 메서드를 사용하는 예제 코드를 보여드리겠습니다.

import java.util.Optional;

public class OptionalExample {

    public static void main(String[] args) {
        // 1. Optional 만들기
        Optional<String> optional1 = Optional.of("Hello");
        Optional<String> optional2 = Optional.ofNullable(null);
        Optional<String> optional3 = Optional.empty();

        // 2. Optional에 값이 있는지 없는지 확인하기
        if (optional1.isPresent()) {
            System.out.println("Value is present: " + optional1.get());
        }
        if (optional3.isEmpty()) {
            System.out.println("Value is empty");
        }

        // 3. Optional에 있는 값 가져오기
        try {
            String value = optional2.get(); // NoSuchElementException 발생
        } catch (Exception e) {
            System.out.println("Caught exception: " + e);
        }

        // 4. Optional에 값이 있는 경우에 그 값을 가지고 ~~를 하라
        optional1.ifPresent(value -> System.out.println("Value is: " + value));

        // 5. Optional에 값이 있으면 가져오고 없는 경우에 ~~를 리턴하라
        String defaultValue = optional2.orElse("Default Value");
        System.out.println("Default value: " + defaultValue);

        // 6. Optional에 값이 있으면 가져오고 없는 경우에 ~~를 하라
        String orElseGetValue = optional2.orElseGet(() -> "Created New Value");
        System.out.println("OrElseGet value: " + orElseGetValue);

        // 7. Optional에 값이 있으면 가져오고 없는 경우 에러를 던져라
        try {
            String orElseThrowValue = optional2.orElseThrow(() -> new IllegalArgumentException("No value present"));
        } catch (Exception e) {
            System.out.println("Caught exception: " + e);
        }

        // 8. Optional에 들어있는 값 걸러내기
        Optional<String> filteredOptional = optional1.filter(value -> value.startsWith("H"));
        filteredOptional.ifPresent(value -> System.out.println("Filtered value: " + value));

        // 9. Optional에 들어있는 값 변환하기
        Optional<Integer> lengthOptional = optional1.map(String::length);
        lengthOptional.ifPresent(length -> System.out.println("Length: " + length));

        Optional<Optional<String>> nestedOptional = Optional.of(Optional.of("Nested Value"));
        nestedOptional.flatMap(Function.identity())
                      .ifPresent(nestedValue -> System.out.println("Nested value: " + nestedValue));
    }
}

이 예제는 다양한 Optional 메서드를 사용하는 방법을 보여줍니다. 각 메서드가 어떻게 동작하는지, 어떤 상황에서 사용해야 하는지 이해하는 데 도움이 될 것입니다.

[Java8] Optional을 사용할 때 주의해야 할 사항과 관련된 예제 소스

shoney9254 — Wed, 12 Jun 2024 22:35:42 +0900

Java 8에서 Optional을 사용할 때 주의해야 할 사항과 관련된 예제 소스

1. 리턴값으로만 쓰기를 권장한다

메소드의 매개변수 타입, 맵의 키 타입, 인스턴스 필드 타입으로 사용하지 않는 것이 좋습니다.

// 권장되지 않는 사용 예
public void process(Optional<String> input) {
    // ...
}

// 권장되는 사용 예
public Optional<String> process() {
    // ...
}

2. Optional을 리턴하는 메소드에서 null을 리턴하지 말자

Optional을 반환하는 메소드에서는 절대로 null을 반환하지 않도록 합니다.

// 잘못된 사용 예
public Optional<String> getValue() {
    return null; // 절대 이렇게 하지 말 것
}

// 올바른 사용 예
public Optional<String> getValue() {
    return Optional.ofNullable(null); // null일 경우 빈 Optional을 반환
}

3. 프리미티브 타입용 Optional이 따로 있다

프리미티브 타입을 위한 OptionalInt, OptionalLong 등을 사용합니다. (성능, 명확한 의도 표현)

// Optional 사용 예
public OptionalInt getOptionalInt() {
    int value = ...;
    return (value != -1) ? OptionalInt.of(value) : OptionalInt.empty();
}

OptionalInt, OptionalLong, ...

4. Collection, Map, Stream, Array, Optional을 Optional로 감싸지 말 것

Collection, Map, Stream, Array, Optional 타입을 다시 Optional로 감싸지 않도록 합니다.

// 잘못된 사용 예
public Optional<Optional<String>> getOptionalValue() {
    Optional<String> value = Optional.of("test");
    return Optional.of(value); // 이런 중첩은 피할 것
}

// 올바른 사용 예
public Optional<String> getOptionalValue() {
    return Optional.of("test");
}

종합 예제

위의 주의사항을 종합하여 하나의 클래스 예제로 보여드리겠습니다.

import java.util.Optional;
import java.util.OptionalInt;

public class OptionalExample {

    // 리턴값으로만 Optional 사용
    public Optional<String> findValue() {
        String value = null; // 비어있을 수 있는 값
        return Optional.ofNullable(value);
    }

    // null을 리턴하지 말고 Optional.empty() 사용
    public Optional<String> getValue() {
        String value = null;
        return (value != null) ? Optional.of(value) : Optional.empty();
    }

    // 프리미티브 타입용 Optional 사용
    public OptionalInt findOptionalInt() {
        int value = -1; // 기본값
        return (value != -1) ? OptionalInt.of(value) : OptionalInt.empty();
    }

    // Collection, Map, Stream, Array, Optional 타입을 Optional로 감싸지 말 것
    public Optional<String> getNestedOptional() {
        return Optional.of("test");
    }

    public static void main(String[] args) {
        OptionalExample example = new OptionalExample();

        // findValue 메서드 사용
        example.findValue().ifPresent(System.out::println);

        // getValue 메서드 사용
        example.getValue().ifPresent(System.out::println);

        // findOptionalInt 메서드 사용
        example.findOptionalInt().ifPresent(System.out::println);

        // getNestedOptional 메서드 사용
        example.getNestedOptional().ifPresent(System.out::println);
    }
}

이 예제 코드는 Optional을 올바르게 사용하는 방법을 보여줍니다. 메서드는 Optional을 리턴하지만, 메서드 매개변수나 클래스 필드로는 사용하지 않습니다. 또한 Optional을 리턴할 때 null을 리턴하지 않고, 프리미티브 타입용 Optional을 사용하며, 중첩 Optional을 사용하지 않습니다.

[React] JWT Util만들기, Axios 인터셉터 설정하기

shoney9254 — Mon, 8 Apr 2024 22:10:32 +0900

리액트 애플리케이션에서 JWT(JSON Web Token)을 활용하여 Axios를 호출하기 전에 액세스 토큰을 요청하여 사용할 수 있는 유틸리티를 만들어 보았습니다. 이를 통해 애플리케이션에서 보안적인 통신을 구현할 수 있게 되었습니다.

JWT Util로 Axios 인터셉터 설정하기

import axios from "axios";
import { getCookie, setCookie } from "./cookieUtil";
import { API_SERVER_HOST } from "../api/todoApi";

// Axios 인스턴스 생성
const jwtAxios = axios.create();

// JWT 갱신 함수
const refreshJWT = async (accessToken, refreshToken) => {
  const host = API_SERVER_HOST;
  const header = { headers: { Authorization: `Bearer ${accessToken}` } };
  const res = await axios.get(
    `${host}/api/member/refresh?refreshToken=${refreshToken}`,
    header
  );
  console.log(res.data);
  return res.data;
};

// 요청 전 처리
const beforeReq = (config) => {
  console.log("before request.............");

  const memberInfo = getCookie("member");
  if (!memberInfo) {
    console.log("Member NOT FOUND");
    return Promise.reject({
      response: {
        data: { error: "REQUIRE_LOGIN" },
      },
    });
  }
  const { accessToken } = memberInfo;
  config.headers.Authorization = `Bearer ${accessToken}`;
  return config;
};

// 실패한 요청 처리
const requestFail = (err) => {
  console.log("request error............");
  return Promise.reject(err);
};

// 응답 전 처리
const beforeRes = async (res) => {
  console.log("before return response...........");

  const data = res.data;

  if (data && data.error === "ERROR_ACCESS_TOKEN") {
    const memberCookieValue = getCookie("member");

    const result = await refreshJWT(
      memberCookieValue.accessToken,
      memberCookieValue.refreshToken
    );

    // 새로운 토큰으로 쿠키 갱신 필요
    memberCookieValue.accessToken = result.accessToken;
    memberCookieValue.refreshToken = result.refreshToken;
    setCookie("member", JSON.stringify(memberCookieValue), 1);

    // 새로운 액세스 토큰으로 원래 하려고 했던 작업을 다시 작업
    const originalRequest = res.config;
    originalRequest.headers.Authorization = `Bearer ${result.accessToken}`;

    return await axios(originalRequest);
  }
  return res;
};

// 실패한 응답 처리
const responseFail = (err) => {
  console.log("response fail error.............");
  return Promise.reject(err);
};

// Axios 인터셉터 설정
jwtAxios.interceptors.request.use(beforeReq, requestFail);
jwtAxios.interceptors.response.use(beforeRes, responseFail);

export default jwtAxios;

주요 포인트

Axios 인스턴스를 생성하여 JWT 관련 설정을 추가합니다.
요청 전, 응답 전, 실패한 요청, 실패한 응답에 대한 처리 함수를 정의하여 인터셉터에 추가합니다.
액세스 토큰이 만료된 경우, 리프레시 토큰을 사용하여 새로운 액세스 토큰을 요청하고 쿠키를 갱신합니다.

이제 위의 JWT Util을 사용하여 Axios를 호출하면, 보안적인 통신을 구현할 수 있게 됩니다. 사용자의 인증 및 권한을 효과적으로 관리하여 안전한 애플리케이션을 개발할 수 있습니다.

[Spring] JPA Query 메서드 DTO 바로 생성하기

shoney9254 — Sun, 7 Apr 2024 15:49:26 +0900

Spring Data JPA를 사용하여 데이터베이스에서 정보를 가져올 때 DTO(DTO: Data Transfer Object)를 사용하는 경우가 많습니다. DTO는 보통 데이터베이스의 엔티티(Entity)와 클라이언트 간의 데이터 전송을 위해 사용됩니다. 이 글에서는 Spring Data JPA에서 Query 메서드를 사용하여 DTO를 바로 생성하는 방법을 알아보겠습니다.

1. DTO 클래스 생성

DTO 클래스는 데이터 전송을 위한 객체입니다. 먼저 DTO 클래스를 생성해야 합니다. 예를 들어, 장바구니에 담긴 상품 정보를 전달하기 위한 CartItemListDto 클래스를 만들어봅시다.

package com.example.demo_mall.mallapi.dto;

public class CartItemListDto {
    private Long cino;
    private int qty;
    private String pname;
    private double price;
    private String fileName;

    // 생성자, 게터 및 세터 생략
}

2. Repository 인터페이스 작성

이제 DTO를 사용하여 데이터를 가져올 Repository 인터페이스를 작성합니다. 여기서는 CartItemRepository를 예로 들어 설명하겠습니다.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface CartItemRepository extends JpaRepository<CartItem, Long> {

    @Query("select " +
            "new com.example.demo_mall.mallapi.dto.CartItemListDto(ci.cino, ci.qty, p.pname, p.price, pi.fileName) " +
            "from CartItem ci " +
            "inner join Cart mc on ci.cart = mc  " +
            "left join Product p on ci.product = p " +
            "left join p.imageList pi " +
            "where mc.owner.id = :id " +
            "and pi.ord = 0 " +
            "order by ci.cino desc")
    List<CartItemListDto> getItemsOfCartDtoById(@Param("memberId") Long id);
}

위의 코드에서 @Query 어노테이션을 사용하여 직접 SQL 쿼리를 정의하고 있습니다. 그러나 여기서 특이한 점은 SQL 쿼리의 결과를 바로 CartItemListDto 객체로 매핑하고 있다는 것입니다.

3. Query 메서드 사용하기

Spring Data JPA에서는 Query 메서드를 사용하여 간단한 쿼리를 작성할 수 있습니다. 그러나 Query 메서드를 사용하여 DTO를 바로 생성하는 것은 조금 더 복잡합니다. 따라서 위와 같이 @Query 어노테이션을 사용하여 직접 SQL 쿼리를 작성하는 것이 필요합니다.

위의 예제에서는 getItemsOfCartDtoById 메서드를 통해 CartItemListDto 객체를 바로 생성하고 있습니다.

결론

이렇게 Spring Data JPA를 사용하여 Query 메서드를 통해 DTO를 바로 생성하는 방법을 알아보았습니다. DTO를 사용하여 데이터베이스에서 필요한 정보를 효율적으로 전달할 수 있습니다. 이를 통해 코드의 가독성과 유지 보수성을 향상시킬 수 있습니다.

[Spring] Security CSRF 비활성화 (6.1 버전 이상)

shoney9254 — Fri, 9 Feb 2024 22:43:19 +0900

0. 먼저 CSRF란?

CSRF(Cross-Site Request Forgery, 사이트 간 요청 위조)는 웹 보안 취약점 중 하나로, 사용자가 자신의 의지와는 무관하게 공격자가 조작한 요청을, 신뢰할 수 있는 사이트에 대해 보내도록 만드는 공격입니다. 이 공격은 사용자가 해당 사이트에 로그인한 상태에서 이루어지면, 사용자의 권한을 이용하여 악의적인 변경사항(예: 비밀번호 변경, 무단 게시물 작성 등)을 적용할 수 있습니다.

1. CSRF 비활성화 방법 (시큐리티 6.1버전 이상)

스프링 시큐리티 6버전부터는 보안 구성 방식에 몇 가지 변화가 있습니다. CSRF 보호를 비활성화하는 방법에도 변화가 있을 수 있으며, 새로운 방식을 적용해야 할 필요가 있습니다. 스프링 시큐리티 6버전에서 CSRF 보호를 비활성화하는 방식은 다음과 같습니다:

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.Customizer;

@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // CSRF 비활성화
            .authorizeHttpRequests(auth -> auth
                .anyRequest().permitAll()
            );

        return http.build();
    }
}

이 예제에서는 .csrf(csrf -> csrf.disable()) 구문을 사용하여 CSRF 보호를 비활성화하고 있습니다. 이는 스프링 시큐리티 6버전에서 도입된 새로운 구성 방식을 반영한 것으로, 보다 선언적이고 람다 기반의 구성 방식을 사용하여 보안 구성을 더욱 간결하고 읽기 쉽게 만듭니다.

스프링 시큐리티 6버전에서의 변경사항을 적용할 때는 공식 문서를 참조하는 것이 좋습니다. 스프링 프로젝트와 스프링 시큐리티 프로젝트의 문서는 항상 최신 기능과 변화된 사항을 상세히 설명하고 있으며, 보안 구성의 최선의 방법을 제시합니다.

[Spring] @RestControllerAdvice 사용해서 Controller 예외처리

shoney9254 — Fri, 9 Feb 2024 21:15:06 +0900

1. @RestControllerAdvice 사용해서 Controller 예외처리

@RestControllerAdvice 어노테이션은 Spring Framework에서 예외 처리를 위해 사용되는 특별한 클래스에 붙이는 어노테이션입니다. 이 어노테이션을 사용하면 전역에서 발생할 수 있는 예외를 캡처하고, 공통된 예외 처리 로직을 적용하여 API 응답을 일관성 있게 관리할 수 있습니다. @RestControllerAdvice는 @ControllerAdvice에 @ResponseBody가 추가된 형태로, REST API 개발 시 JSON 등의 응답 바디를 직접 제어할 수 있게 해줍니다.

1-1. 동작 방식

Spring의 AOP(Aspect-Oriented Programming)를 이용하여, 애플리케이션의 컨트롤러 계층에서 발생하는 예외를 잡아낸 후, 지정된 예외 처리 로직에 따라 처리합니다.
@ExceptionHandler 어노테이션을 사용하여 특정 예외를 처리하는 메서드를 정의할 수 있습니다.
@RestControllerAdvice 어노테이션을 사용한 클래스는 애플리케이션 전역에서 발생하는 예외를 처리할 수 있는 공통의 예외 처리기 역할을 합니다.
예외 처리 메서드는 예외 유형별로 다르게 정의할 수 있으며, 예외 발생 시 적절한 HTTP 상태 코드와 메시지를 응답으로 반환할 수 있습니다.

1-2. 전역 예외 처리기 구현

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.http.ResponseEntity;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    public ResponseEntity<String> handleGenericException(Exception e) {
        // 모든 예외를 처리하고 500 Internal Server Error 반환
        return ResponseEntity
                .status(500)
                .body("Internal Server Error: " + e.getMessage());
    }

    @ExceptionHandler(value = NullPointerException.class)
    public ResponseEntity<String> handleNullPointerException(NullPointerException e) {
        // NullPointerException을 처리하고 400 Bad Request 반환
        return ResponseEntity
                .status(400)
                .body("Null Pointer Exception: " + e.getMessage());
    }

    @ExceptionHandler(value = CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException e) {
        // 사용자 정의 예외 처리
        return ResponseEntity
                .status(e.getStatusCode())
                .body("Custom Error: " + e.getMessage());
    }
}

이 예시에서는 세 가지 예외 처리 메서드를 정의하고 있습니다:

Exception.class에 대한 처리: 모든 종류의 예외를 처리하며, HTTP 상태 코드 500을 반환합니다.
NullPointerException.class에 대한 처리: NullPointerException을 처리하며, HTTP 상태 코드 400을 반환합니다.
CustomException.class에 대한 처리: 사용자 정의 예외를 처리하며, 예외에 설정된 상태 코드와 메시지를 반환합니다.

@RestControllerAdvice를 사용함으로써 애플리케이션 전역에서 발생하는 예외를 효과적으로 관리할 수 있으며, API 응답의 일관성을 유지할 수 있습니다.

2. 상속 관계에서의 예외처리는 어떻게 되는 것일까?

Spring에서는 예외 처리 시 클래스 간의 상속 관계를 고려하여 더 구체적인 예외, 즉 자식 예외 클래스에 대한 처리기(**@ExceptionHandler**가 붙은 메서드)가 있을 경우, 그 처리기를 우선적으로 사용합니다. 이는 예외가 발생했을 때 더 세밀한 예외 처리를 가능하게 합니다.

예를 들어, **NullPointerException**이 **RuntimeException**의 자식 클래스인 경우, 두 예외 모두를 처리할 수 있는 **@ExceptionHandler**가 있다면 **NullPointerException**에 대한 처리기가 우선적으로 호출됩니다. 만약 해당하는 구체적인 예외를 처리하는 **@ExceptionHandler**가 없다면, 상위 클래스를 처리하는 **@ExceptionHandler**가 대신 호출됩니다.

이러한 방식은 예외를 더 정확하게 처리하고, 다양한 예외 상황에 대해 더 상세한 응답을 제공하는 데 유용합니다. 예외 클래스의 상속 구조를 이해하고 올바르게 활용하면, 예외 처리 로직을 효과적으로 구성할 수 있습니다.

2-1. 상속 관계에서의 예시

아래는 상속 관계에 있는 예외를 처리하는 간단한 예시입니다. 이 예시에서는 RuntimeException과 그 자식 예외인 ArithmeticException을 처리하는 방법을 보여줍니다. ArithmeticException이 발생하면, 더 구체적인 예외 처리기인 handleArithmeticException 메서드가 호출되며, RuntimeException이나 그 외의 자식 예외들이 발생할 경우 handleRuntimeException 메서드가 호출됩니다.

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.http.ResponseEntity;

@RestControllerAdvice
public class ExceptionHandlingController {

    // ArithmeticException 처리
    @ExceptionHandler(ArithmeticException.class)
    public ResponseEntity<String> handleArithmeticException(ArithmeticException e) {
        return ResponseEntity
                .badRequest()
                .body("Arithmetic Exception Occurred: " + e.getMessage());
    }

    // RuntimeException 및 그 자식들 처리 (ArithmeticException 제외)
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException e) {
        return ResponseEntity
                .status(500)
                .body("Runtime Exception Occurred: " + e.getMessage());
    }
}

이 예시에서는 다음과 같은 작동 방식을 확인할 수 있습니다:

ArithmeticException 발생 시: handleArithmeticException 메서드가 호출되어 HTTP 상태 코드 400(Bad Request)과 함께 "Arithmetic Exception Occurred: [에러 메시지]"라는 응답 바디를 반환합니다.
ArithmeticException 이외의 RuntimeException 발생 시: handleRuntimeException 메서드가 호출되어 HTTP 상태 코드 500(Internal Server Error)과 함께 "Runtime Exception Occurred: [에러 메시지]"라는 응답 바디를 반환합니다.

이 방식을 통해 애플리케이션에서 발생할 수 있는 다양한 예외 상황에 대해 더 세분화된 예외 처리를 구현할 수 있으며, 예외의 유형에 따라 적절한 응답을 제공할 수 있습니다.

[Spring] @SuperBuilder 의 특징과 간단한 예제

shoney9254 — Fri, 9 Feb 2024 16:53:22 +0900

@SuperBuilder 의 특징과 간단한 예제

@SuperBuilder는 Project Lombok 라이브러리의 어노테이션 중 하나로, 상속 구조를 가진 클래스에서 빌더 패턴을 쉽게 사용할 수 있게 해줍니다. 일반적인 @Builder 어노테이션과 달리 @SuperBuilder는 부모 클래스와 자식 클래스 간의 상속 관계를 고려하여 빌더를 생성합니다. 이를 통해 각 클래스의 필드를 초기화하는 데 필요한 빌더 메소드를 자동으로 생성해줍니다.

1. @SuperBuilder의 장점

상속 구조 지원: 상속 구조에서도 빌더 패턴을 쉽게 구현할 수 있게 해줍니다. 부모 클래스의 필드와 자식 클래스의 필드를 모두 한 번에 설정할 수 있는 빌더 클래스를 생성합니다.
타입 안전성: 빌더 패턴을 사용함으로써 객체를 생성할 때 타입 안전성을 보장받을 수 있습니다. 필요한 필드에 대한 값을 메소드 체이닝 방식으로 설정하기 때문에, 컴파일 타임에 타입 체크가 가능합니다.
가독성 향상: 객체 생성 시 생성자에 여러 매개변수를 전달하는 대신, 메소드 체이닝을 통해 필요한 필드만을 명시적으로 설정할 수 있습니다. 이는 코드의 가독성을 크게 향상시킵니다.
불변 객체 생성 용이: 빌더 패턴은 불변 객체(Immutable Objects)를 생성하기에 적합한 패턴입니다. 객체 생성 후 상태를 변경할 필요가 없는 경우, 빌더를 통해 불변 객체를 손쉽게 생성할 수 있습니다.

2. @SuperBuilder 예제

부모 클래스 Vehicle과 이를 상속받는 자식 클래스 Car가 있다고 가정해보겠습니다. @SuperBuilder를 사용하여 빌더 패턴을 적용하는 예제 코드는 다음과 같습니다.

2-1. 부모 클래스 (Vehicle.java)

import lombok.experimental.SuperBuilder;

@SuperBuilder
public class Vehicle {
    private String brand;
    private String model;
}

2-2. 자식 클래스 (Car.java)

import lombok.experimental.SuperBuilder;

@SuperBuilder
public class Car extends Vehicle {
    private int seats;
    private boolean sportsCar;
}

2-3. 객체 생성 예제

public class Main {
    public static void main(String[] args) {
        Car car = Car.builder()
                      .brand("Toyota")
                      .model("Supra")
                      .seats(2)
                      .sportsCar(true)
                      .build();

        System.out.println(car);
    }
}

이 예제에서는 @SuperBuilder를 사용하여 Vehicle 클래스와 Car 클래스에 대한 빌더를 생성했습니다. Car 객체를 생성할 때 Car.builder() 메소드를 사용하여 부모 클래스인 Vehicle의 필드(brand, model)와 Car의 필드(seats, sportsCar)를 모두 설정할 수 있습니다. 이렇게 @SuperBuilder를 사용하면, 상속 구조에서도 각 클래스의 필드를 쉽게 설정하며 객체를 생성할 수 있습니다.

[Spring] DTO 간 복사(BeanUtils, ModelMapper커스텀 하는방법 포함)

shoney9254 — Fri, 9 Feb 2024 13:18:24 +0900

DTO 간 복사

Spring에서 DTO 간 변수를 복사하는 경우, 주로 BeanUtils.copyProperties 메소드를 사용하거나 ModelMapper 라이브러리를 활용할 수 있습니다. 아래에 두 방법을 사용하는 예시를 제시하겠습니다.

1. BeanUtils 사용하기

BeanUtils.copyProperties 메소드는 스프링 프레임워크에 포함된 유틸리티 메소드로서, 한 객체의 프로퍼티 값을 다른 객체로 복사하는 데 사용됩니다. 이 방법은 추가적인 라이브러리를 필요로 하지 않으며, Spring Framework에 기본적으로 포함되어 있습니다.

import org.springframework.beans.BeanUtils;

// Source DTO
public class SourceDto {
    private String name;
    private int age;
    // getters and setters
}

// Target DTO
public class TargetDto {
    private String name;
    private int age;
    // getters and setters
}

SourceDto source = new SourceDto();
// source 객체 초기화

TargetDto target = new TargetDto();
BeanUtils.copyProperties(source, target);

2. ModelMapper 사용하기

ModelMapper는 더 복잡한 매핑이 필요할 때 유용하며, 객체 간의 데이터 매핑을 보다 세밀하게 제어할 수 있습니다. 이 라이브러리는 별도로 추가해야 합니다. ModelMapper를 사용하면 복잡한 매핑 규칙도 쉽게 정의할 수 있습니다.

<!-- pom.xml -->
<dependency>
    <groupId>org.modelmapper</groupId>
    <artifactId>modelmapper</artifactId>
    <version>2.3.8</version>
</dependency>

import org.modelmapper.ModelMapper;

// Source DTO
public class SourceDto {
    private String name;
    private int age;
    // getters and setters
}

// Target DTO
public class TargetDto {
    private String name;
    private int age;
    // getters and setters
}

ModelMapper modelMapper = new ModelMapper();
SourceDto source = new SourceDto();
// source 객체 초기화

TargetDto target = modelMapper.map(source, TargetDto.class);

ModelMapper는 좀 더 복잡한 변환 작업에 유리하며, 자동 매핑 외에도 맞춤 매핑 전략을 정의할 수 있습니다. BeanUtils에 비해 세밀한 제어가 가능하지만, 성능면에서는 BeanUtils가 더 빠를 수 있습니다. 따라서 상황에 맞게 선택하여 사용하시면 됩니다.

3. ModelMapper 커스텀 하는 예시

ModelMapper는 복잡한 변환 작업에 유리한 여러 가지 이유가 있는데, 그 중 하나는 객체 간의 필드 이름이 다르거나, 변환 로직이 필요할 때 보다 유연하게 대응할 수 있다는 점입니다. 예를 들어, 한 객체의 필드를 다른 객체의 여러 필드로 나누거나, 반대로 여러 필드를 하나로 합치는 등의 작업을 ModelMapper를 사용하여 쉽게 처리할 수 있습니다.

아래 예시에서는 ModelMapper를 사용하여 서로 다른 필드 이름을 매핑하고, 특정 필드에 대해 커스텀 변환 로직을 적용하는 방법을 보여줍니다.

3-1. Source DTO

public class SourceDto {
    private String fullName; // TargetDto에서는 firstName과 lastName으로 나누어져 있음
    private String email;
    private String joinDate; // String 형식, TargetDto에서는 LocalDate 형식으로 변환 필요
    // getters and setters
}

3-2. Target DTO

public class TargetDto {
    private String firstName;
    private String lastName;
    private String email;
    private LocalDate joinDate; // SourceDto에서는 String 형식, 여기서는 LocalDate로 변환
    // getters and setters
}

3-3. ModelMapper 설정 및 사용

import org.modelmapper.ModelMapper;
import org.modelmapper.PropertyMap;
import org.modelmapper.Converter;
import org.modelmapper.spi.MappingContext;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

ModelMapper modelMapper = new ModelMapper();

// fullName을 firstName과 lastName으로 나누는 커스텀 매핑
modelMapper.addMappings(new PropertyMap<SourceDto, TargetDto>() {
    @Override
    protected void configure() {
        map().setEmail(source.getEmail());
        using((Converter<String, String>) context -> context.getSource().split(" ")[0]).map(source.getFullName(), destination.getFirstName());
        using((Converter<String, String>) context -> context.getSource().split(" ").length > 1 ? context.getSource().split(" ")[1] : null).map(source.getFullName(), destination.getLastName());
        // joinDate 변환
        using(new Converter<String, LocalDate>() {
            @Override
            public LocalDate convert(MappingContext<String, LocalDate> context) {
                return LocalDate.parse(context.getSource(), DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            }
        }).map(source.getJoinDate(), destination.getJoinDate());
    }
});

SourceDto source = new SourceDto();
// source 객체 초기화

TargetDto target = modelMapper.map(source, TargetDto.class);

이 예시에서는 ModelMapper의 addMappings 메소드를 사용하여 커스텀 매핑을 정의했습니다. fullName을 firstName과 lastName으로 나누는 로직과 joinDate를 String에서 LocalDate로 변환하는 로직을 구현했습니다. 이처럼 ModelMapper는 필드 이름이 다르거나, 특정 필드에 대한 변환 로직이 필요할 때 유연하게 대응할 수 있는 강력한 도구입니다.

[Spring] 시큐리티 예외 처리와 사용자 인증 (시큐리티6 이상)

shoney9254 — Tue, 30 Jan 2024 17:56:44 +0900

스프링 시큐리티는 애플리케이션의 보안을 강화하고, 다양한 상황에서의 인증 및 권한 부여를 관리합니다. 오늘은 스프링 시큐리티의 exceptionHandling() 메서드를 활용한 예외 처리 방법과 사용자 인증 과정에 대해 알아보겠습니다.

예외 처리 설정 (exceptionHandling())

스프링 시큐리티에서 예외 처리는 보안 관련 예외가 발생했을 때 적절한 대응을 할 수 있도록 돕습니다. 대표적으로 두 가지 핸들러를 설정할 수 있습니다.

1. AuthenticationEntryPoint (인증 진입점)

.exceptionHandling(xh -> xh
    .authenticationEntryPoint(new AuthenticationEntryPoint() {
        @Override
        public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
            response.sendRedirect("/login");
        }
    })
)

인증되지 않은 사용자가 보호된 리소스에 접근하려 할 때 실행됩니다.
예를 들어, 로그인하지 않은 사용자가 로그인이 필요한 페이지에 접근하려고 시도할 때, 로그인 페이지로 리다이렉트합니다.

2. AccessDeniedHandler (접근 거부 핸들러)

.exceptionHandling(xh -> xh
    .accessDeniedHandler(new AccessDeniedHandler() {
        @Override
        public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
            response.sendRedirect("/denied");
        }
    })
)

사용자가 필요한 권한 없이 보호된 리소스에 접근하려 할 때 실행됩니다.
예를 들어, 일반 사용자가 관리자 페이지에 접근하려고 시도할 때, 접근 거부 페이지로 리다이렉트합니다.

이러한 예외 처리 설정을 통해, 애플리케이션의 보안을 강화하고 사용자에게 적절한 피드백을 제공할 수 있습니다.

3. 로그인 성공 핸들러 (AuthenticationSuccessHandler)

.formLogin(f -> f
    .successHandler(new AuthenticationSuccessHandler() {
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
            RequestCache requestCache = new HttpSessionRequestCache();
            SavedRequest savedRequest = requestCache.getRequest(request, response);
            String redirectUrl = savedRequest.getRedirectUrl();
            response.sendRedirect(redirectUrl);
        }
    })
)

사용자가 성공적으로 로그인한 후 실행되는 로직을 정의합니다.
사용자가 원래 요청했던 URL로 리다이렉트하는 기능을 구현할 수 있습니다.

이러한 설정을 통해 사용자 인증 과정을 보다 유연하게 관리하고, 사용자 경험을 개선할 수 있습니다.

스프링 시큐리티의 이러한 기능들은 애플리케이션의 보안을 강화하는 데 핵심적인 역할을 합니다. 코드의 각 부분이 어떻게 작동하는지 이해하고 적절히 활용한다면, 보다 안전하고 사용자 친화적인 웹 애플리

[Feasibility Study] 타당성 조사란

shoney9254 — Tue, 30 Jan 2024 13:00:45 +0900

타당성 조사(Feasibility Study)에 대한 블로그 글

타당성 조사란 무엇인가요?

타당성 조사는 새로운 프로젝트, 제품, 서비스 등을 시작하기 전에 그 실현 가능성과 경제적 타당성을 평가하는 중요한 과정입니다. 이 과정을 통해 프로젝트의 성공 가능성을 높이고, 실패 위험을 최소화할 수 있습니다.

타당성 조사의 주요 요소

시장 타당성: 시장의 수요, 경쟁 상황 분석을 통해 제품이나 서비스의 시장 내 성공 가능성을 평가합니다.
기술적 타당성: 프로젝트나 제품이 기술적으로 실행 가능한지를 평가합니다. 여기에는 필요한 기술, 자원, 전문 지식 등이 포함됩니다.
경제적 타당성: 비용과 예상 수익을 비교하여 프로젝트나 제품의 경제적 수익성을 분석합니다.
법적 및 규제적 타당성: 프로젝트나 제품이 관련 법률 및 규정을 준수하는지 평가합니다.
조직적 타당성: 프로젝트가 조직의 목표와 전략에 부합하며 조직 내에서 실행 가능한지를 평가합니다.

타당성 조사의 중요성

타당성 조사는 프로젝트나 사업의 성공 가능성을 높이고, 실패 위험을 최소화하기 위해 필수적인 과정입니다. 충분한 조사와 분석을 통해 투자의 위험을 줄이고, 보다 효과적인 의사결정을 할 수 있게 됩니다.

[Spring] Security 6 버전 인메모리 사용자 설정 간단한 예제

shoney9254 — Tue, 30 Jan 2024 12:41:15 +0900

권한 설정과 표현식

Spring Security 5에서는 **AuthenticationManagerBuilder**를 사용하여 메모리 인증을 설정할 수 있었지만, Spring Security 6에서는 몇 가지 변경이 있을 수 있습니다.

1. PassworEncoder 사용 필수

먼저, Spring Security 6에서는 비밀번호 암호화에 대한 설정이 강화되었으므로 **{noop}**을 사용하는 것이 더 이상 권장되지 않습니다. 대신에 비밀번호 인코더를 명시적으로 지정해야 합니다. 그래서 아래와 같이 PasswordEncoder를 빈으로 등록하는 소스코드를 먼저 작성합니다.

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

2. inMemoryAuthentication 사용해서 메모리 인증 설정

아래는 Spring Security 6에 대한 예제입니다. 여기서는 **PasswordEncoder**를 사용하여 비밀번호를 인코딩하고 **inMemoryAuthentication**을 통해 사용자를 설정합니다.

@Primary
@Bean
public AuthenticationManagerBuilder configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
    auth.inMemoryAuthentication().withUser("user1").password(passwordEncoder().encode("1111")).roles("USER")
            .and().withUser("sys").password(passwordEncoder().encode("1111")).roles("SYS", "USER")
            .and().withUser("admin").password(passwordEncoder().encode("1111")).roles("ADMIN", "SYS", "USER");
    return auth;
}

AuthenticationManagerBuilder를 사용하여 세 가지 유형의 사용자 - 일반 사용자(USER), 시스템 관리자(SYS), 그리고 최고 관리자(ADMIN) - 를 설정합니다.
패스워드는 인코드 사용해야합니다. (시큐리티6 이상부터 필수)
user에 roles를 통해 역할을 부여합니다.

3. url과 권한 Matcher

다음으로, HTTP 요청에 대한 보안을 설정합니다. HttpSecurity 객체를 사용하여 다양한 HTTP 경로에 대한 접근 제어를 설정할 수 있습니다.

스프링 시큐리티 5에서는 antMatchers를 사용해서 권한설정을 했다면, 6버전 이상부터는 requestMatchers 를 사용해서 url의 권한을 매칭할 수 있습니다.

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
            .authorizeHttpRequests(ar -> ar
                    .requestMatchers("/user").hasRole("USER")
                    .requestMatchers("/admin/pay").hasRole("ADMIN")  // 더 구체적인 범위가 위에 나와야합니다.
                    .requestMatchers("/admin/**").hasAnyRole("ADMIN", "SYS") // 6.0 이하 버전에서는 antMatchers("/admin/**").access("hasRole('ADMIN') or hasRole('SYS')")
                    .anyRequest()
                    .authenticated()
            )
            .formLogin(withDefaults())
            .build();
}

더 구체적인 범위가 위에 나와야지 세부 권한을 적용 할 수 있습니다.
이 설정에서는 /user 경로는 USER 역할을 가진 사용자만, **/admin/pay**는 ADMIN 역할을 가진 사용자만 접근할 수 있습니다. /admin/** 경로는 ADMIN 또는 SYS 역할을 가진 사용자가 접근할 수 있습니다. 그리고 모든 요청은 인증을 필요로 합니다.

Spring Security를 이용하면 몇 가지 간단한 설정만으로도 강력한 인증 및 권한 관리 시스템을 구현할 수 있습니다. 이 글이 Spring Security의 기본적인 사용 방법을 이해하는 데 도움이 되길 바랍니다.

[Swagger] Spring 3.0 이상 버전에서 스웨거 적용하는 방법

shoney9254 — Mon, 29 Jan 2024 20:24:17 +0900

0. 기존 SpringFox로 설치할 경우 발생하는 문제

기존 방법대로 springfox 스웨거를 implementaion하면 에러가 발생합니다.

기존 방식

implementation 'io.springfox:springfox-swagger2:2.9.2'
implementation 'io.springfox:springfox-swagger-ui:2.9.2'

기존 방식대로 했을 경우 아래와 같은 에러가 발생하는 것을 확인 할 수 있습니다.

print 결과

Action:

Correct the classpath of your application so that it contains compatible versions of the classes org.springframework.plugin.core.support.AbstractTypeAwareSupport$BeansOfTypeTargetSource and org.springframework.util.Assert

더 이상 3.0 버전 이상에서는 Springfox로 설치가 어려워졌습니다.

1. 해결방법

implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'

이제는 그래들 빌드만 해주면, 알아서 스웨거 UI에서 볼수 있게 변경됐습니다.

의존하고 그래들 빌드 한번만 해주면 설정 끝

2. 결과

http://localhost:8080/swagger-ui/index.html#/

[EC2] mysql 설치시 conflicting requests 발생 해결방법

shoney9254 — Mon, 29 Jan 2024 17:29:09 +0900

0. 문제 상황

EC2: Amazon Linux 2023 환경에서 mysql을 설치하려고 하니

에러문구

Error:

Problem: conflicting requests

이라는 문구와 함께 아래처럼 에러가 발생했습니다.

1. 해결방법

지원하지 않는 버전의 설치를 진행했기 때문입니다.

아래의 명령어로 다시 설치 진행해보시면 정상 진행됩니다.

해결방법

sudo dnf install https://dev.mysql.com/get/mysql80-community-release-el9-1.noarch.rpm
sudo dnf install mysql-community-server

[Spring] Access-Control-Allow-Origin header is present 해결방법

shoney9254 — Sat, 27 Jan 2024 22:46:41 +0900

"Access-Control-Allow-Origin" 헤더가 브라우저에서 발생하는 보안 정책 중 하나입니다.

이 헤더는 웹 페이지가 다른 도메인에서 리소스를 요청할 때 CORS(Cross-Origin Resource Sharing) 정책을 적용하도록 브라우저에 지시합니다.

로컬 테스트 서버에서 이 에러가 발생한다면, 보통은 서버 측에서 CORS를 허용하지 않아서 발생합니다.

해결하기 위해서는 서버에서 CORS 정책을 설정해야 합니다. Spring Boot에서는 아래와 같은 방법들로 해결할 수 있습니다.

Spring Boot에서 CORS를 허용하려면 다음과 같이 설정할 수 있습니다.

application.yml 설정
@CrossOrigin 애노테이션 사용

1. application 설정

예를 들어, 모든 요청에 대해 CORS를 허용하려면 Spring Boot의 설정 파일인 application.properties 또는 application.yml에 다음과 같이 추가합니다:

application.properties:

spring.mvc.cors.allowed-origins=*

application.yml:

spring:
  mvc:
    cors:
      allowed-origins: "*"

위 설정은 모든 요청에 대해 모든 Origin을 허용합니다. 실제 환경에서는 보안 상의 이유로 '*'를 사용하는 것보다는 특정 Origin을 명시하는 것이 좋습니다.

2. @CrossOrigin 애노테이션을 사용

가장 간단한 방법은 @CrossOrigin 애노테이션을 사용하는 것입니다. 이를 이용하면 특정 컨트롤러나 메소드에 대해 CORS 정책을 설정할 수 있습니다.

또는 특정 컨트롤러나 메소드에 대해 CORS를 허용하려면 다음과 같이 @CrossOrigin 애노테이션을 사용합니다:

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PostController {

    @CrossOrigin(origins = "<http://localhost:3000>") // 허용할 Origin을 명시
    @GetMapping("/api/posts")
    public List<Post> getPosts() {
        // 게시물을 반환하는 로직
    }
}

위의 예제에서는 /api/posts 엔드포인트에 대해 localhost:3000 Origin에서의 요청을 허용합니다. 이렇게 하면 해당 Origin에서의 요청은 CORS 에러가 발생하지 않습니다.

실제 프로덕션 환경에서는 보안을 고려하여 필요한 Origin만 허용하도록 설정하는 것이 좋습니다.

[Spring] 시큐리티 Security Form Login 인증 기본 설정 (스프링 3.0 버전 이상, 시큐리티 6.0 버전 이상, WebSecurityConfigurerAdapter 대체)

shoney9254 — Wed, 10 Jan 2024 13:56:17 +0900

websecurityconfigureradapter 대체되는 방식으로 form login을 사용하는 기본 예제를 알려드립니다.

스프링 3.0 이상 버전은 스프링 시큐리티 6.0 버전 이상만 사용가능하게 되면서, 기존의 방식으로는 사용불가능합니다.

스프링 3.0 버전 이상부터는 websecurityconfigureradapter deprecated 됨에 따라서,

@Bean을 사용하고 SecurityFilterChain를 리턴하는 함수로 사용해야합니다.

해당 함수는 아래 예제들에서 자세히 설명드리겠습니다.

1. Form Login 인증

아래 예제를 통해서 어떻게 동작하는지 살펴보도록 하겠습니다.

1-1. formLogin 기본적인 내용 입력하기

@Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
                .authorizeHttpRequests(ar -> ar
                        .anyRequest()
                        .authenticated()
                )
                .formLogin(form -> form
                        .loginPage("/loginPage")
                        .defaultSuccessUrl("/members")
                        .failureUrl("/login.html?error=true")
                        .usernameParameter("userid")
                        .passwordParameter("passwd")
                        .loginProcessingUrl("/login_page")
                        .permitAll()
                )
                .build();
    }

- loginPage : 로그인 화면의 url을 설정합니다. (시작 화면으로 지정됩니다.

- defaultSuccessUrl : 로그인이 성공할 경우, 이동하게 되는 디폴트 url을 지정할 수 있습니다.

- failureUrl : 실패시 이동하는 url 설정

- usernameParameter : 웹의 username의 파라이름을 설정 (아래 캡처 참조)

- passwordParameter : 웹의 password의 파라이름을 설정 (아래 캡처 참조)

- loginProcessingUrl : 웹 로그인창의 action 설정 (아래 캡처 참조)

1-2. 핸들러 사용하는 방법

성공 또는 실패할 경우 핸들러를 사용해서 원하는 것들을 실행할 수 있습니다.

아래 예제를 통해서 확인해봅시다.

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
            .authorizeHttpRequests(ar -> ar
                    .anyRequest()
                    .authenticated()
            )
            .formLogin(form -> form
                    .loginPage("/loginPage")
                    .defaultSuccessUrl("/members")
                    .failureUrl("/login.html?error=true")
                    .usernameParameter("userid")
                    .passwordParameter("passwd")
                    .loginProcessingUrl("/login_page")
                    .successHandler(new AuthenticationSuccessHandler() {
                        @Override
                        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
                            System.out.println("authentication :" + authentication.getName());
                            response.sendRedirect("/");
                        }
                    })
                    .failureHandler(new AuthenticationFailureHandler() {
                        @Override
                        public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
                            System.out.println("exception :" + exception.getMessage());
                            response.sendRedirect("/login");
                        }
                    })
                    .permitAll()
            )
            .build();
}

1-1 에서 사용했던 내용과 핸들러가 같이 사용되는 경우는 핸들러의 소스코드를 우선순위가 높게 실행됩니다.

- successHandler : AuthenticationSuccessHandler로 익명 메서드를 만들어서 사용했습니다. response.sendRedirect를 통해서 성공 시 이동하는 url를 입력할 수 있습니다.

- failureHandler : AuthenticationFailureHandler로 익명 메서드를 만들어서 사용했습니다.response.sendRedirect를 통해서 성공 시 이동하는 url를 입력할 수 있습니다.

핸들러 실행결과 로그

- successHandler

- failureHandler

[Spring] 시큐리티 Security 의존성 추가 방법

shoney9254 — Wed, 10 Jan 2024 11:51:57 +0900

1. 의존성 추가

1-1. build.gradle에 의존성 추가

dependencies{
implementation 'org.springframework.boot:spring-boot-starter-security'
}

가장 먼저 해야할 것은 의존성을 추가하는 것입니다.

의존성을 추가하고, 스프링을 실행하게 되면 아래와 같이 패스워드를 제공해주는 로그를 확인 할 수 있습니다.

1-2. 정상적으로 의존 됐는지 확인하는 방법

그리고 크롬으로 localhost:8080/ 을 접속해보면 아래와 같이 로그인 창으로 바로 접속되는 것을 확인 할 수 있습니다.

id는 user, password는 위에서 공유된 내용을 입력하면 본인이 만든 api를 사용할 수 있습니다.

2. 사용자 정의 보안 기능 구현

2-1. appilcation.yml 에서 name, password 지정하는 방법

spring:
  security:
    user:
      name: user
      password: 1111

이렇게 설정하면 Id, password를 지정한 아이디와 패스워드로 사용할 수 있게 됩니다.

2-2. 기본 Config 작성

SecurityConfig.java를 아래와 같이 작성해서 기본적인 Config 설정을 할 수 있습니다.

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().authenticated();
        http
                .formLogin();
        return http.build();
    }
}

[Spring] mybatis에서 카멜케이스로 자동 변환 옵션(application.yml)

shoney9254 — Mon, 8 Jan 2024 14:13:39 +0900

1 사용해야하는 이유

보통 디비에서는 스네이크 표기법 credit_limit

자바에서는 카멜케이스 표기법 creditLimit

이런식으로 자주 사용하게 되는데

Mybatis에서 아무런 설정을 하지 않으면, 아래 처럼 select 문에 alias를 사용해서 직접 매핑해줘야한다.

select
credit_limit as 'creaditLimit'
from customer

하지만, 몇개 변수라면 상관없지만 무수히 많은 변수가 존재한다면 정말 귀찮은 일이다.

2 . 설정 방법

application.yml에서 옵션으로 쉽게 변경가능하다.

mybatis:
  configuration:
    map-underscore-to-camel-case: true #db는 스네이트 표기법, dto는 카멜케이스 사용 시

다른 블로그에서는 뭐 이런저런 설정을 하던데, 사실 이렇게 쉬운 방법이 존재한다.

아래처럼 이렇게만 사용해도 dto의 creditLimit 변수에 값이 들어오는 것을 확인 할 수있다.

select
credit_limit
from customer

3. 결과

아래처럼 dto는 카멜케이스이고, 쿼리는 *로 전체 변수를 가저온다고 할 때

Customer DTO

마이바티스 쿼리문

정상적으로 출력됨을 확인

[mySql] 공식 샘플 데이터 (Example Database)

shoney9254 — Mon, 8 Jan 2024 13:58:13 +0900

0. 필요성

안녕하세요. 사이드 프로젝트를 진행하다가 보면, 데이터들이 많이 필요합니다.

저는 주로 mySql로 사이드 프로젝트를 진행하는데요.

백엔드 사이드 프로젝트에서 데이터를 만드는 일이 쉬운일이 아닙니다.

엔터티간의 관계도 생각해야하고, 테이블을 생성하게 되면 데이터도 다 넣어야하고...

그럴 때는 mySql 공식 홈페이지에서 제공하는 Sample 데이터를 사용하면 매우 용이합니다.

1. mySql 샘플 데이터 링크

https://dev.mysql.com/doc/index-other.html

MySQL :: Other MySQL Documentation

Other MySQL Documentation This page provides additional documentation. There's even more available on these extra pages: MySQL Server Doxygen Documentation Title HTML Online MySQL Server (latest version) View Expert Guides Language Title Version HTML Onlin

dev.mysql.com

위 링크로 들어가시면 됩니다.

2. 사용 방법

아래에 보면 데이터 베이스를 선택할 수 있습니다.

본인이 구현할 프로젝트와 가장 유사한 데이터베이스를 zip으로 다운 받으시면, sql문이 들어가 있습니다.

[Error] No serializer found for class 해결방법

shoney9254 — Fri, 5 Jan 2024 16:23:36 +0900

0. 현상

cohttp://m.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class

아래 캡쳐로 내가 responsebody로 리턴할 클래스가 없다는 표현이 나오는 에러가 발생했다.

1. 원인

- Controller에서 @ResponseBody를 사용해서 json으로 리턴하는 방식으로 구현했는데, @ResponseBody에서 객체를 json으로 변환하려면 객체의 클래스에 Getter가 존재해야한다.

- Setter만 필요해 보였던 클래스라서 Getter를 따로 입력하지 않았는데, 그게 문제가 된 것 같다.

2. 해결방법

2-1. @Getter 추가

- 일반적인 방법은 Getter를 추가하면 됩니다.

- @ResponsBody에서 객체를 Json으로 변환 할 때, Getter를 사용해서 가져오는게 일반적입니다.

2-2. @JsonAutoDetect 추가

- Getter를 사용하기 싫을 때는 JsonAutoDetect를 사용해서 사용하면됩니다.

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)

본인 프로젝트 상황에 맞게 @Getter 또는 @JsonAutoDetect를 사용해서 해결하시면 될것 같습니다.

[IntelliJ] Database에서 DTO/VO 자동 생성 방법

shoney9254 — Thu, 4 Jan 2024 23:32:25 +0900

여러가지 플러그인이 있겠지만, 알고보니 인테리제이에서 기본으로 제공해주는 generater가 있었다.

0. 나의 피시 환경 상태

- Mysql 설치완료

- 인텔리제이에서 db 연결 완료된 상태

먼저 인텔리제이에서 Database가 연결이 되어있는 상태여야한다.

혹시 DB를 연결하지 않았더라면, 인텔리제이 화면 우측 상단에서 데이터 베이스를 연결하면된다.

아래 캡쳐 사진에서 + 버튼을 눌러서 연결하도록 하자 (기본적으로 본인이 사용하는 sql은 설치가 되어있어야 한다.)

저는 이미 데이터 베이스가 연결되어있다.

1. DB -> DTO 파일 뽑아내기

1-1. 원하는 테이블의 우측을 클릭해서, Tools -> Scripted Extesions -> Generate POJOs.groovy 클릭

- 저장할 위치를 지정하라는 창이 뜨면, 자신이 원하는 위치를 선택하면 됩니다.

1-2. 위에서 지정한 위치에 Table 명으로 DTO 클래스가 생성 된 것을 확인 할 수 있습니다.

- dto내의 변수만 존재하는 것이 아니라, 아래에 getter/setter까지 존재하는 것을 확인 할 수 있습니다.

1-3. 위에서 생성 java파일을 원하는 패키지 위치에 옮김과 동시에, Getter/Setter를 지우고 @Data로 변경하면 DTO로 변경 완료

저는 지금까지, 외부 플러그인들을 설치해서 사용했었는데... 인텔리제이에서 기본적으로 제공하는 제너레이터가 있었군요.

위처럼 사용하면 많은 시간을 단축할 수 있습니다.

[Error] Could not find mysql:mysql-connector-java:.

shoney9254 — Thu, 4 Jan 2024 19:23:08 +0900

Could not find mysql:mysql-connector-java:.

에러 발생 시, 해결방법을 공유드립니다.

0. 현상

아래와 같이 에러가 발생합니다. gradle에서 dependencies를 잘못 입력했다는 것을 직감할 수 있습니다.

1. 해결방법

mysql 버전에 따라서 implementation을 다르게 입력해야합니다.

MySQL 8.0.31 이전 버전

implementation 'mysql:mysql-connector-java'

MySQL 8.0.31 이후 버전

implementation 'com.mysql:mysql-connector-j'

자신의 버전에 맞게 mysql connector를 입력하시면 됩니다.

[Error] Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

shoney9254 — Thu, 4 Jan 2024 17:17:09 +0900

0. 문제 현상

위처럼 에러가 발생한 경우, 해결하는 과정을 작성해봤습니다.

아마 이 문제에 직면한 분들은 모두 새롭게 스프링을 설정하는 상황이라서 발생할 겁니다.

application.yml 에 datasource 정보를 입력하지 않아서 발생하는 문제입니다.

1. 해결 방법

application.yml 파일로 들어갑니다. (위치는 resource에 존재합니다.)

아래와 같이 datasource를 입력합니다. (본인의 db정보에 맡게 입력하세요)

application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306
    username: root
    password:

어라? 그렇게 해도 에러가 발생하네요? (아래 에러가 발생하지 않으면, 다음 단계를 진행하실 필요없습니다.)

아래 부터는 추가 에러 발생한 분들만 보시면 됩니다.

2. Error creating bean with name 'dataSourceScriptDatabaseInitializer' 에러 해결방법

스프링 버전 2.5부터 SQL Scrpit DataSource Initialization 기능 변경으로,

아래와 같이 defer-datasoure-initialization: true 로 변경하면 해당 에러도 발생하지 않게 됩니다.

spring:
  datasource:
    url: jdbc:mysql://localhost:3306
    username: root
    password:
  jpa:
    defer-datasource-initialization: true

스트레스 받지 않는 행복한 코딩하시길 바랍니다.

[Spring] 멀티 MQ 리스너 개발 내용

shoney9254 — Wed, 20 Dec 2023 09:30:49 +0900

멀티 MQ 리스너 개발 내용

MQ 서버 추가 및 큐 이름 추가 되는 경우 아래 개발 내용 참조해서 추가하면 됩니다.

단일 MQ 서버 연결에서 다중 MQ 서버로 변경하는 내용을 정리했습니다.

1. MQ application.yml

profile에 맞는 설정을 해야 합니다. 설명을 위해 default profile로 설명 드립니다. (dev, prd는 서버 주소에 맞게 모두 설정해야합니다.)

1-1. MQ 서버 주소를 yml 설정

ibm:
  mq:
    serverA:
      hostName: mqa.server.com
      port: 1961
      queueManager: ABT.PSS
      channel: CLIENT.TO.QNAME
      userName: mpns
      password:
      appName:  QNAME
      retryMaxInterval: 300000
      sleepTime: 2000
    serverB:
      hostName: mqb.server.com
      port: 1962
      queueManager: A1T.PSS
      channel: CLIENT.TO.QNAME
      userName: mpns
      password:
      appName:  QNAME
      retryMaxInterval: 300000
      sleepTime: 2000

serverA와 serverB의 구분이 필요하기 때문에 serverA, serverB 레이어 추가
MQ 서버안에 여러 큐가 존재합니다. 큐 이름 설정은 Listener에서 설정하면 됩니다. (3.MQ JmsListener 참조)

1-2. Props

props는 yml에서 설정한 내용들을 객체로 사용하기 위해서 만들어줍니다.

불필요하면 사용하지 않아도 되지만, Map과 객체를 사용해서 휴먼 에러를 줄일 수 있습니다.

(props를 사용하지 않을 경우에는 @Value로 yml 설정 내용 사용)

1-2-1. MqPropsMap

@Component
@Data
@ConfigurationProperties(prefix = "ibm")
public class MqPropsMap {
    private Map<String, MqProps> mq;
}

@ConfigurationProperties 를 사용해서 MqProps를 Map으로 관리합니다.
단일 서버일 경우에는 MqProps를 바로 만들어도 됩니다.

1-2-2. MqProps

@Data
public class MqProps {
   private String hostName;
    private int port;
    private String queueManager;
    private String channel;
    private String userName;
    private String password;
    private String appName;
    private long retryMaxInterval;
    private long sleepTime;
}

MqProps는 MQQueueConnectionFactory 에서 설정으로 사용할 대상들을 변수 관리합니다.
단일 서버일 경우에는 MqProps클래스에 @ConfigurationProperties 사용해야합니다.

2. MQ Config

아래 두가지 팩토리 클래스로 MQ 서버 연결을 할 수 있습니다.

MQQueueConnectionFactory : MQ 서버 주소 및 옵션 설정

JmsListenerContainerFactory : ConnectionFactory 연결

2-1. MQQueueConnectionFactory

@Bean
public MQQueueConnectionFactory serverAMqQueueConnectionFactory() {
    MQQueueConnectionFactory connectionFactory = createConnectFactory(MqKeys.SERVER_A);
    return connectionFactory;
}

MQ Config 설정을 위해 위 내용을 Bean에 등록합니다.
createConnectFactory은 private 메서드로 아래 내용에서 추가 설명하도록 하겠습니다.
휴먼 에러 및 관리를 위해 MqKeys는 Enum으로 관리합니다.

2-2. MQQueueConnectionFactory 내부의 createConnectFactory private 메서드

private MQQueueConnectionFactory createConnectFactory(MqKeys keys) {
    MQQueueConnectionFactory mqQueueConnectionFactory = new MQQueueConnectionFactory();
    if (mqPropsMap.getMq().containsKey(keys.getKeyName())) {
        MqProps mqProps = mqPropsMap.getMq().get(keys.getKeyName());
        mqQueueConnectionFactory.setHostName(mqProps.getHostName());
        try {
            mqQueueConnectionFactory.setTransportType(WMQConstants.WMQ_CM_CLIENT);
            mqQueueConnectionFactory.setChannel(mqProps.getChannel());
            mqQueueConnectionFactory.setPort(mqProps.getPort());
            mqQueueConnectionFactory.setQueueManager(mqProps.getQueueManager());
            mqQueueConnectionFactory.setAppName(mqProps.getAppName());
            mqQueueConnectionFactory.setClientReconnectOptions(WMQConstants.WMQ_CLIENT_RECONNECT_Q_MGR);
            mqQueueConnectionFactory.setClientReconnectTimeout(43200);        // 12 hours
        } catch (JMSException e) {
log.error("[MQQueueConnectionFactory JMSException - {}] : {}", keys.getKeyName(), e.getMessage());
        }
    }
    return mqQueueConnectionFactory;
}

1-2에서 만든 MqPropsMap를 사용합니다. Map에서 Props를 꺼내고, Props 내의 설정 정보를 꺼내와서 MQQueueConnectionFactory에 설정을 해줍니다.

2-3. JmsListenerContainerFactory

@Bean
public JmsListenerContainerFactory<?> jmsServerAListenerContainerFactory(@Qualifier("serverAMqQueueConnectionFactory") MQConnectionFactory connectionFactory) {
    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    return factory;
}

@Qualifier로 빈 객체명을 정확하게 작성해야지 원하는 서버와 연결이 가능합니다. (MQ 서버가 단일 서버일 경우에는 사용하지 않아도 됩니다.)
setConnectionFactory를 사용해서 JmsListenerContainerFactory 와 MQQueueConnectionFactory간의 연결을 해줍니다.

3. MQ JmsListener

다대일로 구현하기 위해서는 @JmsListener 어노테이션을 사용해서 어떤 서버의 어떤 큐로 부터 메세지를 받을 건지 지정할 수 있습니다.

@JmsListener(destination = "SERVER_A_MQNAME_1", containerFactory = "jmsServerAListenerContainerFactory")
public void onMessageA1(Message message) {
	// 로직 구현 
}

@JmsListener(destination = "SERVER_A_MQNAME_2", containerFactory = "jmsServerAListenerContainerFactory")
public void onMessageA2(Message message) {
	// 로직 구현 
}

@JmsListener(destination = "SERVER_B_MQNAME_1", containerFactory = "jmsServerBListenerContainerFactory")
public void onMessageB1(Message message) {
	// 로직 구현 
}

이 처럼 사용하게 되면, Controller의 메서드와 비슷한 포맷으로 사용할 수 있습니다.

destination : 큐 이름을 작성하면, 해당 큐에서 메세지를 가져옵니다. (큐 이름 기준)
containerFactory : ContainerFactory 빈 객체 명을 작성 (MQ 서버 ContainerFactory 기준)

※ 하나의 MQ 서버에 여러 이름의 큐가 들어가 있을 수 있다.

[Spring] 페이지 처리 Request, Response Dto 변수 항목

shoney9254 — Sun, 16 Jul 2023 00:11:19 +0900

Controller 소스코드로 설명을 진행하려고 합니다. 아래 소스코드를 참조해주세요.

소스 코드

@GetMapping("/announcement/page")

public Map<String, Object> getAnnouncePage(@RequestParam String reqPageNo, @RequestParam String reqPageRowCnt){

List<AnnouncementDto> announcementDtos = announcementMapper.getAnnouncementListWithSkill();

Map<String, Object> responseMap = new HashMap<>();

int pageNo = Integer.parseInt(reqPageNo);

int pageRowCnt = Integer.parseInt(reqPageRowCnt);

int totalCnt = announcementDtos.size();

int totalPageCnt = (int) Math.ceil((double) totalCnt/pageRowCnt);

int start = (pageNo - 1) * pageRowCnt;

int end = Math.min(start + pageRowCnt, totalCnt);

responseMap.put("list", announcementDtos.subList(start, end)); // 보여질 항목

responseMap.put("totalCnt", totalCnt); // 전체 item 개수

responseMap.put("totalPageCnt", totalPageCnt); // 전체 페이지 개수

responseMap.put("pageNo", pageNo); // 현재 페이지

responseMap.put("pageRowCnt", pageRowCnt); // 페이지에 보여질 item row 개수

return responseMap;

}

1. Request 항목

요청 항목에서는 현재 페이지 번호(=pageNo), 페이지에 보여질 항목의 갯수(=pageRowCnt)를 요청하면된다.

위 소스코드에서는 쿼리파라로 요청하는 방식으로 구현하기 위해, RequestParam으로 사용했다.

요청 url

/announcement/page?reqPageNo=2&reqPageRowCnt=3

2. Response 항목

ORM에서 해당 항목만 가져오도록 start, end 인덱스를 활용해 가져오는 것이 메모리 및 성능 측면에서 더 좋겠지만, 지금 게시글은 페이지 처리 하는 방법에 대해서만 설명하기 위해서 이렇게 Controller에서 모든 것을 표현했다.

소스 코드

int totalCnt = announcementDtos.size();

int totalPageCnt = (int) Math.ceil((double) totalCnt/pageRowCnt);

int start = (pageNo - 1) * pageRowCnt;

int end = Math.min(start + pageRowCnt, totalCnt);

responseMap.put("list", announcementDtos.subList(start, end)); // 보여질 항목

responseMap.put("totalCnt", totalCnt); // 전체 item 개수

responseMap.put("totalPageCnt", totalPageCnt); // 전체 페이지 개수

responseMap.put("pageNo", pageNo); // 현재 페이지

responseMap.put("pageRowCnt", pageRowCnt); // 페이지에 보여질 item row 개수

1) 보여질 Content : 위 자바버전이 11이전이라서 subList를 통해서 List 항목을 가져왔다. 11이후 버전부터는 List.copyOfRange() 도 사용가능하다. start, end 인덱스를 계산해서 사용하면 된다.

2) 전체 item 개수 : 프론트에서 전체 카운트 개수를 보여주기 위해 사용한다.

3) 현재 페이지 : 요청에서 보내준 값을 그대로 보여주면 된다.

4) 페이지에 보여질 item row 개수 : 요청에서 보내준 값을 그대로 보여주면 된다.

프론트도 리액트로 간단하게 구현

1. 리액트로 간단하게 페이지 처리 구현

소스코드는 아래와 같다.

소스 코드

import axios from "axios";

import { useEffect, useState } from "react";

function App() {

const [totalPageCnt, setTotalPageCnt] = useState(0);

const [reqPageNo, setReqPageNo] = useState(1);

const [list, setList] = useState([]);

const getData = () => {

axios

.get(

`http://localhost:8080/api/v1/announcement/page?reqPageNo=${reqPageNo}&reqPageRowCnt=4`

)

.then((res) => {

setTotalPageCnt(res.data?.totalPageCnt);

setList(res.data.list);

});

};

console.log(totalPageCnt);

const clickPage = (page) => () => {

setReqPageNo(page);

};

useEffect(() => {

getData();

}, [reqPageNo]);

return (

<div>hello</div>

<ul>

{list.map((item) => (

<li>

{item.id} : {item.title}

</li>

))}

</ul>

{Array(totalPageCnt)

.fill(0)

.map((_, index) => (

{index + 1}

</span>

))}

</>

);

}

export default App;

2. 프론트 결과 확인

총 10개의 데이터를 DB구성했고, 4개씩 보이는 것으로 현재페이지 1페이지를 요청하니 아래와 같이 보이게 된다.

[Mybatis] resultMap을 이용해서 쿼리 서브 정보 받아오기 (left join 정보 받아오기)

shoney9254 — Sat, 15 Jul 2023 17:54:10 +0900

jpa를 사용하는 환경이면 @OneToMany를 사용해서 Dto안의 List<Dto>를 반환하는 것을 쉽게 구현할 수 있다. 하지만, mybatis에서는 resultMap을 이용해서 서브정보를 쿼리로 반환해야 한다. (xml에 resultMap을 사용하는 예시를 바로 보려면 2-2. 쿼리작성 부터 보시면 됩니다.)

1. 요구사항

프론트에서 아래와 같은 json 포맷으로 요구했다. 메인 정보 안에 서브정보를 리스트로 반환해야 한다.

요구사항 JSON

[
  {
    "id": "an001",
    "title": "데브옵스개발팀에 초대합니다.",
    "content": "오세요",
    "skills": [
      {
        "skillId": "sk001",
        "skNm": "java"
      },
      {
        "skillId": "sk002",
        "skNm": "python"
      },
      {
        "skillId": "sk003",
        "skNm": "react"
      }
    ]
  },
  {
    "id": "an002",
    "title": "춘개발자를 모집합니다.",
    "content": "오십쇼",
    "skills": [
      {
        "skillId": "sk002",
        "skNm": "python"
      },
      {
        "skillId": "sk004",
        "skNm": "mySql"
      }
    ]
  }
]

위처럼 반환하기 위해서는 여러 가지 방법이 있겠지만, resultMap을 사용해서 한 번에 반환해 보자.

2. 해결방법

2-1. dto를 2개 만든다.

위에 json 내용을 보면 공고에 대한 정보(=dto) 하나 안에, 스킬에 관한 서브정보(=dto)로 2개의 dto가 필요할 것을 예상할 수 있다.

2-1-1. 공고 dto

AnnouncementDto

@Data

public class AnnouncementDto {

String id;

String title;

String content;

List<SkillDto> skills;

}

2-1-2. 스킬 dto

SkillDto

@Data

public class SkillDto {

String skillId;

String skNm;

}

2-2. 쿼리 작성

xml에 쿼리를 작성할 때, resultMap을 사용하면 된다.

쿼리

</collection>

</resultMap>

SELECT ta.Id, ta.title, ta.content, tas.skill_id, ts.sk_nm

FROM kickboard_svc.t_announcement ta

LEFT OUTER JOIN kickboard_svc.t_announcement_skill tas

ON ta.Id = tas.an_id

INNER JOIN kickboard_svc.t_skill ts

ON tas.skill_id = ts.sk_id

</select>

위처럼, resultMap을 사용해서 메인 dto, 서브 dto 관계를 정의를 해서 쿼리문에서 사용하면 된다.

3. 결과 확인

vscode에서는 Thunder Client로 api를 테스트할 수 있다. 아래 캡처 화면을 보면 정상적으로 반환되는 것을 확인할 수 있다.

스프링

shoney9254 — Mon, 10 Jul 2023 12:27:17 +0900

6. 스프링 MVC - 기본 기능.pdf

0.86MB

4. 데이터 접근 기술 - MyBatis.pdf

0.30MB

[Spring] Mybatis Sample

shoney9254 — Sun, 9 Jul 2023 22:55:46 +0900

컨트롤러

@RestController

@CrossOrigin(origins = "*", allowedHeaders = "*")

@RequestMapping(value = "/api/v1")

@RequiredArgsConstructor

public class UserdataController {

private final UsedataService usedataService;

private final UserService userService;

//제공 api : 수정 불가

@RequestMapping(value = "/user/{user_no}", method = RequestMethod.GET)

public UserInfoDto getUseInfo(@PathVariable("user_no")String user_no) {

UserInfoDto result = userService.getUserInfo(user_no);

return result;

}

//제공 api : 해당 api를 바탕으로 프론트엔드를 구현하시오

@RequestMapping(value = "/user/{user_no}/usage/summary", method = RequestMethod.GET)

public UsedataDto getUseData(@PathVariable("user_no")String user_no , @RequestParam("ptype")int ptype ) {

String start_dt = getStartDate(ptype);

UsedataDto result = usedataService.getUseData(user_no, start_dt);

return result;

}

// 작성해야할 api

@RequestMapping(value = "/user/{user_no}/usage", method = RequestMethod.GET)

public Map<String, Object> getUsedList(@PathVariable("user_no")String user_no , @RequestParam("ptype")int ptype) {

String start_dt = getStartDate(ptype);

Map<String, Object> result = usedataService.getUsedList(user_no, start_dt);

return result;

}

// 날짜 계산을 위한 제공 method

private String getStartDate(int type){

Calendar currentCalendar = Calendar.getInstance();

int nType = type;

switch(nType){

case 1: // 1주일 전

currentCalendar.add(Calendar.DATE, -7);

break;

case 2: // 1달 전

currentCalendar.add(Calendar.MONTH, -1);

break;

case 3: // 3달 전

currentCalendar.add(Calendar.MONTH, -3);

break;

default:

currentCalendar.add(Calendar.DATE, -7);

break;

}

String returnDate = new java.text.SimpleDateFormat("yyyy-MM-dd").format(currentCalendar.getTime());

return returnDate;

}

매퍼

@Mapper

public interface UsedataMapper {

UsedataDto getUseData(@Param("user_no")String user_no, @Param("start_dt")String start_dt);

List<UsedListDto> getUsedList(@Param("user_no")String user_no, @Param("start_dt")String start_dt);

}

서비스 i/f

package com.lgcns.tct.service;

import org.apache.ibatis.annotations.Param;

import com.lgcns.tct.dto.UsedataDto;

import java.util.*;

public interface UsedataService {

public UsedataDto getUseData(@Param("user_no")String user_no, @Param("start_dt")String start_dt);

public Map<String, Object> getUsedList(@Param("user_no")String user_no, @Param("start_dt")String start_dt);

}

서비스 impl

@Service

@RequiredArgsConstructor

public class UseddataServiceimpl implements UsedataService {

@Autowired

private final UsedataMapper usedataMapper;

@Override

public UsedataDto getUseData(String user_no, String start_dt){

UsedataDto result = usedataMapper.getUseData(user_no, start_dt);

return result;

}

@Override

public Map<String, Object> getUsedList(String user_no, String start_dt){

List<UsedListDto> list = usedataMapper.getUsedList(user_no, start_dt);

Map<String, Object> result = new HashMap<>();

result.put("list", list);

return result;

}

매퍼xml

SELECT COUNT(*) AS usage_count

, SUM(use_time) AS usage_minute

, SUM(use_distance) AS usage_meter

, round(SUM(use_distance)/1000*0.232, 1) AS carbon_reduction

FROM kickboard_svc.t_svc_use

WHERE 1=1

AND user_no=#{user_no}

AND DATE(use_start_dt)>=#{start_dt}

</select>

SELECT svc.USE_NO AS use_no

, svc.USE_DISTANCE AS use_distance

, svc.USE_TIME AS use_time

, date_format(svc.USE_START_DT, '%Y-%m-%d %h:%i') AS use_start_dt

, date_format(svc.USE_END_DT, '%Y-%m-%d %h:%i') AS use_end_dt

, date_format(pay.PAY_DATETIME, '%Y-%m-%d %h:%i') AS pay_datetime

, max(case when pay.PAYMETHOD_CODE = 'C' then pay.PAY_COST END) AS card_pay

, max(case when pay.PAYMETHOD_CODE = 'P' then pay.PAY_COST END) AS point_pay

FROM kickboard_svc.t_svc_use_pay as pay

, kickboard_svc.t_svc_use AS svc

WHERE 1=1

AND svc.USE_NO = pay.USE_NO

AND svc.USER_NO =#{user_no}

AND DATE(svc.use_start_dt)>=#{start_dt}

GROUP BY svc.USE_NO

ORDER BY use_start_dt DESC

</select>

[SourceTree] window에서 소스트리 실행 안될 때

shoney9254 — Sun, 2 Jul 2023 22:13:20 +0900

1. 문제 상황

갑자기 소스트리가 실행이 안된다.

아래 화면에서 더 진행이 안되고 바로 꺼진다.

이 화면에서 더이상 실행 없이 꺼짐

2. 해결방법

이럴 때, 아래 경로에 있는 SourceTree.exe._Url_로 시작하는 폴더를 삭제하면 실행된다.

경로 : C:\Users\User\AppData\Local\Atlassian

[MySql] COALESCE 함수 사용 예제

shoney9254 — Tue, 27 Jun 2023 17:51:31 +0900

MySQL의 COALESCE 함수는 인자로 전달된 여러 개의 값 중에서 첫 번째로 NULL이 아닌 값을 반환하는 함수입니다. 즉, NULL이 아닌 첫 번째 값을 찾아 반환하거나, 모든 값이 NULL인 경우에는 NULL을 반환합니다.
COALESCE 함수는 다음과 같은 형태로 사용됩니다

COALESCE(value1, value2, ...)

여러 개의 값(value1, value2, ...)이 주어지고, COALESCE 함수는 이 값들을 왼쪽에서 오른쪽으로 순서대로 확인하여 첫 번째로 NULL이 아닌 값을 반환합니다.

간단한 예제로 설명해보면,

아래는 customers 테이블의 테이터이다.

id	name	city
1	John	NULL
2	Alice	London
3	Michael	NULL

보통 아래와 같이 없는 city가 null인 경우에는 Unknown으로 표현하는 예제처럼 사용한다.

예제

SELECT id, name, COALESCE(city, 'Unknown') AS city FROM customers;

위 쿼리를 실행하면 다음과 같은 결과는 아래와 같다.

id	name	city
1	John	Unknown
2	Alice	London
3	Michael	Unknown

COALESCE 함수는 NULL 처리나 기본값을 설정할 때 유용하게 사용될 수 있습니다.

[React] axios 사용한 GET, POST, PUT, DELETE 메서드 구현 간단한 예제

shoney9254 — Sun, 25 Jun 2023 15:55:10 +0900

리액트에서 axios로 get, post, put, delete 간단한 예제를 알아보도록 하자.

소스 코드

import React, { useEffect, useState } from "react";

import axios from "axios";

function App() {

const [users, setUsers] = useState([]);

const [name, setName] = useState("");

const [email, setEmail] = useState("");

useEffect(() => {

getUsers();

}, []);

const getUsers = () => {

axios

.get("https://api.example.com/users")

.then((response) => {

setUsers(response.data);

})

.catch((error) => {

console.error(error);

});

};

const addUser = () => {

axios

.post("https://api.example.com/users", { name, email })

.then(() => {

getUsers();

setName("");

setEmail("");

})

.catch((error) => {

console.error(error);

});

};

const updateUser = (userId) => {

axios

.put(`https://api.example.com/users/${userId}`, { name, email })

.then(() => {

getUsers();

setName("");

setEmail("");

})

.catch((error) => {

console.error(error);

});

};

const deleteUser = (userId) => {

axios

.delete(`https://api.example.com/users/${userId}`)

.then(() => {

getUsers();

})

.catch((error) => {

console.error(error);

});

};

return (

<div>

<h1>Users</h1>

<ul>

{users.map((user) => (

{user.name} - {user.email}

<button onClick={() => deleteUser(user.id)}>Delete</button>

</li>

))}

</ul>

<input

type="text"

value={name}

onChange={(e) => setName(e.target.value)}

placeholder="Name"

<input

type="text"

value={email}

onChange={(e) => setEmail(e.target.value)}

placeholder="Email"

</div>

);

}

export default Test;

결과

[SQL] CASE 문으로 유용한 쿼리문 예시

shoney9254 — Sun, 21 May 2023 17:30:17 +0900

https://overit.tistory.com/entry/SQL-CASE-%EC%8B%9D-Feat-%EC%A1%B0%EA%B1%B4%EB%B6%84%EA%B8%B0

[Spring] 컨트롤러 Request, Response 간단한 예시

shoney9254 — Tue, 16 May 2023 17:27:37 +0900

Request 받는 예시

자주 사용하는 1. 쿼리파라, 2.변수패스, 3. json 바디 예시를 작성했습니다.

1. 쿼리 파라미터

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @GetMapping("/search")
    public List<Book> searchBooks(@RequestParam("keyword") String keyword) {
        return bookService.searchBooks(keyword);
    }
}

위의 예제에서는 `@RequestParam` 어노테이션을 사용하여 `keyword`라는 이름의 쿼리 파라미터를 전달받습니다. `/api/books/search?keyword=java`와 같은 요청을 처리합니다.

2. URL 경로 변수(Path variable)

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @GetMapping("/{id}")
    public Book getBookById(@PathVariable("id") Long id) {
        return bookService.getBookById(id);
    }
}

위의 예제에서는 `@PathVariable` 어노테이션을 사용하여 `id`라는 이름의 경로 변수를 전달받습니다. `/api/books/1`와 같은 요청을 처리합니다.

3. JSON

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @PostMapping
    public Book addBook(@RequestBody Book book) {
        return bookService.addBook(book);
    }
}

위의 예제에서는 `@RequestBody` 어노테이션을 사용하여 JSON 형식의 데이터를 전달받습니다. 클라이언트에서는 HTTP POST 요청을 보내며, 요청 본문에 JSON 형식의 Book 객체를 담아 전송합니다.

Response

다음은 Spring MVC에서 자주 사용되는 response 유형 예시입니다.

1. Map을 사용하여 JSON 응답 생성하기

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @GetMapping("/{id}")
    public Map<String, Object> getBookById(@PathVariable("id") Long id) {
        Book book = bookService.getBookById(id);
        Map<String, Object> response = new HashMap<>();
        response.put("title", book.getTitle());
        response.put("author", book.getAuthor());
        response.put("publishedYear", book.getPublishedYear());
        return response;
    }
}

위의 예제에서는 Map 객체를 사용하여 JSON 응답을 생성합니다. 클라이언트에서 `/api/books/1`와 같은 GET 요청을 보내면, 해당 Book 객체를 Map으로 변환하여 JSON 형식으로 응답합니다.

2. List를 사용하여 JSON 응답 생성하기

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @GetMapping("/all")
    public List<Book> getAllBooks() {
        return bookService.getAllBooks();
    }
}

위의 예제에서는 List 객체를 사용하여 JSON 응답을 생성합니다. 클라이언트에서 `/api/books/all`와 같은 GET 요청을 보내면, 모든 Book 객체를 List에 담아 JSON 형식으로 응답합니다.

3. DTO(Data Transfer Object)를 사용하여 JSON 응답 생성하기

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    @Autowired
    private BookService bookService;

    @GetMapping("/{id}")
    public BookDto getBookById(@PathVariable("id") Long id) {
        Book book = bookService.getBookById(id);
        BookDto bookDto = new BookDto();
        bookDto.setTitle(book.getTitle());
        bookDto.setAuthor(book.getAuthor());
        bookDto.setPublishedYear(book.getPublishedYear());
        return bookDto;
    }
}

위의 예제에서는 DTO 객체를 사용하여 JSON 응답을 생성합니다. BookDto는 Book 엔티티 클래스와 유사하지만, 클라이언트에 필요한 필드만을 가지고 있습니다. 클라이언트에서 `/api/books/1`와 같은 GET 요청을 보내면, 해당 Book 객체를 BookDto로 변환하여 JSON 형식으로 응답합니다.

[Java] 가변객체, 불변객체

shoney9254 — Thu, 30 Mar 2023 14:10:46 +0900

Java에서 가변(mutable) 객체와 불변(immutable) 객체의 차이점은 객체의 내용을 변경할 수 있는지 여부!

사실 자바를 사용했다면, 해당 어휘에 대해서만 모를 뿐이지 모두가 사용해본 내용일 것이다.

아래 내용들을 보면서 어떤 의미인지 알아보자.

1. 가변 객체 (Mutable Object)

객체의 내용을 변경할 수 있는 객체입니다.
객체가 생성된 후, 내부의 상태를 변경할 수 있습니다.
가변 객체를 사용하면 메모리 사용량이 크게 증가할 수 있습니다.

List<String> mutableList = new ArrayList<>();
mutableList.add("A");
mutableList.add("B");
mutableList.add("C");
mutableList.remove(1); // "B" 제거

2. 불변 객체 (Immutable Object)

객체가 생성된 후, 내부의 상태를 변경할 수 없는 객체입니다.
불변 객체를 사용하면 안정성과 보안성이 향상됩니다.
불변 객체는 스레드 안전성을 보장합니다.

String immutableString = "Hello, world!";
immutableString.toUpperCase(); // 새로운 문자열을 반환하지만 immutableString 객체의 내용은 변하지 않음

불변 객체의 경우, 객체가 생성된 후에는 내부 상태를 변경할 수 없으므로, 새로운 객체를 생성하거나 복사해야 하는 경우가 많습니다. 이러한 특성으로 인해, 불변 객체는 보안성이나 안정성이 중요한 경우, 혹은 함수형 프로그래밍에서 많이 사용됩니다.

반면, 가변 객체는 내부 상태를 변경할 수 있으므로, 유연한 코드 작성이 가능하며, 일부 자료 구조나 알고리즘에서는 가변 객체를 사용해야만 효율적인 작업이 가능한 경우가 있습니다.

[Java] String, StringBuilder, StringBuffer 차이점

shoney9254 — Thu, 30 Mar 2023 13:50:48 +0900

Java에서 문자열을 사용할 때, 자주 보이는 클래스 String, StringBuffer, StringBuilder 차이점을 알아봅시다.

1. String

String은 불변(immutable)한 문자열을 나타내는 클래스입니다.
문자열을 변경할 경우, 기존 문자열 객체를 변경하는 것이 아니라 새로운 문자열 객체를 생성합니다.
멀티 스레드 환경에서 안전합니다.

String str = "hello";
str = str + " world"; // "hello world" 문자열 생성

2. StringBuilder

StringBuilder는 가변(mutable)한 문자열을 나타내는 클래스입니다.
문자열을 변경할 때, 기존 객체를 변경하며, 새로운 객체를 생성하지 않습니다.
멀티 스레드 환경에서 안전하지 않습니다.

StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // "hello world" 문자열 생성

3. StringBuffer

StringBuffer는 StringBuilder와 기능이 거의 동일하지만, 멀티 스레드 환경에서 안전합니다.
StringBuilder와 달리 동기화를 지원하므로, 스레드 안전성을 보장합니다.

StringBuffer sb = new StringBuffer("hello");
sb.append(" world"); // "hello world" 문자열 생성

[Spring] @ResponseBody에서 객체를 JSON 반환(HttpMessageConverter)

shoney9254 — Thu, 30 Mar 2023 11:20:31 +0900

결론은 @ResponseBody어노테이션을 사용해도, Getter 사용하지 않는 필드는 자동으로 JSON 변환이 안됩니다. (Getter를 사용해!)

롬복 @Data 어노테이션을 남발하다 보면, 기본적인 @ResponseBody가(이것도 물론 @RestController로 사용하긴 합니다.) 작동하는 최소의 조건을 잊고 살 수 있다. 토이 프로젝트를 진행하면서 최소한의 어노테이션으로 진행해보려고 하니 예전에 배웠던 것들도 다시 한번 정리하는 시간을 가지게 되었다. 하나둘 씩 정리해서 블로그에 올리려고 한다.

1. @ResponseBody

- @ResponseBody 어노테이션은 컨트롤러 메서드에서 반환되는 객체를 HTTP 응답 본문에 직접 쓰기 위해 사용됩니다.

- 반환 타입에 따라 적절한 HttpMessageConverter가 선택되어 해당 객체를 변환 후 응답 바디에 쓰여진다.

2. HttpMessageConverter

- 스프링에서 요청과 응답할 때 HttpMessageConverter를 사용해서 변환한다.

- 예를 들어, String은 StringHttpMessageConverter가 선택되어 반환.

- Json은 MappingJackson2HttpMessageConverter 가 선택되어서 반환.

- MappingJackson2HttpMessageConverter가 반환할 때, 필드의 Getter를 사용해서 JSON객체로 변환한다.

[JAVA] StringBuilder 메서드 별 간단한 사용 예제

shoney9254 — Wed, 29 Mar 2023 22:43:20 +0900

StringBuilder 클래스는 Java에서 문자열을 효율적으로 처리하는 데 사용되는 클래스이다.

사실, + 를 통해서 String을 append 하는 것 보다 객체 생성될 여지가 적기 때문에, 약간의 속도 개선이 있다. (가독성이 떨어진다는 점은 단점이긴 하다)

다양한 메서드와 사용 방법을 간단한 예제를 통해서 알아보자.

1. append(String str) : 문자열을 추가합니다.

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World");
String result = sb.toString(); // "Hello World"

2. insert(int offset, String str) : 문자열을 특정 위치에 삽입합니다.

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.insert(2, "Java ");
String result = sb.toString(); // "HeJava llo"

3. delete(int start, int end) : 문자열의 일부를 삭제합니다.

StringBuilder sb = new StringBuilder();
sb.append("Hello World");
sb.delete(5, 11);
String result = sb.toString(); // "Hello"

4. replace(int start, int end, String str) : 문자열의 일부를 다른 문자열로 교체합니다.

StringBuilder sb = new StringBuilder();
sb.append("Hello World");
sb.replace(6, 11, "Java");
String result = sb.toString(); // "Hello Java"

5. reverse() : 문자열을 뒤집습니다.

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.reverse();
String result = sb.toString(); // "olleH"

[macOS] 실행중인 포트 종료하기 (lsof, kill 명령어 옵션 설명)

shoney9254 — Fri, 17 Mar 2023 10:47:18 +0900

급하신 분들을 위해 해결 방법부터 설명하고, 옵션에 대한 추가적인 설명을 하도록 하겠습니다.

1. 해결 방법 (포트 번호 8080 기준)

1) 터미널에서 lsof -i :8080 입력합니다.

터미널

$ lsof -i :8080

터미널에 lsof -i 8080 명령어를 입력하게 되면, 아래와 같이 해당 포트의 PID를 알수있습니다.

8080포트에서는 java가 실행중이고 PID는 1621인것을 알수있습니다.

2) 터미널에서 해당 PID를 종료시키기(PID 1621기준)

터미널

$ kill -9 1621

-9옵션은 강제 종료 옵션입니다. 뒤에 PID를 붙인 명령어를 입력해서 강제 종료합니다.

위 명령어를 입력하고 다시 lsof -i :8080으로 실행하고 있는지 조회해보면 제대로 종료 됐는지 확인할 수 있습니다.

2. 추가적인 옵션 설명

1) lsof (list open files 약자)

'lsof'는 열린 파일 목록(list open files)을 나타내는 명령어입니다.

다음은 macOS에서 'lsof' 명령어에 사용 가능한 옵션들입니다.

'-c': 프로세스 이름으로 파일을 찾습니다.
'-d': 파일 기술자 (file descriptor)를 찾습니다.
'-g': 그룹 ID로 파일을 찾습니다.
'-i': 네트워크 소켓을 찾습니다.
'-n': 호스트 이름을 IP 주소로 해석하지 않습니다.
'-P': 포트 번호를 숫자로 보여줍니다.
'-p': 지정한 프로세스 ID의 파일을 찾습니다.
'-u': 사용자 ID로 파일을 찾습니다.
'-t': 지정한 파일 타입의 파일을 찾습니다.

2) kill

'kill' 명령어는 다른 프로세스를 중지시키는 명령어입니다.

'kill' 명령어에는 여러 옵션이 있습니다. 일반적으로 많이 사용되는 몇 가지 옵션을 살펴보겠습니다.

'-9' : SIGKILL 시그널을 보내며, 프로세스를 즉시 강제 종료합니다.
'-15' : SIGTERM 시그널을 보내며, 프로세스에게 정상적인 종료를 요청합니다.
'-s' : 보낼 시그널을 지정합니다. 기본적으로 SIGTERM 시그널이 사용됩니다.
'-l' : 사용 가능한 시그널 목록을 보여줍니다.
'-u' : 프로세스의 유저 ID를 지정합니다.
'-c' : 프로세스의 이름을 지정합니다.