深入学习Java中的结构型模式：适配器

第一部分：适配器模式概述

1.1 什么是适配器模式？

适配器模式是一种结构型设计模式，用于将一个类的接口转换为客户端期望的另一个接口，使原本不兼容的接口能够协同工作。其核心思想类似于现实生活中的电源适配器，将不匹配的插头与插座连接起来。适配器模式在软件开发中主要解决以下问题：

• 接口不兼容：当现有类（Adaptee）的接口与客户端期望的接口（Target）不匹配时，适配器（Adapter）充当中间层进行转换。
• 复用现有代码：在不修改现有代码的情况下，通过适配器使其适配新的接口需求。
• 系统集成：在集成第三方库或遗留系统时，适配器模式能够桥接不同接口。

适配器模式在 Java 中广泛应用于各种场景，例如 I/O 流处理、数据库访问和微服务架构中的 API 转换等。

1.2 适配器模式的组成

适配器模式包含以下核心角色：

1. 目标接口（Target）：客户端期望使用的接口，定义了客户端需要的功能。
2. 被适配者（Adaptee）：需要被适配的现有类，拥有实际的功能但接口不兼容。
3. 适配器（Adapter）：实现目标接口，并通过组合或继承调用被适配者的功能。
4. 客户端（Client）：使用目标接口的代码，调用适配器以间接访问被适配者的功能。

适配器模式有两种主要实现方式：

• 类适配器：通过继承实现，适配器类继承被适配者并实现目标接口。
• 对象适配器：通过组合实现，适配器持有被适配者的实例并实现目标接口。

在 Java 中，对象适配器因其灵活性和低耦合性更为常见。

第二部分：适配器模式的实现方式

2.1 类适配器模式

类适配器通过继承实现目标接口和被适配者，利用多重继承（在 Java 中通过实现接口模拟）完成接口转换。以下是一个简单的类适配器示例：

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

// 被适配者
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee 的特定请求");
    }
}

// 类适配器
class ClassAdapter extends Adaptee implements Target {
    @Override
    public void request() {
        // 调用被适配者的方法
        specificRequest();
    }
}

// 客户端代码
public class ClassAdapterExample {
    public static void main(String[] args) {
        Target adapter = new ClassAdapter();
        adapter.request(); // 输出：Adaptee 的特定请求
    }
}

优点：

• 直接继承被适配者，可以重用其方法。
• 适配器与被适配者的耦合较高，适合简单场景。

缺点：

• Java 不支持多重继承，限制了类适配器的灵活性。
• 继承导致高耦合，难以动态替换被适配者。

2.2 对象适配器模式

对象适配器通过组合实现，适配器持有被适配者的实例并实现目标接口。以下是一个对象适配器的示例：

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

// 被适配者
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee 的特定请求");
    }
}

// 对象适配器
class ObjectAdapter implements Target {
    private Adaptee adaptee;

    public ObjectAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        // 调用被适配者的方法
        adaptee.specificRequest();
    }
}

// 客户端代码
public class ObjectAdapterExample {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new ObjectAdapter(adaptee);
        adapter.request(); // 输出：Adaptee 的特定请求
    }
}

优点：

• 符合组合优于继承的原则，灵活性更高。
• 支持动态替换被适配者。
• 降低适配器与被适配者的耦合。

缺点：

• 需要额外创建适配器对象，略增加代码复杂性。

在 Java 中，对象适配器因其灵活性和低耦合性更常被使用，尤其是在需要适配多个被适配者或动态调整适配逻辑的场景。

2.3 默认适配器模式

默认适配器模式（也称为接口适配器）是一种特殊变体，用于处理接口中方法过多的情况。它通过提供一个抽象类实现目标接口，并为所有方法提供默认实现，客户端只需重写需要的方法。以下是一个示例：

// 目标接口（包含多个方法）
interface AdvancedTarget {
    void method1();
    void method2();
    void method3();
}

// 默认适配器（提供空实现）
abstract class DefaultAdapter implements AdvancedTarget {
    @Override
    public void method1() {
        // 默认空实现
    }

    @Override
    public void method2() {
        // 默认空实现
    }

    @Override
    public void method3() {
        // 默认空实现
    }
}

// 具体适配器
class ConcreteAdapter extends DefaultAdapter {
    @Override
    public void method1() {
        System.out.println("实现了 method1");
    }
}

