최지희 님의 블로그

LangChain + FAISS + Redis 기반 RAG 챗봇 구현

jiheechoi — Mon, 25 May 2026 00:47:16 +0900

1. 들어가며

이 글은 CrossAlpha를 개발하면서 RAG 기반 챗봇을 구현한 경험을 정리한 글이다.

CrossAlpha는 투자자가 "왜 이 거래를 했는가"를 기록하고, 행동 패턴을 분석하여 투자 습관을 개선할 수 있도록 돕는 트레이딩 저널 및 AI 기반 투자 행동 분석 서비스이다. CrossAlpha의 종목 상세 페이지에는 차트 분석 AI 어시스턴트 기능이 있는데, 사용자가 현재 보유 종목의 기술적 지표(RSI, SMA, 볼린저 밴드 등)에 대해 자연어로 질문하면 AI가 답변해주는 기능이다.

단순히 LLM을 호출하는 것이 아니라, 기술적 지표 문서를 기반으로 검색하고 현재 종목의 실시간 데이터를 결합하여 답변하는 RAG(Retrieval-Augmented Generation) 구조로 구현했다. 여기에 Redis를 활용한 대화 히스토리 관리를 추가하여 이전 대화 맥락을 기억하는 챗봇을 만들었다.

2. 왜 RAG인가

단순히 LLM에 질문만 던지는 방식으로는 두 가지 문제가 있었다.

문제 1 — LLM이 기술적 지표를 틀리게 설명할 수 있다

RSI, 볼린저 밴드 같은 기술적 지표는 정확한 해석 기준이 있다. 하지만 LLM은 hallucination으로 잘못된 해석을 줄 수 있다. 예를 들어 RSI 70 이상이 과매수 구간이라는 기준을 틀리게 설명하거나, 볼린저 밴드 해석을 임의로 만들어낼 수 있다. 신뢰할 수 있는 문서를 기반으로 답변하도록 RAG 구조를 도입한 이유가 여기에 있다.

문제 2 — LLM은 현재 종목의 실시간 데이터를 모른다

"지금 NVDA RSI가 어때?"라고 물어봐도 LLM은 실시간 데이터를 알 수 없다. 이건 RAG로 해결할 수 있는 문제가 아니라, 매 요청마다 현재 종목의 기술적 지표 스냅샷을 직접 context로 주입하는 방식으로 해결했다.

이러한 문제들로 인해 결국 이 두 접근이 결합된 구조를 선택하였다. RAG로 문서 기반의 정확한 해석을 제공하고, 스냅샷 주입으로 실시간 종목 데이터를 반영하는 방식이다.

3. 개발 환경 및 설정

- 전체 스택

CrossAlpha의 백엔드는 다음과 같은 환경으로 구성되어 있다.

백엔드	FastAPI (Docker 컨테이너)
배포	Railway
DB	PostgreSQL (Railway)
대화 히스토리	Redis (Railway)
LLM	GPT-4o-mini (OpenAI)
벡터스토어	FAISS (로컬 파일)

Railway 위에 FastAPI Docker 컨테이너, PostgreSQL, Redis가 같은 프로젝트 안에서 내부 네트워크로 연결되어 있다.

- Railway에 Redis 서비스 추가하기

Railway 대시보드에서 아래 순서로 Redis를 추가했다.

1. 프로젝트 대시보드 → Add 클릭

2. Database → Redis 선택

대시보드에 Redis 추가 완료!

3. 추가 완료 후 FastAPI 서비스 → Variables 탭 → Add Variable로 REDIS_URL 추가

Redis variables에서 REDIS_URL값 복붙하기

Railway 내부에서 서비스끼리 통신할 때는 private endpoint를 사용한다. Redis를 추가하면 두 가지 URL이 생성된다.

변수 용도

REDIS_URL	Railway 내부 통신 (배포 환경) — 무료
REDIS_PUBLIC_URL	외부 접근 (로컬 개발 환경) — 소량 비용 발생

배포 환경에서는 Railway Variables에 설정한 REDIS_URL이 자동으로 주입되고, 로컬 개발 환경에서는 .env 파일에 REDIS_PUBLIC_URL 값을 REDIS_URL로 넣어서 사용했다.

- 패키지 설치

requirements.txt에 아래 패키지를 추가했다.

redis
langchain-redis

로컬에서도 설치했다.

pip install redis langchain-redis

4. 전체 구조

사용자 질문
    ↓
FAISS에서 관련 기술적 지표 문서 검색 (Retrieval)
    +
현재 종목 기술적 지표 스냅샷 주입 (RSI, SMA, 볼린저 밴드 등)
    +
Redis에서 이전 대화 히스토리 로드
    ↓
LLM (GPT-4o-mini)
    ↓
답변 생성 + Redis에 대화 저장

5. 기술적 지표 문서 벡터스토어 구성하기

RAG의 핵심은 검색할 문서를 벡터로 변환해서 저장하는 벡터스토어다. CrossAlpha에서는 RSI, SMA, 볼린저 밴드, 복합 신호 해석 문서를 마크다운 형태로 작성하고 FAISS에 저장했다.

# build_vectorstore.py
from pathlib import Path
from langchain_community.vectorstores import FAISS
from langchain_core.documents import Document
from langchain_openai import OpenAIEmbeddings

DOCS_DIR = Path("rag/docs")
SAVE_DIR = "rag/vectorstore"

def build_vectorstore():
    docs = []
    for path in DOCS_DIR.glob("*.md"):
        content = path.read_text(encoding="utf-8")
        docs.append(
            Document(
                page_content=content,
                metadata={"source": path.name},
            )
        )

    embeddings = OpenAIEmbeddings(api_key="YOUR_API_KEY")
    vectorstore = FAISS.from_documents(docs, embeddings)
    vectorstore.save_local(SAVE_DIR)

if __name__ == "__main__":
    build_vectorstore()

→ 문서를 추가하거나 수정할 때마다 이 스크립트를 실행해서 벡터스토어를 다시 빌드했다.

6. 종목 스냅샷 + RAG 결합한 체인 만들기

LangChain의 RunnableParallel을 활용해서 세 가지 context를 병렬로 준비하고 LLM에 넘겼다.

chain = (
    RunnableParallel(
        {
            # 현재 종목 기술적 지표 스냅샷
            "snapshot_context": RunnableLambda(_build_snapshot_context),

            # FAISS에서 관련 문서 검색
            "retrieved_context": (
                RunnableLambda(lambda x: x["question"])
                | retriever
                | RunnableLambda(_format_docs)
            ),

            # 사용자 질문
            "question": RunnableLambda(lambda x: x["question"]),

            # Redis에서 대화 히스토리 로드
            "chat_history": RunnableLambda(lambda x: history.messages),
        }
    )
    | prompt
    | llm
    | StrOutputParser()
)

→ RunnableParallel을 쓰면 스냅샷 가져오기와 문서 검색이 동시에 실행되어 응답 속도가 빨라진다.

스냅샷은 이런 형태로 구성했다.

def _build_snapshot_context(inputs: dict) -> str:
    snapshot = get_technical_summary_with_llm(ticker=ticker, rng=range_)
    return f"""
ticker: {snapshot.ticker}
rsi14: {snapshot.indicators.rsi14}
sma20: {snapshot.indicators.sma20}
sma50: {snapshot.indicators.sma50}
bollinger_upper: {snapshot.indicators.bollinger.upper}
bollinger_middle: {snapshot.indicators.bollinger.middle}
bollinger_lower: {snapshot.indicators.bollinger.lower}
""".strip()

7. Redis로 대화 히스토리 관리하기

단발성 질답이 아니라 이전 대화 맥락을 기억하는 챗봇을 만들기 위해 Redis를 도입했다.

LangChain의 RedisChatMessageHistory를 사용하면 히스토리 저장/로드를 자동으로 처리해준다.

from langchain_redis import RedisChatMessageHistory

history = RedisChatMessageHistory(
    session_id=session_id,
    redis_url=REDIS_URL,
    ttl=60 * 60 * 24 * 7,  # 7일
)

# 히스토리 로드 (자동으로 Redis에서 가져옴)
print(history.messages)

# 답변 후 저장
history.add_user_message(question)
history.add_ai_message(answer)

→ TTL을 7일로 설정하면 7일간 대화가 없으면 자동으로 만료된다.

8. session_id로 사용자/종목별 대화 분리하기

여러 사용자가 여러 종목을 동시에 사용하기 때문에 대화가 섞이지 않도록 session_id로 분리했다. CrossAlpha에서는 {user_id}:{ticker} 조합으로 session_id를 구성했다.

session_id의미

42:NVDA	user 42번의 NVDA 대화
42:TSLA	user 42번의 TSLA 대화
99:NVDA	user 99번의 NVDA 대화

프론트엔드에서 이렇게 생성해서 매 요청에 포함시킨다.

const sessionId = `${userId}:${ticker}`

await fetch(`/api/tickers/${ticker}/assistant`, {
    method: "POST",
    body: JSON.stringify({
        question: question,
        range: "3M",
        session_id: sessionId,
    })
})

10. 테스트

멀티턴이 정상 작동하는지 확인하기 위해 스냅샷에 없는 정보를 첫 번째 대화에서 언급하고, 두 번째에서 기억하는지 확인해보았다.

테스트용 request body 작성

// 첫 번째 질문
{
    "question": "현재 RSI 기준으로 과매수 구간까지 몇 포인트 남았어?",
    "range": "3M",
    "session_id": "test:NVDA"
}

// 두 번째 질문 — 히스토리 없이는 답할 수 없음
{
    "question": "방금 말한 포인트 수치가 정확히 얼마였지?",
    "range": "3M",
    "session_id": "test:NVDA"
}

테스트 결과

첫 번째 요청에 대한 실행 결과

두 번째 요청에 대한 실행 결과

두 번째 질문에서 첫 번째 답변의 수치를 정확히 기억하고 답하는 것을 확인하였다!

FinanceDataReader + GPT API로 주식 보조 지표 자동 해석하기

jiheechoi — Wed, 26 Nov 2025 23:13:14 +0900

*작성일자: 2025-11-26 / 작성자: 컴퓨터공학과 2376302 최지희

0. 들어가며

