Flutter 中的那些设计模式的写法（持续更新）

🕗 发布于 2024-11-08 11:53 flutter 设计模式移动开发 android

前言

我们都知道设计模式是相同的，同一种设计模式的理念不会因为语言不同而会有所改变，但是由于语法的差异，设计模式的写法也有所差异，本文会介绍一些flutter中常用设计模式的写法以及使用场景。
常见的设计模式有23种，按照类型可以细分为：
创建型模式

单例模式 (Singleton)
工厂方法模式 (Factory Method)
抽象工厂模式 (Abstract Factory)
建造者模式 (Builder)
原型模式 (Prototype)

结构型模式

适配器模式 (Adapter)
桥接模式 (Bridge)
组合模式 (Composite)
装饰模式 (Decorator)
外观模式 (Facade)
享元模式 (Flyweight)
代理模式 (Proxy)

行为型模式

责任链模式 (Chain of Responsibility)
命令模式 (Command)
解释器模式 (Interpreter)
迭代器模式 (Iterator)
中介者模式 (Mediator)
备忘录模式 (Memento)
观察者模式 (Observer)
状态模式 (State)
策略模式 (Strategy)
模板方法模式 (Template Method)
访问者模式 (Visitor)

单例模式

想必对于大部分的开发来说，这是咱们接触最多的设计模式之一了。
单例模式（Singleton Pattern）理念：

唯一实例: 单例模式保证了某个类只有一个实例存在。这意味着无论何时何地调用该类，只会返回同一个对象实例。
全局访问: 提供一个全局访问点来获取该唯一实例。通常通过一个静态方法或属性来实现。
延迟实例化: 单例模式通常支持延迟实例化，即在第一次请求时创建实例，以节省资源。

设计思路:

私有构造函数: 将类的构造函数设为私有，以防止外部通过普通构造方法创建实例。
静态实例: 使用静态变量存储类的唯一实例。
静态方法: 提供一个公共的静态方法或属性，返回该唯一实例。

代码实现：

1. 饿汉式单例

这种方式在类加载时就创建实例，线程安全，但如果实例初始化开销大且不一定会用到，会造成资源浪费。

class Singleton {
  //私有构造函数
  Singleton._privateConstructor();

  // 静态实例
  static final Singleton instance = Singleton._privateConstructor();

  // 内部方法
  void printHello() {
    print('Hello');
  }
}
//调用方式
 Singleton.instance.printHello();

2. 懒汉式单例
这种方式在第一次使用时才创建实例，延迟加载。

class SingletonLazy {
  //私有构造
  SingletonLazy._privateConstructor();

  //静态实例
  static SingletonLazy? _instance;

  //获取实列方法
  static SingletonLazy getInstance() {
    if (_instance == null) {
      _instance = SingletonLazy._privateConstructor();
    }
    return _instance!;
  }
}

也可以通过dart中的工厂类来创建懒汉式

class SingletonFactory {
  // 私有构造函数
  SingletonFactory._privateConstructor();

  // 静态变量来存储唯一实例
  static SingletonFactory? _instance;

  // 工厂构造函数
  factory SingletonFactory() {
    if (_instance == null) {
      _instance = SingletonFactory._privateConstructor();
    }
    return _instance!;
  }

  void someMethod() {
    print('This is a method in SingletonFactory');
  }
}

3.静态内部类
这种方式利用 Dart 的静态内部类特性，既实现了延迟加载，又保证了线程安全。

class Singleton {
  // 私有构造函数
  Singleton._privateConstructor();

  // 静态内部类
  static final Singleton instance = _SingletonHolder.instance;

  // 内部类
  static class _SingletonHolder {
    static final Singleton instance = Singleton._privateConstructor();
  }
}

4. 懒汉式双重检查