// 客户端代码
public class DefaultAdapterExample {
    public static void main(String[] args) {
        AdvancedTarget adapter = new ConcreteAdapter();
        adapter.method1(); // 输出：实现了 method1
        adapter.method2(); // 无输出（默认实现）
        adapter.method3(); // 无输出（默认实现）
    }
}

适用场景：

• 当目标接口包含大量方法，而客户端只需实现部分方法时。
• 常用于 Java 的事件监听机制（如 WindowAdapter、MouseAdapter）。

第三部分：适配器模式在 Java 标准库中的应用

适配器模式在 Java 标准库中被广泛应用，以下是几个典型示例：

3.1 I/O 流中的适配器

Java 的 I/O 流体系广泛使用了适配器模式。例如，InputStreamReader 是一个对象适配器，将字节流（InputStream）适配为字符流（Reader）：

import java.io.*;

public class InputStreamReaderExample {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("example.txt");
        Reader reader = new InputStreamReader(inputStream); // 适配器
        int data = reader.read();
        while (data != -1) {
            System.out.print((char) data);
            data = reader.read();
        }
        reader.close();
    }
}

在这里，InputStreamReader 将 InputStream 的字节操作适配为 Reader 的字符操作，客户端可以直接以字符流的方式处理字节数据。

3.2 事件监听中的默认适配器

Java AWT 和 Swing 中的事件监听器广泛使用默认适配器模式。例如，WindowAdapter 为 WindowListener 接口提供默认实现：

import java.awt.event.*;
import javax.swing.*;

public class WindowAdapterExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Window Adapter Example");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

        // 使用默认适配器
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("窗口正在关闭");
                System.exit(0);
            }
        });

        frame.setVisible(true);
    }
}

WindowAdapter 提供了 WindowListener 接口的空实现，客户端只需重写感兴趣的方法（如 windowClosing），提高了代码简洁性。

3.3 集合框架中的适配器

Java 集合框架中的 Arrays.asList 方法可以看作一种适配器，将数组适配为 List 接口：

import java.util.Arrays;
import java.util.List;

public class ArraysAsListExample {
    public static void main(String[] args) {
        String[] array = {"Java", "Python", "C++"};
        List<String> list = Arrays.asList(array); // 适配器
        System.out.println("List: " + list); // 输出：List: [Java, Python, C++]
    }
}

Arrays.asList 将数组适配为 List 接口，使客户端可以通过 List 的方法操作数组。

第四部分：适配器模式的实际业务场景

4.1 电商平台：支付接口适配

在中国的电商行业中，支付系统需要对接多种第三方支付平台（如支付宝、微信支付、银联），但这些平台的接口往往不统一。适配器模式可以用来统一支付接口。以下是一个示例：

// 目标接口：统一支付接口
interface PaymentProcessor {
    void processPayment(double amount);
}

// 被适配者：支付宝支付
class Alipay {
    public void makePayment(double money) {
        System.out.println("通过支付宝支付: " + money + " 元");
    }
}

// 被适配者：微信支付
class WeChatPay {
    public void pay(double amount) {
        System.out.println("通过微信支付: " + amount + " 元");
    }
}

// 适配器：支付宝适配器
class AlipayAdapter implements PaymentProcessor {
    private Alipay alipay;

    public AlipayAdapter(Alipay alipay) {
        this.alipay = alipay;
    }

    @Override
    public void processPayment(double amount) {
        alipay.makePayment(amount);
    }
}

// 适配器：微信支付适配器
class WeChatPayAdapter implements PaymentProcessor {
    private WeChatPay weChatPay;

    public WeChatPayAdapter(WeChatPay weChatPay) {
        this.weChatPay = weChatPay;
    }

    @Override
    public void processPayment(double amount) {
        weChatPay.pay(amount);
    }
}

// 客户端代码
public class PaymentAdapterExample {
    public static void main(String[] args) {
        PaymentProcessor alipayProcessor = new AlipayAdapter(new Alipay());
        PaymentProcessor weChatProcessor = new WeChatPayAdapter(new WeChatPay());

        alipayProcessor.processPayment(100.0); // 输出：通过支付宝支付: 100.0 元
        weChatProcessor.processPayment(200.0); // 输出：通过微信支付: 200.0 元
    }
}

在这个场景中，适配器模式统一了支付宝和微信支付的接口，客户端只需调用 PaymentProcessor 接口即可完成支付操作，降低了系统复杂度。

4.2 微服务架构：API 适配

在微服务架构中，不同服务可能使用不同的数据格式或协议。适配器模式可以用于转换 API 数据格式。例如，假设一个新服务需要调用老服务的 JSON 接口，但客户端期望 XML 格式：

