TypeScript 추상 클래스: 부분 구현 패턴 마스터하기

추상 클래스는 객체 지향 프로그래밍(OOP)의 기본 개념으로, 다른 클래스를 위한 청사진을 제공합니다. TypeScript에서 추상 클래스는 공통 기능을 정의하면서 파생 클래스에 특정 구현 요구사항을 강제하는 강력한 메커니즘을 제공합니다. 이 글에서는 TypeScript 추상 클래스의 복잡한 측면을 깊이 파고들어, 부분 구현을 위한 실용적인 패턴에 초점을 맞추고, 이러한 패턴이 프로젝트의 코드 재사용성, 유지보수성, 유연성을 어떻게 크게 향상시킬 수 있는지 알아봅니다.

추상 클래스란 무엇인가?

TypeScript의 추상 클래스는 직접 인스턴스화할 수 없는 클래스입니다. 다른 클래스의 기반 클래스 역할을 하며, 파생 클래스가 반드시 구현(또는 재정의)해야 하는 속성과 메서드 집합을 정의합니다. 추상 클래스는 abstract 키워드를 사용하여 선언됩니다.

주요 특징:

직접 인스턴스화할 수 없습니다.
추상 메서드(구현이 없는 메서드)를 포함할 수 있습니다.
구체적인 메서드(구현이 있는 메서드)를 포함할 수 있습니다.
파생 클래스는 모든 추상 메서드를 구현해야 합니다.

추상 클래스를 사용하는 이유?

추상 클래스는 소프트웨어 개발에서 여러 가지 이점을 제공합니다:

코드 재사용성: 관련된 클래스에 대한 공통 기반을 제공하여 코드 중복을 줄입니다.
강제된 구조: 파생 클래스가 특정 인터페이스와 동작을 준수하도록 보장합니다.
다형성: 파생 클래스를 추상 클래스의 인스턴스로 취급할 수 있게 합니다.
추상화: 구현 세부 정보를 숨기고 필수적인 인터페이스만 노출합니다.

기본적인 추상 클래스 예제

TypeScript에서 추상 클래스의 기본 구문을 설명하기 위해 간단한 예제부터 시작하겠습니다:


abstract class Animal {
 abstract makeSound(): string;

 move(): void {
 console.log("Moving...");
 }
}

class Dog extends Animal {
 makeSound(): string {
 return "Woof!";
 }
}

class Cat extends Animal {
 makeSound(): string {
 return "Meow!";
 }
}

//const animal = new Animal(); // 오류: 추상 클래스의 인스턴스를 생성할 수 없습니다.

const dog = new Dog();
console.log(dog.makeSound()); // 출력: Woof!
dog.move(); // 출력: Moving...

const cat = new Cat();
console.log(cat.makeSound()); // 출력: Meow!
cat.move(); // 출력: Moving...

이 예제에서 Animal은 추상 메서드인 makeSound()와 구체적인 메서드인 move()를 가진 추상 클래스입니다. Dog와 Cat 클래스는 Animal을 확장하고 makeSound() 메서드에 대한 구체적인 구현을 제공합니다. `Animal`을 직접 인스턴스화하려고 시도하면 오류가 발생하는 점에 유의하세요.

부분 구현 패턴

추상 클래스의 강력한 측면 중 하나는 부분 구현을 정의하는 기능입니다. 이를 통해 일부 메서드에 대한 기본 구현을 제공하면서 파생 클래스가 다른 메서드를 구현하도록 요구할 수 있습니다. 이는 코드 재사용성과 유연성 사이의 균형을 맞춥니다.

1. 파생 클래스에서 구현이 필요한 추상 메서드

이 패턴에서 추상 클래스는 파생 클래스에서 *반드시* 구현해야 하는 추상 메서드를 선언하지만, 기본 구현은 제공하지 않습니다. 이는 파생 클래스가 자체 로직을 제공하도록 강제합니다.