额～～～写java过来的人条件反射就是，单例要考虑线程安全，加锁。。。
其实在flutter中，由于Flutter是单线程模式的，很少会有多线程切换的使用场景，它的异步操作是通过Future来实现的，其内部也是通过堆栈来实现阻塞（await）和插件队列执行，理论上是线程安全的，除非你非得使用Isolates，但是Isolates一种多线程模型，每个 Isolate 拥有独立的内存空间，因此单例在不同的 Isolate 中不会共享。这意味着在 Dart 中，通常不需要担心传统意义上的多线程竞争条件。所以个人觉得，没有必要加锁考虑并发情况，非得写考虑 静态内部类

工厂设计模式

在 Flutter 中，工厂设计模式（Factory Pattern）是一种创建型设计模式，用于定义一个接口或抽象类以创建对象，但让子类决定要实例化的类。工厂模式可以将实例化对象的逻辑与使用对象的逻辑分离，提高代码的可扩展性和可维护性。
像支付（不同的支付类型）、日志、等都可以使用该模式

工厂模式的主要分类

简单工厂模式: 提供一个创建对象实例的方法，根据传入的参数决定创建哪种类型的对象。
抽象工厂模式:提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。

简单工厂模式
简单工厂模式通过一个静态方法创建对象实例。

//对象实例子
abstract class Shape {
  void draw();
}
//实现抽象方法，重写自己的实例子
class Circle implements Shape {
  @override
  void draw() {
    print("Drawing a Circle");
  }
}

class Square implements Shape {
  @override
  void draw() {
    print("Drawing a Square");
  }
}

class ShapeFactory {
// 创建静态方法，通过传入不同的类型来判断要执行的工厂类
  static Shape createShape(String type) {
    if (type == 'circle') {
      return Circle();
    } else if (type == 'square') {
      return Square();
    } else {
      throw Exception("Shape type $type not recognized");
    }
  }
}
// 调用实现
void main() {
  Shape circle = ShapeFactory.createShape('circle');
  circle.draw(); // 输出: Drawing a Circle

  Shape square = ShapeFactory.createShape('square');
  square.draw(); // 输出: Drawing a Square
}

抽象工厂模式
抽象工厂模式用于创建相关或依赖对象的家族。

abstract class Button {
  void paint();
}

class WindowsButton implements Button {
  @override
  void paint() {
    print("Rendering a button in Windows style");
  }
}

class MacOSButton implements Button {
  @override
  void paint() {
    print("Rendering a button in MacOS style");
  }
}

abstract class GUIFactory {
  Button createButton();
}

class WindowsFactory implements GUIFactory {
  @override
  Button createButton() {
    return WindowsButton();
  }
}

class MacOSFactory implements GUIFactory {
  @override
  Button createButton() {
    return MacOSButton();
  }
}

void main() {
  GUIFactory factory = WindowsFactory();
  Button button = factory.createButton();
  button.paint(); // 输出: Rendering a button in Windows style

  factory = MacOSFactory();
  button = factory.createButton();
  button.paint(); // 输出: Rendering a button in MacOS style
}

策略设计模式

在 Flutter 中，策略模式（Strategy Pattern）是一种常用的设计模式，它允许你定义一系列算法，将每一个算法封装起来，并且使它们可以互相替换。而不用每次改动都去修改代码实现，策略模式可以让我们不用关注算法的具体实现是什么。

策略模式的结构

策略接口（Strategy Interface）: 定义算法或行为的接口。
具体策略（Concrete Strategies）: 实现策略接口的不同算法。
上下文（Context）: 维护对策略对象的引用，并在需要时调用策略对象的方法。

我们以用算不同类型的折扣为例。策略模式可以帮助我们在不同的折扣计算方法之间切换。

定义策略接口
首先，定义一个策略接口，描述不同折扣算法的通用方法。

abstract class DiscountStrategy {
//计算折扣金额
  double calculateDiscount(double price);
}

2. 实现具体策略
为不同的折扣类型算法的具体的策略类。

