【设计模式】

最新推荐文章于 2024-05-02 17:01:34 发布

海峰丶丶丶

最新推荐文章于 2024-05-02 17:01:34 发布

阅读量77

点赞数

文章标签：设计模式 javascript java

本文链接：https://blog.csdn.net/a1131368173/article/details/131471493

版权

设计模式是什么

设计模式是在软件设计过程中经常出现的问题的通用解决方案。它们对于提高代码的可重用性、可维护性和灵活性非常有价值。设计模式可以说是从实践中总结出来的一系列经验，是在特定情况下证明有效的解决方案。
设计模式能够帮助开发人员遵循面向对象设计原则，并在应用程序中解决常见的设计问题。每个设计模式都有其特定的名称、目标、问题场景和解决方案。它们提供了一种共享的语言和方式，使开发人员能够更好地理解和沟通设计思想。
常见的设计模式包括但不限于：

创建型模式：如工厂模式、抽象工厂模式、建造者模式、单例模式等。
结构型模式：如适配器模式、装饰器模式、代理模式、组合模式等。
行为型模式：如观察者模式、策略模式、命令模式、迭代器模式等。

使用设计模式可以提供一致的设计方案，使得代码更易于理解、扩展和维护。然而，不应盲目地使用设计模式，而是根据具体情况选择合适的模式，遵循设计原则，并结合团队和项目需求进行灵活的设计。

设计模式有什么用

设计模式是在软件开发中用于解决常见问题的一种经过验证的解决方案。它们提供了一种结构化的方法来设计和组织代码，以实现可重用性、可扩展性和易维护性。
以下是设计模式的几个主要用途：

提高代码质量：设计模式可以帮助开发人员编写更具可读性、可扩展性和可维护性的代码。
促进团队合作：设计模式提供了一个公认的词汇和架构，使得团队成员之间更容易理解和交流。
加快开发速度：使用设计模式可以更快地开发软件，因为它们提供了一套经过验证的解决方案，而不需要从头开始设计和实现。
提高系统的灵活性和可扩展性：设计模式使系统更易于扩展和修改，从而适应未来需求的变化。
降低系统的复杂性：设计模式通过将代码分解为独立部分，每个部分都解决一个特定的问题，从而降低系统的复杂性。

对于Java而言，设计模式同样具有很多重要用处：

提供可重用的解决方案：Java是一种面向对象的编程语言，设计模式提供了一组被广泛接受和验证的解决方案。通过应用设计模式，可以避免重复劳动并帮助开发人员构建具有高度可重用性的代码。
促进代码组织和结构化：设计模式为Java开发人员提供了一套共享的语言和思维模型，使得团队成员之间更容易理解和协作。它们定义了一种通用的架构模式，使得代码更易于维护、扩展和修改。
优化性能和可扩展性：设计模式可以帮助Java开发人员编写更高效和可扩展的代码。例如，使用享元模式可以减少内存消耗，使用观察者模式可以实现松散耦合的组件间通信，从而提高系统的性能和可伸缩性。
降低系统复杂度：Java项目往往拥有庞大的代码库和复杂的业务逻辑。设计模式通过将代码分解为独立的部分，每个部分负责解决一个特定的问题，从而降低系统的复杂性。这使得代码更易于理解、测试和维护。
改善代码质量：设计模式鼓励使用面向对象的原则和最佳实践，如单一责任原则（SRP）、开闭原则（OCP）和依赖倒置原则（DIP）。遵循这些原则可以提高代码的可读性、可维护性和可测试性，并最终改善代码质量。

对于JavaScript（JS）而言，设计模式同样可以发挥重要作用：

