Java适配器案例

本文目录导读：

1. 基础案例：电源适配器
2. 实际业务案例：支付系统适配
3. 类适配器（使用继承）
4. 企业级应用：数据转换适配器
5. JDK中的适配器示例
6. 完整的多适配器管理器
7. 适配器模式要点总结

我来为你提供几个Java适配器模式的典型案例,从基础到实际应用。

基础案例：电源适配器

场景

不同国家的电源插座标准不同,需要一个适配器来转换。

// 目标接口（中国标准插座）
interface ChinaSocket {
    void connectChinaPlug();
}
// 适配者类（美国标准插座）
class USASocket {
    public void connectUSAPlug() {
        System.out.println("连接美国标准插头");
    }
}
// 对象适配器
class SocketAdapter implements ChinaSocket {
    private USASocket usaSocket;
    public SocketAdapter(USASocket usaSocket) {
        this.usaSocket = usaSocket;
    }
    @Override
    public void connectChinaPlug() {
        System.out.println("使用转换器转换电压和插头");
        usaSocket.connectUSAPlug();
    }
}
// 使用示例
public class SocketDemo {
    public static void main(String[] args) {
        ChinaSocket chinaSocket = new SocketAdapter(new USASocket());
        chinaSocket.connectChinaPlug();
    }
}

实际业务案例：支付系统适配

场景

整合不同的支付服务提供商（支付宝、微信、PayPal）。

// 目标接口
interface PaymentGateway {
    void processPayment(double amount);
    void refund(double amount);
}
// 支付宝实现
class AlipayGateway {
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount + "元");
    }
    public void refundMoney(double amount) {
        System.out.println("支付宝退款: " + amount + "元");
    }
}
// 微信支付实现
class WeChatPayGateway {
    public void makePayment(double amount) {
        System.out.println("微信支付: " + amount + "元");
    }
    public void processRefund(double amount) {
        System.out.println("微信退款: " + amount + "元");
    }
}
// 支付宝适配器
class AlipayAdapter implements PaymentGateway {
    private AlipayGateway alipayGateway;
    public AlipayAdapter(AlipayGateway alipayGateway) {
        this.alipayGateway = alipayGateway;
    }
    @Override
    public void processPayment(double amount) {
        alipayGateway.pay(amount);
    }
    @Override
    public void refund(double amount) {
        alipayGateway.refundMoney(amount);
    }
}
// 微信适配器
class WeChatPayAdapter implements PaymentGateway {
    private WeChatPayGateway weChatPayGateway;
    public WeChatPayAdapter(WeChatPayGateway weChatPayGateway) {
        this.weChatPayGateway = weChatPayGateway;
    }
    @Override
    public void processPayment(double amount) {
        weChatPayGateway.makePayment(amount);
    }
    @Override
    public void refund(double amount) {
        weChatPayGateway.processRefund(amount);
    }
}
// 使用示例
public class PaymentDemo {
    public static void main(String[] args) {
        PaymentGateway alipay = new AlipayAdapter(new AlipayGateway());
        PaymentGateway weChatPay = new WeChatPayAdapter(new WeChatPayGateway());
        // 统一下单
        alipay.processPayment(99.9);
        weChatPay.processPayment(199.9);
        // 统一退款
        alipay.refund(10.0);
        weChatPay.refund(20.0);
    }
}

类适配器（使用继承）

场景

将一个类接口转换为目标接口。

// 目标接口
interface NewLogger {
    void logInfo(String msg);
    void logError(String msg);
}
// 旧日志类（已有实现）
class OldLogger {
    public void log(String level, String message) {
        System.out.println("[" + level + "] " + message);
    }
}
// 类适配器（使用继承）
class LoggerAdapter extends OldLogger implements NewLogger {
    @Override
    public void logInfo(String msg) {
        log("INFO", msg);
    }
    @Override
    public void logError(String msg) {
        log("ERROR", msg);
    }
}
// 使用示例
public class LoggerDemo {
    public static void main(String[] args) {
        NewLogger logger = new LoggerAdapter();
        logger.logInfo("应用启动");
        logger.logError("发生异常");
    }
}

企业级应用：数据转换适配器

场景

将不同格式的数据转换为统一格式。