어느덧 졸업을 1년 앞둔 컴공과 3학년 학부생이 된 나는, 이번 학기부터 학부 졸업 과제인 캡스톤 팀 프로젝트를 시작하게 되었다. 우리 팀이 진행하는 프로젝트의 주제는 <시간과 전문성이 부족한 개인 주식 투자자를 위한, 포트폴리오 기반 투자 행동 인사이트 & 학습 서비스>이다. 이 서비스는 투자에 관심은 있지만 스스로 시장을 해석하기 어렵거나, 자신의 투자 패턴을 객관적으로 파악하기 힘든 초보 투자자를 위한 도구를 만드는 것을 목표로 한다.
이를 위해 우리 팀은 크게 세 가지 기능을 설계했다.

정성적 분석 – 섹터별 뉴스 맥락 해석 및 톤 분류
정량적 분석 – 가격 기반 기술 지표 계산 및 해석 제공
투자 행동 학습 로그 – 사용자의 매매 기록 기반 행동 분석 및 자기 피드백

이번 글에서는 그중에서도 내가 맡은 정량적 분석 기능의 기술 요소를 기말 기술 검증 시연에 대비하여 구현·점검한 과정을 중심으로 정리한다. FinanceDataReader로 주가 데이터를 수집하고, SMA·RSI·볼린저밴드 등 핵심 지표를 계산한 뒤, 이를 기반으로 GPT 모델이 자연어 해석을 생성하는 전체 흐름을 코드와 함께 기록하고자 한다.

1. 준비하기(환경 설정 및 개발 준비 과정)

1-1) 개발 환경

파이썬 3.13.9 버전 설치

-파이썬 3.13.9 버전, 파이참 다운로드

1-2) 필요한 라이브러리 설치

pip install finance-datareader pandas numpy python-dotenv openai

터미널에 다음과 같은 명령어를 입력하여 필요한 라이브러리들을 설치하였다.

FinanceDataReader : 국내/해외 주가 데이터 수집을 위한 라이브러리
Pandas : 이동평균·볼린저밴드·RSI 계산 등 시계열 기반 지표 계산
NumPy : 수치 연산 최적화 및 Pandas 연산 보조
python-dotenv : OpenAI API 키를 .env에서 불러오는 역할
openai : GPT 모델 호출을 통해 지표 해석과 주요 신호 요약에 활용

1-3) GPT API 키 발급

OpenAI 플랫폼에서 API key 발급하기

GPT 모델을 통해 지표 해석(요약문 생성, 주요 신호 정리)을 생성하기 위해 OpenAI 플랫폼에서 API Key를 발급하고, 이를 .env 파일로 관리하도록 구성하였다.

2. 기술 검증 코드 및 결과

실제 서비스에서는 사용자가 포트폴리오에 보유 종목을 등록할 때 종목명을 기준으로 검색·선택하고, 내부적으로는 종목코드(티커)와 매핑하여 지표 계산 및 분석 로직이 동작하도록 설계할 예정이다. 다만 이번 글에서는 핵심 기술 요소인 “가격 데이터 수집 → 지표 계산 → GPT 기반 해석” 흐름을 검증하는 것에 집중하기 위해, 예시 종목을 하나 선정하여 해당 종목을 기준으로 정량 분석 파이프라인을 구현하고 테스트하였다.

2-1) 주가 데이터 수집 - FinanceDataReader를 활용한 최근 1년 OHLCV 수집

def load_price(symbol, period=365):

    #오늘 기준 최근 period일 주가 데이터 로드.
    #FinanceDataReader 사용.

    end = datetime.today().date()
    start = end - timedelta(days=period)

    df = fdr.DataReader(symbol, start=start, end=end)
    df = df.rename(
        columns={
            "Open": "open",
            "High": "high",
            "Low": "low",
            "Close": "close",
            "Volume": "volume",
        }
    )
    return df[["open", "high", "low", "close", "volume"]]

- DataReader()를 사용해 오늘 기준 최근 1년(365일) 데이터를 조회

2-2) 기술적 지표 계산 - SMA / RSI / Bollinger Band

def calc_rsi(close, period=14):

    #기본형 RSI 계산 (단순 이동평균 기반).

    delta = close.diff()

    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)

    avg_gain = gain.rolling(period).mean()
    avg_loss = loss.rolling(period).mean()

    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))

    return rsi


def calc_indicators(df):

    #SMA20/50/120, RSI14, Bollinger Bands, Bollinger Width 계산.

    out = df.copy()

    # 이동평균 (SMA)
    out["sma_20"] = out["close"].rolling(20).mean()
    out["sma_50"] = out["close"].rolling(50).mean()
    out["sma_120"] = out["close"].rolling(120).mean()

    # RSI(14)
    out["rsi_14"] = calc_rsi(out["close"], 14)

    # Bollinger Band (20일 기준, ±2표준편차)
    mid = out["close"].rolling(20).mean()
    std = out["close"].rolling(20).std()
    out["bb_mid"] = mid
    out["bb_upper"] = mid + 2 * std
    out["bb_lower"] = mid - 2 * std

    # Bollinger Width
    out["bollinger_width"] = (out["bb_upper"] - out["bb_lower"]) / out["bb_mid"]

    return out.dropna()

- 지표 계산을 LLM에 맡길 경우 비용 증가 + 결과 일관성 저하 위험이 있어, 모든 수식 기반 계산 로직은 백엔드에서 직접 수행함.

- 기말 기술 검증 단계에서는 시간 제약으로 인해 SMA20/50/120, RSI14, Bollinger Band(20일 ±2σ) 등 고정된 파라미터만 우선 적용하여 지표를 계산함.

- 향후 실제 서비스 개발 단계에서는 EMA, MACD 등 추가 지표를 포함하고, 각 지표의 기간·파라미터 역시 사용자가 직접 선택할 수 있는 옵션 형태로 확장할 예정임.

2-3) 규칙 기반 정량 분석

def categorize_volatility(width_value, low_th, high_th):
    """
    볼린저 폭 분위수를 기준으로 변동성 구간 라벨링.
    - 상위 33% 이상: '높음'
    - 하위 33% 이하: '낮음'
    - 나머지: '보통'
    """
    if width_value >= high_th:
        return "높음"
    elif width_value <= low_th:
        return "낮음"
    return "보통"


def calc_support_resistance(df_calc, window=60):
    """
    최근 window일 종가 기준:
    - 최저가 = 지지선
    - 최고가 = 저항선
    """
    recent = df_calc.tail(window)
    support = float(recent["close"].min())
    resistance = float(recent["close"].max())
    return support, resistance

- 변동성, 지지선 저항선은 모두 명확한 규칙 기반으로 계산할 수 있는 지표이므로, 백엔드에서 직접 산출하는 방식으로 구현함.

- 변동성은 Bollinger Band 폭을 활용해, 33%·66% 분위수 기준으로 ‘높음/보통/낮음’ 세 단계로 라벨링함.

- 지지선과 저항선은 최근 60일 종가의 최저값·최고값을 기준으로 단순 계산하여, 초보 사용자도 이해하기 쉬운 형태로 구성함.

- 기말 기술 검증 단계에서는 구현 범위를 최소화하기 위해 위의 단순 규칙 기반 계산만 적용함.

- 향후 실제 서비스 개발 단계에서는 EMA, MACD, OBV 등 추가 지표를 활용하여 변동성·지지선·저항선 계산을 더욱 정교화할 계획임.

2-4) GPT에 전달할 Snapshot 구성

def make_snapshot(symbol, df_calc, display_name=None):
    """
    GPT에 전달할 Snapshot 생성.
    - symbol / name
    - date / price
    - volatility (낮음/보통/높음)
    - support / resistance
    - indicators (SMA20/50/120, RSI14, Bollinger Width)
    """
    last = df_calc.iloc[-1]

    # 변동성 분위수 계산
    width_series = df_calc["bollinger_width"].dropna()
    low_th = float(width_series.quantile(0.33))
    high_th = float(width_series.quantile(0.66))

    volatility = categorize_volatility(float(last["bollinger_width"]), low_th, high_th)
    support, resistance = calc_support_resistance(df_calc)

    name = display_name if display_name is not None else symbol

    snapshot = {
        "symbol": symbol,
        "name": name,
        "date": last.name.strftime("%Y-%m-%d"),
        "price": float(last["close"]),
        "volatility": volatility,
        "support": support,
        "resistance": resistance,
        "indicators": {
            "sma_20": float(last["sma_20"]),
            "sma_50": float(last["sma_50"]),
            "sma_120": float(last["sma_120"]),
            "rsi_14": float(last["rsi_14"]),
            "bollinger_width": float(last["bollinger_width"]),
        },
    }
    return snapshot

- LLM이 해석해야 할 최소 정보만 전달하기 위해, 백엔드에서 지표 계산 후 하나의 snapshot(dict) 형태로 구조화함.

- snapshot은 종목코드, 날짜, 현재가, 변동성 라벨, 지지선/저항선, 핵심 지표(SMA·RSI·Bollinger)를 포함.

- 모든 수치는 이미 백엔드에서 검증된 값이기 때문에, LLM이 임의로 숫자를 생성하지 않고 설명에만 집중하도록 설계함.

2-5) 프롬프트 설계

SYSTEM_PROMPT = """
당신은 초보 개인 투자자를 위한 기술적 지표 해설 전문가입니다.

반드시 지켜야 할 것:
- 모든 결과는 한국어로 작성합니다.
- 매수/매도, 종목 추천 등 직접적인 투자 조언을 하지 않습니다.
- 미래 가격을 단정적으로 예측하지 않습니다.
- 주어진 스냅샷(JSON)에 포함된 정보만 근거로 사용합니다.
- 초보자도 이해할 수 있도록, 전문 용어는 필요 시 괄호로 간단히 풀어서 설명합니다.

톤:
- 중립적이고 차분한 톤
- "확실하다", "반드시 오른다/내린다"와 같은 표현은 사용하지 않습니다.
""".strip()