提供可重用的解决方案：JS是一种灵活的脚本语言，设计模式提供了在JS中解决常见问题的通用解决方案。通过应用设计模式，可以避免重复编写代码，并帮助开发人员构建可重用的、高质量的JS代码。
促进代码组织和结构化：设计模式为JS开发人员提供了一套标准的架构模式，使得代码更易于理解、维护和协作。例如，使用模块模式可以将代码组织成独立的模块，使用观察者模式可以实现松散耦合的组件间通信，从而提高代码的可读性和可扩展性。
支持异步编程：JS在处理异步操作时很常见，设计模式如Promise、回调函数、观察者模式等都可以用来优化异步编程。它们能够有效地管理异步任务的顺序、并发和错误处理，提供更好的用户体验和代码可维护性。
优化性能和响应性：设计模式可以提供一些优化性能和提高响应性的技巧。例如，使用享元模式可以减少内存消耗，使用节流（Throttling）和防抖（Debouncing）模式可以控制事件触发频率，提升交互体验。
降低代码的复杂度：设计模式通过将代码分解为独立的部分，每个部分负责解决一个特定的问题，从而降低代码的复杂性。这有助于提高代码的可读性、可维护性和可测试性，减少潜在的错误和冗余代码。

设计模式有哪些

根据设计模式的参考书 Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素）中所提到的，总共有 23 种设计模式。这些模式可以分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns）。当然，我们还会讨论另一类设计模式：J2EE 设计模式。

创建型模式
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

结构型模式

这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

行为型模式
这些设计模式特别关注对象之间的通信。

责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

J2EE 模式
这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。

MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）

工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种通过调用工厂方法来创建对象的机制，从而隐藏了具体类的实例化逻辑。该模式将对象的实例化过程封装在一个单独的工厂类中，而不是直接在客户端代码中使用 new 操作符来创建对象。
使用工厂模式的好处有：

将对象的创建和使用分离，降低了客户端代码与具体产品类的耦合度。
扩展性高，如果要新增一种产品，只需要添加对应的具体产品类和具体工厂类即可，而无需修改已有的代码。
可以隐藏创建产品的细节，对客户端屏蔽了具体实现，提供了更简洁的接口。

以下是一个Java示例，展示了如何使用工厂模式来创建不同类型的汽车对象：
首先，我们定义抽象产品接口 Car，其中包含一个方法 drive 用于驾驶汽车:

public interface Car {
    void drive();
}

然后，我们创建两个具体产品类 SedanCar（轿车）和 SUVCar（SUV车），它们实现了 Car 接口并实现了 drive 方法：

public class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a Sedan car...");
    }
}

public class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car...");
    }
}

接下来，我们定义抽象工厂接口 CarFactory，其中包含一个工厂方法 createCar 用于创建汽车对象：

public interface CarFactory {
    Car createCar();
}

然后，我们创建两个具体工厂类 SedanCarFactory 和 SUVCarFactory，它们分别实现了 CarFactory 接口，并分别负责创建轿车和SUV：

public class SedanCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

public class SUVCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUVCar();
    }
}

最后，我们可以在客户端使用工厂模式来创建汽车对象，而无需直接实例化具体产品类：

public class Client {
    public static void main(String[] args) {
        // 创建轿车工厂
        CarFactory sedanCarFactory = new SedanCarFactory();
        // 使用轿车工厂创建轿车对象
        Car sedanCar = sedanCarFactory.createCar();
        // 驾驶轿车
        sedanCar.drive();

        // 创建SUV工厂
        CarFactory suvCarFactory = new SUVCarFactory();
        // 使用SUV工厂创建SUV对象
        Car suvCar = suvCarFactory.createCar();
        // 驾驶SUV
        suvCar.drive();
    }
}

输出结果将分别是：

Driving a Sedan car...
Driving an SUV car...

通过使用工厂模式，我们可以根据需要创建不同类型的汽车对象，而无需直接与具体产品类进行耦合，从而提供了更灵活和可扩展的设计。

以下是使用 JavaScript 实现相同示例的代码：
首先，我们定义一个抽象类 Car，其中包含一个方法 drive() 用于驾驶汽车：

class Car {
  drive() {
    console.log("Driving a car...");
  }
}

然后，我们创建两个具体类 SedanCar（轿车）和 SUVCar（SUV车），它们继承自 Car 类并实现了 drive() 方法：

class SedanCar extends Car {
  drive() {
    console.log("Driving a Sedan car...");
  }
}

