초반에는 확실히 가능해 보였다. 코드 생성 속도는 놀라울 정도로 빨랐고, 반복 작업은 거의 즉시 해결되었다.

하지만 프로젝트가 커질수록 어려움을 맞이 했고 봇의 커밋만 있던 레파지토리에 납기와 품질을 지키 위해 결국 나의 커밋이 끼어들기 시작했다. 새로운 아이디어는 설렘에서 부담으로 전환 되었다.

생성은 빠르지만, 통합은 느리다

애플리케이션이 커질수록 다음과 같은 일이 반복되었다.

• 컨텍스트가 점점 많아지고

• 이를 AI에게 설명하는 오버헤드가 커졌으며

• 디자인과 코드의 일관성이 흔들리기 시작했다

• 기능이 많아 질수록 인프라와 보안의 부담은 점점 커져갔다.

아무리 skill을 정교하게 정의해도, 아무리 문서화를 상세히 해도, 결국 장기적인 설계 의도와 시스템의 정합성을 유지하는 일은 나의 몫이었다.

시간이 지날수록 깨닫게 되었다.

AI에게 기대했던 일들이 점점 다시 나에게 돌아오고 있었다.

생성은 AI가 담당했지만, 통합과 QC 책임은 여전히 개발자의 영역이었다.

명세 지옥

AI는 명세를 기반으로 동작한다. 주어진 정보 안에서 최적의 결과를 생성하는 데에는 매우 강하다.

하지만 현실의 소프트웨어 개발은 단순히 명세를 구현하는 일이 아니다.

현실에는:

• 불완전한 요구사항

• 암묵적인 도메인 지식

• 장기 유지보수 고려

• 리스크 판단과 안정성 확보

• 책임 있는 의사결정

이 존재한다.

AI는 뛰어난 생성 능력을 가졌지만, 위험을 감지하고 장기적인 안정성을 책임지는 존재는 아니다.

그 부분은 여전히 인간의 역할이다.

결론

AI는 분명 강하다. 그리고 앞으로 더 강해질 것이다.

하지만 AI는 개발자를 대체하는 존재가 아니라 하나의 개발 툴로 인식하게 되었다.

AI의 발전에 지나치게 긴장할 필요도, 과도하게 들뜰 필요도 없다.

AI가 우리의 기술적 구현 능력을 빠르게 따라잡고 있는 것은 사실이지만, 문제를 정의하고, 맥락을 이해하고, 책임 있는 결정을 내리는 능력은 또 다른 차원의 영역이다.

예전처럼 기본기를 다듬고, 꾸준히 나아가자.

AI는 새로운 개발 툴의 등장일 뿐이다. 공포에 휘둘릴 필요는 없다.

문제 상황

• OCI OKE 클러스터에서 ArgoCD 설치 후 private GitHub repository 연결 실패
• dial tcp 20.200.245.247:22: connect: connection timed out 에러 발생

문제 진단 과정

1. 네트워크 설정 확인

# 외부 연결 테스트
kubectl run test-curl --image=curlimages/curl --restart=Never -- curl -m 5 -I https://github.com
# 결과: Connection timed out

2. OCI VCN 설정 점검

• ✅ Security List: 0.0.0.0/0 Egress Rules 설정됨
• ✅ Route Table: Internet Gateway 연결됨
• ✅ Public Subnet: 워커 노드에 Public IP 할당됨
• ✅ NSG: 적용되지 않음

3. 핵심 문제 발견

# Host network Pod에서는 연결 성공
kubectl exec -n kube-system kube-proxy-xxx -- curl -I https://github.com
# HTTP/2 200 ✅

# 일반 Pod에서는 연결 실패  
kubectl run test --image=curlimages/curl -- curl -I https://github.com
# Connection timed out ❌

원인: OCI VCN-Native CNI에서 Pod의 외부 연결을 위한 SNAT 설정 이슈

임시 해결책

ArgoCD repo-server를 hostNetwork로 실행

# repo-server 설정 백업
kubectl get deployment argocd-repo-server -n argocd -o yaml > backup.yaml

# hostNetwork 설정 적용
kubectl patch deployment argocd-repo-server -n argocd --patch='{
  "spec": {
    "template": {
      "spec": {
        "hostNetwork": true,
        "dnsPolicy": "ClusterFirstWithHostNet"
      }
    }
  }
}'

결과 확인

kubectl get pods -n argocd | grep repo-server
# argocd-repo-server-xxx  1/1  Running

결론

• OCI OKE의 VCN-Native CNI에서 Pod 외부 연결 문제 발생
• hostNetwork 설정으로 임시 해결 가능
• 근본적 해결을 위해서는 OCI 지원팀 문의 필요

참고사항

• 이 문제는 OKE Quick Create로 생성된 클러스터에서 발생
• Security List, Route Table 등 모든 설정이 올바르더라도 Pod 레벨에서 외부 연결 차단됨
• Production 환경에서는 OCI 지원을 통한 근본적 해결 권장

객체의 구현부와 추상부를 분리하여 독립적으로 확장할 수 있도록 설계하는 구조적 디자인 패턴입니다. 이 패턴은 기능 계층과 구현 계층을 분리하여, 하나의 계층을 변경해도 다른 계층에 영향을 주지 않도록 설계합니다.

목적

• 기능(Fuctionality)와 구현(Implementation)을 분리하여 독립적인 확장을 가능하게 합니다.
• 계층 구조가 복잡해지는 것을 방지하고, 코드의 유연성과 확장성을 높입니다.
• 런타임 시에 구현 객체를 동적으로 변경할 수 있습니다.

구조

• Abstraction (추상화):
  • 기능 계층을 정의합니다.
  • 구현 객체에 대한 참조를 포함하고, 클라이언트가 사용할 인터페이스를 제공합니다.
• Implementor (구현부):
  • 구체적인 구현을 정의합니다.
  • 추상화 계층에 의해 호출됩니다.
• RefinedAbstraction (확장된 추상화):
  • Abstraction을 확장하여 추가 기능을 제공합니다.
• ConcreteImplementor (구체적인 구현부):
  • Implementor의 구체적인 구현을 제공합니다.

장점

• 기능과 구현의 독립적인 확장이 가능합니다. 하나를 변경해도 다른 계층에 영향을 미치지 않습니다.
• 런타임에서 구현 객체를 동적으로 변경할 수 있습니다.
• 복잡성 감소: 상속 관계가 많아지는 문제를 해결합니다.

단점

• 계층 분리를 위해 구현이 복잡해질 수 있음.
• 초기 설계 단계에서 계층을 명확히 구분하는 설계가 요구됩니다.

브리지 패턴의 예제

# Implementor: 색상을 정의하는 인터페이스
class Color:
    def apply_color(self):
        pass


# ConcreteImplementor: 색상의 구체적인 구현
class Red(Color):
    def apply_color(self):
        return "Red"


class Blue(Color):
    def apply_color(self):
        return "Blue"


# Abstraction: 모양을 정의하는 클래스
class Shape:
    def __init__(self, color: Color):
        self.color = color

    def draw(self):
        pass


# RefinedAbstraction: 모양의 구체적인 확장
class Circle(Shape):
    def draw(self):
        return f"Circle filled with {self.color.apply_color()} color"


class Square(Shape):
    def draw(self):
        return f"Square filled with {self.color.apply_color()} color"


# Client Code
red = Red()
blue = Blue()

circle = Circle(red)
square = Square(blue)

print(circle.draw())  # Output: Circle filled with Red color
print(square.draw())  # Output: Square filled with Blue color

복잡한 서브시스템을 단순화하기 위해 제공되는 단순한 인터페이스를 설계하는 구조적 디자인 패턴입니다. 여러 클래스와 그들의 메서드로 구성된 복잡한 시스템을 사용할 때, 클라이언트가 직접 복잡성을 다루지 않고 단순한 인터페이스만으로 시스템을 쉽게 사용할 수 있도록 도와줍니다.

목적

복잡한 서브시스템의 사용성을 개선하기 위해 사용됩니다. 클라이언트 코드가 서브시스템의 세부사항에 종속되지 않도록 보호합니다. 서브시스템 내부 구현이 변경되더라도 클라이언트 코드에 영향을 최소화합니다.

구조

• Subsystem (서브시스템): 복잡한 로직을 포함하는 클래스들의 집합입니다. 각 클래스는 고유한 기능을 가지고 있습니다.
• Facade (파사드): 서브시스템의 복잡성을 숨기고, 클라이언트가 사용할 단순화된 인터페이스를 제공합니다.
• Client (클라이언트): 파사드 객체를 사용해 서브시스템의 기능을 간접적으로 호출합니다.

장점

• 서브시스템의 복잡성 숨기기: 클라이언트는 단순화된 인터페이스를 통해 복잡한 서브시스템을 쉽게 사용할 수 있습니다.
• 유지보수성 증가: 서브시스템 내부 구현이 변경되더라도, 파사드 인터페이스만 유지되면 클라이언트 코드에는 영향을 미치지 않습니다.
• 서브시스템 의존성 감소: 클라이언트가 서브시스템의 구체적인 클래스에 의존하지 않도록 분리합니다.

단점

• 서브시스템의 모든 기능을 파사드에 노출하려면 복잡성이 증가할 수 있습니다.
• 잘못 설계된 파사드는 추가 기능 추가 시 유연성이 부족할 수 있습니다.

