Dart 中的 SOLID 原则：构建稳健的 Flutter 应用

发布: 3天前 (2026年2月9日 GMT+8 01:00)

10 分钟阅读

原文: Dev.to

Source: Dev.to

请提供您希望翻译的正文内容，我将为您翻译成简体中文并保留原有的格式、Markdown 语法以及技术术语。

Flutter 中的 SOLID 原则

在飞速发展的 Flutter 开发世界里，将业务逻辑和 UI 代码混在一起是很诱人的。随着应用的增长，这些“快速修复”会导致代码库僵硬，单一次修改可能会破坏无关的功能。

SOLID 原则 是五条设计指南，帮助你的 Dart 代码保持灵活、可测试且可扩展。下面是针对 Flutter 的每条原则的简要说明。

1. 单一职责原则（SRP）

“一个类应该只有一个且唯一的改变理由。”

在 Flutter 中，最常见的 SRP 违规是 “上帝 Widget” —— 一个 StatefulWidget 同时负责 API 调用、业务逻辑以及复杂的 UI 渲染。

解决方案 – 将逻辑拆分到 Controller 或 BLoC 中，保持 UI 只在 StatelessWidget 中。

结果 – 你可以在不渲染任何像素的情况下测试业务逻辑。

❌ BAD – SRP 违规

class User {
  String name;
  String email;

  User(this.name, this.email);

  // Responsibility 1: User data validation
  bool isValidEmail() {
    return email.contains('@') && email.contains('.');
  }

  // Responsibility 2: Database operations
  void saveToDatabase() {
    print('Saving user to database...');
    // Database logic here
  }

  // Responsibility 3: Email notifications
  void sendWelcomeEmail() {
    print('Sending welcome email to $email...');
    // Email sending logic here
  }

  // Responsibility 4: Logging
  void logUserActivity(String activity) {
    print('[$name] $activity');
    // Logging logic here
  }
}

✅ GOOD – SRP 应用

// Responsibility: Hold user data
class User {
  final String name;
  final String email;

  User(this.name, this.email);
}

// Responsibility: Validate user data
class UserValidator {
  bool isValidEmail(String email) =>
      email.contains('@') && email.contains('.');

  bool isValidName(String name) => name.isNotEmpty && name.length >= 2;
}

// Responsibility: Handle database operations for users
class UserRepository {
  void save(User user) {
    print('Saving user ${user.name} to database...');
    // Database logic here
  }

  User? findByEmail(String email) {
    print('Finding user by email: $email');
    // Database query logic here
    return null;
  }
}

// Responsibility: Send email notifications
class EmailService {
  void sendWelcomeEmail(User user) {
    print('Sending welcome email to ${user.email}...');
    // Email sending logic here
  }

  void sendPasswordResetEmail(User user) {
    print('Sending password reset email to ${user.email}...');
    // Email sending logic here
  }
}

// Responsibility: Log application activities
class Logger {
  void logUserActivity(String userName, String activity) {
    final timestamp = DateTime.now();
    print('[$timestamp] [$userName] $activity');
    // Logging logic here
  }

  void logError(String error) {
    print('[ERROR] $error');
    // Error logging logic here
  }
}

2. 开放/封闭原则（OCP）

“软件实体应该对扩展开放，但对修改封闭。”

如果你需要添加一种新的支付方式，就不应该去修改已有的 PaymentProcessor 类。

解决方案 – 使用 抽象类（接口）来定义契约，让具体实现去继承它们。

❌ BAD – OCP 违规

class PaymentProcessor {
  void processPayment(String paymentType, double amount) {
    if (paymentType == 'creditCard') {
      print('Processing credit card payment of \$$amount');
      // Credit card processing logic
    } else if (paymentType == 'paypal') {
      print('Processing PayPal payment of \$$amount');
      // PayPal processing logic
    } else if (paymentType == 'stripe') {
      print('Processing Stripe payment of \$$amount');
      // Stripe processing logic
    }
    // Every time we add a new payment method, we need to modify this class!
  }
}

✅ GOOD – OCP 应用

// Abstract base class – CLOSED for modification
abstrac

### 3. 里氏替换原则（LSP）

> *“超类的对象应该能够被其子类的对象替换，而不会导致程序出错。”*

在 Dart 中，如果 `Square` 继承自 `Rectangle`，但设置 `Square` 的宽度时会同时改变其高度，那么子类就不再表现得像基类——这就是典型的 LSP 违例。

#### ❌ BAD – LSP 违例（Square / Rectangle）

```dart
class Rectangle {
  double width;
  double height;

  Rectangle(this.width, this.height);

  void setWidth(double w) => width = w;
  void setHeight(double h) => height = h;

  double area() => width * height;
}

// Square inherits from Rectangle but forces width == height
class Square extends Rectangle {
  Square(double side) : super(side, side);

  @override
  void setWidth(double w) {
    width = w;
    height = w; // Enforces square shape – breaks LSP
  }

  @override
  void setHeight(double h) {
    width = h;
    height = h; // Enforces square shape – breaks LSP
  }
}

✅ GOOD – 符合 LSP 的设计

// Define a shape contract that does not assume mutable dimensions
abstract class Shape {
  double area();
}

// Rectangle implements Shape
class Rectangle implements Shape {
  final double width;
  final double height;

  Rectangle(this.width, this.height);

  @override
  double area() => width * height;
}

// Square implements Shape independently (no inheritance from Rectangle)
class Square implements Shape {
  final double side;

  Square(this.side);

  @override
  double area() => side * side;
}

// Client code can use any Shape without caring about its concrete type
void printArea(Shape shape) {
  print('Area: ${shape.area()}');
}

继续对剩余的 SOLID 原则（接口分离原则 & 依赖倒置原则）采用同样的清理方式，以保持你的 Flutter 代码库健壮且易于维护。

Source: …