본문 바로가기
Programming/13. Book

리팩터링 - 12장

by @sangseophwang 2024. 3. 2.

Chapter 12. 상속 다루기

✏️ 메서드 올리기

배경

  • 메서드 올리기를 적용하기 가장 쉬운 상황은 메서드들의 본문 코드가 똑같을 때다.
    • 이럴 땐 그냥 복사 - 붙여넣기면 끝이다.
  • 보통 메서드 올리기를 적용하려면 선행 단계가 필요하다.
    • e.g. 서로 다른 두 클래스의 두 메서드를 같은 메서드로 만들기
      • 각각의 함수를 매개변수화한 후 메서드를 상속 계층의 위로 올리기

절차

  1. 같은 동작의 메서드인지 확인한다.
  2. 메서드 안에서 호출하는 다른 메서드와 참조하는 필드들을 슈퍼클래스에서도 호출하고 참조할 수 있는지 확인한다.
  3. 함수 선언 바꾸기로 슈퍼클래스에서 사용하고 싶은 형태로 통일한다.
  4. 서브클래스 중 하나의 메서드를 제거한다.
  5. 모든 서브클래스의 메서드가 없어질 때까지 하나씩 제거한다.

예시

Before

// 코드 내용: Party 클래스를 상속한 Employee, Department 클래스에서 동일한 메서드 발견
// 슈퍼클래스에는 없지만 서브 클래스에 존재하는 상태

class Employee extends Party {
  get annualCost() {
    return this.monthlyCost * 12;
  }
}

class Department extends Party {
  get totalAnnualCost() {
    return this.monthlyCost * 12;
  }
}

After

  • 함수 선언 바꾸기로 이름 통일 (annualCost)
  • 슈퍼클래스인 Party로 annualCost 메서드 올리기
class Party {
  get annualCost() {
    return this.monthlyCost * 12;
  }
}

class Department extends Party {
}
class Employee extends Party {
}

✏️ 필드 올리기

배경

  • 서브클래스들이 독립적으로 개발되었거나 뒤늦게 하나의 계층구조로 리팩토링된 경우 일부 기능이 중복될 수 있다.
    • 특히 필드
  • 필드들이 비슷한 방식으로 쓰인다고 판단되면 슈퍼클래스로 끌어올린다.
  • 이렇게 하면 두 가지 중복을 줄일 수 있다.
    • 데이터 중복 선언 없애기
    • 해당 필드를 사용하는 동작을 슈퍼클래스로 옮기기 가능

절차

  1. 후보 필드들이 사용하는 곳에서 동일한 방식으로 사용하는지 확인한다.
  2. 필드 이름 바꾸기로 같은 이름으로 변경한다.
  3. 슈퍼클래스에 새로운 필드를 생성하고 서브클래스 필드들을 제거한다.

예시

Before

// 코드 내용 : 서브클래스에서 동일하게 사용되는 name 필드 발견

class Employee {}

class Salesperson extends Employee {
  #name;
}

class Engineer extends Employee {
  #name;
}

After

  • 슈퍼클래스로 name 필드를 옮기고 서브클래스에서는 제거
class Employee {
  #name;
}

class Salesperson extends Employee {
}

class Engineer extends Employee {
}

✏️ 생성자 본문 올리기

배경

  • 이번 리팩토링이 간단히 끝날 것 같지 않다면 생성자를 팩토리 함수 바꾸기를 고려해본다.

절차

  1. 슈퍼클래스에 생성자가 없다면 하나 정의한다.
  2. 문장 슬라이드하기로 공통 문장 모두를 super() 호출 직후로 옮긴다.
  3. 공통 코드를 슈퍼클래스에 추가하고 서브클래스들을 제거한다.
  4. 생성자 매개변수 중 공통 코드에서 참조하는 값들을 모두 super()로 건넨다.
  5. 생성자 시작 부분으로 옮길 수 없는 공통 코드에는 함수 추출하기와 메서드 올리기를 차례로 적용한다.

예시

Before

// 코드 내용: 서브클래스 생성자에 공통으로 사용되는 name 발견

class Party {}

class Employee extends Party {
  constructor(name, id, monthlyCost) {
    super();
    this._id = id;
    this._name = name; 📍
    this._monthlyCost = monthlyCost;
  }
}