파사드 패턴의 예제

# Subsystem: 홈 시어터 구성 요소
class BluRayPlayer:
    def on(self):
        print("BluRay Player is ON")

    def play(self, movie: str):
        print(f"Playing movie: {movie}")

    def stop(self):
        print("Stopping BluRay Player")

    def off(self):
        print("BluRay Player is OFF")


class Projector:
    def on(self):
        print("Projector is ON")

    def wide_screen_mode(self):
        print("Projector is set to wide screen mode")

    def off(self):
        print("Projector is OFF")


class SurroundSoundSystem:
    def on(self):
        print("Surround Sound System is ON")

    def set_volume(self, level: int):
        print(f"Setting volume to {level}")

    def off(self):
        print("Surround Sound System is OFF")


# Facade: 홈 시어터 파사드
class HomeTheaterFacade:
    def __init__(self, blu_ray: BluRayPlayer, projector: Projector, sound_system: SurroundSoundSystem):
        self.blu_ray = blu_ray
        self.projector = projector
        self.sound_system = sound_system

    def watch_movie(self, movie: str):
        print("\nStarting the movie experience...")
        self.blu_ray.on()
        self.blu_ray.play(movie)
        self.projector.on()
        self.projector.wide_screen_mode()
        self.sound_system.on()
        self.sound_system.set_volume(10)

    def end_movie(self):
        print("\nEnding the movie experience...")
        self.blu_ray.stop()
        self.blu_ray.off()
        self.projector.off()
        self.sound_system.off()


# Client: 클라이언트 코드
blu_ray = BluRayPlayer()
projector = Projector()
sound_system = SurroundSoundSystem()

# Facade 객체 생성
home_theater = HomeTheaterFacade(blu_ray, projector, sound_system)

# 영화 관람
home_theater.watch_movie("Inception")
# 영화 종료
home_theater.end_movie()

프록시(Proxy) 패턴은 어떤 객체에 대한 접근을 제어하는 대리자 객체를 제공하는 구조적 디자인 패턴입니다. 프록시 객체는 실제 객체의 대리 역할을 하며, 클라이언트가 실제 객체에 접근할 때 이를 대신 처리하거나 중간 작업을 수행합니다. 프록시 패턴은 주로 객체 접근을 제어하고, 추가 기능(예: 로깅, 캐싱, 지연 로딩 등)을 추가할 때 유용합니다.

프록시 패턴은 클라이언트가 직접 접근하지 않도록 막아야 하거나, 객체 접근을 추가 로직으로 제어해야 할 때 사용됩니다. 예를 들어, 리소스가 큰 객체의 초기화를 지연시킨다거나, 객체 접근 시 인증을 체크하는 것 등이 프록시 패턴의 주요 사용 예입니다.

프록시 패턴의 종류

프록시 패턴은 다양한 방식으로 구현될 수 있으며, 일반적으로 다음과 같은 종류로 나뉩니다:

• 가상 프록시(Virtual Proxy): 객체의 초기화가 무겁거나 지연 로딩이 필요한 경우, 필요할 때만 객체를 생성합니다.
• 원격 프록시(Remote Proxy): 원격 객체에 대한 대리자 역할을 하여 네트워크 상의 객체와의 통신을 처리합니다.
• 보호 프록시(Protection Proxy): 객체 접근에 대한 권한을 제어합니다.
• 스마트 프록시(Smart Proxy): 접근 시 추가적인 행동을 수행하는 프록시입니다. (예: 참조 카운팅, 로깅)

장점

• 지연 로딩을 통해 성능을 최적화할 수 있습니다.
• 접근 제어와 같은 추가 작업을 객체의 주된 기능에 영향을 주지 않고도 구현할 수 있습니다.
• 리소스 관리: 사용하지 않는 자원의 초기화를 늦춰 리소스 관리가 용이합니다.

단점

• 객체를 실제로 사용하기 전에 프록시를 통해 접근하므로 복잡도가 증가할 수 있습니다.
• 프록시 객체를 관리해야 하므로, 코드가 복잡해질 수 있으며, 디버깅과 유지보수가 어려울 수 있습니다.

예제: Python으로 프록시 패턴 구현하기

아래 예제에서는 프록시 패턴을 사용하여 파일 읽기 작업을 지연 로딩하는 가상 프록시를 구현해 보겠습니다. 실제 파일을 읽는 RealFile 클래스에 접근하기 전에 프록시가 대신 역할을 수행하다가, 진짜 객체가 필요한 경우에만 초기화합니다.

from time import sleep

# RealSubject: 실제 객체 역할을 하는 클래스
class RealFile:
    def __init__(self, filename):
        self.filename = filename
        self.load_file()  # 파일을 실제로 로드하는 작업

    def load_file(self):
        print(f"Loading file '{self.filename}'...")
        sleep(2)  # 파일 로딩 시뮬레이션

    def display_content(self):
        return f"Displaying content of '{self.filename}'"

# Proxy: 실제 객체에 접근을 제어하는 프록시 클래스
class FileProxy:
    def __init__(self, filename):
        self.filename = filename
        self._real_file = None  # 실제 객체를 지연 로딩합니다.

    def display_content(self):
        # 실제 객체를 필요할 때만 초기화
        if self._real_file is None:
            self._real_file = RealFile(self.filename)
        return self._real_file.display_content()

# Client Code
file_proxy = FileProxy("sample.txt")

# 파일을 처음 호출할 때 로드하고 내용을 출력
print(file_proxy.display_content())  
# 두 번째 호출부터는 이미 로드된 파일을 사용
print(file_proxy.display_content())

프록시 패턴의 사용 예

• 지연 초기화: 무거운 리소스를 사용할 때, 실제로 필요할 때까지 초기화를 지연시킵니다.
• 액세스 제어: 특정 객체에 대한 접근 권한을 관리하는 경우(예: 인증 및 권한 검사).
• 네트워크 프록시: 원격 서버나 네트워크 상의 자원에 접근할 때, 네트워크 요청을 프록시가 대신 처리하여 클라이언트가 원격 객체와 상호작용할 수 있게 합니다.

배열 (Array)

연속된 메모리 블록에 요소를 저장하는 자료구조입니다. 각 요소는 인덱스를 통해 직접 접근할 수 있어, 고정된 크기의 데이터를 다룰 때 효율적입니다.

링크드 리스트 (Linked List)

요소(노드)가 포인터로 연결된 자료구조입니다. 각 노드는 데이터를 저장하는 공간과 다음 노드를 가리키는 포인터로 구성됩니다. 노드가 동적으로 메모리에 할당되므로, 배열과 달리 크기가 가변적입니다.

시간 복잡도

배열 (Array)

접근: O(1) – 인덱스를 통해 즉시 접근할 수 있습니다. 삽입/삭제: O(n) – 요소를 삽입하거나 삭제할 때, 다른 요소를 이동해야 하므로 시간이 걸립니다.

링크드 리스트 (Linked List)

접근: O(n) – 인덱스를 통한 직접 접근이 불가능하고, 첫 노드부터 순차적으로 탐색해야 합니다. 삽입/삭제: O(1) (앞이나 뒤에서 삽입/삭제 시) – 포인터를 변경하는 것만으로 가능하므로 빠릅니다. 그러나 중간에 삽입이나 삭제는 탐색이 필요해 O(n)이 될 수 있습니다.

가비지 컬렉션(GC)

배열 (Array)

배열은 연속된 메모리 블록을 할당받기 때문에, 요소가 할당된 상태에서 연속된 블록으로 유지됩니다. 단일 메모리 할당/해제가 이뤄지므로, GC 부담이 적고 메모리 단편화가 줄어듭니다. 메모리에 오래 남아 있는 요소는 적으므로 GC의 빈도와 부담이 낮습니다.

링크드 리스트 (Linked List)

노드마다 개별적으로 동적 메모리를 할당받으므로, 사용이 끝난 노드가 많아지면 GC가 빈번하게 작동하게 됩니다. 각 노드의 포인터로 연결되어 있어, 참조가 복잡하게 얽히면 사용되지 않는 노드도 메모리에서 해제되지 않는 경우가 발생할 수 있습니다. 메모리 단편화가 발생할 수 있으며, 이는 GC 성능에 악영향을 미칩니다.

호환되지 않는 인터페이스를 가진 클래스들이 함께 동작할 수 있도록 중간에 어댑터 역할을 하는 클래스를 두는 구조적 디자인 패턴입니다. 어댑터는 기존 클래스를 수정하지 않고 다른 인터페이스와 호환되도록 도와주기 때문에 기존 코드에 대한 수정이 필요 없고, 새로운 코드와 쉽게 통합할 수 있습니다.

어댑터 패턴을 사용하는 이유

• 호환성 문제 해결: 서로 다른 인터페이스를 사용하는 클래스들이 함께 작동하도록 해줍니다.
• 재사용성 증가: 기존 코드를 수정하지 않고도 새로운 요구사항이나 환경에 맞게 기존 클래스를 재사용할 수 있습니다.
• 유연성 향상: 어댑터를 사용하면 코드 구조를 변경하지 않고 새로운 기능을 추가할 수 있습니다.

구조