USER_PROMPT_TEMPLATE = """
아래는 사용자가 선택한 종목에 대한 기술적 지표 스냅샷(JSON)입니다.

요구사항:
1) "주요 신호" 섹션을 작성하세요.
   - SMA20/50/120, RSI14, Bollinger 폭 등을 기반으로
     핵심 신호를 3~4개 불릿 포인트로 정리합니다.
   - 단순 숫자 나열이 아니라, '해당 지표 상태가 무엇을 의미하는지'를 중심으로 설명합니다.

   예시:
     - 20일선이 50일선 위에 있어 단기 상승 흐름을 유지하고 있습니다.
     - 현재가 120일선 위에 위치해 장기 우상향 기조를 나타냅니다.
     - RSI가 50대 중반으로, 과열되지 않은 범위 내에서 상승 모멘텀이 이어지고 있습니다.
     - 볼린저 밴드 폭이 최근 확대되어 단기 변동성이 증가한 상황입니다.

2) "차트 요약" 섹션을 작성하세요.
   - 변동성, 지지선, 저항선 값을 활용하여
     현재 차트 상황을 2~4문장으로 종합적으로 설명합니다.
   - 예측이 아니라, 현재 상태를 기반으로 작성하세요.
   - 예시:
       - 최근 변동성이 확대되며 가격 움직임이 커진 상황입니다.
       - 현재 가격은 주요 지지선 위에 있어 단기적으로 방어력이 있는 위치입니다.
       - 다만 저항선과의 가격 차이가 좁아져 주의 깊은 관찰이 필요합니다.

형식 예시는 다음과 같습니다:

주요 신호:
- ...

차트 요약:
- ...

스냅샷(JSON):
{snapshot_json}

위 두 개 섹션만 출력하세요.
JSON, 코드 블록, 추가 설명 문구는 포함하지 마세요.
""".strip()

- 출력 포맷을 엄격하게 지정하여 주요 신호 3~4개, 2~4문장 요약 형태로만 결과가 나오도록 제어함.

- 투자 조언, 미래 예측, 강한 확신 표현 등을 전부 금지하여 모델 안전성·일관성·정책 준수를 확보함.

- 초보 사용자 대상 서비스 특성에 맞게 문장은 짧고, 필요 시 괄호를 통한 단어 풀이 등 친절한 톤을 유지하도록 프롬프트 스타일을 제한함.

- snapshot의 값이 프롬프트 내부에 그대로 주입되므로, LLM은 해석만 수행하고 계산은 하지 않도록 책임 분리가 이루어짐.

2-6) GPT 호출 - gpt-4o-mini 기반 해석 생성

def build_user_prompt(snapshot):

    #Snapshot(dict)를 JSON 문자열로 직렬화해서 USER_PROMPT_TEMPLATE에 삽입.

    snapshot_json = json.dumps(snapshot, ensure_ascii=False, indent=2)
    prompt = USER_PROMPT_TEMPLATE.format(snapshot_json=snapshot_json)
    return prompt


def explain_with_gpt(user_prompt):

    #OpenAI GPT API 호출하여 SYSTEM_PROMPT + USER_PROMPT로 차트 해석 텍스트 생성.

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_prompt},
        ],
        max_tokens=600,
    )
    return response.choices[0].message.content

- max_tokens를 600으로 지정하여 주요 신호 + 요약 문단이 안정적으로 생성될 수 있는 범위를 확보함.

- 응답은 문자열로 반환되며, 실제 서비스에서는 JSON 응답 또는 구조화된 객체로 변경해 API와 연동할 수 있음.

2-7) 전체 실행 흐름 및 실행 결과

def demo(symbol="005930", name="삼성전자"):

    df = load_price(symbol)
    df_calc = calc_indicators(df)
    snapshot = make_snapshot(symbol, df_calc, display_name=name)
    user_prompt = build_user_prompt(snapshot)
    explanation = explain_with_gpt(user_prompt)

    print("=== Snapshot (입력) ===")
    print(json.dumps(snapshot, ensure_ascii=False, indent=2))
    print("\n=== GPT 해석 (출력) ===\n")
    print(explanation)

- demo() 함수는 이번 기술 검증을 위해 단일 종목(예: 삼성전자) 을 기준으로 전체 흐름을 단일 실행 스크립트에서 검증하기 위해 작성함.

- 실행 흐름은 다음과 같은 단계로 구성됨:

load_price() – 최근 1년간 주가 데이터 불러오기
calc_indicators() – SMA, RSI, Bollinger Band 계산
make_snapshot() – LLM 전달용 snapshot 구성
build_prompt() – 해석용 프롬프트 생성
explain_with_gpt() – GPT API 호출
snapshot(원본 수치) + LLM 해석 결과 출력

- 검증 목적상 콘솔 출력 형태로 테스트했으나, 실제 서비스에서는 snapshot과 해석 결과를 모두 프론트엔드에 JSON 형태로 전달해 렌더링하는 방식으로 확장할 예정임.

실행 결과. 주가 수집 → 지표 계산 및 차트 분석 요소 산출 → Snapshot 생성→ GPT 해설 생성까지 전체 흐름이 기대한 대로 정상 작동함.

[스프링 부트] 9장~11장

jiheechoi — Sat, 28 Jun 2025 06:05:49 +0900

9. CURD와 SQL 쿼리 종합

1. JPA 로깅 설정하기

-서버에서 데이터 생성, 조회, 수정, 삭제 등을 요청하면 JPA의 리파지터리가 DB에 해당 요청을 전달함. → 요청을 받은 DB는 SQL로 쿼리를 작성해 테이블 속 데이터를 관리.

-쿼리란, DB에 정보를 요청하는 구문으로 INSERT문, SELECT문, UPDATE문, DELETE문이 있음.

*JPA 로깅 레벨 설정하기(application.properties 수정)

#JPA 로깅 설정
#디버그 레벨로 쿼리 출력
logging.level.org.hibernate.SQL=DEBUG

→ 로깅 레벨에는 7단계가 있고, 레벨을 설정하면 해당 레벨 이상의 로그가 출력됨. DEBUG로 설정하면 JPA가 동작할 때 수행되는 SQL 쿼리를 볼 수 있음.

*그외 수정사항(application.properties에 추가)

#JPA 로깅 설정
#디버그 레벨로 쿼리 출력
logging.level.org.hibernate.SQL=DEBUG
#쿼리 줄바꿈하기
spring.jpa.properties.hibernate.format_sql=true
#매개변수 값 보여주기
logging.level.org.hibernatetype.descriptor.sql.BasicBinder=TRACE

#DB URL 설정
#유니크 URL 생성하지 않기
spring.datasource.generate-unique-name=false
#고정 URL 설정하기
spring.datasource.url=jdbc:h2:mem:testdb

2. SQL 쿼리 로그 확인하기

1) 데이터 생성시:INSERT문

-데이터 생성하기

-데이터 생성시 INSERT문 동작

2) 데이터 조회 시: SELECT문

-localhost:8080/articles 페이지 접속해서 모든 데이터 조회하기

-데이터 조회시 SELECT문 동작

3) 데이터 수정시: UPDATE문

-id=4인 article을 수정

-데이터 수정시 UPDATE문 동작

4) 데이터 삭제 시: DELETE문

-id=4인 article 삭제하기

-데이터 삭제시 DELETE문 동작

3. 기본 SQL 쿼리 작성하기

1) coffee 테이블 만들기

2) coffee 데이터 생성하기

3) coffee 데이터 조회하기

4) coffee 데이터 수정하기

5) coffee 데이터 삭제하기

10. REST API와 JSON

1. REST API와 JSON의 등장배경

-REST API는 서버의 자원을 클라이언트에 구애받지 않고 사용할 수 있게 하는 설계 방식임.

-REST API 방식에서는 HTTP 요청에 대한 응답으로 서버의 자원을 반환함. → 서버에서 보내는 응답이 특정 기기에 종속되지 않도록 모든기기에서 통용될 수 있는 응답 데이터를 반환(JSON)

-JSON 데이터: key와 value로 구성된 정렬되지 않은 속성의 집합. 키는 문자열이므로 항상 큰따옴표로 감싸고, 값은 문자열인 경우에만 큰따옴표로 감쌈.

2. REST API 동작 살펴보기

1) GET 요청하고 응답받기

-JSON placeholder 사이트에서 확인한 게시글, 댓글 등의 자원을 Talend API Tester 프로그램을 이용해 JSON 형식으로 받아오는 실습

모든 게시글 조회하기

1번 게시글 조회

※ HTTP 상태 코드: 클라이언트가 보낸 요청이 성공했는지, 실패했는지 알려 주는 코드

1XX(정보): 요청이 수신돼 처리 중임.
2XX(성공): 요청이 정상적으로 처리됨.
3XX(리다이렉션 메시지): 요청을 완료하려면 추가 행동이 필요함.
4XX(클라이언트 요청 오류): 클라이언트의 요청이 잘못돼 서버가 요청을 수행할 수 없음.
5XX(서버 응답 오류): 서버 내부에 에러가 발생해 클라이언트 요청에 대해 적절히 수행하지 못함.

※ HTTP 요청 메시지와 응답 메시지

-HTTP 메서드를 통한 데이터 조회 요청과 그에 대한 응답은 HTTP 메시지에 실려 전송됨. 요청할 때는 HTTP 요청 메시지에, 응답할 때는 응답 메시지에 내용이 실림.

-HTTP 메시지의 구성

시작 라인: HTTP 요청 또는 응답 내용이 있음. 시작라인은 항상 한줄로 끝남.
헤더: HTTP 전송에 필요한 부가 정보가 있음.
빈 라인: 헤더의 끝을 알리는 빈 줄로, 헤더가 모두 전송되었음을 알림.
본문: 실제 전송하는 데이터가 있음.

2) POST 요청하고 응답받기

데이터 생성 요청

3) PATCH 요청하고 응답받기

1번 게시글 수정 요청하기

4) DELETE 요청하고 응답받기

10번 게시글 삭제 요청하기

11. HTTP와 REST 컨트롤러

1. REST API의 동작 이해하기

-REST API 방식에서는 HTTP 요청에 대한 응답으로 서버의 자원을 반환함. → 서버에서 보내는 응답이 특정 기기에 종속되지 않도록 모든기기에서 통용될 수 있는 응답 데이터를 반환.

-REST API의 응답 표준으로 사용하는 것이 JSON.

-REST API를 잘 구현하면 클라이언트가 기기에 구애받지 않고 서버의 자원을 이용할 수 있으며, 서버가 클라이언트의 요청에 체계적으로 대응 가능함.

2. REST API의 구현 과정

-주소 설계

조회 요청: /api/articles or /api/articles/{id} → GET 메서드로 Article 목록 전체 또는 단일 Article 조회
생성 요청: /api/articles → POST 메서드로 새로운 Article을 생성해 목록에 저장
수정 요청: /api/articles/{id} → PATCH 메서드로 특정 Article의 내용을 수정
삭제 요청: /api/articles/{id} → DELETE 메서드로 특정 Article 삭제

- URL 요청을 받아 그 결과를 JSON으로 반환해 줄 컨트롤러 생성(REST 컨트롤러)

