likes
comments
collection
share

Flutter开发实战:桥接模式（Bridge Pattern）

作者站长头像
站长
· 阅读数 36

桥接模式（Bridge Pattern）是一种常见的软件设计模式，属于结构型模式之一。它的目的是将抽象部分与实现部分分离，使它们可以独立地变化，从而降低系统中不同维度的耦合性。

在软件设计中，经常会遇到类的多层继承结构，这样的设计可能会导致类的数量迅速增加，并且难以维护。桥接模式通过将继承关系转换为组合关系，来解决这个问题。

桥接模式包含以下几个关键角色：

  1. 抽象部分（Abstraction）：定义抽象类或接口，并维护一个指向实现部分的引用。通常这个抽象类包含高层次的业务逻辑。

  2. 扩展抽象部分（Refined Abstraction）：是抽象部分的子类，通常用来扩展或修改抽象部分所定义的行为。

  3. 实现部分（Implementor）：定义实现类的接口，这些接口不一定要与抽象部分的接口完全一致。实现部分提供了基本操作，供抽象部分调用。

  4. 具体实现部分（Concrete Implementor）：是实现部分的具体子类，负责实现实现部分的接口。

通过桥接模式，可以让抽象部分和实现部分可以独立地变化，实现了两者之间的解耦。这样一来，如果需要新增一种抽象部分或实现部分，只需要新增对应的子类，而不会影响到其他已有的部分。

桥接模式的优点：

1. 解耦抽象部分和实现部分，使得两者可以独立地变化和扩展。

2. 提高系统的灵活性和可扩展性，减少类的数量，便于维护。

3. 改善了系统的可读性和可理解性。

但是，桥接模式也有一定的缺点，主要表现在增加了系统的复杂性，特别是在存在多层次的继承结构时。因此，使用桥接模式需要权衡利弊，并根据具体情况进行合理的设计。

如何在Flutter开发中使用桥接模式（Bridge Pattern），下面让我们用两个实际开发中的场景来举例说明一下：

场景一:音乐播放器

我们将创建一个音频播放器，该播放器在iOS和Android上使用不同的原生代码来播放音频，但在Flutter中提供一致的接口。这意味着，我们将抽象出一个音频播放器类，这个类定义了播放、暂停和停止的操作，而具体的实现将由特定平台的代码来完成。

主要的代码分层：

  1. 抽象部分（Abstraction）：我们定义了一个AudioPlayer接口，这个接口包含了播放、暂停和停止音频的操作。

  2. 实现部分（Implementor）：我们定义了一个AudioPlayerImplementor接口，这个接口包含了开始播放、暂停播放和停止播放音频的操作。

  3. 具体实现部分（Concrete Implementor）：我们为iOS和Android各定义了一个类（IOSAudioPlayer和AndroidAudioPlayer），这两个类都实现了AudioPlayerImplementor接口。这两个类的作用是，根据平台的不同，执行具体的播放、暂停和停止音频的操作。

  4. 扩展抽象部分（Refined Abstraction）：我们定义了一个MyAudioPlayer类，这个类实现了AudioPlayer接口，并且持有一个AudioPlayerImplementor的引用。这个类的作用是，通过调用持有的AudioPlayerImplementor的方法，来实现AudioPlayer接口的操作。

// 抽象部分（Abstraction）
// 定义了一个音频播放器接口，这个接口包含播放、暂停和停止的操作
abstract class AudioPlayer {
  void play(String audioFile);
  void pause();
  void stop();
}

// 实现部分（Implementor）
// 定义了一个音频播放器实现接口，这个接口包含启动播放、暂停播放和停止播放的操作
abstract class AudioPlayerImplementor {
  void startPlay(String audioFile);
  void pausePlay();
  void stopPlay();
}

// 具体实现部分（Concrete Implementor）
// 这是iOS的播放器实现
class IOSAudioPlayer implements AudioPlayerImplementor {
  @override
  void startPlay(String audioFile) {
    // 在这里实现iOS的音频播放代码
  }

  @override
  void pausePlay() {
    // 在这里实现iOS的暂停播放代码
  }