//无折扣
class NoDiscountStrategy implements DiscountStrategy {
  @override
  double calculateDiscount(double price) {
    return 0.0;
  }
}
//具体折扣
class PercentageDiscountStrategy implements DiscountStrategy {
  final double percentage;

  PercentageDiscountStrategy(this.percentage);

  @override
  double calculateDiscount(double price) {
    return price * (percentage / 100);
  }
}
//全免
class FixedAmountDiscountStrategy implements DiscountStrategy {
  final double discountAmount;

  FixedAmountDiscountStrategy(this.discountAmount);

  @override
  double calculateDiscount(double price) {
    return discountAmount;
  }
}

3. 创建上下文
定义一个上下文类（Context），用于持有策略对象，并在需要时调用策略的方法。

class ShoppingCart {
  DiscountStrategy _discountStrategy;

  ShoppingCart(this._discountStrategy);

  void setDiscountStrategy(DiscountStrategy strategy) {
    _discountStrategy = strategy;
  }
  //计算打完折后的最终价格
  double calculateFinalPrice(double price) {
    double discount = _discountStrategy.calculateDiscount(price);
    return price - discount;
  }
}

4. 使用策略模式
现在可以在应用程序中使用策略模式，根据不同的需求动态选择折扣策略。

void main() {
  double itemPrice = 100.0;

  ShoppingCart cart = ShoppingCart(NoDiscountStrategy());
  print("Final price with no discount: ${cart.calculateFinalPrice(itemPrice)}");

  cart.setDiscountStrategy(PercentageDiscountStrategy(10));
  print("Final price with 10% discount: ${cart.calculateFinalPrice(itemPrice)}");

  cart.setDiscountStrategy(FixedAmountDiscountStrategy(15));
  print("Final price with $15 discount: ${cart.calculateFinalPrice(itemPrice)}");
}

建造者模式（Builder Pattern）

建造者模式（Builder Pattern）是一种创建型设计模式，它允许使用者一步步构建一个复杂对象。与直接使用构造函数或工厂模式不同，建造者模式提供了一种灵活的方式来创建对象，特别是当对象的创建过程涉及多个步骤或需要复杂配置时。

在 Flutter 中，建造者模式（链式调用）可以用于构建复杂的 UI 组件或对象配置，像UI组件的封装使用构建者模式是非常常用的。

建造者模式的结构

产品（Product）: 需要构建的复杂对象。
建造者接口（Builder Interface）: 定义创建产品对象的所有步骤。
具体建造者（Concrete Builder）: 实现 Builder 接口，并提供创建产品的具体步骤。
指挥者（Director）: 控制构建过程，按顺序调用建造者中的各个步骤。

下面以封装一个UI组件为例：
1. 定义产品
首先，定义需要创建的复杂对象（对象参数比较多，或者链路很长）。

class ComplexWidget {
  String? title;
  String? imageUrl;
  String? description;

  @override
  String toString() {
    return 'ComplexWidget(title: $title, imageUrl: $imageUrl, description: $description)';
  }
}

2. 定义建造者接口
定义一个接口，描述创建产品的步骤。

abstract class ComplexWidgetBuilder {
  void setTitle(String title);
  void setImageUrl(String imageUrl);
  void setDescription(String description);
  ComplexWidget getResult();
}

3. 实现具体建造者
实现建造者接口，提供具体的构建步骤。

class ConcreteComplexWidgetBuilder implements ComplexWidgetBuilder {
  final ComplexWidget _complexWidget = ComplexWidget();

  @override
  void setTitle(String title) {
    _complexWidget.title = title;
  }

  @override
  void setImageUrl(String imageUrl) {
    _complexWidget.imageUrl = imageUrl;
  }

  @override
  void setDescription(String description) {
    _complexWidget.description = description;
  }

  @override
  ComplexWidget getResult() {
    return _complexWidget;
  }
}

4. 定义指挥者
定义一个指挥者类，用于控制构建过程。

class Director {
  late ComplexWidgetBuilder _builder;