→ 응답할 때 적절한 상태의 코드를 반환하기 위해 ResponseEntity 클래스 활용

3. REST API 구현하기

1) REST 컨트롤러 생성

-FirstApiController.java 생성

package com.example.firstproject.api;

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

@RestController
public class FirstApiController {
    @GetMapping("/api/hello")
    public String hello() {
        return "Hello World";
    }
}

-REST 컨트롤러와 일반 컨트롤러의 차이: REST 컨트롤러는 JSON이나 텍스트 같은 데이터를 반환하는 반면, 일반 컨트롤러는 뷰 페이지를 반환함.

2) REST API: GET/POST/PATCH/DELETE 구현하기

-FirstApiController.java

package com.example.firstproject.api;

import com.example.firstproject.dto.ArticleForm;
import com.example.firstproject.entity.Article;
import com.example.firstproject.repository.ArticleRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
public class ArticleApiController { 
    @Autowired
    private ArticleRepository articleRepository;
    
    //GET
    @GetMapping("/api/articles")
    public List<Article> index() {
        return articleRepository.findAll();
    }

    @GetMapping("/api/articles/{id}")
    public Article show(@PathVariable Long id) {
        return articleRepository.findById(id).orElse(null);
    }
    
    //POST
    @PostMapping("/api/articles")
    public Article create(@RequestBody ArticleForm dto) {
        Article article = dto.toEntity();
        return articleRepository.save(article);
    }
    
    //PATCH
    @PatchMapping("/api/articlces/{id}")
    public ResponseEntity<Article> update(@PathVariable Long id, @RequestBody ArticleForm dto) {
        Article article = dto.toEntity();
        log.info("id: {}, article: {}", id, article.toString());
        Article target = articleRepository.findById(id).orElse(null);
        if (target == null || id != article.getId()) {
            log.info("잘못된 요청! id: {}, article: {}", id, article.toString());
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
        }
        target.patch(article);
        Article updated = articleRepository.save(article);
        return ResponseEntity.status(HttpStatus.OK).body(updated);
    }
    
    //DELETE
    @DeleteMapping("/api/articles/{id}")
    public ResponseEntity<Article> delete(@PathVariable Long id) {
        Article target = articleRepository.findById(id).orElse(null);
        if (target == null) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
        }
        articleRepository.delete(target);
        return ResponseEntity.status(HttpStatus.OK).build();
    }
}

-Article.java 수정

package com.example.firstproject.entity;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.ToString;

@AllArgsConstructor
@NoArgsConstructor //기본 생성자 추가 어노테이션
@ToString
@Entity
@Getter
public class Article {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) //DB가 id 자동 생성
    private Long id;
    @Column
    private String title;
    @Column
    private String content;

    public void patch(Article article) {
        if (article.title != null) {
            this.title = article.title;
        }
        if (article.content != null) {
            this.content = article.content;
        }
    }
}

[스프링 입문] 6. 회원 관리 예제 ~ 8. AOP

jiheechoi — Sat, 21 Jun 2025 11:43:11 +0900

6. 회원 관리 예제 - 웹 MVC 개발

1. 회원 웹 기능 - 홈 화면 추가

1) 홈 컨트롤러 추가(HomeCotroller 클래스)

2) 회원 관리용 홈(home.html)

2. 회원 웹 기능 - 등록

1) 회원 등록 폼 컨트롤러(MemberController 클래스 수정)

2) 회원 등록 폼 html(createMemberForm.html)

3) 웹 등록 화면에서 데이터를 전달 받을 폼 객체(MemberForm 클래스)

4) 회원 컨트롤러에서 회원을 실제 등록하는 기능(MemberController 클래스 수정)

@PostMapping
    public String create(MemberForm form) {
        Member member = new Member();
        member.setName(form.getName());

        memberService.join(member);

        return "redirect:/";
    }

3. 회원 웹 기능 - 조회

1) 회원 컨트롤러에서 조회 기능(MemberController 클래스 수정)

2) 회원 리스트 html(memberList.html)

7. 스프링 DB 접근 기술

1. H2 데이터베이스 설치

1) 다운로드 후 터미널에서 권한 부여('chmod 755 h2.sh') 후 실행 ('./h2.sh')

2) member 테이블 생성 후 insert문 실행해보기

2. 순수 JDBC

1) 환경설정

- jdbc 회원 리포지토리

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;
import org.springframework.jdbc.datasource.DataSourceUtils;
import javax.sql.DataSource;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class JdbcMemberRepository implements MemberRepository {
    private final DataSource dataSource;
    public JdbcMemberRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    @Override
    public Member save(Member member) {
        String sql = "insert into member(name) values(?)";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql,
                    Statement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, member.getName());
            pstmt.executeUpdate();
            rs = pstmt.getGeneratedKeys();
            if (rs.next()) {
                member.setId(rs.getLong(1));
            } else {
                throw new SQLException("id 조회 실패");
            }
            return member;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public Optional<Member> findById(Long id) {
        String sql = "select * from member where id = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, id);
            rs = pstmt.executeQuery();
            if(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                return Optional.of(member);
            } else {
                return Optional.empty();
            }
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public List<Member> findAll() {
        String sql = "select * from member";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            rs = pstmt.executeQuery();
            List<Member> members = new ArrayList<>();
            while(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                members.add(member);
            }
            return members;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public Optional<Member> findByName(String name) {
        String sql = "select * from member where name = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, name);
            rs = pstmt.executeQuery();
            if(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                return Optional.of(member);
            }
            {
            }
            return Optional.empty();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    private Connection getConnection() {
        return DataSourceUtils.getConnection(dataSource);
    }
    private void close(Connection conn, PreparedStatement pstmt, ResultSet rs)
    {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
        e.printStackTrace();
        }
        try {
            if (pstmt != null) {
                pstmt.close();
            }
        } catch (SQLException e) {
        e.printStackTrace();
        }
        try {
            if (conn != null) {
                close(conn);
            }
        } catch (SQLException e) {
        e.printStackTrace();
        }
}

private void close(Connection conn) throws SQLException {
    DataSourceUtils.releaseConnection(conn, dataSource);
}

- 스프링 설정 변경(SpringConfig.java 수정)

package hello.hello_spring.service;

import hello.hello_spring.repository.JdbcMemberRepository;
import hello.hello_spring.repository.MemberRepository;
import hello.hello_spring.repository.MemoryMemberRepository;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class SpringConfig {
    private final DataSource dataSource;
    public SpringConfig(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository());
    }
    @Bean
    public MemberRepository memberRepository() {
// return new MemoryMemberRepository();
        return new JdbcMemberRepository(dataSource);
    }
}

3. 스프링 통합 테스트(MemberServiceIntegrationTest 클래스)

@SpringBootTest : 스프링 컨테이너를 띄워서 실제 애플리케이션 환경과 동일하게 테스트할 수 있게 해준다.
@Transactional : 테스트 실행 시 트랜잭션을 시작하고 완료 후 자동으로 롤백하여 DB에 데이터가 남지 않게 해 다음 테스트에 영향을 주지 않게 해준다.

package hello.hello_spring.service;

import hello.hello_spring.domain.Member;
import hello.hello_spring.repository.MemberRepository;
import hello.hello_spring.repository.MemoryMemberRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

@SpringBootTest
@Transactional
class MemberServiceIntegrationTest {

    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    public void 회원가입() throws Exception {
        //Given
        Member member = new Member();
        member.setName("hello");

        //When
        Long saveId = memberService.join(member);

        //Then
        Member findMember = memberRepository.findById(saveId).get();
        assertEquals(member.getName(), findMember.getName());
    }

    @Test
    public void 중복_회원_예외() throws Exception {
        //Given
        Member member1 = new Member();
        member1.setName("spring");
        Member member2 = new Member();
        member2.setName("spring");

        //When
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class,
                () -> memberService.join(member2));//예외가 발생해야 한다.
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }
}

4. 스프링 JdbcTemplate

1) 스프링 JdbcTemplate 회원 리포지토리

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public class JdbcTemplateMemberRepository implements MemberRepository {

    private JdbcTemplate jdbcTemplate;

    public JdbcTemplateMemberRepository(DataSource dataSource) {
        jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Override
    public Member save(Member member) {
        SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
        jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");

        Map<String, Object> parameters = new HashMap<>();
        parameters.put("name", member.getName());

        Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));
        member.setId(key.longValue());
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        List<Member> result = jdbcTemplate.query("select * from member where id = ?", memberRowMapper(),id);
        return result.stream().findAny();
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> result = jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name);
        return result.stream().findAny();
    }

    @Override
    public List<Member> findAll() {
        return jdbcTemplate.query("select * from member", memberRowMapper());
    }

    private RowMapper<Member> memberRowMapper(){
        return (rs, rowNum) -> {

            Member member = new Member();
            member.setId(rs.getLong("id"));
            member.setName(rs.getString("name"));
            return member;
        };
    }
}

5. JPA

-JPA는 SQL을 직접 작성하지 않아도 객체 중심으로 데이터를 다룰 수 있게 해 개발 생산성과 유지보수성을 높여주는 기술임.

1) build.gradle 파일에 JPA, h2 데이터베이스 관련 라이브러리 추가

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	runtimeOnly 'com.h2database:h2'testImplementation('org.springframework.boot:spring-boot-starter-test') {
	exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}

2) 스프링 부트에 JPA 설정 추가

spring.application.name=hello-spring
spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

3) JPA 엔티티 매핑(Member 클래스)

package hello.hello_spring.domain;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

4) JPA 회원 리포지토리(JpaMemberReposityory 클래스)

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;
import jakarta.persistence.EntityManager;

import java.util.List;
import java.util.Optional;

public class JpaMemberRepository implements MemberRepository {

    private final EntityManager em;

    public JpaMemberRepository(EntityManager em) {
        this.em = em;
    }
    public Member save(Member member) {
        em.persist(member);
        return member;
    }
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }
    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }
    public Optional<Member> findByName(String name) {
        List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
        return result.stream().findAny();
    }
}

6. 스프링 데이터 JPA

-스프링 부트와 JPA 위에 스프링 데이터 JPA를 사용하면 반복적인 CRUD 코드 없이 인터페이스만으로도 개발이 가능해져 생산성이 비약적으로 향상되고, 개발자는 핵심 비즈니스 로직에 집중할 수 있음.

1) 스프링 데이터 JPA 회원 리포지토리(SpringDataJpaMemberRepository 클래스)

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {

    @Override
    Optional<Member> findByName(String name);
}