  @override
  void stopPlay() {
    // 在这里实现iOS的停止播放代码
  }
}

// 具体实现部分（Concrete Implementor）
// 这是Android的播放器实现
class AndroidAudioPlayer implements AudioPlayerImplementor {
  @override
  void startPlay(String audioFile) {
    // 在这里实现Android的音频播放代码
  }

  @override
  void pausePlay() {
    // 在这里实现Android的暂停播放代码
  }

  @override
  void stopPlay() {
    // 在这里实现Android的停止播放代码
  }
}

// 扩展抽象部分（Refined Abstraction）
// 扩展抽象化，它使用一个AudioPlayerImplementor来实现抽象操作
class MyAudioPlayer implements AudioPlayer {
  AudioPlayerImplementor _implementor;

  MyAudioPlayer(this._implementor);

  @override
  void play(String audioFile) {
    _implementor.startPlay(audioFile);
  }

  @override
  void pause() {
    _implementor.pausePlay();
  }

  @override
  void stop() {
    _implementor.stopPlay();
  }
}

AudioPlayer

void main() {
  runApp(MyPlayer());
}

class MyPlayer extends StatefulWidget {
  MyApp({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() => MyPlayerState();
}

class MyPlayerState extends State<MyPlayer> {
  AudioPlayer? player;
  void play() {
    if (Platform.isIOS) {
      player = MyAudioPlayer(IOSAudioPlayer());
    } else if (Platform.isAndroid) {
      player = MyAudioPlayer(AndroidAudioPlayer());
    }

    player?.play('audio.mp3');
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('AudioPlayer'),
        ),
        body: Center(
          child: ElevatedButton(
            child: Text('Play'),
            onPressed: () {
              play();
            }, 
          ),
        ),
      ),
    );
  }
}

这个设计允许使用一致的接口来播放音频，而不需要关心具体的平台实现。这就是桥接模式的优点：它能够将抽象与实现分离，使它们可以独立地变化。

场景二:图形绘制

我们有不同类型的形状（如圆形、矩形等）和不同的颜色（如红色、蓝色等），传统的设计方法可能是为每种形状都创建一套颜色的组合，这样会导致类的爆炸式增长。

使用桥接模式来处理形状（Shape）和颜色（Color）的组合。通过这种方式，我们能够将形状和颜色解耦，从而避免了类的爆炸式增长。

主要的代码分层：

  1. 抽象部分（Abstraction）：定义了一个Shape接口，这个接口包含了一个draw()方法，表示绘制一个形状。

  2. 实现部分（Implementor）：定义了一个CColor接口，这个接口包含了一个getColor()方法，表示获取颜色。

  3. 具体实现部分（Concrete Implementor）：创建了两个颜色的具体实现类：Red和Blue，它们都实现了Color接口。Red类返回红色，Blue类返回蓝色。

  4. 扩展抽象部分（Refined Abstraction）：创建了两个形状的具体实现类：Circle和Rectangle，它们都实现了Shape接口，并且都是Flutter的Widget。Circle类表示一个圆形，Rectangle类表示一个矩形。这两个类都使用了CColor接口的实现类来设置自己的颜色。

// 抽象部分（Abstraction）
// 绘制的方法
abstract class Shape {
  void draw();
}

// 实现部分（Implementor）
// 定义了一个获取颜色的方法
abstract class CColor {
  Color? getColor();
}

// 具体实现部分（Concrete Implementor）
// 这是红色的具体实现，它实现了CColor接口
class Red implements CColor {
  @override
  Color? getColor() {
    return Colors.red;
  }
}

// 具体实现部分（Concrete Implementor）
// 这是蓝色的具体实现，它实现了CColor接口
class Blue implements CColor {
  @override
  Color? getColor() {
    return Colors.blue;
  }
}

// 扩展抽象部分（Refined Abstraction）
// 圆形，它是Shape的子类
class Circle extends StatelessWidget implements Shape {
  final CColor color;

  Circle(this.color);