class SUVCar extends Car {
  drive() {
    console.log("Driving an SUV car...");
  }
}

接下来，我们定义一个工厂类 CarFactory，它包含一个静态方法 createCar(type) 用于创建汽车对象：

class CarFactory {
  static createCar(type) {
    switch (type) {
      case "sedan":
        return new SedanCar();
      case "suv":
        return new SUVCar();
      default:
        throw new Error("Invalid car type.");
    }
  }
}

最后，我们可以在客户端使用工厂模式来创建汽车对象，而无需直接实例化具体类：

// 使用 SedanCar 工厂创建轿车对象
const sedanCar = CarFactory.createCar("sedan");
// 驾驶轿车
sedanCar.drive();

// 使用 SUVCar 工厂创建 SUV 对象
const suvCar = CarFactory.createCar("suv");
// 驾驶 SUV
suvCar.drive();

执行上述代码的输出结果将分别是：

Driving a Sedan car...
Driving an SUV car...

通过使用工厂模式，我们可以根据需要创建不同类型的汽车对象，而无需直接与具体类进行耦合，这提供了更灵活和可扩展的设计。

观察者模式

观察者模式是一种软件设计模式，用于在对象之间建立一对多的依赖关系。该模式包含两个主要角色：观察者和被观察者（也称为主题或发布者）。当被观察者的状态发生变化时，所有观察者都会收到相应的通知，并进行相应的更新操作。观察者模式的核心思想是解耦对象之间的关联关系，使它们之间的关系松散、可扩展和可维护。被观察者维护一个观察者列表，而观察者注册到被观察者上，以便在状态改变时接收通知。这样，被观察者和观察者可以独立演化，互不影响。

在Java中，观察者模式有广泛的应用。以下是一些Java中观察者模式的常见用途：

MVC架构：观察者模式是实现模型-视图-控制器（Model-View-Controller，MVC）架构中的一个重要方法之一。模型表示数据和业务逻辑，视图负责显示和用户交互，控制器协调模型和视图之间的交互。通过观察者模式，模型和视图可以解耦，当模型变化时，视图可以及时更新。
Java消息服务（Java Message Service，JMS）：JMS是一种用于发送和接收异步消息的Java API。观察者模式可以应用于JMS中，观察者可以订阅特定的消息主题，并在消息到达时接收通知。
跨组件通信：在大型应用程序中，不同的组件可能需要交换信息。观察者模式可以用于跨组件通信，其中发布者可以将事件通知发送给多个订阅者，订阅者可以根据需要对事件进行处理。

在JavaScript中，观察者模式同样具有广泛的应用。以下是一些JavaScript中观察者模式的常见用途：

事件处理：JavaScript中的DOM事件机制就是观察者模式的一种实现。可以通过给元素绑定事件处理程序（观察者），在事件发生时接收相应的通知并执行对应的操作。
异步编程：当异步任务完成时，可以使用观察者模式通知相关的观察者进行处理。例如，在AJAX请求完成后，观察者可以接收到响应的数据并更新页面。
发布-订阅模式：发布-订阅模式是观察者模式的一种变体，也称为消息队列或事件总线。在JavaScript中，可以使用自定义事件或第三方库（如EventEmitter）实现发布-订阅模式，将消息发送者（发布者）与消费者（订阅者）解耦，订阅者可以根据需要订阅感兴趣的事件，并在事件发生时接收通知。
状态管理：在前端开发中，状态管理是一个重要的主题。使用观察者模式可以实现状态的监听和更新，当状态发生变化时，相关的观察者可以接收到通知并进行相应的界面更新。

PS:
Promise（承诺）是一种用于处理异步操作的编程模式，它解决了传统的回调函数方式在处理多个异步操作时出现的回调地狱问题，并提供了一种更优雅、可读性更高的方式来管理和处理异步代码。
Promise表示一个尚未完成但最终会完成或失败的操作，并返回一个代表该操作的异步结果的对象。它有三种状态：

Pending（进行中）：初始状态，表示操作正在进行中。
Fulfilled（已完成）：表示操作成功完成并返回了一个值。
Rejected（已失败）：表示操作因某些原因失败，返回一个错误（异常）对象。