2) 스프링 데이터 JPA 회원 리포지토리를 사용하도록 스프링 설정 변경

package hello.hello_spring.service;

import hello.hello_spring.repository.*;
import jakarta.persistence.EntityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class SpringConfig {
    private final MemberRepository memberRepository;

    @Autowired
    public SpringConfig(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository);
    }
    //@Bean
    //public MemberRepository memberRepository() {
        // return new MemoryMemberRepository();
        // return new JdbcMemberRepository(dataSource);
        //return new JdbcTemplateMemberRepository(dataSource);
        //return new JpaMemberRepository(em);
   // }
}

8. AOP

1. AOP가 필요한 상황

-회원 가입, 회원 조회 등 모든 메소드의 실행 시간을 측정하고 싶다면 AOP가 필요함.

시간 측정은 공통 관심 사항이며, 비즈니스 로직(핵심 관심 사항)과는 분리되어야 함.
시간 측정 코드를 각 메소드에 직접 작성하면 유지보수가 어렵고 중복이 많아짐.
로직 수정 시 모든 코드를 찾아서 변경해야 하는 번거로움이 생김
OOP만으로는 메소드 실행 전후 처리를 효율적으로 분리하기 어려움.

-> AOP를 사용하면 실행 시간 측정과 같은 공통 로직을 핵심 로직과 분리해 깔끔하게 관리 가능.

2. AOP 적용

[스프링부트] 2. MVC 패턴 이해와 실습

jiheechoi — Fri, 23 May 2025 02:35:07 +0900

1. 뷰 템플릿과 MVC 패턴

1) 뷰 템플릿이란

-뷰 템플릿은 화면을 담당하는 기술로, 웹 페이지를 하나의 틀로 만들고 여기에 변수를 삽입해 서로 다른 페이지로 보여줌.

-1장에서 스프링 부트 프로젝트를 만들 때 추가한 머스테치가 바로 뷰 템플릿을 만드는 도구에 해당.

2) MVC 패턴

-MVC 패턴: 웹페이지를 화면에 보여주고(view), 클라이언트의 요청을 받아 처리하고(controller), 데이터를 관리하는(model) 역할을 나누는 기법

-컨트롤러: 클라이언트의 요청에 따라 서버에서 이를 처리하는 역할을 함.

-모델: 데이터를 관리하는 역할을 함.

2. MVC 패턴을 활용해 뷰 템플릿 페이지 만들기

(1) 뷰 템플릿 페이지 만들기: src > main > resources > templates 에 greetings.mustache 작성

(2) 컨트롤러 만들고 실행하기

-컨트롤러는 src > main > java 디렉터리에 있는 기본 패키지 아래에 하나의 패키지로 만듦.

-만든 controller 패키지 밑에 FirstController 클래스를 만들고 이 클래스가 컨트롤러임을 선언하는 @Controller 어노테이션을 작성함.

-반환형이 문자열인 niceToMeetYou() 메서드를 선언하여 앞에서 만든 greetings.mustache 페이지를 반환하도록 함.

-niceToMeetYou 메서드 앞에 @GetMapping()을 추가하고 괄호 안에 URL 주소인 "/hi"를 넣음 -> 페이지(greetings.mustache)를 반환해 달라는 URL 요청을 접수하는 부분임. 웹 브라우저에서 localhost:8080/hi로 접속하면 greetings.mustache 파일을 찾아 반환하라는 뜻.

localhost:8080/hi

(3) 모델 추가하기

greetings.mustache에 변수 추가

컨트롤러의 메서드에서 매개변수로 모델을 받아도록 수정하고 username 변수 등록

3. MVC의 역할과 실행 흐름 이해하기

-웹 서비스는 클라이언트-서버 구조로 동작하고, 스프링 부트는 서버의 역할을 함.

-서버는 모델, 뷰, 컨트롤러가 유기적으로 역할을 분담해 클라이언트의 요청을 처리함. -> 컨트롤러가 클라이언트의 요청을 받고, 뷰가 최종 페이지를 만들고, 모델이 최종 페이지에 쓰일 데이터를 뷰에 전달함.

1) /hi 페이지의 실행 흐름(FirstController.java)

이 파일이 컨트롤러임을 선언함.
클라이언트로부터 "/hi"라는 요청을 받아 접수
"/hi"라는 요청을 받음과 동시에 niceToMeetYou() 메서드를 수행함.
뷰 템플릿 페이지에서 사용할 변수를 등록하기 위해 모델 객체를 매개변수로 가져옴.
모델에서 사용할 변수를 등록함. 변숫값에 따라 서로 다른 뷰 템플릿 페이지 출력됨.
메서드를 수행한 결과로 greetings.mustache 파일 반환함. return 문에는 파일 이름만 작성하면 됨.

2) /bye 페이지의 실행 흐름

bye.mustache

FirstController 수정

4. 뷰 템플릿 페이지에 레이아웃 적용하기

-레이아웃이란 화면에 요소를 배치하는 일을 말함.

-헤더-푸터 레이아웃은 가장 기본이 되는 레이아웃임.

상단의 헤더 영역에는 사이트 안내를 위한 내비게이션을 넣음.
하단의 푸터 영역에는 사이트 정보를 넣음.
두 영역 사이에는 사용자가 볼 핵심 내용인 콘텐트를 배치함.

1) /hi 페이지에 헤더-푸터 레이아웃 적용하기

*greetings.mustache 페이지를 쉽고 빠르게 꾸미기 위해 부트스트랩을 사용하자.(부트스트랩이란 웹 페이지를 쉽게 만들 수 있도록 작성해 놓은 코드 모음으로 각종 레이아웃, 버튼, 입력창 등 디자인을 미리 구현해 놓은 것)

-greetings.mustache 코드 작성

<!doctype html>
<html lang="en">
<head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">

    <title>Hello, world!</title>
</head>
<body>
    <!-- navigation -->
    <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <div class="container-fluid">
            <a class="navbar-brand" href="#">Navbar</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse" id="navbarSupportedContent">
                <ul class="navbar-nav me-auto mb-2 mb-lg-0">
                    <li class="nav-item">
                        <a class="nav-link active" aria-current="page" href="#">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="#">Link</a>
                    </li>
                    <li class="nav-item dropdown">
                        <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">
                            Dropdown
                        </a>
                        <ul class="dropdown-menu" aria-labelledby="navbarDropdown">
                            <li><a class="dropdown-item" href="#">Action</a></li>
                            <li><a class="dropdown-item" href="#">Another action</a></li>
                            <li><hr class="dropdown-divider"></li>
                            <li><a class="dropdown-item" href="#">Something else here</a></li>
                        </ul>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link disabled" href="#" tabindex="-1" aria-disabled="true">Disabled</a>
                    </li>
                </ul>
                <form class="d-flex">
                    <input class="form-control me-2" type="search" placeholder="Search" aria-label="Search">
                    <button class="btn btn-outline-success" type="submit">Search</button>
                </form>
            </div>
        </div>
    </nav>

    <!-- content -->
    <div class="bg-dark text-white p-5">
        <h1>{{username}}님, 반갑습니다!</h1>
    </div>

    <!-- site info -->
    <div class="mb-5 container-fluid">
        <hr>
        <p> CloudStudying : <a href="#">Privacy</a> : <a href="#">Terms</a></p>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>

</body>
</html>

/hi 페이지에 헤더-푸터 레이아웃 적용

2) /bye 페이지에 헤더-푸터 레이아웃 적용하기

-앞선 방식과 똑같이 수행한다면 코드가 너무 길고 비효율적이므로 /hi 페이지를 템플릿화해서 사용함. -> 템플릿화란, 코드를 하나의 틀로 만들어 변수화한다는 뜻임.

-특정 코드 영역을 변수화해 사용하려면 각 영역을 발췌하여 템플릿 파일로 만들어야 함(templates 디렉터리)

뷰 템플릿 파일을 불러올 떄는 일반 변수를 {{변수명}}으로 사용하는 것과 달리 {{>파일명}}으로 작성함.greetins.mustache 파일의 내비게이션 바 부분을 잘라내 templates > layouts 디렉터리에 header.mustache로 만들고, 푸터 부분 역시 잘라내 footer.mustache에 붙여넣음.

greetings.mustache 수정

goodbye.mustache 수정

[스프링부트] 1. 스프링 부트 개요

jiheechoi — Fri, 23 May 2025 00:39:57 +0900

1. 스프링 부트란

- 스프링 부트란 더 쉽고 빠르게 자바 웹 프로그램을 만들 수 있도록 스프링 프레임워크를 개선한 것.

개발 환경 설정을 간소화: 스프링은 버전에 따라 동작하는 외부 라이브러리를 일일이 찾아 연동해야 했지만, 스프링 부트는 미리 설정된 스타터 프로젝트로 외부 라이브러리를 최적화해 제공하므로 사용자가 직접 연동할 필요가 x
웹 애플리케이션 서버를 내장: 스프링 부트는 내부에 톰캣이라는 웹 애플리케이션 서버를 내장하고 있어 웹 서비스를 jar 파일로 간편하게 배포 가능

2. 스프링 부트 개발 환경 설정하기

JDK 설치하기
IDE 설치하기
스프링 부트 프로젝트 만들기

(1) Spring Initializr 페이지에 접속하여 스프링 부트 프로젝트를 만든다.

(2)다운로드 받은 프로젝트의 압축을 풀고 인텔리제이에서 실행한다. 모든 빌드가 끝나면 BUILD SUCCESSFUL 메시지가 나온다.

(3) 메인 메서드 실행해 프로젝트 동작해보기(헬로 월드! 출력하기)

localhost:8080/hello.html

3. 웹 서비스의 동작 원리 이해하기

1) 클라이언트-서버 구조

-웹 서비스는 클라이언트의 요청에 따른 서버의 응답으로 동작함.

-클라이언트: 서비스를 사용하는 프로그램 또는 컴퓨터

-서버: 서비스를 제공하는 프로그램 또는 컴퓨터

2) localhost:8080/hello.html의 의미

-localhost: 실행 중인 서버의 주소 중 특별한 주소인 '내 컴퓨터'를 의미함.

-8080: 포트번호를 의미함. 스프링 부트 프로젝트는 톰캣에 담겨 8080에서 기본 실행됨.

-hello.html: 서버에 요청하는 파일을 의미함.