  void setBuilder(ComplexWidgetBuilder builder) {
    _builder = builder;
  }

  ComplexWidget buildCompleteWidget() {
    _builder.setTitle("Sample Title");
    _builder.setImageUrl("http://example.com/image.png");
    _builder.setDescription("This is a sample description.");
    return _builder.getResult();
  }
}

5. 使用建造者模式
在应用程序中使用建造者模式来创建复杂对象。

void main() {
  Director director = Director();
  ComplexWidgetBuilder builder = ConcreteComplexWidgetBuilder();

  director.setBuilder(builder);
  ComplexWidget widget = director.buildCompleteWidget();

  print(widget);
  // 输出: ComplexWidget(title: Sample Title, imageUrl: http://example.com/image.png, description: This is a sample description.)
}

未完待续

后面慢慢会把常用的设计模式都在这里做更新。。。

每个设计模式都有自己的优缺点，其实适合自己的才是最合理的，不要为了设计代码而设计代码,如果不理解业务场景强上设计模式，只会让代码写的更复杂

原文地址：https://blog.csdn.net/qiaoshi96_bk/article/details/143585073

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：React 中 `key` 属性的警告及其解决方案
下一篇：vue.js组件和传值以及微信小程序组件和传值

oracle字符集的使用(修改字符集可能导致索引失效)
oracle字符集的使用(修改字符集可能导致索引失效)
阅读更多2024-11-08
学习threejs，使用JSON格式保存和加载整个场景
本文详细介绍如何基于threejs在三维场景中使用JSON格式保存和加载整个场景，亲测可用。希望能帮助到您。一起学习，加油！加油！
阅读更多2024-11-08
现代Web开发：GraphQL入门指南
GraphQL 是一种用于 API 的查询语言，它提供了一种标准的方式来请求和操作数据。GraphQL 由 Facebook 开发并于 2015 年开源，现已广泛应用于各种规模的项目中。`);`);}
阅读更多2024-11-08
flutter鸿蒙模拟器 Win环境调试报错问题记录（暂未解决）
我在华为论坛找到了带图的案例，主要聚焦在支付包插件的使用上，但我本来也没有使用该插件，加上了也运行不起来。解决效果：跑了一个flutter空工程，排除第三方插件干扰，依然报错，修改abiFilters
阅读更多2024-11-08
基于SSM（Spring + Spring MVC + MyBatis）框架的药房管理系统
用户管理：管理员可以添加、删除、修改和查询用户信息。药品管理：支持对药品信息的增删改查操作，包括药品名称、价格、库存量等。供应商管理：记录供应商信息，如名称、联系方式等。销售管理：处理销售订单，记录销
阅读更多2024-11-08
大数据中的Kafka， Zookeeper，Flume，Nginx， Sqoop与ETL
大数据中有用的重要概念
阅读更多2024-11-08
Python | Leetcode Python题解之第530题二叉搜索树的最小绝对差
Python | Leetcode Python题解之第530题二叉搜索树的最小绝对差
阅读更多2024-11-08
《Python OpenCV从菜鸟到高手》——零基础进阶，开启图像处理与计算机视觉的大门！
《Python OpenCV从菜鸟到高手》是一本深入探讨Python与OpenCV技术的图像处理教程。从Python的基础知识到OpenCV的强大功能，这本书带领读者逐步掌握计算机视觉的核心技术。Py
阅读更多2024-11-08
Python决策树、随机森林、朴素贝叶斯、KNN（K-最近邻居）分类分析银行拉新活动挖掘潜在贷款客户附数据代码
最近我们被客户要求撰写关于银行拉新活动的研究报告，包括一些图形和统计输出。项目背景：银行的主要盈利业务靠的是贷款，这些客户中的大多数是存款大小不等的责任客户（存款人）。银行拥有不断增长的客户该银行希望
阅读更多2024-11-08
[C++]使用cpphttplib的http服务上传和下载
cpphttplib的http服务上传下载代码
阅读更多2024-11-08