Promise对象具有以下特点和方法：

链式调用：可以使用then方法对Promise对象进行链式调用，处理操作成功或失败的情况。
错误处理：可以使用catch方法或在then方法中通过第二个参数来处理操作失败的情况。
并行执行：可以使用Promise.all方法将多个Promise对象组合起来，并行执行它们。
串行执行：可以使用async/await结合Promise来实现清晰的异步代码写法。

使用Promise可以使异步代码更加易读、简洁和可维护。它提供了一种统一的方式来处理异步操作，避免了回调地狱，并使错误处理更加方便和可控。

以下是使用 JavaScript使用观察者模式实现Promise的例子

class MyPromise {
  constructor() {
    this.state = 'pending'; // Promise 状态，初始为 'pending'
    this.value = null; // Promise 结果值或失败原因
    this.callbacks = []; // 保存回调函数的数组
  }

  resolve(value) {
    if (this.state === 'pending') {
      this.state = 'fulfilled'; // 将状态设置为 'fulfilled'
      this.value = value; // 设置 Promise 结果值
      this.callbacks.forEach(callback => {
        callback.onFulfilled(value); // 触发所有注册的成功回调函数
      });
    }
  }

  reject(reason) {
    if (this.state === 'pending') {
      this.state = 'rejected'; // 将状态设置为 'rejected'
      this.value = reason; // 设置 Promise 失败原因
      this.callbacks.forEach(callback => {
        callback.onRejected(reason); // 触发所有注册的失败回调函数
      });
    }
  }

  then(onFulfilled, onRejected) {
    const callback = {};

    if (typeof onFulfilled === 'function') {
      callback.onFulfilled = onFulfilled; // 注册成功回调函数
    }

    if (typeof onRejected === 'function') {
      callback.onRejected = onRejected; // 注册失败回调函数
    }

    this.callbacks.push(callback); // 将回调函数保存起来

    if (this.state === 'fulfilled') {
      callback.onFulfilled(this.value); // 如果 Promise 已经是成功状态，立即执行成功回调函数
    }

    if (this.state === 'rejected') {
      callback.onRejected(this.value); // 如果 Promise 已经是失败状态，立即执行失败回调函数
    }

    return this; // 返回当前 Promise 实例，支持链式调用
  }
}

// 使用示例：
const myPromise = new MyPromise();
myPromise.then(value => {
  console.log('Fulfilled:', value);
}, reason => {
  console.log('Rejected:', reason);
});

setTimeout(() => {
  myPromise.resolve('Hello, Promise!'); // 触发成功回调函数
}, 1000);

上述代码中，我们创建了一个名为 MyPromise 的类，它具有三个主要属性：state（表示 Promise 状态，初始为 ‘pending’）、value（表示 Promise 结果值或失败原因）和 callbacks（保存回调函数的数组）。
该类包含三个方法：resolve、reject 和 then。resolve 方法将 Promise 状态设置为 fulfilled 并触发所有注册的成功回调函数，reject 方法将 Promise 状态设置为 rejected 并触发所有注册的失败回调函数，then 方法用于注册成功和失败回调函数，并在合适的时机执行它们。
在使用示例中，我们创建了一个 MyPromise 实例，然后通过调用 then 方法注册了成功和失败的回调函数。最后，通过调用 resolve 方法来触发成功回调函数的执行。
请注意，这只是一个简单的实现示例，没有考虑到异步操作、链式调用等更复杂的情况。在实际应用中，建议使用现有的 Promise 实现，如 JavaScript 原生的 Promise 或第三方库（例如 axios、Q.js 等）。

以下是一个java实现相同示例的代码：

import java.util.ArrayList;
import java.util.List;

class MyPromise {
    private String state;
    private Object value;
    private List<Callback> callbacks;

    public MyPromise() {
        this.state = "pending";
        this.value = null;
        this.callbacks = new ArrayList<>();
    }