• Target (목표 인터페이스): 클라이언트가 기대하는 인터페이스입니다.
• Client (클라이언트): Target 인터페이스를 사용해 필요한 작업을 수행하는 객체입니다.
• Adaptee (적응 대상): 기존의 인터페이스를 가진 클래스입니다.
• Target과 호환되지 않아 어댑터가 필요합니다.
• Adapter (어댑터): Target 인터페이스를 구현하고, Adaptee를 감싸서 클라이언트가 Target을 통해 Adaptee의 기능을 사용할 수 있도록 합니다.

장점

• 기존 코드를 수정하지 않고, 새로운 기능을 추가하거나 호환성을 확보할 수 있습니다.
• 인터페이스가 맞지 않는 객체들을 함께 사용할 수 있습니다.
• 코드 재사용성을 높이고, 시스템의 확장성을 증대시킵니다.

단점

• 구조가 복잡해질 수 있으며, 너무 많은 어댑터를 사용하면 코드의 가독성이 떨어질 수 있습니다.
• 시스템 내 의존성이 증가할 수 있습니다.

예제 코드

# Target Interface (클라이언트가 기대하는 인터페이스)
class EuropeSocket:
    def plug_in_european_socket(self):
        return "Using European socket power."

# Adaptee (기존에 존재하는 호환되지 않는 클래스)
class USAPowerPlug:
    def plug_in_usa_socket(self):
        return "Using USA socket power."

# Adapter (어댑터 클래스)
class USAToEuropeAdapter(EuropeSocket):
    def __init__(self, usa_plug: USAPowerPlug):
        self.usa_plug = usa_plug

    def plug_in_european_socket(self):
        # 호환되지 않는 인터페이스를 맞춰주는 어댑터 메서드
        return self.usa_plug.plug_in_usa_socket()

# Client Code (클라이언트 코드)
def charge_device(socket: EuropeSocket):
    print(socket.plug_in_european_socket())

# Usage Example
usa_plug = USAPowerPlug()
adapter = USAToEuropeAdapter(usa_plug)
charge_device(adapter)
# Output:
# Using USA socket power.

실제 사용 예

• 라이브러리 통합: 기존 시스템에 새 라이브러리를 도입할 때, 새 라이브러리의 인터페이스가 기존 시스템과 맞지 않다면 어댑터를 사용해 인터페이스를 맞춥니다.
• 레거시 코드 통합: 기존 레거시 시스템이 다른 인터페이스를 사용할 경우, 어댑터를 통해 새 시스템과 호환되도록 만들 수 있습니다.

클래스의 인스턴스가 오직 하나만 생성되도록 보장하며, 전역 접근이 가능하게 하는 디자인 패턴입니다. 주로 글로벌 상태를 유지해야 하거나, 자원을 공유해야 하는 경우에 유용합니다. 대표적인 예로 로그 파일 관리 객체, 설정 객체, 데이터베이스 연결 객체 등이 있습니다.

싱글톤 패턴을 사용하는 이유

• 자원의 절약: 여러 번 인스턴스를 생성하지 않고, 하나의 인스턴스를 공유함으로써 메모리와 자원을 절약할 수 있습니다.
• 전역 접근: 애플리케이션 전역에서 동일한 인스턴스를 참조할 수 있어 상태 관리와 접근이 간단해집니다.
• 데이터 일관성: 특정 자원의 상태나 설정 값이 여러 인스턴스에서 충돌하거나 일관성이 깨지는 것을 방지합니다.

장점

• 자원 절약 및 성능 최적화에 도움이 됩니다.
• 애플리케이션 전체에서 동일한 인스턴스를 통해 일관된 상태 유지가 가능합니다.

  단점

• 전역 상태를 유지하기 때문에, 코드의 복잡성이 증가하고 의존성이 높아질 수 있습니다.
• 다중 스레드 환경에서 싱글톤 객체의 동기화 처리가 필요할 수 있습니다.

싱글톤 패턴의 사용 예

• 로그 객체: 여러 클래스가 동일한 로그 파일에 로그를 남길 때.
• 설정 객체: 애플리케이션의 설정 값을 공유하는 객체.
• 데이터베이스 연결 풀: DB와의 연결을 유지하고 공유해야 할 때.

구현

new 메서드를 사용하는 싱글톤 패턴

class Singleton:
    _instance = None  # 인스턴스 저장을 위한 클래스 변수

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

# Example usage
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # True, 두 객체는 동일한 인스턴스입니다.

데코레이터를 사용한 싱글톤 패턴

def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance

@singleton
class Singleton:
    pass

# Example usage
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # True

복잡한 객체를 단계적으로 생성하는 방법을 제공하는 생성 패턴입니다. 이 패턴은 객체 생성 과정에서의 세부 설정이나 조립이 필요한 경우에 유용하며, 다양한 속성들을 선택적으로 설정하여 객체를 만들 수 있게 합니다. 특히, 복잡한 객체 생성 시 코드를 더 읽기 쉽게 만들고, 유연성을 높이며, 객체 생성의 과정과 표현을 분리하는 데 중점을 둡니다.

빌더 패턴을 사용하는 이유

• 객체 생성 과정의 복잡도 감소: 복잡한 객체의 생성 과정이 빌더 클래스로 분리되어, 가독성과 유지보수가 쉬워집니다.
• 유연한 객체 구성: 선택적인 속성들을 가질 수 있으며, 필요한 속성만 설정하여 객체를 생성할 수 있습니다.
• 변경 용이성: 빌더 클래스를 수정하여 다양한 객체 구성을 쉽게 추가할 수 있습니다.

빌더 패턴의 구조

• Builder (빌더): 객체를 단계별로 생성하는 인터페이스나 추상 클래스를 정의합니다.
• Concrete Builder (구체 빌더): 빌더 인터페이스를 구현하여 실제 객체를 생성하는 클래스입니다.
• Director (디렉터): 빌더 객체를 통해 각 단계별로 생성 과정을 정의하여 최종 제품을 반환합니다.
• Product (제품): 생성될 복합 객체입니다. 여러 단계에서 설정되는 속성을 포함합니다.

장점

• 코드의 가독성이 높아지고, 객체 생성 로직이 명확하게 드러납니다.
• 불변 객체를 쉽게 만들 수 있습니다. 객체 생성 후에는 속성이 변경되지 않도록 할 수 있습니다.
• 복잡한 객체 생성 시 객체의 일관성을 보장합니다. 필수 필드가 누락되었을 때 에러를 발생시키는 등의 로직을 추가할 수 있습니다.

예제 코드

# Product Class
class UserProfile:
    def __init__(self, name, age, address, phone, email):
        self.name = name
        self.age = age
        self.address = address
        self.phone = phone
        self.email = email

    def __str__(self):
        return f"UserProfile(name={self.name}, age={self.age}, address={self.address}, phone={self.phone}, email={self.email})"

# Builder Class
class UserProfileBuilder:
    def __init__(self):
        self.name = None
        self.age = None
        self.address = None
        self.phone = None
        self.email = None

    def set_name(self, name):
        self.name = name
        return self

    def set_age(self, age):
        self.age = age
        return self

    def set_address(self, address):
        self.address = address
        return self

    def set_phone(self, phone):
        self.phone = phone
        return self

    def set_email(self, email):
        self.email = email
        return self

    def build(self):
        # 필요한 속성을 체크하고, 조건이 만족되면 최종 객체를 반환
        if self.name is None or self.age is None:
            raise ValueError("Name and age are required")
        return UserProfile(self.name, self.age, self.address, self.phone, self.email)

# Client Code
try:
    user = (UserProfileBuilder()
            .set_name("Alice")
            .set_age(30)
            .set_address("123 Main St")
            .set_phone("555-1234")
            .set_email("alice@example.com")
            .build())

    print(user)
    # 출력:
    # UserProfile(name=Alice, age=30, address=123 Main St, phone=555-1234, email=alice@example.com)
except ValueError as e:
    print(f"Error: {e}")

추상화 팩토리 패턴(Abstract Factory Pattern)은 관련된 객체들을 그룹으로 묶어 일관된 방식으로 생성할 수 있도록 하는 디자인 패턴입니다. 여러 종류의 객체를 묶어서 생성할 때 유용하며, 객체의 구체적인 클래스가 아닌 추상적인 인터페이스에 의존하게 하여 유연성을 높입니다.

추상화 팩토리 패턴의 구조

• AbstractFactory (추상 팩토리): 관련 객체들을 생성하는 메서드들을 선언하는 인터페이스입니다.
• ConcreteFactory (구체 팩토리): AbstractFactory를 구현하여 특정 제품군을 생성하는 메서드를 제공합니다.
• AbstractProduct (추상 제품): 생성될 제품의 인터페이스를 정의합니다.
• ConcreteProduct (구체 제품): AbstractProduct를 구현한 실제 제품 클래스입니다.
• Client (클라이언트): AbstractFactory와 AbstractProduct를 사용하여 구체적인 객체 생성에 대해 알 필요 없이 객체들을 사용합니다.

장점

• 일관성: 관련 있는 객체들을 일관성 있게 생성할 수 있습니다.
• 확장성: 새로운 제품군을 추가할 때 ConcreteFactory만 추가하면 되므로 코드 확장이 용이합니다.
• 의존성 감소: 클라이언트는 구체 클래스가 아닌 추상 인터페이스에 의존하므로 구체적인 제품 변경이 클라이언트에 영향을 주지 않습니다.

예제 코드

from abc import ABC, abstractmethod

# 1. Abstract Products 정의
class Button(ABC):
    @abstractmethod
    def click(self) -> str:
        pass

