Java设计模式解析之适配器模式怎么实现

1. 适配器模式简介

适配器模式（Adapter Pattern）是一种结构型设计模式，它允许不兼容的接口之间进行协作。适配器模式通过将一个类的接口转换成客户期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

1.1 适配器模式的应用场景

适配器模式通常在以下场景中使用：

• 系统需要使用现有的类，但这些类的接口不符合系统的需求。
• 需要创建一个可以复用的类，该类可以与不相关或不可预见的类协同工作。
• 需要使用多个现有的子类，但通过子类化每个类来适配它们的接口是不现实的。

1.2 适配器模式的优点

• 复用性：适配器模式可以让原本不兼容的类协同工作，提高了代码的复用性。
• 灵活性：适配器模式可以在不修改现有代码的情况下，增加新的功能。
• 解耦：适配器模式将目标类和适配者类解耦，使得系统更加灵活。

1.3 适配器模式的缺点

• 复杂性：适配器模式增加了系统的复杂性，因为需要引入新的类和接口。
• 性能损耗：适配器模式可能会引入额外的性能损耗，特别是在频繁调用的情况下。

2. 适配器模式的实现方式

适配器模式主要有两种实现方式：类适配器模式和对象适配器模式。

2.1 类适配器模式

类适配器模式通过继承来实现适配器。适配器类继承自目标类，并实现适配者接口。这样，适配器类既可以调用目标类的方法，也可以调用适配者类的方法。

2.1.1 类适配器模式的UML类图

classDiagram
    class Target {
        +request()
    }
    class Adaptee {
        +specificRequest()
    }
    class Adapter {
        +request()
    }
    Target <|-- Adapter
    Adaptee <|-- Adapter

2.1.2 类适配器模式的代码实现

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

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器类
class Adapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.request();
    }
}

2.2 对象适配器模式

对象适配器模式通过组合来实现适配器。适配器类持有适配者类的实例，并实现目标接口。这样，适配器类可以通过调用适配者类的方法来实现目标接口的功能。

2.2.1 对象适配器模式的UML类图

classDiagram
    class Target {
        +request()
    }
    class Adaptee {
        +specificRequest()
    }
    class Adapter {
        -adaptee: Adaptee
        +request()
    }
    Target <|-- Adapter
    Adapter --> Adaptee

2.2.2 对象适配器模式的代码实现

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

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器类
class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}

3. 适配器模式的扩展

3.1 双向适配器

双向适配器是一种特殊的适配器，它既可以作为目标接口的适配器，也可以作为适配者接口的适配器。双向适配器通常用于需要双向转换的场景。

3.1.1 双向适配器的UML类图

classDiagram
    class Target {
        +request()
    }
    class Adaptee {
        +specificRequest()
    }
    class Adapter {
        -target: Target
        -adaptee: Adaptee
        +request()
        +specificRequest()
    }
    Target <|-- Adapter
    Adaptee <|-- Adapter

3.1.2 双向适配器的代码实现

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

// 适配者接口
interface Adaptee {
    void specificRequest();
}

// 适配器类
class Adapter implements Target, Adaptee {
    private Target target;
    private Adaptee adaptee;

    public Adapter(Target target, Adaptee adaptee) {
        this.target = target;
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }

    @Override
    public void specificRequest() {
        target.request();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Target target = new Target() {
            @Override
            public void request() {
                System.out.println("Target's request");
            }
        };

        Adaptee adaptee = new Adaptee() {
            @Override
            public void specificRequest() {
                System.out.println("Adaptee's specific request");
            }
        };

        Adapter adapter = new Adapter(target, adaptee);
        adapter.request();
        adapter.specificRequest();
    }
}

3.2 缺省适配器

缺省适配器是一种特殊的适配器，它为适配者接口提供了一个默认的实现。缺省适配器通常用于需要为接口提供默认实现的场景。

3.2.1 缺省适配器的UML类图

classDiagram
    class Target {
        +request()
    }
    class DefaultAdapter {
        +request()
    }
    class Adaptee {
        +specificRequest()
    }
    Target <|-- DefaultAdapter
    DefaultAdapter <|-- Adapter
    Adaptee <|-- Adapter

3.2.2 缺省适配器的代码实现

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

// 缺省适配器类
class DefaultAdapter implements Target {
    @Override
    public void request() {
        System.out.println("DefaultAdapter's request");
    }
}

// 适配者类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request");
    }
}

// 适配器类
class Adapter extends DefaultAdapter {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}

4. 适配器模式的实际应用

4.1 Java中的适配器模式

在Java中，适配器模式被广泛应用于各种场景。例如，Java的InputStreamReader和OutputStreamWriter就是适配器模式的典型应用。

4.1.1 InputStreamReader和OutputStreamWriter的适配器模式

InputStreamReader和OutputStreamWriter是Java I/O库中的两个类，它们分别将字节流适配为字符流。

// 使用InputStreamReader将字节流适配为字符流
InputStream inputStream = new FileInputStream("file.txt");
Reader reader = new InputStreamReader(inputStream);

// 使用OutputStreamWriter将字符流适配为字节流
OutputStream outputStream = new FileOutputStream("file.txt");
Writer writer = new OutputStreamWriter(outputStream);

4.2 Spring中的适配器模式

在Spring框架中，适配器模式也被广泛应用。例如，Spring MVC中的HandlerAdapter就是适配器模式的典型应用。

4.2.1 HandlerAdapter的适配器模式

HandlerAdapter是Spring MVC中的一个接口，它用于将不同类型的处理器适配为统一的处理接口。

// HandlerAdapter接口
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
    long getLastModified(HttpServletRequest request, Object handler);
}

// 具体的HandlerAdapter实现
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof Controller);
    }

    @Override
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return ((Controller) handler).handleRequest(request, response);
    }

    @Override
    public long getLastModified(HttpServletRequest request, Object handler) {
        if (handler instanceof LastModified) {
            return ((LastModified) handler).getLastModified(request);
        }
        return -1L;
    }
}

5. 总结

适配器模式是一种非常有用的设计模式，它可以帮助我们在不修改现有代码的情况下，将不兼容的接口转换为兼容的接口。适配器模式主要有两种实现方式：类适配器模式和对象适配器模式。此外，适配器模式还可以扩展为双向适配器和缺省适配器，以满足不同的需求。

在实际开发中，适配器模式被广泛应用于各种场景，例如Java I/O库中的InputStreamReader和OutputStreamWriter，以及Spring MVC中的HandlerAdapter。通过理解和掌握适配器模式，我们可以更好地设计和实现灵活、可扩展的系统。