바꾸기 쉬운 코드는 어떻게 설계되는가 — SOLID와 패턴

SOLID는 로버트 마틴(Uncle Bob)이 정리한 객체지향 설계 5원칙의 머리글자예요. 공통 목표는 하나 — 요구사항이 바뀔 때 고쳐야 할 범위를 최소화하는 것. 각 원칙은 "결합을 줄이고 응집을 높이는" 서로 다른 각도의 처방입니다.

SRP(단일 책임 원칙) — "한 클래스는 하나의 액터(변경을 요구하는 주체)에게만 책임진다"가 정확한 표현이에요. 아래 Report는 계산·서식·저장 세 책임을 한 몸에 담아, 서로 다른 이유로 자꾸 바뀝니다.

// ❌ SRP 위반: 계산 + 서식 + 저장이 한 클래스에
class Report {
    double calcTotal() { /* 회계 로직 */ return 0; }
    String toHtml()    { /* 표현 로직 */ return ""; }
    void saveToDb()    { /* 영속 로직 */ }
}

// ✅ 개선: 책임별로 분리 (바뀔 이유가 하나씩)
class ReportCalculator { double calcTotal() { return 0; } }
class ReportRenderer   { String toHtml(Report r) { return ""; } }
class ReportRepository { void save(Report r) { } }

// ❌ OCP 위반: 종류가 늘 때마다 이 메서드를 계속 수정
double discount(String grade, double price) {
    if (grade.equals("GOLD"))   return price * 0.8;
    if (grade.equals("SILVER")) return price * 0.9;
    return price; // 새 등급마다 여기 또 손댐
}

// ✅ 개선: 확장은 새 구현 추가로, 기존 코드는 닫힘
interface DiscountPolicy { double apply(double price); }
class GoldPolicy   implements DiscountPolicy { public double apply(double p){ return p*0.8; } }
class SilverPolicy implements DiscountPolicy { public double apply(double p){ return p*0.9; } }
// 새 등급? 새 클래스만 추가하면 됨

LSP(리스코프 치환 원칙) — 하위 타입은 상위 타입의 계약(사전조건·사후조건·불변식)을 지켜, 어디서든 상위 타입 자리에 넣어도 동작이 깨지지 않아야 해요. 유명한 정사각형-직사각형 문제가 대표적 위반입니다.

// ❌ LSP 위반: Square는 Rectangle의 계약을 깬다
class Rectangle {
    protected int w, h;
    void setW(int w){ this.w = w; }
    void setH(int h){ this.h = h; }
    int area(){ return w * h; }
}
class Square extends Rectangle {          // "정사각형 is-a 직사각형"의 함정
    void setW(int w){ this.w = this.h = w; }   // 너비 바꿨는데 높이도 바뀜
    void setH(int h){ this.w = this.h = h; }
}
// setW(3); setH(4); 후 area()가 12가 아니라 16 → 상위 타입 기대를 위반

DIP(의존 역전 원칙) — 고수준 모듈이 저수준 모듈에 직접 의존하지 않고, 둘 다 추상(인터페이스)에 의존해야 해요. 그리고 그 추상을 소유하는 쪽은 고수준입니다("의존의 방향이 역전"된다는 이름의 유래).

// ❌ DIP 위반: 고수준(주문서비스)이 저수준(구체 클래스)에 직접 의존
class OrderService {
    private MySqlOrderRepository repo = new MySqlOrderRepository(); // 콘크리트에 못박힘
}

// ✅ 개선: 양쪽 모두 추상(OrderRepository)에 의존, 구현은 주입
interface OrderRepository { void save(Order o); }
class OrderService {
    private final OrderRepository repo;               // 추상에 의존
    OrderService(OrderRepository repo){ this.repo = repo; } // DI로 주입
}
class MySqlOrderRepository implements OrderRepository { public void save(Order o){} }

응집이 높으면 바뀔 이유가 한 곳에 모여 수정이 쉽고, 결합이 낮으면 한 모듈을 고쳐도 파급이 작아요. SOLID 원칙 대부분이 결국 이 둘을 좋게 만드는 방법입니다.

// ❌ 상속 남용: HashSet의 내부 구현에 결합 → addAll이 add를 호출하면 이중 카운트
class CountingSet<E> extends HashSet<E> {
    int count = 0;
    public boolean add(E e){ count++; return super.add(e); }
    public boolean addAll(Collection<? extends E> c){ count += c.size(); return super.addAll(c); }
}

// ✅ 조합 + 전달(forwarding): 내부 Set에 위임, 구현 변화에 견고
class CountingSet<E> {
    private final Set<E> delegate;      // has-a
    private int count = 0;
    CountingSet(Set<E> s){ this.delegate = s; }
    public boolean add(E e){ count++; return delegate.add(e); }
    public int count(){ return count; }
}

패턴은 공통 어휘예요. "여기 전략 패턴 쓰자"는 한마디로 팀이 같은 그림을 그리죠. 유형은 크게 셋 — 객체를 어떻게 만드는가(생성), 어떻게 조립하는가(구조), 어떻게 협력하는가(행위).

Strategy는 OCP를 실현하는 대표 패턴이에요. 앞서 본 DiscountPolicy가 바로 전략 패턴 — 알고리즘을 인터페이스 뒤에 두고 런타임에 주입·교체합니다.

// Strategy: 정렬 기준을 런타임에 교체 (Comparator가 곧 전략)
List<User> users = ...;
Comparator<User> byName = Comparator.comparing(User::name);
Comparator<User> byAge  = Comparator.comparingInt(User::age);
users.sort(byName);   // 전략 주입
users.sort(byAge);    // 다른 전략으로 교체 — sort 코드는 그대로

불변 객체(immutable)는 생성 후 상태가 절대 바뀌지 않는 객체예요(String·Integer·LocalDate·record). 이점이 많아요 — 스레드 안전(공유해도 동기화 불필요), 부작용 없음, 안심하고 캐싱/공유, 방어적 복사 불필요. 만드는 법은 final 필드 + setter 없음 + final 클래스입니다.

// 불변 객체 + 방어적 복사 (가변 필드가 새어 나가지 않게)
final class Period {
    private final Date start, end;   // Date는 가변! 그래서 복사 필요
    Period(Date start, Date end) {
        this.start = new Date(start.getTime());  // 생성자 방어적 복사 (입력 보호)
        this.end   = new Date(end.getTime());
        if (this.start.after(this.end)) throw new IllegalArgumentException();
    }
    public Date start() { return new Date(start.getTime()); } // 게터도 복사 (내부 보호)
}