abstract class DataProcessor {
 abstract fetchData(): Promise;
 abstract processData(data: any): any;
 abstract saveData(processedData: any): Promise;

 async run(): Promise {
 const data = await this.fetchData();
 const processedData = this.processData(data);
 await this.saveData(processedData);
 }
}

class APIProcessor extends DataProcessor {
 async fetchData(): Promise {
 // API에서 데이터를 가져오는 구현
 console.log("Fetching data from API...");
 return { data: "API Data" }; // 모의 데이터
 }

 processData(data: any): any {
 // API 데이터에 특화된 데이터 처리 구현
 console.log("Processing API data...");
 return { processed: data.data + " - Processed" }; // 모의 처리된 데이터
 }

 async saveData(processedData: any): Promise {
 // 처리된 데이터를 API를 통해 데이터베이스에 저장하는 구현
 console.log("Saving processed API data...");
 console.log(processedData);
 }
}

const apiProcessor = new APIProcessor();
apiProcessor.run();

이 예제에서 DataProcessor 추상 클래스는 fetchData(), processData(), saveData()라는 세 가지 추상 메서드를 정의합니다. APIProcessor 클래스는 DataProcessor를 확장하고 각 메서드에 대한 구체적인 구현을 제공합니다. 추상 클래스에 정의된 run() 메서드는 전체 프로세스를 조율하여 각 단계가 올바른 순서로 실행되도록 보장합니다.

2. 추상 의존성을 가진 구체적인 메서드

이 패턴은 추상 클래스 내의 구체적인 메서드가 특정 작업을 수행하기 위해 추상 메서드에 의존하는 것을 포함합니다. 이를 통해 공통 알고리즘을 정의하면서 구현 세부 정보를 파생 클래스에 위임할 수 있습니다.


abstract class PaymentProcessor {
 abstract validatePaymentDetails(paymentDetails: any): boolean;
 abstract chargePayment(paymentDetails: any): Promise;
 abstract sendConfirmationEmail(paymentDetails: any): Promise;

 async processPayment(paymentDetails: any): Promise {
 if (!this.validatePaymentDetails(paymentDetails)) {
 console.error("Invalid payment details.");
 return false;
 }

 const chargeSuccessful = await this.chargePayment(paymentDetails);
 if (!chargeSuccessful) {
 console.error("Payment failed.");
 return false;
 }

 await this.sendConfirmationEmail(paymentDetails);
 console.log("Payment processed successfully.");
 return true;
 }
}

class CreditCardPaymentProcessor extends PaymentProcessor {
 validatePaymentDetails(paymentDetails: any): boolean {
 // 신용카드 세부 정보 유효성 검사
 console.log("Validating credit card details...");
 return true; // 모의 유효성 검사
 }

 async chargePayment(paymentDetails: any): Promise {
 // 신용카드 결제
 console.log("Charging credit card...");
 return true; // 모의 결제
 }

 async sendConfirmationEmail(paymentDetails: any): Promise {
 // 신용카드 결제 확인 이메일 발송
 console.log("Sending confirmation email for credit card payment...");
 }
}

const creditCardProcessor = new CreditCardPaymentProcessor();
creditCardProcessor.processPayment({ cardNumber: "1234-5678-9012-3456", expiryDate: "12/24", cvv: "123", amount: 100 });

이 예제에서 PaymentProcessor 추상 클래스는 전체 결제 처리 로직을 담당하는 processPayment() 메서드를 정의합니다. 그러나 validatePaymentDetails(), chargePayment(), sendConfirmationEmail() 메서드는 추상적이므로 파생 클래스가 각 결제 방법(예: 신용카드, 페이팔 등)에 대한 특정 구현을 제공해야 합니다.

3. 템플릿 메서드 패턴

