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

hello world smile2024-11-11 15:23

前言

我们都知道设计模式是相同的，同一种设计模式的理念不会因为语言不同而会有所改变，但是由于语法的差异，设计模式的写法也有所差异，本文会介绍一些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. 饿汉式单例

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

dart 复制代码 
class Singleton {
  //私有构造函数
  Singleton._privateConstructor();

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

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

2. 懒汉式单例

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

dart 复制代码 
class SingletonLazy {
  //私有构造
  SingletonLazy._privateConstructor();

  //静态实例
  static SingletonLazy? _instance;

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

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

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 的静态内部类特性，既实现了延迟加载，又保证了线程安全。

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）是一种创建型设计模式，用于定义一个接口或抽象类以创建对象，但让子类决定要实例化的类。工厂模式可以将实例化对象的逻辑与使用对象的逻辑分离，提高代码的可扩展性和可维护性。

像支付（不同的支付类型）、日志、等都可以使用该模式

工厂模式的主要分类

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

简单工厂模式

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

dart 复制代码 
//对象实例子
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
}

抽象工厂模式

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

dart 复制代码 
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）: 维护对策略对象的引用，并在需要时调用策略对象的方法。

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

  1. 定义策略接口
    首先，定义一个策略接口，描述不同折扣算法的通用方法。
dart 复制代码 
abstract class DiscountStrategy {
//计算折扣金额
  double calculateDiscount(double price);
}

2. 实现具体策略

为不同的折扣类型算法的具体的策略类。

dart 复制代码 
//无折扣
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），用于持有策略对象，并在需要时调用策略的方法。

dart 复制代码 
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. 使用策略模式

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

dart 复制代码 
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. 定义产品

首先，定义需要创建的复杂对象（对象参数比较多，或者链路很长）。

dart 复制代码 
class ComplexWidget {
  String? title;
  String? imageUrl;
  String? description;

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

2. 定义建造者接口

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

dart 复制代码 
abstract class ComplexWidgetBuilder {
  void setTitle(String title);
  void setImageUrl(String imageUrl);
  void setDescription(String description);
  ComplexWidget getResult();
}

3. 实现具体建造者

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

dart 复制代码 
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. 定义指挥者

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

dart 复制代码 
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. 使用建造者模式

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

dart 复制代码 
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.)
}

未完待续

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

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

相关推荐
花追雨8 小时前
Android -- 双屏异显之方法一
android·双屏异显
小趴菜82278 小时前
安卓 自定义矢量图片控件 - 支持属性修改矢量图路径颜色
android
氤氲息8 小时前
Android v4和v7冲突
android
KdanMin8 小时前
高通Android 12 Launcher应用名称太长显示完整
android
chenjk48 小时前
Android不可擦除分区写文件恢复出厂设置，无法读写问题
android
袁震8 小时前
Android-Glide缓存机制
android·缓存·移动开发·glide
工程师老罗8 小时前
Android笔试面试题AI答之SQLite（2）
android·jvm·sqlite
NorthCastle9 小时前
设计模式-创建型模式-简单工厂模式详解
设计模式·简单工厂模式
User_undefined10 小时前
uniapp Native.js 调用安卓arr原生service
android·javascript·uni-app
安小牛10 小时前
android anr 处理
android
热门推荐
01SQL 主从数据库实时备份02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04基于大语言模型（LLM）的合成数据生成、策展和评估的综述05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07VSCode插件 —— Cody AI （免费AI助手！）08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10ARM学习（31）编译器对overlay方式的支持