class Checkbox(ABC):
    @abstractmethod
    def check(self) -> str:
        pass

# 2. Concrete Products 정의
class MacButton(Button):
    def click(self) -> str:
        return "Clicking a Mac-styled Button"

class WindowsButton(Button):
    def click(self) -> str:
        return "Clicking a Windows-styled Button"

class MacCheckbox(Checkbox):
    def check(self) -> str:
        return "Checking a Mac-styled Checkbox"

class WindowsCheckbox(Checkbox):
    def check(self) -> str:
        return "Checking a Windows-styled Checkbox"

# 3. Abstract Factory 정의
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

# 4. Concrete Factories 정의
class MacFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacButton()

    def create_checkbox(self) -> Checkbox:
        return MacCheckbox()

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

# 5. Client 코드
def create_ui(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    print(button.click())
    print(checkbox.check())

# 팩토리 선택에 따라 Mac 또는 Windows 스타일의 UI 생성
if __name__ == "__main__":
    os_type = "Mac"  # 혹은 "Windows"

    if os_type == "Mac":
        factory = MacFactory()
    elif os_type == "Windows":
        factory = WindowsFactory()
    else:
        raise ValueError("Unknown OS type")

    create_ui(factory)
    # 출력 예시:
    # Clicking a Mac-styled Button
    # Checking a Mac-styled Checkbox

팩토리 메서드 패턴은 객체 생성 코드를 서브클래스에서 정의하도록 위임하는 디자인 패턴입니다. 팩토리 메서드는 구체적인 클래스 대신 부모 클래스 또는 인터페이스에서 정의한 메서드를 통해 객체를 생성하게 하여, 객체 생성의 책임을 서브클래스가 지도록 합니다.

이 패턴은 상속과 다형성을 활용하여 생성 과정을 커스터마이즈할 수 있도록 하는데, 특히 생성해야 할 객체 타입이 자주 변경되거나 새로운 타입이 추가될 가능성이 있는 경우에 유용합니다.

팩토리 메서드 패턴의 구조

• Creator (창조자): 객체 생성을 위한 팩토리 메서드를 선언하는 추상 클래스입니다. 팩토리 메서드는 일반적으로 추상 메서드로 정의되며, 이를 구현하는 서브클래스들이 실제 생성 로직을 담당합니다.
• ConcreteCreator (구체 창조자): Creator의 서브클래스이며, 특정 제품(객체)을 생성하는 팩토리 메서드를 구현합니다.
• Product (제품): 생성될 객체의 인터페이스 또는 추상 클래스입니다.
• ConcreteProduct (구체 제품): 실제 생성되는 객체들로, Product 인터페이스를 구현합니다.

장점

• 객체 생성의 책임 분리: 객체 생성 로직을 별도의 메서드로 분리하여 관리합니다.
• 확장성: 새로운 타입의 객체를 쉽게 추가할 수 있으며, 클라이언트 코드를 수정하지 않고도 새로운 객체를 생성할 수 있습니다.
• 유연성: 클라이언트는 추상 클래스를 통해 작업하므로 객체 생성 방식을 변경하거나 확장해도 클라이언트 코드에는 영향을 주지 않습니다.

예제 코드

from abc import ABC, abstractmethod

# 1. Product 인터페이스 정의
class Document(ABC):
    @abstractmethod
    def render(self):
        pass

# 2. ConcreteProduct 클래스 정의
class PDFDocument(Document):
    def render(self):
        return "Rendering PDF Document"

class WordDocument(Document):
    def render(self):
        return "Rendering Word Document"

# 3. Creator 추상 클래스 정의
class DocumentCreator(ABC):
    @abstractmethod
    def create_document(self) -> Document:
        pass

    def render_document(self):
        # 팩토리 메서드를 통해 Document 객체를 생성하여 사용하는 메서드
        doc = self.create_document()
        return doc.render()

# 4. ConcreteCreator 클래스 정의
class PDFCreator(DocumentCreator):
    def create_document(self) -> Document:
        return PDFDocument()

class WordCreator(DocumentCreator):
    def create_document(self) -> Document:
        return WordDocument()

# 5. 클라이언트 코드
if __name__ == "__main__":
    creators = [PDFCreator(), WordCreator()]

    for creator in creators:
        print(creator.render_document())
    # 출력:
    # Rendering PDF Document
    # Rendering Word Document

팩토리 디자인 패턴은 객체 생성 로직을 캡슐화하여 코드의 유연성과 확장성을 높이는 디자인 패턴입니다. 이를 통해 객체 생성에 관한 로직을 클라이언트 코드에서 분리하고, 객체 생성 방식을 재정의하거나 확장할 수 있는 구조를 제공합니다.

팩토리 패턴의 핵심 아이디어는 객체 생성 과정을 메소드에 위임하여, 객체를 직접 생성하지 않고 해당 메소드가 올바른 인스턴스를 반환하도록 하는 것입니다. 이는 코드 변경 없이 새로운 객체 타입을 쉽게 추가할 수 있도록 하며, 특히 클라이언트 코드가 생성되는 구체 클래스에 의존하지 않도록 하는 데에 효과적입니다.

장점

• 유연성 증가: 객체 생성 로직을 한 곳에 집중하여 유지보수와 확장이 쉽습니다.
• 코드 재사용성: 클라이언트 코드가 객체 생성 방식을 알 필요가 없으므로 코드 재사용성이 높아집니다.
• 의존성 감소: 클라이언트는 구체 클래스가 아닌 인터페이스에 의존하므로, 코드 변경이 덜 필요하게 됩니다.

예제 코드

from abc import ABC, abstractmethod

# 1. Animal 추상 클래스 정의
class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

# 2. 구체적인 클래스 정의
class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# 3. AnimalFactory 클래스 정의
class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")

# 4. 클라이언트 코드에서 팩토리 메서드를 사용해 객체 생성
if __name__ == "__main__":
    animal_type = "dog"  # 혹은 "cat"
    animal = AnimalFactory.create_animal(animal_type)
    print(animal.speak())  # 출력: "Woof!" 또는 "Meow!"

Rasberry pi5 ubuntu 23.10

fastapi 코드 만들기

프로젝트세팅

pip install poetry
poetry new fastapi-ml

fastapi-ml
├── app
├──── __init__.py
├──── main.py
├── tests
├──── __init__.py
├── Dockerfile
├── poetry.lock
├── project.toml
├── README.md

main.py 작성

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.get("/check")
def check():
    return "success"

dockerfile 작성

FROM python:3.11.6-slim

RUN mkdir -p /app
COPY . /app/
WORKDIR /app

RUN pip3 install poetry
# poetry lock에서 requirements.txt 생성
RUN poetry export -f requirements.txt --output requirements.txt --without-hashes
RUN pip3 install --no-cache-dir -r requirements.txt

# app 실행
CMD gunicorn app.main:app --bind 0.0.0.0:8000 -w 3 -k uvicorn.workers.UvicornWorker

docker hub 배포

docker build -t stygj/fastapi-ml:0.0.1 .
docker push stygj/fastapi-ml:0.0.1

minikube 설치

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
sudo install minikube-linux-arm64 /usr/local/bin/minikube && rm minikube-linux-arm64

minikube 시작

minikube start

deployment 만들기

fastapi-ml-deployment.yaml 작성

apiVersion: apps/v1
kind: Deployment
metadata:
  name: fastapi-ml-deployment
  labels:
    app: fastapi-ml
spec:
  replicas: 3
  selector:
    matchLabels: 
      app: fastapi-ml
  template:
    metadata:
      labels:
        app: fastapi-ml
    spec:
      containers:
        - name: fastapi-ml
          image: stygj/fastapi-ml:0.0.1
          ports:
          - containerPort: 8000

실행

kubectl apply -f fastapi-ml-deployment.yaml

service 만들기

fastapi-ml-service.yaml 작성

apiVersion: v1
kind: Service
metadata:
  name: fastapi-ml-service
  labels:
    name: fastapi-ml
spec:
  selector:
    app: fastapi-ml
  type: NodePort
  ports:
  - port: 8000
    targetPort: 8000
    name: http
    protocol: TCP

실행

kubectl apply -f fastapi-ml-service.yaml
minikube service fastapi-ml-service --url

kubectl get service
kubectl describe svc/fastapi-ml-service

테스트

kubectl get pods
kubectl logs -f [podsname]

kubectl port-forward svc/fastapi-ml-service --address=0.0.0.0 8000:8000
curl -XGET http://127.0.0.1:8000/check

ingress 만들기

fastapi-ml-ingress.yaml 작성

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: fastapi-ml-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: fastapi-ml-service
            port:
              number: 8000

실행

kubectl apply -f fastapi-ml-ingress.yaml

kubectl get ingess
kubectl describe ingress fastapi-ml-ingress

테스트

minikube ip -> 192.168.49.2
curl -XGET http://192.168.49.2/check

assertNotNull

특정 객체가 null이 아님을 확인합니다.

import org.junit.Test;
import static org.junit.Assert.assertNotNull;

public class MyTests {
    @Test
    public void testObjectIsNotNull() {
        String str = "JUnit Test";
        assertNotNull("The object should not be null", str);
    }
}

assertNull

객체가 null인지 확인합니다.

import org.junit.Test;
import static org.junit.Assert.assertNull;

public class MyTests {
    @Test
    public void testObjectIsNull() {
        String str = null;
        assertNull("The object should be null", str);
    }
}

assertEquals

두 값이 동일한지 확인합니다.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class MyTests {
    @Test
    public void testSum() {
        int expectedSum = 5;
        int actualSum = sum(2, 3);
        assertEquals("Sum should be 5", expectedSum, actualSum);
    }

    public int sum(int a, int b) {
        return a + b;
    }
}

assertTrue & assertFalse

주어진 조건이 true또는 false인지 확인합니다.

import org.junit.Test;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertFalse;

public class MyTests {
    @Test
    public void testIsEven() {
        assertTrue("Number should be even", isEven(4));
        assertFalse("Number should be odd", isEven(3));
    }

    public boolean isEven(int number) {
        return number % 2 == 0;
    }
}

assertArrayEquals

두 배열이 동일한지 비교합니다.

import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;

public class MyTests {
    @Test
    public void testArrayEquals() {
        int[] expectedArray = {1, 2, 3};
        int[] actualArray = {1, 2, 3};
        assertArrayEquals("Arrays should be equal", expectedArray, actualArray);
    }
}

assertThrows

특정 예외가 발생하는지를 확인합니다.

import org.junit.Test;
import static org.junit.Assert.assertThrows;

public class MyTests {
    @Test
    public void testThrowsException() {
        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> {
            throw new IllegalArgumentException("Exception message");
        });

        assertEquals(ex.getMessage(), "Exception message");
    }
}