class Department extends Party {
  constructor(name, staff) {
    super();
    this._name = name; 📍
    this._staff = staff;
  }
}

After

  • Employee의 name을 super 아래로 옮긴다. (문장 슬라이드하기)
  • Party 클래스에 name을 추가하고 이 인수를 슈퍼클래스 생성자에 매개변수로 건넨다.
class Party {
  constructor(name) {
    this._name = name;
  }
}

class Employee extends Party {
  constructor(name, id, monthlyCost) {
    super(name);
    this._id = id;
    this._monthlyCost = monthlyCost;
  }
}

class Department extends Party {
  constructor(name, staff) {
    super(name);
    this._staff = staff;
  }
}

✏️ 메서드 내리기

배경

  • 특정 서브클래스 하나(혹은 소수)만 관련된 메서드는 슈퍼클래스에서 제거하고 해당 서브클래스에 추가하는 편이 깔끔하다.

절차

  1. 대상 메서드를 모든 서브클래스에 복사한다.
  2. 슈퍼클래스에서 그 메서드를 제거한다.
  3. 이 메서드를 사용하지 않는 모든 서브클래스에서 제거한다.

예시

Before

// 코드 내용: 슈퍼클래스에 있는 quota 메서드는 Salesperson 클래스에서만 사용중

class Employee {
  get quota() {}
}

class Engineer extends Employee {}
class Salesperson extends Employee {}

After

  • Salesperson 서브클래스로 메서드를 옮긴 후 슈퍼클래스와 나머지 서브 클래스들에서 제거
class Employee {
}

class Engineer extends Employee {}
class Salesperson extends Employee {
  get quota() {}
}

✏️ 필드 내리기

배경

  • 서브클래스 하나(혹은 소수)에서만 사용하는 필드는 해당 서브클래스(들)로 옮긴다.

절차

  1. 대상 필드를 모든 서브클래스에 정의한다.
  2. 슈퍼클래스에서 그 필드를 제거한다.
  3. 이 필드를 사용하지 않는 모든 서브클래스에서 제거한다.

예시

Before

// 코드 내용: 슈퍼클래스에 있는 quota 필드는 Salesperson에서만 사용중

class Employee {
  #quota;
}

class Engineer extends Employee {}
class Salesperson extends Employee {}

After

  • Salesperson 서브클래스로 필드를 옮긴 후 슈퍼클래스와 나머지 서브 클래스들에서 제거
class Employee {
}

class Engineer extends Employee {}
class Salesperson extends Employee {
  #quota;
}

✏️ 타입 코드를 서브클래스로 바꾸기

배경

  • 소프트웨어 시스템에서는 비슷한 대상들을 특정 특성에 따라 구분해야 할 때가 있다.
    • 직원을 담당 업무로 구분
    • 주문을 시급성으로 구분
  • 이런 일을 다루는 수단으로는 타입 코드(type code) 필드가 있다.
    • 열거형, 심볼, 문자열, 숫자 등
  • 타입 코드 이상으로 무언가가 필요할 때 서브클래스를 사용하면 좋다.
    • 조건에 따라 다르게 동작하도록 해주는 다형성 제공
    • 특정 타입에서만 의미 있는 값을 사용하는 필드나 메서드가 있을 때 활용성 증대

절차

  1. 타입 코드 필드를 자가 캡슐화한다.
  2. 타입 코드 값 하나를 선택해 서브클래스를 만든다.
  3. 매개변수로 받은 타입 코드와 서브클래스를 매핑하는 선택 로직을 만든다.
  4. 타입 코드 값 각각에 대해 서브클래스 생성과 선택 로직 추가를 반복한다.
  5. 타입 코드를 제거한다.
  6. 타입 코드 접근자를 이용하는 메서드 모두에 메서드 내리기와 조건부 로직을 다형성으로 바꾸기를 적용한다.

예시

Before

// 코드 내용 : engineer, manager, salesperson 타입을 체크하는 validateType 함수

class Employee {
  constructor(name, type) {
    this.validateType(type);
    this._name = name;
    this._type = type;
  }

  validateType(arg) {
    if (!['engineer', 'manager', 'salesperson'].includes(arg)) {
      throw new Error(`${arg}라는 직원 유형은 없습니다.`);
    }
  }

