关于flutter:Flutter-设计模式｜工厂模式家族

文 / 杨加康，CFUG 社区成员，《Flutter 开发之旅从南到北》作者，小米工程师

在围绕设计模式的话题中，工厂这个词频繁呈现，从 简略工厂 模式到 工厂办法 模式，再到 形象工厂 模式。工厂名称含意是制作产品的工业场合，利用在面向对象中，牵强附会的成为了比拟典型的创立型模式。

从模式上讲，工厂能够是一个返回咱们想要对象的一个办法 / 函数，即能够作为构造函数的一种形象。

本文，就带大家应用 Dart 了解它们的各自的实现，以及它们之间的关系。

简略工厂模式 不在 23 种 GoF 设计模式中，却是咱们最常应用的一种编程形式。
其中次要波及到一个非凡的办法，专门用来提供咱们想要的实例对象（对象工厂），
咱们能够将这个办法放到一个独自的类 SimpleFactory 中，如下：

class SimpleFactory {

  /// 工厂办法
  static Product createProduct(int type) {if (type == 1) {return ConcreteProduct1();
    }
    if (type == 2) {return ConcreteProduct2();
    }
    return ConcreteProduct();}
}

咱们认为该办法要创立的对象同属一个 Product 类（抽象类），并通过参数 type 指定要创立具体的对象类型。
Dart 不反对 interface 关键词，但咱们能够应用 abstract 以抽象类的形式定义接口，
而后各个具体的类型继承实现它即可：

/// 抽象类
abstract class Product {String? name;}

/// 实现类
class ConcreteProduct implements Product {
  @override
  String? name = 'ConcreteProduct';
}

/// 实现类 1
class ConcreteProduct1 implements Product {
  @override
  String? name = 'ConcreteProduct1';
}

/// 实现类 2
class ConcreteProduct2 implements Product {
  @override
  String? name = 'ConcreteProduct2';
}

当咱们想要在代码中获取对应的类型对象时，只须要通过这个办法传入想要的类型值即可，
咱们不用关怀生产如何被生产以及哪个对象被抉择的具体逻辑：

void main() {final Product product = SimpleFactory.createProduct(1);
  print(product.name); // ConcreteProduct1
}

这就是 简略工厂模式 。
说到这里，就不得不提到 Dart 中特有的 factory 关键词了。

factory 关键词 能够用来润饰 Dart 类的构造函数，意为 工厂构造函数 ，它可能让类的构造函数人造具备工厂的性能，应用形式如下：

class Product {
  /// 工厂构造函数（润饰 create 构造函数）factory Product.createFactory(int type) {if (type == 1) {return Product.product1;} else if (type == 2) {return Product._concrete2();
    }
    return Product._concrete();}

  /// 命名构造函数
  Product._concrete() : name = 'concrete';

  /// 命名构造函数 1
  Product._concrete1() : name = 'concrete1';

  /// 命名构造函数 2
  Product._concrete2() : name = 'concrete2';

  String name;
}

factory 润饰的构造函数须要返回一个以后类的对象实例，
咱们能够依据参数调用对应的构造函数，返回对应的对象实例。

void main() {Product product = Product.createFactory(1);
  print(product.name); // concrete1
}

此外，工厂构造函数也并不要求咱们每次都必须生成新的对象，
咱们也能够在类中事后定义一些对象供工厂构造函数应用，
这样每次在应用同样的参数构建对象时，返回的会是同一个对象，
在单例模式的章节中咱们曾经介绍过：

class Product {
  /// 工厂构造函数
  factory Product.create(int type) {if (type == 1) {return product1;} else if (type == 2) {return product2();
    }
    return Product._concrete();}

  static final Product product1 = Product._concrete1();
  static final Product product2 = Product._concrete2();}

factory 除了能够润饰命名构造函数外，也能够润饰默认的非命名构造函数，

class Product {factory Product(int type) {return Product._concrete(); 
  }

  String? name;
}

到这里为止，工厂构造函数的一个毛病曾经凸显了进去，即使用者并不能直观的感觉到本人正在应用的是工厂函数。
工厂构造函数的应用办法和一般构造函数没有区别，但这个构造函数生产的实例相当于是一种单例：

void main() {Product product = Product(1);
  print(product.name); // concrete1
}

这样的用法很容易造成使用者的困扰，因而，咱们该当尽量应用特定的
命名构造函数 作为工厂构造函数（如下面示例中的 createFactory）。

工厂办法模式同样也是咱们编程中最罕用到的一种伎俩。

在简略工厂中，它次要服务的对象是客户，而 工厂办法 的使用者与工厂自身的类并不相干，
而工厂办法模式次要服务本身的父类，如下的 ProductFactory（类比 UML 中的 Creator）：

/// 形象工厂
abstract class ProductFactory {
  /// 形象工厂办法
  Product factoryMethod();

  /// 业务代码
  void dosomthing() {Product product = factoryMethod();
    print(product.name);
  }
}

在 ProductFactory 类中，工厂办法 factoryMethod 是形象办法，
每个子类都必须重写这个办法并返回对应不同的 Product 对象，
在 dosomthing() 办法被调用时，就能够依据返回的对象做出不同的响应。
具体应用办法如下：

/// 具体工厂
class ProductFactory1 extends ProductFactory {
  
  /// 具体工厂办法 1
  @override
  Product factoryMethod() {return ConcreteProduct1();
  }
}

class ProductFactory2 extends ProductFactory {
  /// 具体工厂办法 2
  @override
  Product factoryMethod() {return ConcreteProduct2();
  }
}