assertAll

람다 표현식이나 메서드 참조를 사용하여 각 단언을 전달합니다.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MyTests {
    @Test
    public void testMultipleAssertions() {
        String str1 = "JUnit 5";
        String str2 = "JUnit 5";
        String str3 = "Unit testing";

        assertAll("Test all assertions",
            () -> assertEquals("JUnit 5", str1),
            () -> assertEquals("JUnit 5", str2),
            () -> assertEquals("JUnit 5", str3)  // This will fail
        );
    }
}

assertj의 assertThat 알아보기

객체 비교

import static org.assertj.core.api.Assertions.assertThat;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class MyTests {
    @Test
    public void testObjects() {
        Person person = new Person("John", 30);
        assertThat(person).isNotNull();
        assertThat(person.name).isEqualTo("John");
        assertThat(person.age).isBetween(20, 40);
    }
}

타입 비교

import static org.assertj.core.api.Assertions.assertThat;

public class MyTests {
    @Test
    public void testBasicTypes() {
        int number = 10;
        assertThat(number).isGreaterThan(5).isLessThanOrEqualTo(10);

        String text = "Hello";
        assertThat(text).isEqualTo("Hello").startsWith("He").endsWith("lo").contains("ell");
    }
}

컬렉션 및 배열 비교

import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.List;

public class MyTests {
    @Test
    public void testCollections() {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        assertThat(names).hasSize(3).contains("Alice", "Charlie").doesNotContain("Eve");

        int[] numbers = {1, 2, 3, 4, 5};
        assertThat(numbers).containsExactly(1, 2, 3, 4, 5).doesNotContain(0);
    }
}

예외 검증

import static org.assertj.core.api.Assertions.assertThatThrownBy;

public class MyTests {
    @Test
    public void testException() {
        assertThatThrownBy(() -> { throw new IllegalArgumentException("Invalid argument"); })
            .isInstanceOf(IllegalArgumentException.class)
            .hasMessage("Invalid argument");
    }
}

assumingThat

• 조건: boolean 표현식으로, 이 조건이 참일 때 코드 블록이 실행됩니다.
• 코드 블록: 조건이 참일 때 실행할 코드 블록을 람다 표현식으로 작성합니다.

import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.junit.jupiter.api.Assumptions.assumingThat;
import org.junit.jupiter.api.Test;

public class MyTests {

    @Test
    public void testWithAssumption() {
        String environment = System.getenv("TEST_ENV");

        // 조건이 참일 때만 코드 블록을 실행합니다.
        assumingThat(
            "PROD".equals(environment),
            () -> {
                // 환경이 "PROD"일 때만 실행
                System.out.println("Running in production environment");
                // production-specific tests
            }
        );

        // 항상 실행되는 코드
        System.out.println("Running in all environments");
        // common tests
    }
}

java 17 Spring 3.3.0 Postgresql 15.5

User table (flyway V1__init.sql)

CREATE SEQUENCE users_seq START WITH 1;
COMMENT ON SEQUENCE users_seq IS 'users 테이블에 대한 유일한 ID를 생성하기 위한 시퀀스';

CREATE TABLE users (
    id BIGINT DEFAULT nextval('users_seq') PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100) ,
    phone VARCHAR(20),
    authority VARCHAR(5),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
)
;
COMMENT ON TABLE users IS '사용자 정보를 저장하는 테이블';
COMMENT ON COLUMN users.id IS '사용자를 식별하는 고유값';
COMMENT ON COLUMN users.username IS '사용자의 계정 이름';
COMMENT ON COLUMN users.password IS '사용자릐 계정 암호';
COMMENT ON COLUMN users.email IS '사용자의 이메일';
COMMENT ON COLUMN users.phone IS '사용자의 전화번호';
COMMENT ON COLUMN users.authority IS '사용자의 권한';
COMMENT ON COLUMN users.created_at IS '생성일시';
COMMENT ON COLUMN users.updated_at IS '변경일시';
COMMENT ON COLUMN users.deleted_at IS '삭제일시';

build.gradle

    // Spring security
    implementation 'org.springframework.boot:spring-boot-starter-security'
    testImplementation 'org.springframework.security:spring-security-test'

    // JWT
    implementation group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.5'
    runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.5'
    runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.5'

application.yml

jwt:
  secret: [secret key]
  expirationTime: [expiration time]

SecurityConfig.java

비밀번호 인코더 빈 생성

@Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

RESTFUL API에서 불필요하여 CSRF를 비활성화

http.csrf(AbstractHttpConfigurer::disable);

예외 처리 구성

http.exceptionHandling(exception ->
        exception.authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .accessDeniedHandler(jwtAccessDeniedHandler));

세션을 STATELESS로 설정

http.sessionManagement(sessionManagement ->
        sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS));

JWT 필터 추가

http.addFilterBefore(new JwtFilter(tokenProvider, customUserDetailsService), UsernamePasswordAuthenticationFilter.class);

인증 없이 접근할 수 있는 엔드포인트 설정

return web -> web.ignoring().requestMatchers(
        "/swagger-ui/**",
        "/signUp",
        "/signIn");

전체 코드

import com.boilerplate.jwt.*;
import com.boilerplate.service.CustomUserDetailsService;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;


@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
@RequiredArgsConstructor
public class SecurityConfig {
    private final TokenProvider tokenProvider;

    private final CustomUserDetailsService customUserDetailsService;

    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .csrf(AbstractHttpConfigurer::disable)
                .exceptionHandling(exception ->
                        exception.authenticationEntryPoint(jwtAuthenticationEntryPoint)
                                .accessDeniedHandler(jwtAccessDeniedHandler))
                .sessionManagement(sessionManagement ->
                        sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                ).authorizeHttpRequests(authorizeRequests ->
                        authorizeRequests
                                .anyRequest().authenticated()
                )
                .addFilterBefore(new JwtFilter(tokenProvider, customUserDetailsService), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    public WebSecurityCustomizer configure() {
        return web -> web.ignoring().requestMatchers(
                "/swagger-ui/**",
                "/signUp",
                "/signIn"
        );
    }
}

JWT 토큰 발급 구현

import com.boilerplate.entitiy.Users;
import io.jsonwebtoken.*;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;

import java.security.Key;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;

@Component
public class TokenProvider implements InitializingBean {
    private static final Logger logger = LoggerFactory.getLogger(TokenProvider.class);

    private final String secret;

    private final Long expirationTime;

    private Key key;

    public TokenProvider(@Value("${jwt.secret}") String secret, @Value("${jwt.expirationTime}") long expirationTime) {
        this.secret = secret;
        this.expirationTime = expirationTime;
    }

    @Override
    public void afterPropertiesSet() {
        byte[] keyBytes = Decoders.BASE64.decode(secret);
        this.key = Keys.hmacShaKeyFor(keyBytes);
    }

    public String createToken(Users uesrs) {
        Claims claims = Jwts.claims();
        claims.put("username", uesrs.getUsername());
        claims.put("email", uesrs.getEmail());
        claims.put("phone", uesrs.getPhone());
        claims.put("authority", uesrs.getAuthority());

        ZonedDateTime now = ZonedDateTime.now();
        ZonedDateTime tokenValidity = now.plusSeconds(this.expirationTime);

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(Date.from(now.toInstant()))
                .setExpiration(Date.from(tokenValidity.toInstant()))
                .signWith(this.key, SignatureAlgorithm.HS256)
                .compact();
    }

    public Collection<? extends GrantedAuthority> getAuthentication(String token) {
        Claims claims = getAllClaims(token);

        List<String> authorites = new ArrayList<>();
        authorites.add("ROLE_"+ claims.get("authority").toString());

        return authorites.stream()
                .map(SimpleGrantedAuthority::new)
                .toList();
    }

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

    public Claims getAllClaims(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(this.secret).build()
                .parseClaimsJws(token)
                .getBody();
    }

}

JWT 필터 구현

import com.boilerplate.service.CustomUserDetailsService;
import com.querydsl.core.util.StringUtils;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.filter.GenericFilterBean;

import java.io.IOException;
import java.util.Arrays;
import java.util.Optional;

@RequiredArgsConstructor
public class JwtFilter extends GenericFilterBean {
    private static final Logger log = LoggerFactory.getLogger(JwtFilter.class);

