Java 适配器模式 详解

适配器模式详解

一、适配器模式概述

适配器模式(Adapter Pattern)是一种结构型设计模式，它允许不兼容的接口之间能够协同工作。适配器充当两个不兼容接口之间的桥梁。

核心特点

• 接口转换：将一个类的接口转换成客户期望的另一个接口
• 解耦：使原本因接口不匹配而无法一起工作的类可以协同工作
• 复用：可以复用现有的类，而不需要修改其源代码

二、适配器模式的类型

1. 类适配器（通过继承实现）

// 目标接口
public interface Target {
    void request();
}

// 需要适配的类
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊请求");
    }
}

// 适配器（通过继承）
public class ClassAdapter extends Adaptee implements Target {
    public void request() {
        specificRequest(); // 调用父类方法
    }
}

2. 对象适配器（通过组合实现）

// 目标接口（同上）
public interface Target {
    void request();
}

// 需要适配的类（同上）
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊请求");
    }
}

// 适配器（通过组合）
public class ObjectAdapter implements Target {
    private Adaptee adaptee;
    
    public ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    
    public void request() {
        adaptee.specificRequest();
    }
}

三、适配器模式的应用场景

1. 旧系统整合

// 旧系统接口
public interface LegacyUserService {
    User getLegacyUser(int id);
}

// 新系统接口
public interface ModernUserService {
    UserDTO getUser(String userId);
}

// 适配器实现
public class UserServiceAdapter implements ModernUserService {
    private LegacyUserService legacyService;
    
    public UserServiceAdapter(LegacyUserService service) {
        this.legacyService = service;
    }
    
    public UserDTO getUser(String userId) {
        // 转换逻辑
        User legacyUser = legacyService.getLegacyUser(Integer.parseInt(userId));
        return convertToDTO(legacyUser);
    }
    
    private UserDTO convertToDTO(User user) {
        // 转换实现
    }
}

2. 第三方库适配

// 我们的应用接口
public interface Logger {
    void log(String message, Level level);
}

// 第三方日志库
public class ThirdPartyLogger {
    public void log(String message, int severity) {
        // 第三方实现
    }
}

// 适配器
public class LoggerAdapter implements Logger {
    private ThirdPartyLogger thirdPartyLogger;
    
    public LoggerAdapter(ThirdPartyLogger logger) {
        this.thirdPartyLogger = logger;
    }
    
    public void log(String message, Level level) {
        int severity = convertLevelToSeverity(level);
        thirdPartyLogger.log(message, severity);
    }
    
    private int convertLevelToSeverity(Level level) {
        // 转换逻辑
    }
}

3. 设备驱动适配

// 标准设备接口
public interface Device {
    void connect();
    void sendData(byte[] data);
}

// 特定厂商实现
public class VendorDevice {
    public void vendorConnect() { /*...*/ }
    public void transmit(byte[] data) { /*...*/ }
}

// 适配器
public class DeviceAdapter implements Device {
    private VendorDevice vendorDevice;
    
    public DeviceAdapter(VendorDevice device) {
        this.vendorDevice = device;
    }
    
    public void connect() {
        vendorDevice.vendorConnect();
    }
    
    public void sendData(byte[] data) {
        vendorDevice.transmit(data);
    }
}

四、适配器模式的变体

1. 双向适配器

public class BidirectionalAdapter implements Target, AdapteeInterface {
    private Target target;
    private AdapteeInterface adaptee;
    
    public BidirectionalAdapter(Target target, AdapteeInterface adaptee) {
        this.target = target;
        this.adaptee = adaptee;
    }
    
    // 实现Target接口方法
    public void request() {
        adaptee.specificRequest();
    }
    
    // 实现AdapteeInterface接口方法
    public void specificRequest() {
        target.request();
    }
}

2. 默认适配器（缺省适配器）

// 大型接口
public interface Service {
    void operation1();
    void operation2();
    void operation3();
}

// 缺省适配器
public abstract class ServiceAdapter implements Service {
    public void operation1() {}
    public void operation2() {}
    public void operation3() {}
}

// 具体实现只需覆盖需要的方法
public class ConcreteService extends ServiceAdapter {
    public void operation1() {
        // 具体实现
    }
}

五、适配器模式的优缺点

优点

1. 兼容性：使不兼容的接口能够一起工作
2. 复用性：可以复用现有的类
3. 灵活性：可以适配多个不同的类
4. 开闭原则：无需修改现有代码即可引入适配器

缺点

1. 复杂性：增加系统中类的数量
2. 过度使用：可能导致系统结构复杂化
3. 性能开销：额外的间接调用可能带来性能损耗

六、最佳实践

1. 接口设计先行：尽量设计通用的接口
2. 适度使用：不要过度使用适配器模式
3. 文档化：明确记录适配器的用途和转换逻辑
4. 考虑替代方案：评估是否可以通过修改接口来避免使用适配器
5. 测试：特别注意适配器的边界条件测试

七、总结

适配器模式是解决接口不兼容问题的有效方案，特别适用于：

• 集成遗留系统
• 使用第三方库
• 系统升级过渡期
• 设备驱动开发

在实际开发中，适配器模式常见于：

• 企业系统集成
• 框架扩展开发
• 跨平台开发
• 微服务接口适配

正确使用适配器模式可以提高代码的复用性和系统的灵活性，但需要注意不要滥用，以免增加系统复杂性。