适配器模式
约 522 字
适配器模式
核心思想
适配器模式负责在一个或多个类之间做接口转换,使得原本不兼容的接口能在一起工作。
典型用例
统一不同的接口
在处理多个具有不同接口的类时,适配器模式可以用来提供一个统一的接口,使得客户端代码可以以统一的方式与这些类交互。
在这个例子中,适配器实现了新的接口,但在内部使用了旧的接口实例,使得客户端代码可以通过新接口与旧的接口交互,而无需关心内部的具体实现。
// 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