// 目标接口：XML 数据提供者
interface XmlDataProvider {
    String getDataAsXml();
}

// 被适配者：JSON 数据服务
class JsonDataService {
    public String getDataAsJson() {
        return "{\"name\": \"Product\", \"price\": 100}";
    }
}

// 适配器：JSON 转 XML
class JsonToXmlAdapter implements XmlDataProvider {
    private JsonDataService jsonService;

    public JsonToXmlAdapter(JsonDataService jsonService) {
        this.jsonService = jsonService;
    }

    @Override
    public String getDataAsXml() {
        String json = jsonService.getDataAsJson();
        // 简化的 JSON 转 XML 逻辑
        String xml = "<data><name>Product</name><price>100</price></data>";
        return xml;
    }
}

// 客户端代码
public class ApiAdapterExample {
    public static void main(String[] args) {
        XmlDataProvider adapter = new JsonToXmlAdapter(new JsonDataService());
        System.out.println("XML 数据: " + adapter.getDataAsXml());
        // 输出：XML 数据: <data><name>Product</name><price>100</price></data>
    }
}

这个示例展示了如何通过适配器模式将 JSON 数据适配为 XML 格式，适用于微服务间的格式转换。

4.3 遗留系统重构：数据库访问适配

在遗留系统重构中，适配器模式常用于适配旧的数据库访问接口。以下是一个示例：

// 目标接口：新数据库访问接口
interface NewDatabaseAccess {
    String queryData(String query);
}

// 被适配者：旧数据库访问接口
class LegacyDatabase {
    public String executeQuery(String sql) {
        return "查询结果: " + sql;
    }
}

// 适配器
class DatabaseAdapter implements NewDatabaseAccess {
    private LegacyDatabase legacyDatabase;

    public DatabaseAdapter(LegacyDatabase legacyDatabase) {
        this.legacyDatabase = legacyDatabase;
    }

    @Override
    public String queryData(String query) {
        // 将新查询格式转换为旧格式
        String sql = "SELECT * FROM " + query;
        return legacyDatabase.executeQuery(sql);
    }
}

// 客户端代码
public class DatabaseAdapterExample {
    public static void main(String[] args) {
        NewDatabaseAccess adapter = new DatabaseAdapter(new LegacyDatabase());
        String result = adapter.queryData("users");
        System.out.println(result); // 输出：查询结果: SELECT * FROM users
    }
}

适配器模式允许新系统继续使用旧数据库的逻辑，而无需修改原有代码。

第五部分：适配器模式的性能优化与最佳实践

5.1 性能优化策略

虽然适配器模式提高了系统的灵活性，但也可能引入性能开销。以下是一些优化建议：

• 减少对象创建：对象适配器需要创建额外的适配器对象，可通过缓存或单例模式减少开销。
• 简化适配逻辑：避免在适配器中加入复杂的转换逻辑，将复杂操作交给被适配者或其他服务。
• 选择合适的实现方式：根据场景选择类适配器或对象适配器，对象适配器通常更灵活但开销稍大。

5.2 最佳实践

以下是使用适配器模式的最佳实践：

• 明确接口定义：目标接口应清晰定义客户端需求，避免过于复杂的接口。
• 优先使用对象适配器：对象适配器符合组合优于继承的原则，适合大多数场景。
• 保持适配器简单：适配器应专注于接口转换，避免包含过多业务逻辑。
• 测试适配器行为：通过单元测试确保适配器的正确性，尤其是在并行或高并发场景中。
• 文档化适配逻辑：在代码注释或文档中说明适配器的作用和被适配者的接口。

以下是一个结合最佳实践的综合示例：

// 目标接口：统一日志接口
interface Logger {
    void log(String message);
}

// 被适配者：旧日志系统
class OldLogger {
    public void writeLog(String msg) {
        System.out.println("旧日志: " + msg);
    }
}

// 适配器
class LoggerAdapter implements Logger {
    private OldLogger oldLogger;

    public LoggerAdapter(OldLogger oldLogger) {
        this.oldLogger = oldLogger;
    }

    @Override
    public void log(String message) {
        // 简单的适配逻辑
        oldLogger.writeLog(message);
    }
}

// 客户端代码
public class BestPracticeAdapterExample {
    public static void main(String[] args) {
        Logger logger = new LoggerAdapter(new OldLogger());
        logger.log("测试日志"); // 输出：旧日志: 测试日志
    }
}