  toString() {
    return `${this._name} (${this._type})`;
  }
}

After

  • 타입별로 서브클래스 생성
  • createEmployee 팩토리 함수로 선택 로직 구현
  • 각 타입별로 서브클래스 생성자 리턴
class Employee {
  constructor() {
    this._name = name;
  }
}

class Engineer extends Employee {
  get type() {
    return 'engineer';
  }
}

class Salesperson extends Employee {
  get type() {
    return 'salesperson';
  }
}

function createEmployee(name, type) {
  switch(type) {
    case 'engineer':    return new Engineer();
    case 'salesperson': return new Salesperson();
    default: throw new Error(`${type}라는 직원 유형은 없습니다.`);
  }
}

✏️ 서브클래스 제거하기

배경

  • 서브클래싱은 원래 데이터 구조와는 다른 변종을 만들거나 종류에 따라 동작이 달라지게 할 수 있는 유용한 메커니즘이다.
  • 다만 더 이상 쓰이지 않는 서브클래스는 시간 낭비를 유발할 뿐이므로 제거하는 것이 좋다.

절차

  1. 서브클래스의 생성자를 팩토리 함수로 바꾼다.
  2. 서브클래스의 타입을 검사하는 코드가 있다면 그 코드를 함수 추출하기와 함수 옮기기를 차례로 적용해 슈퍼클래스로 옮긴다.
  3. 서브클래스의 타입을 나타내는 필드를 슈퍼클래스에 만든다.
  4. 서브클래스를 참조하는 메서드가 방금 만든 타입 필드를 이용하도록 수정한다.
  5. 서브클래스를 제거한다.

예시

Before

// 코드 내용: 단순한 역할을 하는 서브 클래스들

class Person {
  constructor(name) {
    this._name = name;
  }

  get name()       { return this._name; }
  get genderCode() { return 'X'; }
}

class Male extends Person {
  get genderCode() { return 'M'; }
}

class Female extends Person {
  get genderCode() { return 'F'; }
}

// 클라이언트
const numberOfMales = people.filter((p) => p instanceof Male).length;

After

  •  
// 직관적인 방법 : 팩토리 함수
function createPerson(name) {
  return new Person(name);
}
function createMale(name) {
  return new Male(name);
}
function createFemale(name) {
  return new Female(name);
}

// 내부 메서드 생성 방법 📍
// Person 클래스에 createPerson 함수를 제작해 기존 서브클래스가 하던 일을 대체

class Person {
  constructor(name, genderCode) {
    this._name = name;
    this._genderCode = genderCode;
  }

  get name()       { return this._name; }
  get genderCode() { return this._genderCode; }

  function createPerson(record){
    switch(record.gender){
      case 'M':
        return new Person(record.name, 'M')
      case 'F':
        return new Person(record.name, 'F')
      default:
        return new Person(record.name, 'X')
    }
  }

  get isMale() { return this.#genderCode === 'M'; }
}


// 클라이언트
const numberOfMales = people.filter((person) => person.isMale).length;

✏️ 슈퍼클래스 추출하기

배경

  • 비슷한 일을 수행하는 두 클래스가 보이면 상속 메커니즘을 이용해 비슷한 부분을 공통의 슈퍼클래스로 옮겨 담을 수 있다.
    • 공통된 부분이 데이터라면
      • 필드 올리기
    • 동작이라면
      • 메서드 올리기
  • 슈퍼클래스 추출하기의 대안으로는 클래스 추출하기가 있다.
    • 어느 것을 선택하느냐는 중복 동작을 상속으로 해결하느냐 위임으로 해결하느냐에 달렸다.

절차

  1. 빈 슈퍼클래스를 만든다. 원래의 클래스들이 새 클래스를 상속하도록 한다.
  2. 생성자 본문 올리기, 메서드 올리기, 필드 올리기를 차례로 적용해 공통 원소를 슈퍼클래스로 옮긴다.
  3. 서브클래스에 남은 메서드들을 검토한다. 공통된 부분은 함수로 추출한 다음 메서드 올리기를 적용한다.

예시

Before

// 코드  내용 : 비용, 이름 등 공통된 기능을 수행하는 듯한 두 클래스

class Employee {
  constructor(name, id, monthlyCost) {
    this._id = id;
    this._name = name;
    this._monthlyCost = monthlyCost;
  }
  