템플릿 메서드 패턴은 추상 클래스에서 알고리즘의 골격을 정의하되, 하위 클래스가 알고리즘의 구조를 변경하지 않고 특정 단계를 재정의할 수 있도록 하는 행동 디자인 패턴입니다. 이 패턴은 특정 순서로 수행되어야 하는 일련의 작업이 있지만 일부 작업의 구현이 컨텍스트에 따라 달라질 수 있을 때 특히 유용합니다.


abstract class ReportGenerator {
 abstract generateHeader(): string;
 abstract generateBody(): string;
 abstract generateFooter(): string;

 generateReport(): string {
 const header = this.generateHeader();
 const body = this.generateBody();
 const footer = this.generateFooter();

 return `${header}\n${body}\n${footer}`;
 }
}

class PDFReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "PDF Report Header";
 }

 generateBody(): string {
 return "PDF Report Body";
 }

 generateFooter(): string {
 return "PDF Report Footer";
 }
}

class CSVReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "CSV Report Header";
 }

 generateBody(): string {
 return "CSV Report Body";
 }

 generateFooter(): string {
 return "CSV Report Footer";
 }
}

const pdfReportGenerator = new PDFReportGenerator();
console.log(pdfReportGenerator.generateReport());

const csvReportGenerator = new CSVReportGenerator();
console.log(csvReportGenerator.generateReport());

여기서 `ReportGenerator`는 `generateReport()`에서 전체 보고서 생성 프로세스를 정의하는 반면, 개별 단계(헤더, 본문, 푸터)는 구체적인 하위 클래스인 `PDFReportGenerator`와 `CSVReportGenerator`에 맡겨집니다.

4. 추상 속성

추상 클래스는 추상 속성도 정의할 수 있습니다. 이는 파생 클래스에서 구현해야 하는 속성입니다. 이는 파생 클래스에 특정 데이터 요소의 존재를 강제하는 데 유용합니다.


abstract class Configuration {
 abstract apiKey: string;
 abstract apiUrl: string;

 getFullApiUrl(): string {
 return `${this.apiUrl}/${this.apiKey}`;
 }
}

class ProductionConfiguration extends Configuration {
 apiKey: string = "prod_api_key";
 apiUrl: string = "https://api.example.com/prod";
}

class DevelopmentConfiguration extends Configuration {
 apiKey: string = "dev_api_key";
 apiUrl: string = "http://localhost:3000/dev";
}

const prodConfig = new ProductionConfiguration();
console.log(prodConfig.getFullApiUrl()); // 출력: https://api.example.com/prod/prod_api_key

const devConfig = new DevelopmentConfiguration();
console.log(devConfig.getFullApiUrl()); // 출력: http://localhost:3000/dev/dev_api_key

이 예제에서 Configuration 추상 클래스는 apiKey와 apiUrl이라는 두 개의 추상 속성을 정의합니다. ProductionConfiguration과 DevelopmentConfiguration 클래스는 Configuration을 확장하고 이러한 속성에 대한 구체적인 값을 제공합니다.

고급 고려사항

추상 클래스와 믹스인(Mixin)

TypeScript에서는 추상 클래스와 믹스인을 결합하여 더 복잡하고 재사용 가능한 컴포넌트를 만들 수 있습니다. 믹스인은 작고 재사용 가능한 기능 조각들을 조합하여 클래스를 구축하는 방법입니다.


// 클래스의 생성자에 대한 타입 정의
type Constructor = new (...args: any[]) => T;

// 믹스인 함수 정의
function Timestamped(Base: TBase) {
 return class extends Base {
 timestamp = new Date();
 };
}

// 또 다른 믹스인 함수
function Logged(Base: TBase) {
 return class extends Base {
 log(message: string) {
 console.log(`${this.constructor.name}: ${message}`);
 }
 };
}

abstract class BaseEntity {
 abstract id: number;
}

// BaseEntity 추상 클래스에 믹스인 적용
const TimestampedEntity = Timestamped(BaseEntity);
const LoggedEntity = Logged(TimestampedEntity);

