GRASP

GRASP

GRASP(General Responsibility Assignment Software Patterns) 는 Craig Larman 이 제안한 객체지향 설계 원칙으로, 객체와 클래스에 책임을 할당하는 9 가지 핵심 패턴을 제공한다. 이 원칙들은 객체의 역할과 협력을 명확히 하여, 시스템의 유연성, 유지보수성, 확장성을 높이는 데 중점을 둔다. GRASP 는 Information Expert, Creator, Controller, Low Coupling, High Cohesion, Polymorphism, Pure Fabrication, Indirection, Protected Variations 등으로 구성되며, 실무에서 객체지향 설계의 기초이자 실질적인 지침으로 널리 활용된다.

핵심 개념

GRASP 의 핵심 개념은 " 책임 할당 (Responsibility Assignment)" 이다. 객체지향 설계에서 가장 중요한 의사결정은 어떤 클래스나 객체가 특정 책임을 담당해야 하는지 결정하는 것이다. 실무에 바로 적용 가능한 구체적이고 명확한 설계 지침이며, SOLID 원칙과 함께 객체지향 설계의 양대 축으로 활용된다.

책임의 두 가지 유형:

• 행동 책임 (Doing Responsibility): 객체 생성, 데이터 처리, 계산 수행, 다른 객체와의 협력 조정
• 인식 책임 (Knowing Responsibility): 개인 데이터, 관련 객체 참조, 파생 가능한 정보

배경 및 목적

GRASP 는 Craig Larman 이 1997 년 객체지향 설계의 경험과 모범 사례를 체계화하여 만든 원칙이다. 기존의 좋은 설계 관행들을 정리하고 표준화한 것으로, 새로운 방법론이 아닌 입증된 설계 원칙들의 집합이다.

목적 및 필요성:

• 객체지향 설계에서 책임 할당의 가이드라인 제공
• 낮은 결합도 (Low Coupling) 와 높은 응집도 (High Cohesion) 달성
• 유지보수성, 재사용성, 확장성이 높은 소프트웨어 개발
• 설계 의사결정에 대한 체계적 접근법 제공

GRASP 원칙

객체 설계 시 각 객체가 자신의 데이터와 행위에 대한 책임을 갖도록 하고, 변화에 강한 구조를 위해 결합도를 낮추고 응집도를 높인다.
시스템 이벤트 처리, 객체 생성, 데이터 관리 등에서 각 원칙을 조합하여 적용한다.

설명:

• 시스템 이벤트를 Controller가 수신하고 처리.
• Controller 는 도메인 객체 생성을 Creator로 위임.
• 도메인 객체는 정보 중심으로 책임을 갖는 Information Expert.
• 다형성과 변동성 보호는 Polymorphism과 Protected Variations로 처리.
• 설계 품질 개선을 위해 Low Coupling, High Cohesion, Indirection, Pure Fabrication을 적용.

graph TD
    User-->|Event|Controller
    Controller-->|Delegates|InformationExpert
    InformationExpert-->|Uses|PureFabrication
    Controller-->|Creates|Creator
    Controller-->|Uses|Indirection
    Indirection-->|Protects|ProtectedVariations
    InformationExpert-->|Polymorphism|Polymorphism

Information Expert (정보 전문가)

원칙: 데이터를 가장 많이 가진 클래스에 책임을 할당한다.

예시: Order 객체가 총합 계산 책임을 가짐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Order:
    def __init__(self):
        self.items = []

    def add_item(self, price, quantity):
        self.items.append({'price': price, 'quantity': quantity})

    def calculate_total(self):
        return sum(item['price'] * item['quantity'] for item in self.items)

# 사용
order = Order()
order.add_item(100, 2)
order.add_item(50, 3)
print(order.calculate_total())  # ➜ 350

Creator (생성자)

원칙: A 객체가 B 객체를 포함하거나 사용하는 경우 A 가 B 를 생성해야 한다.

예시: Order 가 OrderItem 을 생성

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class OrderItem:
    def __init__(self, product, quantity):
        self.product = product
        self.quantity = quantity

class Order:
    def __init__(self):
        self.items = []

    def add_item(self, product, quantity):
        item = OrderItem(product, quantity)
        self.items.append(item)

Controller

원칙: 시스템 이벤트를 처리하는 객체는 UI 외부에 존재해야 한다.

예시: OrderController 가 요청을 처리

1
2
3
4
5
6

class OrderController:
    def create_order(self, data):
        order = Order()
        for item in data['items']:
            order.add_item(item['product'], item['quantity'])
        return order

Low Coupling (낮은 결합도)

원칙: 의존성을 줄여 유지보수성을 높인다.

예시: 인터페이스 추상화

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class PaymentService:
    def pay(self, amount):
        raise NotImplementedError

class PaypalService(PaymentService):
    def pay(self, amount):
        print(f"Paying ${amount} via PayPal")