-웹 브라우저에서 localhost:8080/hello.html로 접속하면 내 컴퓨터의 8080번에서 수행되는 서버에 hello.html 파일을 요청함. 이렇게 파일을 직접 지정할 경우 스프링 부트는 기본적으로 src > main > resources > static 디렉터리에서 파일을 찾음.

[Spring 입문] 4. 회원 관리 예제 - 백엔드 개발

jiheechoi — Sat, 10 May 2025 12:23:42 +0900

1. 비즈니스 요구사항 정리

데이터: 회원 ID, 이름
기능: 회원 등록, 조회
아직 DB는 선정되지 않았다는 시나리오
클래스 의존관계는 다음과 같다.

2. 회원 도메인과 리포지토리 만들기

-회원 객체(Member 클래스)

package hello.hello_spring.domain;

public class Member {
    private Long id;    //시스템이 데이터를 구분하기 위해 저장하는 임의의 아이디
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

- 회원 리포지토리 인터페이스(MemberRepository 인터페이스)

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;

import java.util.List;
import java.util.Optional;

public interface MemberRepository {

    Member save(Member member); //회원을 저장소에 저장
    Optional<Member> findById(Long id); //저장소에서 id로 회원찾기
    Optional<Member> findByName(String name);   //저장소에서 name으로 회원찾기
    List<Member> findAll(); //지금까지 저장된 모든 회원 리스트를 반환
    
}

-회원 리포지토리 메모리 구현체(MemoryMemberRepository 클래스)

package hello.hello_spring.repository;

import hello.hello_spring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {

    private static Map<Long, Member> store = new HashMap<>();
    private static long sequence = 0L;

    @Override
    public Member save(Member member) {
        member.setId(++sequence);
        store.put(member.getId(), member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id));
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }

    @Override
    public List<Member> findAll() {
        return new ArrayList<>(store.values());
    }
}

3. 회원 리포지토리 테스트 케이스 작성

-개발한 기능을 실행하여 테스트 -> main 메소드를 통한 실행 OR 컨트롤러를 통한 실행으로 테스트 가능

-그러나 이러한 방법은 오래 걸리고 반복 실행하기 어렵고 여러 테스트를 한번에 실행하기 어려움 -> JUnit 프레임워크를 이용

-src/test/java 하위 폴더에 생성

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.*;

class MemoryMemberRepositoryTest {
	MemoryMemberRepository repository = new MemoryMemberRepository();
	@AfterEach
	public void afterEach() {
		repository.clearStore();
	}
	@Test
	public void save() {
		//given
		Member member = new Member();
		member.setName("spring");
		
        //when
		repository.save(member);
		
        //then
		Member result = repository.findById(member.getId()).get();
		assertThat(result).isEqualTo(member);
	}
	@Test
	public void findByName() {
		//given
		Member member1 = new Member();
		member1.setName("spring1");
		repository.save(member1);
		
        Member member2 = new Member();
		member2.setName("spring2");
		repository.save(member2);
		
        //when
		Member result = repository.findByName("spring1").get();
		
        //then
		assertThat(result).isEqualTo(member1);
	}
	@Test
	public void findAll() {
		//given
		Member member1 = new Member();
		member1.setName("spring1");
		repository.save(member1);
	
    	Member member2 = new Member();
		member2.setName("spring2");
		repository.save(member2);
		
        //when
		List<Member> result = repository.findAll();
		
        //then
		assertThat(result.size()).isEqualTo(2);
	}
}

@AfterEach
각 테스트 실행 후 저장소(repository)를 비워주는 메소드. 테스트 간 데이터 충돌 방지용.
save() 테스트
→ save() 메소드로 회원을 저장한 뒤, findById()로 잘 저장됐는지 확인.
findByName() 테스트
→ 이름으로 회원을 검색했을 때, 올바른 회원 객체가 반환되는지 검증.
findAll() 테스트
→ 저장된 모든 회원 목록을 조회했을 때, 기대한 개수와 일치하는지 확인.

4. 회원 서비스 개발

package hello.hello_spring.service;

import hello.hello_spring.domain.Member;
import hello.hello_spring.repository.MemberRepository;
import hello.hello_spring.repository.MemoryMemberRepository;

import java.util.List;
import java.util.Optional;

public class MemberService {
    
    private final MemberRepository memberRepository = new MemoryMemberRepository();
    
    /* 회원가입 */
    public Long join (Member member) {
        validateDuplicatemember(member);    //중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicatemember(Member member) {
        memberRepository.findByName(member.getName())
                        .ifPresent(m -> {
                            throw new IllegalStateException("이미 존재하는 회원입니다.");
                        });
    }
    
    /* 전체 회원 조회 */
    public List<Member> findMembers(){
        return memberRepository.findAll();
    }
    
    public Optional<Member> findOne(Long memberId){
        return memberRepository.findById(memberId);
    }
}

memberRepository:
→ 회원 데이터를 저장하고 조회하는 리포지토리로, 현재는 MemoryMemberRepository로 구현됨.
join(Member member):
→ 회원 가입 로직을 담당.
→ 내부적으로 중복 회원 검증을 먼저 수행한 후, 검증을 통과하면 저장.
validateDuplicatemember(Member member):
→ 저장된 회원 중 같은 이름이 있는지 확인.
→ 존재할 경우 IllegalStateException 예외 발생

5. 회원 서비스 테스트

package hello.hello_spring.service;

import hello.hello_spring.domain.Member;
import hello.hello_spring.repository.MemoryMemberRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;

class MemberServiceTest {
    MemberService memberService;
    MemoryMemberRepository memberRepository;
    
    @BeforeEach
    public void beforeEach() {
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }
    
    @AfterEach
    public void afterEach() {
        memberRepository.clearStore();
    }
    
    @Test
    public void 회원가입() throws Exception {
        //Given
        Member member = new Member();
        member.setName("hello");
        
        //When
        Long saveId = memberService.join(member);
        
        //Then
        Member findMember = memberRepository.findById(saveId).get();
        assertEquals(member.getName(), findMember.getName());
    }
    
    @Test
    public void 중복_회원_예외() throws Exception {
        //Given
        Member member1 = new Member();
        member1.setName("spring");
        Member member2 = new Member();
        member2.setName("spring");
        
        //When
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class,
                () -> memberService.join(member2));//예외가 발생해야 한다.
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }
}

[Spring 입문] 5. 스프링 빈과 의존관계

jiheechoi — Sat, 10 May 2025 12:14:56 +0900

1. 스프링 빈이란?

-스프링 빈이란 스프링 컨테이너에서 관리하는 객체를 말함.

-스프링 빈을 등록하는 방식에는 두가지가 있음.

컴포넌트 스캔과 자동 의존관계 설정
자바 코드로 직접 스프링 빈 등록

2. 컴포넌트 스캔과 자동 의존관계 설정

-컴포넌트 스캔 원리

@Component 애노테이션이 있으면 스프링 빈으로 자동 등록됨.
@Controller, @Service, @Repositroy 도 @Component 애노테이션을 포함하므로 스프링 빈으로 자동 등록됨

- 4장 예제 스프링 빈 등록해보기

-> 회원 서비스 스프링 빈 등록

@Service
public class MemberService {

    private final MemberRepository memberRepository;

    @Autowired
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

-> 회원 리포지토리 스프링 빈 등록

@Repository
public class MemoryMemberRepository implements MemberRepository {

    private static Map<Long, Member> store = new HashMap<>();
    private static long sequence = 0L;
    ... }

-> MemberController 클래스

package hello.hello_spring.controller;

import hello.hello_spring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class MemberController {

    private final MemberService memberService;

    @Autowired
    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }
}

3. 자바 코드로 직접 스프링 빈 등록하기

-4장 예제 스프링 빈 등록해보기

package hello.hellospring;

import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {
	@Bean
	public MemberService memberService() {
		return new MemberService(memberRepository());
	}
	@Bean
	public MemberRepository memberRepository() {
		return new MemoryMemberRepository();
	}	
}

-참고사항

XML 설정 방식
- 과거에는 XML로 설정했지만 최근에는 잘 사용하지 않음 → 생략 가능
DI 방법 3가지
- 필드 주입
- Setter 주입
- 생성자 주입 → 권장 방식 (의존관계가 실행 중 동적으로 변할 일이 거의 없기 때문)
컴포넌트 스캔 vs 수동 등록
- 컴포넌트 스캔 사용
  → 정형화된 코드 (예: Controller, Service, Repository)
- 설정을 통한 수동 등록
  → 정형화되지 않거나, 상황에 따라 구현 클래스를 바꿔야 하는 경우
@Autowired 주의점
- @Autowired는 스프링이 관리하는 객체(=스프링 빈) 에서만 동작
- 직접 new로 생성한 객체에서는 작동하지 않음

[SQL] 7. 복수의 테이블 다루기

jiheechoi — Fri, 11 Apr 2025 14:32:11 +0900

1. 집합 연산

1) 집합과 SQL

-SELECT 명령을 실행하면 결과로 몇 개의 행이 반환되는데, 이때 반환된 결과 전체를 하나의 집합이라고 생각하면 됨.

→즉, 데이터베이스에서는 테이블의 행이 집합의 요소에 해당함.

2) UNION으로 합집합 구하기

-SQL에서 합집합을 계산할 경우에는 UNION 키워드를 사용함.

SELECT a FROM sample71_a
UNION
SELECT b FROM sample71_b;

→UNION으로 두 개의 SELECT 명령을 하나로 연계해 질의 결과를 얻을 수 있음.

-이때 각각의 SELECT 명령의 열 내용은 서로 일치해야 함.

→열 이름이 다르더라도 열 개수와 자료형이 일치하면 됨.

-SELECT 명령들을 UNION 으로 묶을 때 나열 순서는 합집합의 결과에 영향을 주지 않음.

SELECT a FROM sample71_a
UNION
SELECT b FROM sample71_b
UNION
SELECT age FROM sample31;

-UNION으로 SELECT 명령을 결합해 합집합을 구하는 경우, 각 SELECT 명령에 ORDER BY를 지정할 수 없음. 즉, 마지막 SELECT 명령에만 지정할 수 있음.

-합집합의 결과를 정렬하는 것이기 때문에 ORDER BY 구를 사용하여 정렬할 때에는, 서로 동일한 별명을 붙여 이름을 일치시켜야 함.

SELECT a AS c FROM sample71_a
UNION
SELECT b AS c FROM sample71_b ORDER BY b;