import java.util.HashMap;
import java.util.Map;
// 目标接口
interface DataConverter {
    Map<String, Object> convert(Object data);
}
// 适配者1：JSON数据转换
class JsonDataHandler {
    public Map<String, Object> parseJson(String jsonData) {
        // 模拟解析JSON
        Map<String, Object> result = new HashMap<>();
        result.put("source", "JSON");
        result.put("content", jsonData);
        return result;
    }
}
// 适配者2：XML数据转换
class XmlDataHandler {
    public Map<String, Object> parseXml(String xmlData) {
        // 模拟解析XML
        Map<String, Object> result = new HashMap<>();
        result.put("source", "XML");
        result.put("content", xmlData);
        return result;
    }
}
// JSON适配器
class JsonAdapter implements DataConverter {
    private JsonDataHandler jsonHandler;
    public JsonAdapter(JsonDataHandler jsonHandler) {
        this.jsonHandler = jsonHandler;
    }
    @Override
    public Map<String, Object> convert(Object data) {
        return jsonHandler.parseJson((String) data);
    }
}
// XML适配器
class XmlAdapter implements DataConverter {
    private XmlDataHandler xmlHandler;
    public XmlAdapter(XmlDataHandler xmlHandler) {
        this.xmlHandler = xmlHandler;
    }
    @Override
    public Map<String, Object> convert(Object data) {
        return xmlHandler.parseXml((String) data);
    }
}
// 使用示例
public class DataConverterDemo {
    public static void main(String[] args) {
        String jsonData = "{\"name\": \"张三\", \"age\": 25}";
        String xmlData = "<person><name>李四</name><age>30</age></person>";
        DataConverter jsonConverter = new JsonAdapter(new JsonDataHandler());
        DataConverter xmlConverter = new XmlAdapter(new XmlDataHandler());
        Map<String, Object> jsonResult = jsonConverter.convert(jsonData);
        Map<String, Object> xmlResult = xmlConverter.convert(xmlData);
        System.out.println("JSON转换结果: " + jsonResult);
        System.out.println("XML转换结果: " + xmlResult);
    }
}

JDK中的适配器示例

import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
// JDK中的适配器示例
public class JdkAdapterDemo {
    public static void main(String[] args) {
        // 将Enumeration适配为Iterator（适配器模式）
        Vector<String> vector = new Vector<>(Arrays.asList("A", "B", "C"));
        Enumeration<String> enumeration = vector.elements();
        // 使用适配器将Enumeration转换为Iterator
        Iterator<String> iterator = new Iterator<String>() {
            private Enumeration<String> enum = enumeration;
            @Override
            public boolean hasNext() {
                return enum.hasMoreElements();
            }
            @Override
            public String next() {
                return enum.nextElement();
            }
        };
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

完整的多适配器管理器

import java.util.HashMap;
import java.util.Map;
// 多种适配器统一管理
interface UnifiedAPI {
    void initialize();
    void execute(String command);
    void cleanup();
}
// 应用A的API
class AppA {
    public void startA() { System.out.println("AppA启动"); }
    public void runA(String cmd) { System.out.println("AppA执行: " + cmd); }
    public void stopA() { System.out.println("AppA停止"); }
}
// 应用B的API
class AppB {
    public void initB() { System.out.println("AppB初始化"); }
    public void processB(String cmd) { System.out.println("AppB处理: " + cmd); }
    public void shutdownB() { System.out.println("AppB关闭"); }
}
// 适配器A
class AdapterA implements UnifiedAPI {
    private AppA appA;
    public AdapterA(AppA appA) {
        this.appA = appA;
    }
    @Override
    public void initialize() { appA.startA(); }
    @Override
    public void execute(String command) { appA.runA(command); }
    @Override
    public void cleanup() { appA.stopA(); }
}
// 适配器B
class AdapterB implements UnifiedAPI {
    private AppB appB;
    public AdapterB(AppB appB) {
        this.appB = appB;
    }
    @Override
    public void initialize() { appB.initB(); }
    @Override
    public void execute(String command) { appB.processB(command); }
    @Override
    public void cleanup() { appB.shutdownB(); }
}
// 适配器管理器
class AdapterManager {
    private Map<String, UnifiedAPI> adapters = new HashMap<>();
    public void registerAdapter(String name, UnifiedAPI adapter) {
        adapters.put(name, adapter);
    }
    public void execute(String name, String command) {
        UnifiedAPI adapter = adapters.get(name);
        if (adapter != null) {
            adapter.initialize();
            adapter.execute(command);
            adapter.cleanup();
        } else {
            System.out.println("找不到适配器: " + name);
        }
    }
}
// 使用示例
public class AdapterManagerDemo {
    public static void main(String[] args) {
        AdapterManager manager = new AdapterManager();
        // 注册适配器
        manager.registerAdapter("AppA", new AdapterA(new AppA()));
        manager.registerAdapter("AppB", new AdapterB(new AppB()));
        // 统一执行
        manager.execute("AppA", "数据分析");
        System.out.println("---");
        manager.execute("AppB", "报表生成");
    }
}

适配器模式要点总结

优点

1. 解耦：使客户端与适配者解耦，不直接依赖具体实现
2. 复用：可以重复使用现有的类，同时不改变现有代码
3. 灵活：增加了类的透明性和复用性

应用场景

• 系统需要使用现有的类，但接口不符合要求
• 想要创建一个可复用的类，该类的接口与多个独立类兼容
• 需要统一多个不同系统的接口

注意事项

• 避免过度使用，不要在系统设计初期就使用大量适配器
• 考虑是否可以通过重构来避免使用适配器
• 对象适配器比类适配器更灵活（使用组合而非继承）

这些案例涵盖了适配器模式的主要应用场景，从简单的接口转换到复杂的系统整合,根据实际需求可以选择对象适配器或类适配器来实现。