  @override
  Widget build(BuildContext context) {
    return Container(
      width: 100,
      height: 100,
      decoration: BoxDecoration(
        color: color.getColor(),
        shape: BoxShape.circle,
      ),
    );
  }

  @override
  void draw() {
    // 在build方法中进行绘制
  }
}

// 扩展抽象部分（Refined Abstraction）
// 矩形，它是Shape的子类
class Rectangle extends StatelessWidget implements Shape {
  final CColor color;

  Rectangle(this.color);

  @override
  Widget build(BuildContext context) {
    return Container(
      width: 100,
      height: 100,
      color: color.getColor(),
    );
  }

  @override
  void draw() {
    // 在build方法中进行绘制
  }
}

// 创建了一个红色的圆形和一个蓝色的矩形
void main() {
  runApp(MaterialApp(
    home: Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Circle(Red()), // 创建一个红色的圆形
            SizedBox(height: 20),
            Rectangle(Blue()), // 创建一个蓝色的矩形
          ],
        ),
      ),
    ),
  ));
}

通过这种方式，我们可以通过组合的方式创建任何颜色和形状的组合，而不需要为每一种组合创建一个新的类。

使用桥接模式的优点：它可以将抽象部分（形状）和实现部分（颜色）分离，使它们可以独立变化。

应用桥接模式解决Flutter开发中的问题

在开发Flutter应用时，经常会遇到一种问题：对于某些功能，需要在不同的平台或者不同的环境中使用不同的实现。这种情况下，如果我们直接将这些不同的实现硬编码到代码中，往往会导致代码的复杂度提高，可维护性降低。为了解决这个问题，可以使用一种设计模式：桥接模式。

音频播放器

桥接模式的第一个应用场景是实现一个音频播放器。在这个场景中，我们需要在iOS和Android平台上播放音频，而且希望在Flutter中提供一致的接口。

我们首先定义了一个AudioPlayer接口（抽象部分），这个接口包含了播放、暂停和停止音频的操作。然后，我们定义了一个AudioPlayerImplementor接口（实现部分），这个接口包含了开始播放、暂停播放和停止播放音频的操作。

针对iOS和Android两个平台，我们分别创建了IOSAudioPlayer和AndroidAudioPlayer两个类（具体实现部分），它们都实现了AudioPlayerImplementor接口，并且提供了平台特定的音频播放功能。

最后，我们创建了一个MyAudioPlayer类（扩展抽象部分），这个类实现了AudioPlayer接口，并且持有一个AudioPlayerImplementor的引用。在实现AudioPlayer接口的操作时，MyAudioPlayer会调用持有的AudioPlayerImplementor的方法。

这样，我们就可以在Flutter中使用一致的接口来播放音频，而不需要关心具体的平台实现。这就是桥接模式的优点：它能够将抽象与实现分离，使它们可以独立地变化。

形状绘制

在这个场景中，我们有多种形状（如圆形、矩形等）和多种颜色（如红色、蓝色等），我们希望能够创建任何颜色和形状的组合。

我们首先定义了一个Shape接口（抽象部分）和一个CColor接口（实现部分）。然后，我们创建了两种颜色的具体实现类：Red和Blue，以及两种形状的具体实现类：Circle和Rectangle。

Circle和Rectangle类都实现了Shape接口，并且都是Flutter的Widget。在创建这两个类的实例时，我们需要提供一个CColor接口的实现类。这样，我们就可以通过组合的方式创建任何颜色和形状的组合，而不需要为每一种组合创建一个新的类。

这就是桥接模式的优点：它可以将抽象部分（形状）和实现部分（颜色）分离，使它们可以独立变化。这样，我们就可以更灵活地处理形状和颜色的组合，而不需要创建大量的类。

结论

桥接模式是一种非常有用的设计模式，它可以帮助我们将抽象与实现分离，使它们可以独立地变化。这样，我们就可以更灵活地处理各种问题，而不需要创建大量的类。在Flutter开发中，我们可以通过应用桥接模式来简化代码，提高代码的可维护性。

希望对您有所帮助谢谢!!！

转载自:https://juejin.cn/post/7259249904777625637
评论
请登录