class Order:
    def __init__(self, payment_service: PaymentService):
        self.payment_service = payment_service

    def checkout(self, amount):
        self.payment_service.pay(amount)

High Cohesion (높은 응집도)

원칙: 관련 기능을 한 클래스에 집중

예시: Order 는 주문 관련 기능만 포함

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Order:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        self.items.append(item)

    def total_items(self):
        return len(self.items)

    def calculate_total(self):
        return sum(item.price for item in self.items)

Polymorphism (다형성)

원칙: 다양한 구현을 동일한 인터페이스로 처리

예시: 다양한 결제 방식

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class PaymentMethod:
    def pay(self, amount):
        raise NotImplementedError

class CreditCardPayment(PaymentMethod):
    def pay(self, amount):
        print(f"Paid ${amount} with Credit Card")

class PayPalPayment(PaymentMethod):
    def pay(self, amount):
        print(f"Paid ${amount} with PayPal")

def process_payment(method: PaymentMethod, amount):
    method.pay(amount)

Pure Fabrication (순수 창작)

원칙: 설계 품질을 높이기 위한 비도메인 클래스

예시: EmailService 는 도메인과 무관하지만 필요

1
2
3

class EmailService:
    def send_receipt(self, order):
        print(f"Sending receipt for order with {len(order.items)} items.")

Indirection (간접화)

원칙: 두 객체 사이의 직접 의존을 줄이기 위한 중개자 사용

예시: PaymentProcessor 가 중개자 역할

1
2
3
4
5
6

class PaymentProcessor:
    def __init__(self, strategy: PaymentMethod):
        self.strategy = strategy

    def execute_payment(self, amount):
        self.strategy.pay(amount)

Protected Variations (변경 보호)

원칙: 변경 가능성이 높은 부분을 인터페이스로 감싸 보호

예시: 인터페이스로 다양한 결제 방식을 보호

1

# 이미 위 Polymorphism 예시가 해당됨

장점과 단점

분류에 따른 종류

실무 적용 예시

활용 사례

사례 1: 온라인 쇼핑몰 시스템

시나리오: 사용자가 온라인 쇼핑몰에서 상품을 주문하고 결제하는 시스템
시스템 구성도:

graph TB
    subgraph "Presentation Layer"
        A[Web UI] --> B[OrderController]
    end
    
    subgraph "Application Layer"
        B --> C[OrderService]
        C --> D[PaymentService]
    end
    
    subgraph "Domain Layer"
        E[Order] --> F[OrderItem]
        E --> G[Customer]
        H[Payment] --> I[PaymentProcessor]
    end
    
    subgraph "Infrastructure Layer"
        J[OrderRepository]
        K[PaymentGateway]
    end
    
    C --> E
    D --> H
    E --> J
    I --> K

GRASP 원칙 적용:

• Information Expert: Order 클래스가 주문 총액 계산
• Creator: OrderService 가 Order 객체 생성
• Controller: OrderController 가 주문 요청 처리
• Polymorphism: 다양한 PaymentProcessor 구현체
• Pure Fabrication: PaymentService 는 도메인 무관 서비스

Workflow:

1. 사용자 주문 요청 → OrderController
2. Controller → OrderService 로 처리 위임
3. OrderService → Order 객체 생성 (Creator)
4. Order → 총액 계산 (Information Expert)
5. PaymentService → 결제 처리 (Pure Fabrication)
6. PaymentProcessor → 결제 방법별 처리 (Polymorphism)

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

최적화를 위한 고려사항

하위 주제 학습 내용

추가 학습 주제 및 관련 분야 정리

용어 정리

GRASP 원칙 (General Responsibility Assignment Software Patterns)

객체지향 핵심 개념

설계 품질 관련 용어

설계 전략 및 기법

참고 및 출처

📘 공식 문서 / 백서 / 전문 블로그

• GRASP Design Principles in OOAD - GeeksforGeeks
• GRASP (object-oriented design) - Wikipedia
• GRASP - General Responsibility Assignment Software Patterns Explained
• GRASP Principles: General Responsibility Assignment Software Patterns - Bool.dev
• GRASP: 9 Must-Know Design Principles for Code - Fluent C++
• Refactoring Guru – GRASP Principles
• Uncle Bob: Principles of OOD 요약

📚 책 / 저자 중심 자료

• Craig Larman의 “Applying UML and Patterns”
• Martin Fowler – Patterns of Enterprise Application Architecture

📝 국내 블로그 및 커뮤니티 정리

• velog: GRASP와 SOLID 원칙 개요
• 티스토리: GRASP 상세 설명
• 안녕지구 블로그: SOLID & GRASP 요약
• Yumin’s Devlog: GRASP 원칙
• 도니의 iOS 프로그래밍 세상: 정보 전문가 패턴
• d-yong’s 블로그: GRASP 개요