-UNION은 합집합을 구하는 것이므로 두 개의 집합에서 겹치는 부분은 공통 요소가 됨.

-중복을 제거하지 않고 2개의 SELECT 결과를 그냥 합치고 싶은 경우, UNION ALL을 사용함.

→DISTINCT나 ALL로 중복제거 여부를 지정할 수 있다는 점은 SELECT 명령과 동일하지만, UNION의 기본동작은 ALL이 아닌 DISTINCT임.

SELECT a FROM sample71_a
UNION ALL
SELECT b FROM sample71_b;

3) 교집합과 차집합

-SQL에서 교집합을 구하려면 INTERSECT를 이용하고, 차집합을 구하려면 EXCEPT를 이용함. (MySQL은 지원 X)

2. 테이블 결합

1) 곱집합과 교차결합

-집합 X 와 집합 Y의 곱집합은 집합 X의 요소에 집합 Y의 각 요소를 붙여 계산하는 것임.

-FROM 구에 복수의 테이블을 지정하면 교차결합을 함. 교차결합은 두 개의 테이블을 곱집합으로 계산함.

SELECT * FROM sample72_x, sample72_y;

-UNION으로 합집합을 구하면 세로 방향으로 더해지게 되는 한편, FROM 구로 테이블을 결합할 경우 가로 방향으로 더해지게 됨.

2) 내부 결합

-내부 결합이란, 교차결합으로 계산된 곱집합에서 원하는 조합을 검색하는 것임.

SELECT 상품.상품명, 재고.재고수 FROM 상품, 재고수 
 WHERE 상품.상품코드 = 재고.재고수
  AND 상품.상품분류 = '식료품';

-교차결합으로 계산된 곱집합에서 원하는 조합을 검색하는 조건을 '결합조건' 이라고 부름.

3) INNER JOIN 으로 내부 결합하기

-INNER JOIN으로 두 개 테이블을 가로로 결합할 수 있음.

→SYNTAX: SELECT * FROM 테이블명1 INNER JOIN 테이블명2 ON 결합조건

SELECT 상품.상품명, 재고수.재고수
 FROM 상품 INNER JOIN 재고수
  ON 상품.상품코드 = 재고수.상품코드
WHERE 상품.상품분류 = '식료품';

4) 내부결합을 활용한 데이터 관리

-코드와 이름을 가지는 테이블로 분할해 관리하면 저장공간을 절약할 수 있음.

-외부키: 다른 테이블의 기본키를 참조하는 열

-자기결합: 테이블에 별명을 붙일 수 있는 기능을 이용해 같은 테이블끼리 결합하는 것

→자기 자신의 기본키를 참조하는 열을 자기 자신이 가지는 데이터 구조로 되어 있을 경우에 자주 사용함.

SELECT S1.상품명, S2.상품명
 FROM 상품 S1 INNER JOIN 상품 S2
  ON S1.상품코드 = S2.상품코드;

5) 외부결합

-결합 방법은 크게 내부결합과 외부결합의 두가지로 구분됨.

-외부결합은 어느 한 쪽에만 존재하는 데이터행을 어떻게 다룰지를 변경할 수 있는 결합 방법

SELECT 상품3.상품명, 재고수.재고수
 FROM 상품3 LEFT JOIN 재고수
  ON 상품3.상품코드 = 재고수.상품코드
WHERE 상품3.상품분류 = '식료품';

-외부결합은 결합하는 테이블 중 어느 쪽을 기준으로 할지 결정할 수 있음.

→왼쪽 테이블을 기준으로 결합할 때: LEFT JOIN / 오른쪽 테이블을 기준으로 결합할 때: RIGHT JOIN

-구식방법에서의 외부결합(Oracle): FROM 구에 결합 조건을 기술하지 않고 WHERE 구로 결합조건을 지정. 그냥 조건식을 지정하면 내부결합이 되어버리므로 외부결합으로 진행하고 싶은 경우에는 (+) 라는 특수 기호를 붙여서 조건식을 지정함.

SELECT 상품3.상품명, 재고수.재고수
 FROM 상품3.재고수
 WHERE 상품3.상품코드 = 재고수.상품코드 (+)
  AND 상품3.상품분류 = '식료품';

3. 관계형 모델

1) 관계형 모델

-관계형 모델의 기본적인 요소는 릴레이션임.

→관계형 모델의 릴레이션은 SQL에서 말하는 테이블에 해당됨.

-릴레이션에는 몇가지 속성이 있는데, 이 속성은 속성 이름과 형 이름으로 구성됨.

→관계형 모델의 속성은 SQL에서 말하는 열에 해당함.

-SQL에서의 행은 관계형 모델에서 튜플이라고 불린다.

-관계대수: 릴레이션은 튜플의 집합이며, 릴레이션에 대한 연산이 집합에 대한 연산에 대응된다는 이론

→관계대수의 기본규칙

하나 이상의 관계를 바탕으로 연산한다.
연산한 결과, 반환되는 것 또한 관계이다.
연산을 중첩구조로 실행해도 상관없다.

2)관계형 모델과 SQL

-합집합: 합집합은 릴레이션끼리의 덧셈을 말함.

→SQL에서는 UNION에 해당함.

-차집합: 차집합은 릴레이션끼리의 뺄셈을 말함

→SQL에서는 EXCEPT에 해당함.

-교집합: 교집합은 릴레이션끼리의 공통부분을 말함.

→SQL에서는 INTERSECT에 해당함.

-곱집합: 곱집합은 릴레이션끼리의 곱셈을 말함.

→SQL에서는 FROM구에 복수의 테이블을 지정한 경우 곱집합으로 계산됨.

-선택: 선택은 튜플의 추출을 말하며, 제한이라고 불리기도 함.

→SQL에서 튜플은 행을 말하기 때문에, WHERE 구에 조건을 지정해 검색하는 것에 해당.

-투영: 선택은 속성의 추출을 말함.

→SQL에서 속성은 열을 말하기 때문에, SELECT 구에 결과로 반환할 열을 지정하는 것에 해당함.

-결합: 결합은 릴레이션끼리 교차결합해 계산된 곱집합에서 결합조건을 만족하는 튜플을 추출하는 연산

→SQL에서는 내부결합에 해당함.

[SQL] 6. 데이터베이스 객체 작성과 객체

jiheechoi — Sat, 5 Apr 2025 01:02:10 +0900

1. 데이터베이스 객체

1) 데이터베이스 객체

-데이터베이스 객체란, 테이블이나 뷰, 인덱스 등 데이터베이스 내에 정의하는 실체를 가지는 모든 것을 의미함.

-객체에 따라 데이터베이스에 저장되는 내용이 달라짐.

-SELECT나 INSERT 등은 클라이언트에서 객체를 조작하는 SQL 명령어이지, 객체가 아님.

-객체에는 이름을 붙일 수 있고, 이름을 붙일 때 다음의 제약사항을 따름.

기존 이름이나 예약어와 중복하지 않음
숫자로 시작할 수 없음
언더스코어(_) 이외의 기호는 사용할 수 없음
한글을 사용할 때는 더블쿼트(MySQL에서는 백쿼트)로 둘러쌈
시스템이 허용하는 길이를 초과하지 않음

2) 스키마

-데이터베이스 객체는 스키마라는 그릇 안에 만들어짐.

-스키마가 서로 다르면 객체의 이름이 같아도 상관 없음.

-데이터베이스에 테이블을 작성해서 구축해나가는 작업을 '스키마 설계'라고 함.

-테이블과 스키마는 무엇인가를 담는 그릇 역할을 한다는 점과 각각의 그릇 안에서는 중복하지 않도록 이름을 정한다는 점이 유사함.

→ 이처럼 이름이 충돌하지 않도록 기능하는 그릇을 '네임스페이스'라고 부름.

2. 테이블 작성/삭제/변경

1) 테이블 작성

-SELECT, INSERT, DELETE, UPDATE는 SQL 명령 중에서도 DML(데이터 조작)로 분류되고, 스키마 내의 객체를 관리하는 명령은 DDL임.

-테이블을 작성할 때 CREATE TABLE 명령을 사용함.

→ SYNTAX

CREATE TABLE 테이블명(
 열 정의1,
 열 정의2,
 ...
 )

→ 열 정의 SYNTAX

열명 자료형 [DEFAULT 기본값] [NULL|NOT NULL]

CREATE TABLE sample62(
 no INTEGER NOT NULL,
 a VARCHAR(30),
 b DATE);

2) 테이블 삭제

-테이블을 삭제할 떄에는 DROP TABLE 명령을 사용함.

-SYNTAX: DROP TABLE 테이블명

-많은 데이터베이스가 SQL 명령을 실행할 때 확인을 요구하지 않으므로 실수로 삭제하지 않도록 주의해야 함.

-테이블 정의는 그대로 둔채 데이터만 삭제할 때는 DELETE 명령을 사용함.

→ 이때, WHERE 조건을 지정하지 않으면 모든 행을 삭제할 수 있음.

-DELETE 명령은 행 단위로 여러가지 내부처리가 일어나므로 삭제할 행이 많으면 처리속도가 느림.

→ TRUNCATE TABLE 명령을 사용하면 모든 행을 삭제해아 할 때 빠른 속도로 삭제 가능함.(DDL 명령, 삭제할 행/WHERE 구 지정 불가)

→ SYNTAX: TRUNCATE TABLE 테이블명

3) 테이블 변경

-테이블을 작성한 뒤 열 구성을 변경하고 싶다면 ALTER TABLE 명령을 사용함.

-ALTER TABLE로 할 수 있는 일은 크게 두가지로 분류함.

열 추가/삭제/변경
제약 추가/삭제

-열 추가: ALTER TABLE에서 열을 추가할 떄는 ADD 하부명령을 통해 실행할 수 있음.

→ SYNTAX: ALTER TABLE 테이블명 ADD 열 정의

ALTER TABLE sample62 ADD newcol INTEGER;

-열 속성 변경: MODIFY 하부명령을 실행. 열 이름은 변경할 수 없고, 자료형/기본값 등의 속성은 변경 가능함.

→ SYNTAX: ALTER TABLE 테이블명 MODIFY 열 정의

ALTER TABLE sample62 MODIFY newcol VARCHAR(20);

-열 이름 변경: CHANGE 하부 명령. CHANGE는 열 이름뿐만 아니라 열 속성도 변경할 수 있음.

→ SYNTAX: ALTER TABLE 테이블명 CHANGE [기존 열 이름] [신규 열 정의]