    private final TokenProvider tokenProvider;

    private final CustomUserDetailsService customUserDetailsService;


    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

        String jwt = resolveToken(httpServletRequest);
        String requestURI = httpServletRequest.getRequestURI();

        String username = String.valueOf(tokenProvider.getAllClaims(jwt).get("username"));
        UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);

        if (!StringUtils.isNullOrEmpty(jwt) && tokenProvider.validateToken(jwt)) {
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(userDetails, null, tokenProvider.getAuthentication(jwt));
            SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            log.debug("save {} in security config / uri : {}", usernamePasswordAuthenticationToken.getName(), requestURI);
        } else {
            log.debug("JWT is empty or null / uri : {}", requestURI);
        }
        filterChain.doFilter(servletRequest, servletResponse);
    }

    private String resolveToken(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        Optional<Cookie> authorizationCookie = Arrays.stream(cookies)
                .filter(cookie -> "Autentication".equals(cookie.getName()))
                .findFirst();
        String bearerToken = authorizationCookie.map(Cookie::getValue).orElse(null);
        if (!StringUtils.isNullOrEmpty(bearerToken)) {
            return bearerToken;
        }
        return null;
    }
}

CustomUserDetails.java 구현

import com.boilerplate.dto.SignInRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.Collections;

@RequiredArgsConstructor
public class CustomUserDetails implements UserDetails {

    private final transient SignInRequest signInRequest;

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

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

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

CustomUserDetailsService.java 구현

import com.boilerplate.dto.SignInRequest;
import com.boilerplate.entitiy.Users;
import com.boilerplate.jwt.CustomUserDetails;
import com.boilerplate.repository.CustomUserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final CustomUserRepository customUserRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Users users = customUserRepository.findOneWithAuthoritiesByUsername(username);

        SignInRequest signInRequest = SignInRequest.builder()
                .username(users.getUsername())
                .password(users.getPassword())
                .build();
        return new CustomUserDetails(signInRequest);
    }
}

권한에러 예외 핸들러 구현

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
    }
}

인증에러 예외 구현

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
    }
}

User Entity

import com.boilerplate.enums.UserAuthority;
import jakarta.persistence.*;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.time.LocalDateTime;

@Entity
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@Table(name="users")
@SequenceGenerator(
        name = "users_seq",
        sequenceName = "users_seq",
        allocationSize = 1
)
@Getter
public class Users {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "users_seq")
    private Long id;

    @Column(name = "username", length = 50)
    private String username;

    @Column(name = "password", length = 255)
    private String password;

    @Column(name = "email", length = 100)
    private String email;

    @Column(name = "phone", length = 100)
    private String phone;

    @Column(name="authority")
    @Enumerated(EnumType.STRING)
    private UserAuthority authority;

    @Column(name = "created_at")
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @Column(name = "deleted_at")
    private LocalDateTime deletedAt;

    @Builder
    public Users(String username, String password, String email, String phone, LocalDateTime createdAt) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.phone = phone;
        this.createdAt = createdAt;

    }
}

CustomUserRepository.java

import com.boilerplate.entitiy.QUsers;
import com.boilerplate.entitiy.Users;
import com.boilerplate.repository.CustomUserRepository;
import com.querydsl.jpa.impl.JPAQueryFactory;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Repository;

@Repository
@AllArgsConstructor
public class CustomUserRepositoryImpl implements CustomUserRepository {
    private final JPAQueryFactory queryFactory;

    @Override
    public boolean existsByUsername(String username) {
        QUsers user = QUsers.users;
        return queryFactory
                .select(user.username)
                .from(user)
                .where(user.username.eq(username)
                        .and(user.deletedAt.isNull()))
                .fetchFirst() != null;
    }

    @Override
    public Users findOneWithAuthoritiesByUsername(String username) {
        QUsers user = QUsers.users;
        return queryFactory
                    .select(user)
                    .from(user)
                    .where(user.username.eq(username)
                            .and(user.deletedAt.isNull()))
                    .fetchOne();
    }
}

AuthService.java

import com.boilerplate.dto.SignInRequest;
import com.boilerplate.dto.SignUpRequest;
import com.boilerplate.entitiy.Users;
import com.boilerplate.jwt.TokenProvider;
import com.boilerplate.repository.CustomUserRepository;
import com.boilerplate.repository.UserRepository;
import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;

@Service
@RequiredArgsConstructor
public class AuthService {

    private final UserRepository userRepository;

    private final CustomUserRepository customUserRepository;

    private final BCryptPasswordEncoder bCryptPasswordEncoder;

    private final TokenProvider tokenProvider;

    public boolean registerUSer(SignUpRequest signUpRequest) {
        String username = signUpRequest.getUsername();
        boolean isExists = this.customUserRepository.existsByUsername(username);
        if (isExists) {
            return false;
        }

        Users user = Users.builder()
                .username(signUpRequest.getUsername())
                .password(bCryptPasswordEncoder.encode(signUpRequest.getPassword()))
                .email(signUpRequest.getEmail())
                .phone(signUpRequest.getPhone())
                .createdAt(LocalDateTime.now())
                .build();
        this.userRepository.save(user);
        return true;
    }

    @Transactional
    public String authenticateUser(SignInRequest signInRequest) throws UsernameNotFoundException{
        Users users = this.customUserRepository.findOneWithAuthoritiesByUsername(signInRequest.getUsername());
        if (bCryptPasswordEncoder.matches(signInRequest.getPassword(), users.getPassword())) {
            return tokenProvider.createToken(users);
        }
        throw new UsernameNotFoundException(signInRequest.getUsername() + " is not found.");
    }
}

AuthController.java

import com.boilerplate.dto.SignInRequest;
import com.boilerplate.dto.SignUpRequest;
import com.boilerplate.service.AuthService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import com.boilerplate.response.MessageResponse;

@Tag(name = "Sign up", description = "회원가입 API")
@RestController
@ResponseBody
@RequiredArgsConstructor
public class AuthController {

    @Value("${jwt.expirationTime}")
    private int expirationTime;

    @Value("${cookie.SameSite}")
    private String sameSite;

    private final AuthService authService;

    @Operation(summary = "로그인", description = "로그인")
    @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = ApiResponse.class)))
    @ApiResponse(responseCode = "401", description = "Unauthorized", content = @Content(schema = @Schema(implementation = ApiResponse.class)))
    @PostMapping(path = "signIn")
    public ResponseEntity<MessageResponse> authenticateUser(@RequestBody SignInRequest signInDto, HttpServletResponse response) {
        String accessToekn = authService.authenticateUser(signInDto);
        Cookie cookie = new Cookie("Autentication",  accessToekn);
        cookie.setHttpOnly(true);
        cookie.setSecure(true);
        cookie.setMaxAge(expirationTime);
        cookie.setAttribute("SameSite", this.sameSite);
        response.addCookie(cookie);
        return ResponseEntity.status(HttpStatus.OK).body(new MessageResponse("success", 200));
    }
}

Spring Security란

스프링 프레임워크 기반의 애플리케이션에서 인증(Authentication)과 권한 부여(Authorization)를 관리하는 강력한 보안 프레임워크입니다. 주요 기능으로는 사용자의 신원을 확인하고, 특정 리소스나 기능에 대한 접근 권한을 제어하는 것입니다. 이 프레임워크는 다양한 인증 메커니즘을 지원하며, 사용자 정의가 용이하도록 설계되었습니다.

구성요소

• Authentication(인증)

  • 사용자의 신원을 확인하는 과정입니다. 예를 들어, 사용자 이름과 비밀번호를 입력하여 사용자가 누구인지 식별합니다.
  • 스프링 시큐리티에서는 AuthenticationManager가 인증을 처리하며, 사용자 정보를 담고 있는 Authentication 객체를 반환합니다.

• Authorization(권한 부여)

  • 인증된 사용자가 어떤 리소스나 기능에 접근할 수 있는지를 결정하는 과정입니다. 예를 들어, 관리자만 특정 페이지에 접근할 수 있도록 설정합니다.
  • 권한은 GrantedAuthority로 표현되며, SecurityContext에 저장된 사용자의 Authentication 객체를 통해 확인할 수 있습니다.

• SecurityContext

  • 현재 인증된 사용자에 대한 정보를 담고 있는 컨텍스트입니다. SecurityContextHolder를 통해 전역적으로 접근할 수 있으며, SecurityContext는 Authentication 객체를 보관합니다.

• Filter Chain

  • 다양한 보안 필터들이 체인으로 구성되어 요청을 처리합니다. 각 필터는 인증이나 권한 부여 등의 보안 작업을 수행합니다.
  • 스프링 시큐리티는 UsernamePasswordAuthenticationFilter, JwtFilter와 같은 다양한 기본 필터를 제공합니다.

• HttpSecurity

  • 웹 애플리케이션 보안을 구성하는 데 사용되는 주요 클래스입니다. 보안 설정을 통해 URL 패턴, 인증 방법, 권한 부여 규칙 등을 정의할 수 있습니다.
  • 주로 configure(HttpSecurity http) 메서드를 오버라이드하여 보안 설정을 적용합니다.