  get monthlyCost() { return this._monthlyCost; }      월간 비용
  get name()        { return this._name; }             이름
  get id()          { return this._id; }               아이디
  get annualCost()  { return this.monthlyCost * 12; }  연간 비용
}

class Department {
  constructor(name, staff) {
    this._name = name;
    this._staff = staff;
  }
  
  get staff()       { return this._staff.slice(); }
  get name()        { return this._name; }
  
  get totalMonthlyCost() {
    return this.staff
      .map(e => e.monthlyCost)
      .reduce((sum, cost) => sum + cost);
  }
  
  get headCount()       { return this.staff.length; }          직원 수
  get totalAnnualCost() { return this.totalMonthlyCost * 12; } 총 연간 비용
}

After

  • Party라는 슈퍼클래스를 생성하고 공통된 메서드를 옮긴다. (메서드 올리기)
  • 슈퍼클래스에서 상속받은 필드, 메서드를 활용해 각 서브클래스에서는 고유의 역할만을 수행한다.
class Party {
  constructor(name) {
    this._name = name;
  }
  
  get name() { return this._name; }

  get annualCost() {
    return this.monthlyCost * 12;
  }
}

class Employee extends Party {
  constructor(name, id, monthlyCost) {
    super(name);
    this._id = id;
    this._monthlyCost = monthlyCost;
  }

  get monthlyCost() { return this._monthlyCost; }
  get id()          { return this._id; }
}

class Department extends Party {
  constructor(name, staff) {
    super(name);
    this._staff = staff;
  }
  
  get staff() { return this._staff.slice(); }

  get monthlyCost() { // 총 월간 비용
    return this.staff
      .map(e => e.monthlyCost)
      .reduce((sum, cost) => sum + cost);
  }
  
  get headCount() {
    return this.staff.length;
  }
}

✏️ 계층 합치기

배경

  • 어떤 클래스와 그 부모가 너무 비슷해져서 더는 독립적으로 존재해야 할 이유가 사라지는 경우
    • 바로 그 둘을 합쳐야 할 시점이다.

절차

  1. 두 클래스 중 제거할 것을 고른다.
  2. 필드 올리기와 메서드 올리기, 혹은 필드 내리기와 메서드 내리기를 적용해 하나의 클래스로 옮긴다.
  3. 제거할 클래스를 참조하던 모든 코드가 남겨질 클래스를 참조하도록 고친다.
  4. 빈 클래스를 제거한다.

예시

Before

class Employee {...}
class Salesperson extends Employee {...}

After

class Employee {...}

✏️ 서브클래스를 위임으로 바꾸기

배경

  • 상속에는 단점이 있다.
    • 가장 명확한 담점은 한 번만 쓸 수 있는 카드라는 것이다.
    • 또 다른 문제로, 상속은 클래스들의 관계가 아주 긴밀하게 결합한다.
      • 부모를 수정하면 이미 존재하는 자식들의 기능을 해치기가 쉽다.
  • 위임은 이 두 문제를 모두 해결해준다.
    • 객체 사이의 일반적인 관계이므로 상호작용에 필요한 인터페이스를 명확히 정의할 수 있다.
    • 즉, 상속보다 결합도가 훨씬 약하다.
  • “(클래스) 상속보다는 (객체) 컴포지션을 사용하라!”
    • 여기서 컴포지션은 사실상 위임과 같은 말이다.
  • 처음에는 상속으로 접근한 다음, 문제가 생기기 시작하면 위임으로 갈아탄다 (저자의 방법)

절차