class User extends LoggedEntity {
 id: number = 123;
 name: string = "John Doe";

 constructor() {
 super();
 this.log("User created");
 }
}

const user = new User();
console.log(user.id); // 출력: 123
console.log(user.timestamp); // 출력: 현재 타임스탬프
user.log("User updated"); // 출력: User: User updated

이 예제는 Timestamped와 Logged 믹스인을 BaseEntity 추상 클래스와 결합하여 세 가지 모두의 기능을 상속받는 User 클래스를 생성합니다.

의존성 주입 (Dependency Injection)

추상 클래스는 의존성 주입(DI)과 함께 효과적으로 사용하여 컴포넌트를 분리하고 테스트 용이성을 향상시킬 수 있습니다. 의존성에 대한 인터페이스로 추상 클래스를 정의한 다음, 구체적인 구현을 클래스에 주입할 수 있습니다.


abstract class Logger {
 abstract log(message: string): void;
}

class ConsoleLogger extends Logger {
 log(message: string): void {
 console.log(`[Console]: ${message}`);
 }
}

class FileLogger extends Logger {
 log(message: string): void {
 // 파일에 로그를 기록하는 구현
 console.log(`[File]: ${message}`);
 }
}

class AppService {
 private logger: Logger;

 constructor(logger: Logger) {
 this.logger = logger;
 }

 doSomething() {
 this.logger.log("Doing something...");
 }
}

// ConsoleLogger 주입
const consoleLogger = new ConsoleLogger();
const appService1 = new AppService(consoleLogger);
appService1.doSomething();

// FileLogger 주입
const fileLogger = new FileLogger();
const appService2 = new AppService(fileLogger);
appService2.doSomething();

이 예제에서 AppService 클래스는 Logger 추상 클래스에 의존합니다. 구체적인 구현(ConsoleLogger, FileLogger)은 런타임에 주입되므로 다양한 로깅 전략 간에 쉽게 전환할 수 있습니다.

모범 사례

추상 클래스는 한 가지에 집중하세요: 각 추상 클래스는 명확하고 잘 정의된 목적을 가져야 합니다.
과도한 추상화를 피하세요: 코드 재사용성이나 강제된 구조 측면에서 상당한 가치를 제공하지 않는 한 추상 클래스를 만들지 마세요.
핵심 기능에 추상 클래스를 사용하세요: 공통 로직과 알고리즘은 추상 클래스에 배치하고, 특정 구현은 파생 클래스에 위임하세요.
추상 클래스를 철저히 문서화하세요: 추상 클래스의 목적과 파생 클래스의 책임을 명확하게 문서화하세요.
인터페이스 사용을 고려하세요: 구현 없이 계약만 정의해야 하는 경우, 추상 클래스 대신 인터페이스 사용을 고려하세요.

결론

TypeScript 추상 클래스는 견고하고 유지보수 가능한 애플리케이션을 구축하기 위한 강력한 도구입니다. 부분 구현 패턴을 이해하고 적용함으로써, 추상 클래스의 이점을 활용하여 유연하고 재사용 가능하며 잘 구조화된 코드를 만들 수 있습니다. 기본 구현이 없는 추상 메서드를 정의하는 것부터 믹스인 및 의존성 주입과 함께 추상 클래스를 사용하는 것까지, 가능성은 무궁무진합니다. 모범 사례를 따르고 설계 선택을 신중하게 고려함으로써, TypeScript 프로젝트의 품질과 확장성을 향상시키기 위해 추상 클래스를 효과적으로 사용할 수 있습니다.

대규모 엔터프라이즈 애플리케이션을 구축하든 소규모 유틸리티 라이브러리를 구축하든, TypeScript에서 추상 클래스를 마스터하는 것은 의심할 여지 없이 소프트웨어 개발 기술을 향상시키고 더 정교하고 유지보수 가능한 솔루션을 만드는 데 도움이 될 것입니다.