适配器模式

核心思想

适配器模式负责在一个或多个类之间做接口转换，使得原本不兼容的接口能在一起工作。

典型用例

统一不同的接口

在处理多个具有不同接口的类时，适配器模式可以用来提供一个统一的接口，使得客户端代码可以以统一的方式与这些类交互。

在这个例子中，适配器实现了新的接口，但在内部使用了旧的接口实例，使得客户端代码可以通过新接口与旧的接口交互，而无需关心内部的具体实现。

// npm run code src/code/design-pattern/adapter/unify-interfaces.ts

export {};

// 第一个接口和类
interface OldInterface {
    specificRequest(): string;
}

class OldClass implements OldInterface {
    specificRequest(): string {
        return 'Response from OldClass';
    }
}

// 第二个接口和类
interface NewInterface {
    request(): string;
}

class NewClass implements NewInterface {
    request(): string {
        return 'Response from NewClass';
    }
}

// 创建适配器，将旧的接口适配到新的接口
class Adapter implements NewInterface {
    private oldInstance: OldInterface;

    constructor(oldInstance: OldInterface) {
        this.oldInstance = oldInstance;
    }

    request(): string {
        // 调用 OldInterface 的方法，并可能进行一些其他操作
        return this.oldInstance.specificRequest();
    }
}

const oldClassInstance = new OldClass();
const adapter = new Adapter(oldClassInstance);

console.log(adapter.request()); // 将输出 "Response from OldClass"

集成第三方库或旧系统

适配器模式可以用于集成第三方库或旧系统。例如：有一个第三方库或旧系统，它提供了一个特定的接口，但这个接口与当前系统的接口不兼容，可以创建一个适配器来解决这个问题。

// npm run code src/code/design-pattern/adapter/integrating-legacy-interface.ts

export {};

// 当前系统的接口
interface ITarget {
    request(): string;
}

// 第三方库或旧系统的接口
interface IAdaptee {
    specificRequest(): string;
}

// 第三方库或旧系统的实现
class Adaptee implements IAdaptee {
    specificRequest(): string {
        return "Specific response from the Adaptee";
    }
}

// 适配器类
class Adapter implements ITarget {
    private adaptee: IAdaptee;

    constructor(adaptee: IAdaptee) {
        this.adaptee = adaptee;
    }

    request(): string {
        // 适配器将 ITarge 接口的调用转换为 IAdaptee 接口的调用
        const result = this.adaptee.specificRequest();
        return `Adapter: (TRANSLATED) ${result}`;
    }
}

// 使用示例
const adaptee = new Adaptee();
const adapter = new Adapter(adaptee);

console.log(adapter.request()); // 适配器使得原本不兼容的接口能够一起工作

替换系统组件

适配器模式可以用于替换系统组件，例如：需要替换系统的一个组件，但新组件的接口与旧组件的接口不同。适配器模式可以用于使新组件与现有系统兼容。

// npm run code src/code/design-pattern/adapter/replacement-system-component.ts

export {};

// 旧组件的接口
interface IOldComponent {
    oldRequest(): string;
}

// 新组件的接口
interface INewComponent {
    newRequest(): string;
}

// 旧组件的实现（将被替换）
class OldComponent implements IOldComponent {
    oldRequest(): string {
        return "Response from Old Component";
    }
}

// 新组件的实现
class NewComponent implements INewComponent {
    newRequest(): string {
        return "Response from New Component";
    }
}

// 适配器类
class ComponentAdapter implements IOldComponent {
    private newComponent: INewComponent;

    constructor(newComponent: INewComponent) {
        this.newComponent = newComponent;
    }

    oldRequest(): string {
        // 将旧组件的调用转换为新组件的调用
        const result = this.newComponent.newRequest();
        return `Adapter: (ADAPTED) ${result}`;
    }
}

// 使用示例
const newComponent = new NewComponent();
const adapter = new ComponentAdapter(newComponent);

console.log(adapter.oldRequest()); // 通过适配器，新组件与旧接口兼容

向旧代码增加新功能

适配器模式可以在不更改旧代码的基础上，向系统添加新功能。适配器模式可以用来封装新功能，确保它们与旧系统的接口保持一致。

// npm run code src/code/design-pattern/adapter/add-new-functionality-to-old-code.ts

export {};

// 旧系统的接口
interface IOldInterface {
    performTask(): string;
}

// 旧系统的实现
class OldSystem implements IOldInterface {
    performTask(): string {
        return "Performing task in the old way.";
    }
}

// 新功能的类
class NewFeature {
    performNewTask(): string {
        return "Performing task using new feature.";
    }
}

// 适配器类
class NewFeatureAdapter implements IOldInterface {
    private newFeature: NewFeature;

    constructor(newFeature: NewFeature) {
        this.newFeature = newFeature;
    }

    performTask(): string {
        // 使用新功能来执行任务
        return this.newFeature.performNewTask();
    }
}

// 使用示例
const oldSystem = new OldSystem();
console.log(oldSystem.performTask()); // 使用旧系统

const newFeature = new NewFeature();
const adapter = new NewFeatureAdapter(newFeature);
console.log(adapter.performTask()); // 使用适配器来使用新功能

API接口适配

适配器模式可以在不同版本的API之间进行适配。例如：一个老旧系统需要与新版本API对接，适配器模式可以用于兼容新旧接口。

// npm run code src/code/design-pattern/adapter/api-interface-adaptation.ts

export {};

// 旧版本 API 的接口
interface IOldAPI {
    requestOld(): string;
}

// 新版本 API 的接口
interface INewAPI {
    requestNew(): string;
}

// 新版本 API 的实现
class NewAPI implements INewAPI {
    requestNew(): string {
        return "Response from New API";
    }
}

// 适配器类
class APIAdapter implements IOldAPI {
    private newApi: INewAPI;

    constructor(newApi: INewAPI) {
        this.newApi = newApi;
    }

    requestOld(): string {
        // 将旧 API 的调用适配为新 API 的调用
        return `Adapter: ${this.newApi.requestNew()}`;
    }
}

// 使用示例
const newApi = new NewAPI();
const adapter = new APIAdapter(newApi);

console.log(adapter.requestOld()); // 通过适配器使用新 API