• AuthenticationManager

  • 인증을 처리하는 인터페이스로, authenticate 메서드를 통해 사용자의 인증을 처리합니다.

• UserDetailsService

  • 사용자 정보를 가져오는 서비스입니다. 주로 데이터베이스에서 사용자 정보를 조회하여 UserDetails 객체를 반환합니다.
  • 사용자 인증을 위해 loadUserByUsername 메서드를 구현해야 합니다.

서버로 들어온 Request 객체를 컨트롤러의 핸들러에 오기 전에 가로채서 원하는 작업을 할 수 있도록 하는 기능이다. 주로 로그인 여부나 권한 등의 여부를 판단하는 기능에 활용 된다.

작동 과정

1. url을 통해 서버에 request 객체 전송
2. DispatcherServlet은 request객체를받아 핸들러를 찾도록 요청한다.
3. 핸들러 실행체인이 인터셉터를 거처 실행된다.

인터셉터의 장점

1. 메모리 낭비 및 서버의 부하를 감소 시킨다. 컨트롤러 마다 검증 코드를 붙이면 그만큼 메모리에 올려야 하는 코드가 많아 지며 서버의 부담이 커지는데 이를 인터셉터 하나에서 관리하면 해결이 가능하다.

2. 코드의 누락 방지 특정 컨트롤러에서 로그인 판단 로직을 빼먹을 걱정을 줄일 수 있다.

구현 방법

1. HandlerInterceptor로 인터페이스를 구현하거나 HandlerInterceptorAdapor를 상속받아 오버라이딩을 하여 인터셉터 클래스를 만든다.

2. 부모 클래스에 오버라이딩 할 수 있는 메서드는 3가지다

• preHandle()
  • 컨트롤러가 호출 되기 전 실행
  • 리턴값이 boolean형으로 true일때는 핸들러에 접근하고 false일 경우 작업을 중단 한다.
• postHandle()
  • 핸들러의 실행이 완료되고 view가 생성되기 전에 호출된다.
  • model 객체의 정보를 조작할 수 있다.
• afterCompletion()
  • view에 최종결과를 생성한 후 실행 된다.

@Entity 어노테이션은 클래스가 JPA 엔티티임을 명시합니다. 이 어노테이션이 선언된 클래스는 데이터베이스 테이블에 매핑됩니다.

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;

    // getters and setters
}

@Table

@Table 어노테이션은 엔티티 클래스가 매핑될 테이블의 이름을 지정합니다. 생략할 경우 클래스 이름이 테이블 이름으로 사용됩니다.

@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;

    // getters and setters
}

@Id

@Id 어노테이션은 엔티티의 기본 키를 지정합니다.

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;

    // getters and setters
}

@GeneratedValue

@GeneratedValue 어노테이션은 기본 키 값의 자동 생성을 지정합니다. strategy 속성을 통해 다양한 생성 전략을 설정할 수 있습니다. 주요 전략은 다음과 같습니다:

GenerationType.AUTO: JPA 구현체가 자동으로 선택합니다. GenerationType.IDENTITY: 데이터베이스의 IDENTITY 컬럼을 사용합니다. GenerationType.SEQUENCE: 데이터베이스의 시퀀스를 사용합니다. GenerationType.TABLE: 키 생성용 별도 테이블을 사용합니다.

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;

    // getters and setters
}

@Column

@Column 어노테이션은 엔티티 필드를 데이터베이스 컬럼에 매핑하는 데 사용됩니다. 다양한 속성을 통해 컬럼의 세부 설정을 지정할 수 있습니다.

name: 컬럼 이름 nullable: NULL 가능 여부 unique: 유니크 제약 조건 설정 length: 문자열 컬럼의 길이 precision, scale: 숫자 컬럼의 정밀도와 스케일

@Column
@Column 어노테이션은 엔티티 필드를 데이터베이스 컬럼에 매핑하는 데 사용됩니다. 다양한 속성을 통해 컬럼의 세부 설정을 지정할 수 있습니다.

name: 컬럼 이름
nullable: NULL 가능 여부
unique: 유니크 제약 조건 설정
length: 문자열 컬럼의 길이
precision, scale: 숫자 컬럼의 정밀도와 스케일

@Temporal

@Temporal 어노테이션은 날짜/시간 타입을 매핑할 때 사용됩니다. TemporalType 속성을 통해 날짜, 시간 또는 타임스탬프를 지정할 수 있습니다.

TemporalType.DATE: 날짜 정보만 TemporalType.TIME: 시간 정보만 TemporalType.TIMESTAMP: 날짜와 시간 정보

@Temporal
@Temporal 어노테이션은 날짜/시간 타입을 매핑할 때 사용됩니다. TemporalType 속성을 통해 날짜, 시간 또는 타임스탬프를 지정할 수 있습니다.

TemporalType.DATE: 날짜 정보만
TemporalType.TIME: 시간 정보만
TemporalType.TIMESTAMP: 날짜와 시간 정보

@Enumerated

@Enumerated 어노테이션은 enum 타입을 매핑할 때 사용됩니다. EnumType 속성을 통해 ORDINAL (숫자 값) 또는 STRING (문자열 값)로 매핑할 수 있습니다.

@Enumerated
@Enumerated 어노테이션은 enum 타입을 매핑할 때 사용됩니다. EnumType 속성을 통해 ORDINAL (숫자 값) 또는 STRING (문자열 값)로 매핑할 수 있습니다.

@Lob

@Lob 어노테이션은 큰 데이터 객체(BLOB, CLOB)를 매핑할 때 사용됩니다. BLOB (Binary Large Object)는 바이너리 데이터를, CLOB (Character Large Object)는 문자열 데이터를 저장합니다.

@Entity
public class Document {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Lob
    private byte[] content;

    // getters and setters
}

@Transient

@Transient 어노테이션은 특정 필드가 데이터베이스 컬럼에 매핑되지 않도록 합니다. 해당 필드는 JPA가 관리하지 않습니다.

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private double price;

    @Transient
    private String temporaryData;

    // getters and setters
}

JPA에서 영속성 컨텍스트(Persistence Context)는 엔티티를 관리하는 환경을 의미합니다. 영속성 컨텍스트는 엔티티 매니저(EntityManager)에 의해 관리되며, 엔티티 매니저는 엔티티의 생명 주기를 관리하고 데이터베이스 작업을 수행하는 데 사용됩니다. 영속성 컨텍스트는 다음과 같은 특징을 갖습니다:

1차 캐시:

영속성 컨텍스트는 엔티티의 1차 캐시 역할을 합니다. 이를 통해 동일한 엔티티에 대한 중복 쿼리를 방지하고, 엔티티를 효율적으로 관리할 수 있습니다. 예를 들어, 동일한 트랜잭션 내에서 동일한 엔티티를 여러 번 조회하면, 데이터베이스를 다시 조회하지 않고 1차 캐시에서 엔티티를 반환합니다.

엔티티 생명 주기:

엔티티는 영속성 컨텍스트 내에서 관리되며, 생명 주기에 따라 상태가 변합니다. JPA에서는 엔티티 상태를 크게 네 가지로 나눕니다:

• 비영속(Transient): 엔티티가 새로 생성되었지만 아직 영속성 컨텍스트에 저장되지 않은 상태.

• 영속(Managed): 엔티티가 영속성 컨텍스트에 저장되어 관리되고 있는 상태.

• 준영속(Detached): 엔티티가 한때 영속성 컨텍스트에 저장되었지만 현재는 분리된 상태.

• 삭제(Removed): 엔티티가 영속성 컨텍스트에서 삭제된 상태.

변경 감지(Dirty Checking):

영속성 컨텍스트는 관리 중인 엔티티의 변경 사항을 추적합니다. 트랜잭션이 커밋될 때, 변경된 엔티티는 자동으로 데이터베이스에 반영됩니다. 변경 감지를 통해 개발자는 엔티티 상태를 명시적으로 업데이트할 필요 없이 편리하게 데이터 변경을 처리할 수 있습니다.

 Product product = new Product();
 product.setName("Laptop");
 product.setPrice(1200.00);
 em.persist(product);
 em.getTransaction().commit();

JPA 영속성 관련 주요 개념

• EntityManager는 JPA의 핵심 인터페이스로, 영속성 컨텍스트를 관리하고 엔티티의 생명 주기를 제어하는 데 사용됩니다. 주로 엔티티의 생성, 조회, 업데이트, 삭제 작업을 수행합니다. Entity Transaction:

• 트랜잭션은 일련의 데이터베이스 작업을 하나의 단위로 묶어 관리합니다. JPA에서는 EntityManager를 통해 트랜잭션을 시작하고 커밋 또는 롤백할 수 있습니다. Cascade:

• JPA에서 연관된 엔티티 간의 작업을 전이(Cascade) 시킬 수 있습니다. 예를 들어, 부모 엔티티를 저장할 때 자식 엔티티도 함께 저장되도록 설정할 수 있습니다. Fetch Type:

• 엔티티의 연관 필드를 가져오는 방식으로, 즉시 로딩(EAGER)과 지연 로딩(LAZY)이 있습니다. 즉시 로딩은 연관된 엔티티를 즉시 가져오는 반면, 지연 로딩은 실제로 사용할 때 가져옵니다.

모든 필드를 인자로 받는 생성자를 자동으로 생성하는 어노테이션입니다.

코드예시

import lombok.AllArgsConstructor;