/// 应用
main() {ProductFactory product = ProductFactory1();
  product.dosomthing();    // ConcreteProduct1}

在 Flutter 中，形象办法有一个十分实用的利用场景。咱们在应用 Flutter 开发多端利用时通常须要思考到多平台的适配，即在多个平台中，同样的操作有时会产生不同的后果 / 款式，咱们能够将这些不同后果 / 款式生成的逻辑放在工厂办法中。

如下，咱们定义一个 DialogFacory，用作生成不同款式 Dialog 的工厂：

abstract class DialogFacory {Widget createDialog(BuildContext context);

  Future<void> show(BuildContext context) async {final dialog = createDialog(context);
    return showDialog<void>(
      context: context,
      builder: (_) {return dialog;},
    );
  }
}

而后，针对 Android 和 iOS 两个平台，就能够创立两个不同款式的 Dialog 了：

/// Android 平台
class AndroidAlertDialog extends DialogFactory {

  @override
  Widget createDialog(BuildContext context) {
    return AlertDialog(title: Text(getTitle()),
      content: const Text('This is the material-style alert dialog!'),
      actions: <Widget>[
        TextButton(onPressed: () {Navigator.of(context).pop();},
          child: const Text('Close'),
        ),
      ],
    );
  }
}
/// iOS 平台
class IOSAlertDialog extends DialogFactory {
  
  @override
  Widget createDialog(BuildContext context) {
    return CupertinoAlertDialog(title: Text(getTitle()),
      content: const Text('This is the cupertino-style alert dialog!'),
      actions: <Widget>[
        CupertinoButton(onPressed: () {Navigator.of(context).pop();},
          child: const Text('Close'),
        ),
      ],
    );
  }
}

当初，咱们就能够像这样应用对应的 Dialog 了：

Future _showCustomDialog(BuildContext context) async {final dialog = AndroidAlertDialog();
  // final dialog = IOSAlertDialog();
  await selectedDialog.show(context);
}

形象工厂模式，相较于 简略工厂 和 工厂办法 最大的不同是：这两种模式只生产一种对象，而形象工厂 生产的是一系列对象 （对象族），而且生成的这一系列对象肯定存在某种分割。比方 Apple 会生产手机、平板等多个产品，这些产品都属于 Apple 这个品牌。

如上面这个形象的工厂类：

abstract class ElectronicProductFactory {Product createComputer();
  
  Product createMobile();

  Product createPad();
  
  // ...
}

对于 Apple 来说，我就是生产这类电子产品的工厂，于是能够继承这个类，实现其中的办法生产各类产品：

class Apple extends ElectronicProductFactory {

  @override
  Product createComputer() {return Mac();
  }

  @override
  Product createMobile() {return IPhone();
  }

  @override
  Product createPad() {return IPad();
  }
  
  // ...
}

同样地，对于华为、小米等电子产品厂商也能够应用雷同的形式示意，这就是形象工厂模式。

在开发 Flutter 利用中，咱们也能够充分利用形象工厂模式做切合利用的适配，咱们能够定义如下这个形象工厂，用于生产 widget：

abstract class IWidgetsFactory {Widget createButton(BuildContext context);
  
  Widget createDialog(BuildContext context);
  
  // ...
}

咱们的利用通常须要针对各个平台展现不同格调的 widget。因而针对每一个平台，咱们都能够实现对应的实现工厂，如下：

/// Material 格调组件工厂
class MaterialWidgetsFactory extends IWidgetsFactory {
  @override
  Widget createButton(BuildContext context, VoidCallback? onPressed, String text) {
    return ElevatedButton(child: Text(text),
      onPressed: onPressed,
    );
  }

  @override
  Widget createDialog(BuildContext context, String title, String content) {return AlertDialog(title: Text(title), content: Text(content));
  }
  
  /// ...
}

/// Cupertino 格调组件工厂
class CupertinoWidgetsFactory extends IWidgetsFactory {
  @override
  Widget createButton(
    BuildContext context,
    VoidCallback? onPressed,
    String text,
  ) {
    return CupertinoButton(child: Text(text),
      onPressed: onPressed,
    );
  }

  @override
  Widget createDialog(BuildContext context, String title, String content) {
    return CupertinoAlertDialog(title: Text(title),
      content: Text(content),
    );
  }
  
  // ...
}

这样，在 Android 平台上咱们应用 MaterialWidgetsFactory，在 iOS 平台上应用 CupertinoWidgetsFactory，就能应用对应平台的 widget，想要适配更多平台只须要再继承 IWidgetsFactory 实现对应平台的工厂类即可。

至此，咱们能够发现，作为创立型模式，这三类工厂模式次要工作就是以不同的形式创建对象，但他们各有特点：简略工厂模式形象的是 生产对象 ，工厂办法模式形象的是 类办法 ，工厂办法模式形象的则是 生产对象的工厂，如何应用就见仁见智了。

百度百科：工厂办法模式
百度百科：形象工厂模式
Mangirdas Kazlauskas：Flutter Design Patterns: Abstract Factory

Flutter / Dart 设计模式从南到北（简称 Flutter 设计模式）系列内容预计两周公布一篇，着重向开发者介绍 Flutter 利用开发中常见的设计模式以及开发方式，旨在推动 Flutter / Dart 语言个性的遍及，以及帮忙开发者更高效地开发出高质量、可保护的 Flutter 利用。

我很乐意持续欠缺本系列中的文章，如果您对本文还有任何疑难或者文章的倡议，欢送向中文社区官网 Github 仓库提交 issue 或者间接与我分割，我会及时回复。

关于flutter:Flutter-设计模式｜工厂模式家族

简略工厂 & factory 关键字

工厂办法模式

形象工厂

拓展浏览

对于本系列文章