6种设计模式：深挖责任链、桥接、适配器、单例、命令

2023-05-30 11:55:58

释放设计模式的奥秘：深入解析责任链、桥接、适配器、单例和命令模式

引言

作为软件开发人员，我们经常面临各种各样的设计挑战，而设计模式为我们提供了解决这些挑战的强大工具。 了解关键设计模式将赋能我们构建更健壮、更可维护和更灵活的应用程序。在本文中，我们将深入探讨五种备受推崇的设计模式：责任链、桥接、适配器、单例和命令模式。我们将逐一剖析它们的原理、应用和优势，并通过代码示例和真实的案例来加深理解。

1. 责任链模式

想像一个流水线，其中任务从一个工人流向另一个工人，每个工人都有机会处理任务。 责任链模式本质上就是这样。它创建一系列处理者对象，每个对象负责处理特定类型的请求。请求依次传递给处理者，直到被成功处理或被拒绝。

优点：

提高代码灵活性
降低耦合度

缺点：

性能可能下降，因为每个请求都必须经过所有处理者

代码示例：

class Handler {
    public void handleRequest(Request request) {
        // 处理请求
    }
}

class ConcreteHandler1 extends Handler {
    // 处理特定类型的请求
}

class ConcreteHandler2 extends Handler {
    // 处理另一类型请求
}

class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNextHandler(handler2);

        Request request = new Request();
        handler1.handleRequest(request);
    }
}

2. 桥接模式

桥接模式通过将抽象和实现分开来提供灵活性。 这样，我们可以在不影响另一个的情况下，独立地改变抽象或实现。

优点：

提高代码灵活性
降低耦合度

缺点：

可能增加代码复杂性

代码示例：

interface Abstraction {
    public void operation();
}

class ConcreteAbstraction1 implements Abstraction {
    // 实现具体操作
}

class ConcreteAbstraction2 implements Abstraction {
    // 实现另一具体操作
}

interface Implementation {
    public void operation();
}

class ConcreteImplementation1 implements Implementation {
    // 实现具体实现
}

class ConcreteImplementation2 implements Implementation {
    // 实现另一具体实现
}

class Bridge {
    private Abstraction abstraction;
    private Implementation implementation;

    public Bridge(Abstraction abstraction, Implementation implementation) {
        this.abstraction = abstraction;
        this.implementation = implementation;
    }

    public void operation() {
        abstraction.operation();
        implementation.operation();
    }
}

class Client {
    public static void main(String[] args) {
        Abstraction abstraction = new ConcreteAbstraction1();
        Implementation implementation = new ConcreteImplementation1();
        Bridge bridge = new Bridge(abstraction, implementation);
        bridge.operation();
    }
}

3. 适配器模式

适配器模式将一个类的接口转换为另一个类的接口，从而使原本不兼容的类可以协同工作。

优点：

提高代码灵活性
降低耦合度

缺点：

可能增加代码复杂性

代码示例：

class Adaptee {
    public void specificOperation() {
        // 具体操作
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void operation() {
        adaptee.specificOperation();
    }
}

class Client {
    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        target.operation();
    }
}

4. 单例模式

单例模式确保一个类只有一个实例，并提供全局访问点来访问该实例。

优点：

提高代码性能
降低内存使用

缺点：

可能降低代码灵活性

代码示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造器防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

5. 命令模式

命令模式将请求封装成一个对象，从而可以参数化其他对象的行为、支持撤销操作和支持日志记录。

优点：

提高代码灵活性
降低耦合度

缺点：

可能增加代码复杂性

代码示例：

interface Command {
    public void execute();
}

class ConcreteCommand1 implements Command {
    private Receiver receiver;

    public ConcreteCommand1(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.operation();
    }
}

class ConcreteCommand2 implements Command {
    private Receiver receiver;

    public ConcreteCommand2(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.anotherOperation();
    }
}

class Receiver {
    public void operation() {
        // 具体操作
    }

    public void anotherOperation() {
        // 另一具体操作
    }
}

class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void invoke() {
        command.execute();
    }
}

class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command1 = new ConcreteCommand1(receiver);
        Command command2 = new ConcreteCommand2(receiver);

        Invoker invoker = new Invoker();
        invoker.setCommand(command1);
        invoker.invoke();

        invoker.setCommand(command2);
        invoker.invoke();
    }
}