  1. 생성자를 호출하는 곳이 많다면 생성자를 팩토리 함수로 바꾼다.
  2. 위임으로 활용할 빈 클래스를 만든다. 이 클래스의 생성자는 서브클래스에 특화된 데이터를 전부 받아야 하며, 보통은 슈퍼클래스를 가리키는 역참조도 필요하다.
  3. 위임을 저장할 필드를 슈퍼클래스에 추가한다.
  4. 서브클래스 생성 코드를 수정해 위임 인스턴스를 생성하고 위임 필드에 대입해 초기화한다.
  5. 서브클래스의 메서드 중 위임 클래스로 이동할 것을 고른다.
  6. 함수 옮기기를 적용해 위임 클래스로 옮긴다.
  7. 서브클래스 외부에도 원래 메서드를 호출하는 코드가 있다면 서브클래스의 위임 코드를 슈퍼클래스로 옮긴다.
  8. 서브클래스의 모든 메서드가 옮겨질 때까지 5~8 과정을 반복한다.
  9. 서브클래스들의 생성자를 호출하는 코드를 찾아서 슈퍼클래스의 생성자를 사용하도록 수정한다.
  10. 서브클래스를 제거한다.

예시

Before

talkback: 반응, 응답

delegate: 위임하다

// 문제 : 여러 요구사항이 추가될수록, 슈퍼클래스 수정이 필요해질수록 관리가 어려워짐

// 공연 예약 슈퍼클래스
class Booking {
  constructor(show, date) {
    this._show = show;
    this._date = date;
  }

  // 관객과의 대화 시간을 성수기가 아닐 때만 제공
  get hasTalkback() {
    return this._show.hasOwnProperty('talkback') && !this.isPeakDay;
  }

  // 성수기, 비수기에 따라 가격 결정
  get basePrice() {
    let result = this._show.price;

    if (this.isPeakDay) {
      result += Math.round(result * 0.15);
    }

    return result;
  }
}

// 프리미엄 예약 서브클래스
class PremiumBooking extends Booking {
  constructor(show, date, extras) {
    super(show, date);
    this._extras = extras;
  }

  get hasTalkback() {
    return this._show.hasOwnProperty('talkback');
  }

  // 슈퍼클래스의 가격에 프리미엄 피를 더한 값
  get basePrice() {
    return Math.round(super.basePrice + this._extras.PremiumFee);
  }

  // 슈퍼클래스에는 없는 기능
  // 성수기가 아닐 때 저녁을 제공하는지 여부
  get hasDinner() {
    return this._extras.hasOwnProperty('dinner') && !this.isPeakDay;
  }
}

After

  • createPremiumBooking, createBooking 팩토리 함수 생성
  • Booking 클래스 내 메서드에 위임이 존재할 때, 존재하지 않을 때의 조건 추가
  • 각각의 고유한 기능들은 분리
class Booking {
  constructor(show, date) {
    this._show = show;
    this._date = date;
  }

  // 위임이 존재하면 위임을 사용하는 분배 로직 추가
  get hasTalkback() {
    return this._premiumDelegate
      ? this._premiumDelegate.hasTalkback
      : this._show.hasOwnProperty('talkback') && !this.isPeakDay;
  }

  get privateBasePrice() {
    let result = this._show.price;

    if (this.isPeakDay) {
      result += Math.round(result * 0.15);

      return result;
    }
  }

  get basePrice() {
    let result = this._show.price;

    if (this.isPeakDay) {
      result += Math.round(result * 0.15);
    }

    return this._premiumDelegate
      ? this._premiumDelegate.extendBasePrice(result)
      : this._privateBasePrice;
  }

  // 위임이 존재할 때만 결과 도출
  get hasDinner() {
    return this._premiumDelegate ? this._premiumDelegate.hasDinner : undefined;
  }

  bePremium(extras) {
    this._premiumDelegate = new PremiumBookingDelegate(this, extras);
  }

  // Booking 슈퍼클래스 생성
  static createBooking(show, date) {
    return new Booking(show, date);
  }

  // Premium 생성 메서드 (bePremium 메서드로 PremiumBookingDelegate 속성들 추가)
  static createPremiumBooking(show, date, extras) {
    const result = new Booking(show, date, extras);
    result._bePremium(extras);
    return result;
  }
}

class PremiumBookingDelegate {
  constructor(hostBooking, extras) {
    this._host = hostBooking;
    this._extras = extras;
  }

  get hasTalkback() {
    return this._host._show.hasOwnProperty('talkback');
  }

  get basePrice() {
    return Math.random(this._host._privateBasePrice + this._extras.PremiumFee);
  }

  get hasDinner() {
    return this._extras.hasOwnProperty('dinner') && !this._host.isPeakDay;
  }

  extendBasePrice(base) {
    return Math.round(base + this._extras.premiumFee);
  }
}

✏️ 슈퍼클래스를 위임으로 바꾸기

배경