ALTER TABLE sample62 CHANGE newcol c VARCHAR(20);

-열 삭제: DROP 하부 명령.

→ SYNTAX: ALTER TABLE 테이블명 DROP 열명

ALTER TABLE sample62 DROP c;

4) ALTER TABLE 로 테이블 관리

-최대길이 연장: 문자열의 최대길이 연장

ALTER TABLE sample MODIFY col VARCHAR(30)

-열 추가: 테이블에 열을 추가

ALTER TABLE sample ADD new_col INTEGER

3. 제약

1) 테이블 작성시 제약 정의

-CREATE TABLE로 테이블을 작성할 떄 제약을 같이 정의함.

-열에 대해 정의하는 제약을 '열 제약'이라고 부르고, 한 개의 제약으로 복수의 열에 제약을 설명하는 경우를 '테이블 제약'이라고 부름.

CREATE TABLE sample631(
 a INTEGER NOT NULL,
 b INTEGER NOT NULL UNIQUE,
 c VARCHAR(30)
 );

-제약에 이름을 붙이면 나중에 관리하기가 쉬워지므로 CONTSTRAINT 키워드를 사용해서 이름을 지정해야 함.

CREATE TABLE sample632(
 a INTEGER NOT NULL,
 b INTEGER NOT NULL UNIQUE,
 c VARCHAR(30)
 CONSTRAINT pkey_sample PRIMARY KEY (no, sub_no)
 );

2) 제약 추가

-열 제약 추가: ALTER TABLE로 열 정의를 변경할 수 있음. 기존 테이블을 변경할 경우에는 제약을 위반하는 데이터가 있는지 먼저 검사함.

ALTER TABLE sample631 MODIFY c VARCHAR (30) NOT NULL;

→ 만약 c 열에 NULL 값이 존재한다면 에러가 발생함.

-테이블 제약 추가: ALTER TABLE의 ADD 하부 명령으로 추가할 수 있음. 열 제약을 추가할 때와 마찬가지로 기존의 행을 검사해 추가할 제약을 위반하는 데이터가 있으면 에러 발생함.

ALTER TABLE sample631 ADD CONSTRAINT pkey_sample631 PRIMARY KEY(a);

3) 제약 삭제

-열 제약 삭제하기: MODIFY 명령어 이용하여 열 정의를 변경함.

ALTER TABLE sample631 MODIFY c VARCHAR(30);

-테이블 제약 삭제하기: DROP 하부 명령으로 삭제 가능

ALTER TABLE sample631 DROP CONSTRAINT pkey_sample631;

-단, 기본키는 테이블당 하나만 설정할 수 있기 때문에 위처럼 굳이 제약명을 지정하지 않고도 삭제 가능함.

4) 기본키

-기본키 제약은 열을 기본키로 지정해 유일한 값을 가지도록 하는 구조임.

-기본키로 지정할 열은 NOT NULL 제약이 설정되어 있어야 하고, INSERT/UPDATE 명령을 실행할 때 중복되는 값을 추가/갱신하려 한다면 기본키 제약에 위반되므로 에러가 발생함.

CREATE TABLE sample634(
 p INTEGER NOT NULL,
 a VARCHAR NOT NULL,
 CONSTRAINT pkey_sample634 PRIMARY KEY(p)
 );

-기본키를 구성하는 열은 복수라도 상관없음. 복수의 열을 기본키로 지정했을 경우, 키를 구성하는 모든 열을 사용해서 중복하는 값이 있는지 없는지를 검사함.

4. 인덱스 구조

1) 인덱스

-인덱스는 테이블에 붙여진 색인이라고 할 수 있음.

-인덱스의 역할은 SELECT 명령에 WHERE 구로 조건을 지정하고 그에 일치하는 행을 찾는 검색 과정에서의 속도 향상임.

-인덱스는 테이블과는 별개의 독립된 데이터베이스 객체이지만, 테이블에 의존하는 객체라고 할 수 있음.

→ 데이터베이스의 인덱스에는 검색 시에 쓰이는 키워드와 대응하는 데이터 행의 장소가 저장되어 있음.

2) 검색에 사용하는 알고리즘

-풀 테이블 스캔: 인덱스가 지정되지 않은 테이블을 검색할 때 사용하는 방법. 테이블에 저장된 모든 값을 처음부터 차례로 조사해나가는 것.

-이진 탐색: 차례로 나열된 집합에 대해 처음부터 순서대로 조사하는 것이 아니고 집합을 반으로 나누어 조사하는 방법.

→ 대량의 데이터를 검색할 떄는 이진탐색이 훨씬 빠름.

-테이블에 인덱스를 작성하면 테이블 데이터와 별개로 인덱스용 데이터가 저장장치에 만들어지는데, 이때 이진트리라는 데이터 구조로 작성됨.

3) 유일성

-이진 트리는 중복된 값을 가지지 않는 구조임.

-기본키 제약은 이진 트리로 인덱스를 작성하는 데이터베이스가 많음.

5. 인덱스 작성과 삭제

1) 인덱스 작성

-CREATE INTDEX 명령으로 인덱스를 작성함.

-인덱스가 데이터베이스 객체가 될지 테이블의 열처럼 취급될지는 데이터베이스 제품에 따라 다름.

→ Oracle, DB2: 스키마 객체 / SQL server, MySQL: 테이블 내의 객체

-SYNTAX: CREATE INDEX 인덱스명 ON 테이블명 (열명1, 열명2, ...)

CREATE INDEX isample65 ON sample62(no);

→ sample62 테이블의 no열에 isample65라는 인덱스를 지정함.

2) 인덱스 삭제

-인덱스는 DROP INDEX 명령으로 삭제함.

→ SYNTAX1(인덱스가 스키마 객체인 경우) : DROP INDEX 인덱스명

→ SYNTAX1(인덱스가 테이블 내 객체인 경우) : DROP INDEX 인덱스명 ON 테이블명

-인덱스는 테이블에 의존하는 객체이므로 테이블을 삭제하면 테이블에 작성된 인덱스도 자동으로 삭제됨. 인덱스만 삭제하는 경우에는 DROP INDEX 명령으로 삭제함.

CREATE INDEX isample65 ON sample62(a);

3) EXPLAIN

-EXPLAIN 명령은 SQL 명령이 어떤 상태로 실행되는지 설명해주는 명령어임.

→ SYNTAX: EXPLAIN SQL 명령

-다만 이 SQL 명령은 실제로는 실행되지 않고 어떻게 실행되는지를 설명해줄 뿐임.

-EXPLAIN은 표준 SQL 에는 존재하지 않는 데이터베이스 의존형 명령임.

EXPLAIN SELECT * FROM sample62 WHERE a = 'a';

id	select_type	table	type	possible_keys	key
1	simple	sample62	ref	isample65	ismple65

→ possible_keys라는 곳에 사용될 수 있는 인덱스가 표시되며, key는 사용된 인덱스가 표시됨.

4) 최적화

-SELECT 명령을 실행할 떄 인덱스의 사용 여부를 선택하는 것은 데이터베이스 내부의 최적화에 의해 처리되는 부분임.

-내부처리에서는 명령을 실행하기 앞서 실행계획을 세우는데, 이 실행계획을 확인하는 명령이 EXPLAIN 명령임.

-실행 계획에서는 인덱스의 유무, 인덱스를 사용할 것인지 여부에 대해 데이터베이스 내부 최적화 처리를 통해 판단. 이때 판단 기준으로 인덱스의 품질도 고려함.

6. 뷰 작성과 삭제

1) 뷰

-뷰란 본래 데이터베이스 객체로 등록할 수 없는 SELECT 명령을 객체로서 이름을 붙여 관리할 수 있도록 한 것.

-뷰를 참조하면 그에 정의된 SELECT 명령의 실행결과를 테이블처럼 사용가능함.

-뷰를 작성하는 것으로 복잡한 SELECT 명령을 간략하게 표현할 수 있음.

-뷰는 테이블처럼 취급하지만 '실체가 존재하지 않는다'는 의미에서 '가상 테이블'이라고 불리기도 함.

→ 테이블처럼 데이터를 쓰고 지울 수 있는 저장공간을 가지지 않기 때문에 SELECT 명령에서만 사용하는 것을 권장함.

2) 뷰 작성과 삭제

-뷰의 작성: CREATE VIEW로 뷰의 이름과 SELECT 명령을 지정함.

→ SYNTAX(뷰 작성): CREATE VIEW 뷰명 AS SELECT 명령

CREATE VIEW sample_view_67 AS SELECT * FROM sample54;

SELECT * FROM sample_view_67

→ SYNTAX(열 지정하기): CREATE VIEW 뷰명 (열병1, 열명2, ...) AS SELECT 명령

-뷰의 열 지정을 생략한 경우에는 SELECT 명령의 SELECT 구에서 지정하는 열 정보가 수집되어 자동적으로 뷰의 열로 지정됨.

-뷰 삭제: DROP VIEW 이용

→ SYNTAX: DROP VIEW 뷰명

3) 뷰의 약점

-뷰는 대량의 저장공간을 필요로 하지 않는 대신, 계산능력을 필요로 하기 때문에 CPU 자원을 사용함.

-뷰를 참조하면 뷰에 등록되어 있는 SELECT 명령이 실행되고, 실행결과는 일시적으로 보존되며 뷰를 참조할 때마다 SELECT 명령이 실행됨.

-뷰의 약점

테이블에 보관하는 데이터 양이 많은 경우, 집계처리를 할 때 뷰가 사용되거나 뷰를 중첩해서 사용하는 경우 처리 속도가 저하됨.

-> 뷰에 지정된 테이블의 데이터가 자주 변경되지 않는 경우라면, 머티리얼라이즈드 뷰로 약점 보완 가능. (머티리얼라이즈드 뷰: 처음 참조되었을 때 데이터를 저장해두고 다시 참조할 떄 이전에 저장해 두었던 데이터를 사용하는 뷰)

부모 쿼리와 어떤 식으로든 연관된 서브쿼리의 경우, 뷰의 SELECT 명령으로 사용할 수 없음.(뷰를 구성하는 SELECT 명령은 단독으로도 실행할 수 있어야 하므로)

-> 함수테이블을 사용하여 보완가능함. (함수 테이블: 테이블을 결괏값으로 반환해주는 사용자 정의 함수. 함수는 인수를 지정할 수 있기 때문에 인수의 값에 따라 WHERE 조건을 붙여 결괏값을 바꿀 수 있음.)