    public synchronized void resolve(Object value) {
        if (state.equals("pending")) {
            state = "fulfilled";
            this.value = value;
            for (Callback callback : callbacks) {
                callback.onFulfilled(value);
            }
        }
    }

    public synchronized void reject(Object reason) {
        if (state.equals("pending")) {
            state = "rejected";
            this.value = reason;
            for (Callback callback : callbacks) {
                callback.onRejected(reason);
            }
        }
    }

    public synchronized MyPromise then(FulfillCallback onFulfilled, RejectCallback onRejected) {
        Callback callback = new Callback(onFulfilled, onRejected);
        callbacks.add(callback);

        if (state.equals("fulfilled")) {
            callback.onFulfilled(value);
        }

        if (state.equals("rejected")) {
            callback.onRejected(value);
        }

        return this;
    }

    // 成功回调函数接口
    interface FulfillCallback {
        void onFulfilled(Object value);
    }

    // 失败回调函数接口
    interface RejectCallback {
        void onRejected(Object reason);
    }

    // 回调函数包装类
    class Callback {
        private final FulfillCallback onFulfilled;
        private final RejectCallback onRejected;

        public Callback(FulfillCallback onFulfilled, RejectCallback onRejected) {
            this.onFulfilled = onFulfilled;
            this.onRejected = onRejected;
        }

        public void onFulfilled(Object value) {
            onFulfilled.onFulfilled(value); // 调用成功回调函数
        }

        public void onRejected(Object reason) {
            onRejected.onRejected(reason); // 调用失败回调函数
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyPromise myPromise = new MyPromise();
        myPromise.then(value -> {
            System.out.println("Fulfilled: " + value);
        }, reason -> {
            System.out.println("Rejected: " + reason);
        });

        try {
            Thread.sleep(1000);
            myPromise.resolve("Hello, Promise!"); // 触发成功回调函数
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述Java代码是JavaScript Promise的等价实现。其中MyPromise类定义了resolve、reject和then方法，通过回调函数实现异步操作的处理。在MyPromise内部，使用synchronized关键字确保线程安全性。
使用示例中，创建一个MyPromise实例并注册成功和失败的回调函数。通过线程休眠模拟异步操作，在一定时间后调用resolve方法触发成功回调函数的执行。
注意：由于Java是一种静态类型语言，相较于JavaScript，需要更多的代码来实现类和接口之间的定义和交互。同时，在Java中还需要考虑线程安全性和异常处理等方面。

在上述例子中，观察者模式体现在MyPromise类的设计中。以下是观察者模式的几个要素在代码中的体现：

Subject（被观察者）：MyPromise类充当被观察者，负责维护和管理一组观察者对象。
Observer（观察者）：FulfillCallback和RejectCallback接口代表观察者，定义了回调方法onFulfilled和onRejected，用于处理被观察者状态发生变化时的通知。
Attach（注册观察者）：then方法用于注册观察者（回调函数），将它们添加到被观察者的观察者列表中。
Notify（通知观察者）：当被观察者状态改变（通过resolve或reject方法）时，遍历观察者列表，并调用相应的回调方法来通知观察者。

在代码中，MyPromise作为被观察者，通过callbacks列表来管理观察者（回调函数）。resolve和reject方法在状态改变时，调用相应的回调方法通知观察者。而then方法则用于注册观察者（回调函数），将其添加到观察者列表中。整个过程符合观察者模式的基本流程。

海峰丶丶丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【设计模式】

当被观察者的状态发生变化时，所有观察者都会收到相应的通知，并进行相应的更新操作。Promise（承诺）是一种用于处理异步操作的编程模式，它解决了传统的回调函数方式在处理多个异步操作时出现的回调地狱问题，并提供了一种更优雅、可读性更高的方式来管理和处理异步代码。通过使用工厂模式，我们可以根据需要创建不同类型的汽车对象，而无需直接与具体产品类进行耦合，从而提供了更灵活和可扩展的设计。通过使用工厂模式，我们可以根据需要创建不同类型的汽车对象，而无需直接与具体类进行耦合，这提供了更灵活和可扩展的设计。
复制链接

扫一扫