  • 제대로 된 상속이라면 서브클래스가 슈퍼클래스의 모든 기능을 사용함은 물론, 서브클래스의 인스턴스를 슈퍼클래스의 인스턴스로도 취급할 수 있어야 한다.
    • 슈퍼클래스가 사용되는 모든 곳에서 서브클래스의 인스턴스를 대신 사용해도 이상없이 동작해야 한다.
  • 위임을 이용하면 기능 일부를 빌려올 뿐인, 서로 별개인 개념임이 명확해진다.
  • 서브클래스 방식 모델링이 합리적일 때라도 슈퍼클래스를 위임으로 바꾸기도 한다.
    • 서로 강하게 결합된 관계라서 슈퍼클래스를 수정하면 서브클래스가 망가지기 쉽기 때문이다.
  • 위임에도 단점이 있다.
    • 위임의 기능을 이용할 호스트의 함수 모두를 전달 함수로 만들어야 한다.
  • 그럼에도 상속이 더는 최선의 방법이 아니게 되면 언제든 이번 리팩토링을 이용해 슈퍼클래스를 위임으로 바꿀 수 있다.
  • 그래서 (웬만하면) 상속을 먼저 적용하고 (만일) 나중에 문제가 생기면 슈퍼클래스를 위임으로 바꾸는 것이 좋다.

절차

  1. 슈퍼클래스 객체를 참조하는 필드를 서브클래스로 만든다.
  2. 슈퍼클래스의 동작 각각에 대응하는 전달 함수를 서브클래스에 만든다.
  3. 슈퍼클래스의 동작 모두가 전달 함수로 오버라이드되었다면 상속 관계를 끊는다.

예시

Before

threshold: 한계점

revered : 존경받는

chrono : 시간, 시대와 관련됨을 나타냄

class CatalogItem {
  constructor(id, title, tags) {
    this._id = id;
    this._title = title;
    this._tags = tags;
  }

  get id()    { return this._id; }
  get title() { return this._title; }
  hasTag(arg) { return this._tags.includes(arg);}
}

// 각 스크롤에는 ID, 제목이 있고 그 외 여러 태그가 붙어 있다.
// 스크롤에는 정기 세척 이력이 필요하기에 CatalogItem을 확장해 세척 관련 데이터 추가
// 사본이 여러 개지만 카탈로그 아이템은 하나일 수 있는 문제 발생
class Scroll extends CatalogItem {
  constructor(id, title, tags, dataLastCleaned) {
    super(id, title, tags);
    this._lastCleaned = dataLastCleaned;
  }

  needsCleaning(targetDate) {
    const threshold = this.hasTag('revered') ? 700 : 1500;

    return this.daysSinceLastCleaning(targetDate) > threshold;
  }

  daysSinceLastCleaning(targetDate) {
    return this._lastCleaned.until(targetDate, ChronoUnit.DAYS);
  }
}

After

  • id, title, hasTag와 같이 서브클래스에서 사용하는 슈퍼클래스의 동작 각각에 대응하는 전달 메서드를 만든다.
  • 카탈로그 아이템 클래스 생성자를 추가하고 상속 관게를 끊는다.
class Scroll {
  constructor(id, title, tags, dataLastCleaned) {
    this._id = id;
    this._catalogItem = new CatalogItem(id, title, tags);
    this._lastCleaned = dataLastCleaned;
  }

  get id()        { return this.id; }
  get title()     { return this._catalogItem.title; }
  hasTag(aString) { return this._catalogItem.tags.hasTag(aString); }

  needsCleaning(targetDate) {
    const threshold = this.hasTag('revered') ? 700 : 1500;

    return this.daysSinceLastCleaning(targetDate) > threshold;
  }

  daysSinceLastCleaning(targetDate) {
    return this._lastCleaned.until(targetDate, ChronoUnit.DAYS);
  }
}

수고하셨습니다 🎉ㅌ

반응형
저작자표시

'Programming > 13. Book' 카테고리의 다른 글

모던 리액트 Deep Dive - 12장  (0) 2024.03.03
리팩터링 - 7장  (1) 2024.03.02
리팩터링 - 11장  (0) 2024.03.02
리팩터링 - 10장  (0) 2024.03.02
리팩터링 - 8, 9장  (0) 2024.03.02

관련글

댓글

티스토리툴바