@AllArgsConstructor
public class MyClass {
    private String field1;
    private int field2;
}

public class MyClass {
    private String field1;
    private int field2;

    public MyClass(String field1, int field2) {
        this.field1 = field1;
        this.field2 = field2;
    }
}

주의사항

1. 상속 관계에서의 사용: 상속 관계에서 @AllArgsConstructor을 사용할 때는 조심해야 합니다. 부모 클래스에 있는 필드들도 자동으로 생성자에 포함되므로, 서브클래스에서 불필요한 생성자가 만들어질 수 있습니다. 이 경우에는 @AllArgsConstructor 대신 @NoArgsConstructor를 사용하고, 필요한 경우에는 @Setter나 @Builder와 같은 Lombok 어노테이션을 사용하여 필드를 초기화하는 것이 좋습니다.

2. 불변 클래스에서의 사용: 불변(immutable) 클래스에서 @AllArgsConstructor을 사용할 때는 주의해야 합니다. 불변 클래스의 경우에는 생성자를 통해 한 번 값을 설정하면 변경할 수 없으므로, 외부에서 생성자를 통해 주입되는 값의 무결성을 보장해야 합니다. 따라서 불변 클래스에서는 생성자를 통해 받은 값이 유효한지 검증하는 로직을 추가하는 것이 좋습니다.

3. 생성자 오버로딩과 충돌 : @AllArgsConstructor을 사용할 때 기존에 직접 정의한 생성자와 충돌할 수 있습니다. 이 경우에는 Lombok 어노테이션의 exclude 옵션을 사용하여 충돌하는 필드를 제외하거나, @NoArgsConstructor와 @AllArgsConstructor을 함께 사용하여 기본 생성자와 모든 필드를 인자로 받는 생성자를 함께 생성하는 것이 좋습니다.

4. 순서와 가독성: 생성자에 포함되는 필드들의 순서가 중요합니다. 생성자의 인자 순서와 필드의 순서가 일치해야 합니다. 이러한 순서의 일치를 유지하면 가독성을 높일 수 있습니다.

@NoArgsConstructor

매개변수가 없는 기본 생성자를 자동으로 생성할 수 있습니다.

코드예시

import lombok.NoArgsConstructor;

@NoArgsConstructor
public class MyClass {
    private String field1;
    private int field2;
}

public MyClass() {

}

주의사항

1. JPA 엔티티 클래스에서의 사용: JPA 엔티티 클래스에서는 매개변수가 없는 기본 생성자가 필수적입니다. 그렇지 않으면 JPA가 올바르게 엔티티를 생성하지 못할 수 있습니다. 따라서 JPA 엔티티 클래스에서는 @NoArgsConstructor를 사용하여 기본 생성자를 명시적으로 추가하는 것이 좋습니다.

2. 다른 생성자와의 충돌: @NoArgsConstructor를 사용할 때 기존에 직접 정의한 생성자와 충돌할 수 있습니다. 이 경우에는 exclude 옵션을 사용하여 제외하거나, @AllArgsConstructor과 함께 사용하여 모든 필드를 인자로 받는 생성자를 함께 생성할 수 있습니다.

3. 불변 클래스에서의 사용: 불변(immutable) 클래스에서는 기본 생성자를 사용하여 객체를 생성할 경우 객체의 상태가 변경되지 않기 때문에 유효한 상태인지를 검증할 수 없습니다. 따라서 불변 클래스에서는 생성자를 통해 초기화하는 것이 좋습니다.

   import lombok.NoArgsConstructor;
   

@NoArgsConstructor(access = AccessLevel.PRIVATE) public class ImmutableClass { private final String field1; private final int field2;

public ImmutableClass(String field1, int field2) {
    this.field1 = field1;
    this.field2 = field2;
}

// Getter 메서드 생략

}

4. **직렬화와의 호환성**: 직렬화(serialization)에 사용되는 클래스에서는 기본 생성자를 반드시 제공해야 합니다. 그렇지 않으면 직렬화 과정에서 오류가 발생할 수 있습니다. 따라서 직렬화를 고려하는 클래스에서는 @NoArgsConstructor를 사용하여 기본 생성자를 명시적으로 추가하는 것이 좋습니다.

### @Getter
클래스의 필드에 대한 getter 메서드가 자동으로 생성됩니다. 이를 통해 외부에서 필드에 접근할 때에는 getter 메서드를 통하여 안전하게 접근할 수 있습니다.

**코드예시**
~~~java
import lombok.Getter;

@Getter
public class MyClass {
    private String field1;
    private int field2;
}

public String getField1() {
    return field1;
}

public int getField2() {
    return field2;
}

주의사항

1. 불변 클래스에서의 사용: 불변(immutable) 클래스에서는 필드에 대한 getter 메서드를 제공하는 것이 일반적입니다. 그러나 setter 메서드를 제공하지 않고, 필드를 초기화한 후에는 변경되지 않도록 만들어야 합니다. 따라서 불변 클래스에서는 @Getter를 사용하여 필드에 대한 getter 메서드를 생성하는 것이 바람직합니다.

2. 보안 문제: @Getter를 사용하여 모든 필드에 대한 getter 메서드를 생성하면 모든 필드에 대한 읽기 권한이 생깁니다. 따라서 보안에 민감한 정보를 포함하는 클래스에서는 신중하게 사용해야 합니다.

3. 불필요한 Getter 생성 : 모든 필드에 대해 getter 메서드를 생성하면 필요하지 않은 경우에도 getter 메서드가 생성됩니다. 이는 클래스의 인터페이스를 불필요하게 노출시킬 수 있으므로 주의해야 합니다.

@Setter

클래스의 필드에 대한 setter 메서드가 자동으로 생성됩니다. 이를 통해 외부에서 필드에 값을 설정할 때에는 setter 메서드를 통하여 안전하게 값을 설정할 수 있습니다.

코드예시

import lombok.Setter;

@Setter
public class MyClass {
    private String field1;
    private int field2;
}

public void setField1(String field1) {
    this.field1 = field1;
}

public void setField2(int field2) {
    this.field2 = field2;
}

주의사항

1. 불변 클래스에서의 사용: 불변(immutable) 클래스에서는 필드의 값을 변경할 수 없도록 만들어야 합니다. 따라서 불변 클래스에서는 @Setter를 사용하여 필드에 대한 setter 메서드를 생성하는 것은 지양해야 합니다.

2. 보안 문제: @Setter를 사용하여 모든 필드에 대한 setter 메서드를 생성하면 모든 필드에 대한 쓰기 권한이 생깁니다. 따라서 보안에 민감한 정보를 포함하는 클래스에서는 신중하게 사용해야 합니다.

3. 불필요한 쓰기 권한 제공: 필드에 대한 setter 메서드를 생성하면 필요하지 않은 경우에도 쓰기 권한이 제공됩니다. 이는 클래스의 상태를 불필요하게 변경할 수 있으므로 주의해야 합니다.

@ToString

래스의 toString() 메서드를 자동으로 생성해줍니다. 이를 통해 객체의 내부 상태를 문자열로 표현할 수 있습니다.

코드예시

import lombok.ToString;

@ToString
public class MyClass {
    private String field1;
    private int field2;
}

@Override
public String toString() {
    return "MyClass(field1=" + field1 + ", field2=" + field2 + ")";
}

주의사항

1. 무분별한 사용: 모든 필드를 포함한 문자열을 생성하기 때문에 클래스의 필드 수가 많을 경우에는 생성된 문자열이 너무 길어질 수 있습니다. 필요한 경우에만 사용하는 것이 좋습니다.

2. 필드 순서: @ToString은 기본적으로 클래스에 선언된 순서대로 필드를 문자열에 포함시킵니다. 필드의 순서를 변경하려면 @ToString 어노테이션에 includeFieldNames 옵션을 사용하여 필드의 순서를 변경할 수 있습니다.

3. 순환 참조 문제: 순환 참조가 있는 경우 무한 루프에 빠질 수 있으므로 주의해야 합니다. 이러한 문제가 발생하는 경우 @ToString의 exclude 또는 of 옵션을 사용하여 순환 참조되는 필드를 제외시킬 수 있습니다.

@Data

클래스에 대한 모든 기본적인 메서드들을 자동으로 생성해줍니다. 이는 @Getter, @Setter, @ToString, @EqualsAndHashCode, @NoArgsConstructor 등 여러 어노테이션들을 포함하고 있습니다. 이를 통해 코드의 가독성을 높이고, 중복된 코드를 줄일 수 있습니다. 다른 블로그를 보면 대부분 @Data 사용은 지양하는 것 같다

주의사항

1. 무분별한 사용: @Data는 모든 필드에 대해 getter와 setter를 생성하기 때문에 보안에 민감한 정보를 포함하는 클래스에서는 신중하게 사용해야 합니다.

2. 불필요한 메서드 생성: 모든 필드에 대해 getter와 setter를 생성하기 때문에 필요하지 않은 경우에도 생성됩니다. 따라서 클래스의 용도에 따라 적절히 선택하여 사용해야 합니다.

3. 상속 문제: @Data를 사용하면 클래스에 대한 모든 기본적인 메서드들이 자동으로 생성되기 때문에 상속을 받을 때에도 부모 클래스의 메서드들이 함께 상속됩니다. 이로 인해 의도하지 않은 동작이 발생할 수 있으므로 주의해야 합니다.

reference

• https://roopredev.tistory.com/14